Can data be filtered based on type definitions using Runtime APIs and TypeDefs?

Question

Can data be filtered based on type definitions using Runtime APIs and TypeDefs?

My theory: Is it feasible to generate a guard from TypeDefs that will be present at runtime? I recall hearing that this is achievable with TS4+.

Essentially, two issues; one potentially resolvable:

If your API (which you can't control) provides noisy data and you need to filter them based on existing type definitions, what approach would you take?
At times, your type definitions may appear unconventional, making it challenging to filter by lodash.keyBy as the iteratee could vary in shape depending on the given TypeDefs.

For instance:

You have an object type defined as follows:

type ObjectType = {
  [key: string]: {
    foo?: string | number;
  };
};

The following data would pass based on the above ObjectType:

const someOKCollection: Array<ObjectType> = [
  { june: { foo: 1 } },
  { earth: {} },
  { milky: { foo: "Hi" } }
];

Imagine this data is received from an API:

const collectionFromApi: Array<unknown> = [
  { car: { foo: 1 } },
  { soup: {} },
  { water: { foo: "Hi" } },
  { sun: { bar: "Hi" } }
];

In this scenario, the entry for sun is unnecessary due to the ObjectType (as it contains bar). The challenge lies in transforming the data into:

const desiredResult = {
  noMatter: { foo: 1 },
  what: {},
  Ever: { foo: "Hi" }
};

Main Question:

Ignoring the solvability of the first question, how should the iteratee be automatically crafted from the TypeDefinition so that utilizing lodash.keyBy or other collection functions results in the desired outcome?

UPDATE: Explore a simplified CodeSandBox here: https://codesandbox.io/s/typescript-lodash-types-6844w0?file=/src/index.type.ts (please note: root key names may differ at runtime; only TypeDefs must be adhered to)

typescript api types runtime lodash

Answer 1

Answer №1

When not using lodash:

Check out this example on CodeSandbox

// import keyBy from "lodash/fp/keyBy";

type ObjectType = {
  [key: string]: {
    foo?: string | number;
  };
};

// const someOKCollection: Array<ObjectType> = [
//   { a: { foo: 1 } },
//   { b: {} },
//   { c: { foo: "Hi" } }
// ];

const collectionFromApi: unknown[] = [
  { a: { foo: 1 } },
  { b: {} },
  { c: { foo: "Hi" } },
  { d: { bar: "Hi" } }
];

type AllowedKey = "a" | "b" | "c";
const allowedKeys = new Set<AllowedKey>(["a", "b", "c"]);

// const desiredResult = {
//   a: { foo: 1 },
//   b: {},
//   c: { foo: "Hi" }
// };

type Result = {
  [key in AllowedKey]: { foo?: string | number };
};

const y = collectionFromApi.reduce<Result>((acc, val) => {
  if (typeof val !== "object" || val === null) return acc;

  const key = Object.keys(val)[0];

  if (
    key === undefined ||
    !allowedKeys.has(key as AllowedKey)
  ) {
    return acc;
  }

  acc[key as AllowedKey] = (val as Result)[key as AllowedKey];
  return acc;

}, {} as Result);
console.log("Y", y);

Answer 2

When not using lodash:

Check out this example on CodeSandbox

// import keyBy from "lodash/fp/keyBy";

type ObjectType = {
  [key: string]: {
    foo?: string | number;
  };
};

// const someOKCollection: Array<ObjectType> = [
//   { a: { foo: 1 } },
//   { b: {} },
//   { c: { foo: "Hi" } }
// ];

const collectionFromApi: unknown[] = [
  { a: { foo: 1 } },
  { b: {} },
  { c: { foo: "Hi" } },
  { d: { bar: "Hi" } }
];

type AllowedKey = "a" | "b" | "c";
const allowedKeys = new Set<AllowedKey>(["a", "b", "c"]);

// const desiredResult = {
//   a: { foo: 1 },
//   b: {},
//   c: { foo: "Hi" }
// };

type Result = {
  [key in AllowedKey]: { foo?: string | number };
};

const y = collectionFromApi.reduce<Result>((acc, val) => {
  if (typeof val !== "object" || val === null) return acc;

  const key = Object.keys(val)[0];

  if (
    key === undefined ||
    !allowedKeys.has(key as AllowedKey)
  ) {
    return acc;
  }

  acc[key as AllowedKey] = (val as Result)[key as AllowedKey];
  return acc;

}, {} as Result);
console.log("Y", y);

Can data be filtered based on type definitions using Runtime APIs and TypeDefs?

Answer №1

Similar questions

When working on styling a different Styled Component, how should one define the type of props required?

webpack - compile one TypeScript file separately (2 actions)

What could be the reason for my Angular 2 app initializing twice?

What is the method in TypeScript for defining a property in an interface based on the keys of another property that has an unknown structure?

Using Typescript for testing React components: successfully passing an array of objects as props

What is the reason for TypeScript not throwing an error when an interface is not implemented correctly?

Challenges encountered when assigning values in a form with Material UI, Formik, and Typescript

Z-order for ClockPicker

Issue with ngClass not updating during Route Event

When I define a type in TypeScript, it displays "any" instead

Using TypeScript to implement Angular Draggable functionality within an ng-template

Using checkboxes for filtering in a React application

Trigger on the cancellation or completion of a nested observable

Creating a type-safe method wrapper in TypeScript based on function names

Having trouble getting useFieldArray to work with Material UI Select component

Using TypeORM to Retrieve Data from Many-to-Many Relationships with Special Attributes

Is there a way to restrict the type of the value returned by URLSearchParams.get() to a specific union type?

Ensuring Type Safety in Typescript

When setting up Webpack with TypeScript, an error is encountered related to imports

Webpack and TypeScript are throwing an error stating that `$styles` is not defined