Typescript convert unknown type to interface type

Issue

I'd like to write a function asA that takes a parameter of type unknown and returns it as a specific interface type A, or throws an error if the parameter doesn't match the interface type A.

The solution is supposed to be robust. I.e. if add a new field to my interface type A, the compiler should complain about my function missing a check for the new field until I fix it.

Below is an example of such a function asA, but it doesn't work. The compiler says:

Element implicitly has an 'any' type because expression of type '"a"' can't be used to index type '{}'. Property 'a' does not exist on type '{}'.(7053)

interface A {
    a: string
}

function asA(data:unknown): A {
    if (typeof data === 'object' && data !== null) {
        if ('a' in data && typeof data['a'] === 'string') {
            return data;
        }
    }
    throw new Error('data is not an A');

}

let data:unknown = JSON.parse('{"a": "yes"}');
let a = asA(data);

How can I write a function asA as outlined above?

I'm fine with using typecasts, e.g. (data as any)['a'], as long as there are no silent failures when new fields are added to A.

Solution

You can use an existing solution such as typescript-is, although that may require you switch to ttypescript (a custom build of the compiler that allows plugins)

If you want a custom solution, we can build one in plain TS. First the requirements:

• Validate that a property is of a specific type
• Ensure that new fields are validated.

The last requirement can be satisfied by having an object with the same keys as A, with all keys required and the value being the type of the property. The type of such an object would be Record<keyof A, Types>. This object can then be used as the source for the validations, and we can take each key and validate it's specified type:

interface A {
  a: string
}

type Types = "string" | "number" | "boolean";
function asA(data: unknown): A {
  const keyValidators: Record<keyof A, Types> = {
    a: "string"
  }
  if (typeof data === 'object' && data !== null) {
    let maybeA = data as A
    for (const key of Object.keys(keyValidators) as Array<keyof A>) {
      if (typeof maybeA[key] !== keyValidators[key]) {
        throw new Error('data is not an A');
      }
    }
    return maybeA;
  }
  throw new Error('data is not an A');

}

let data: unknown = JSON.parse('{"a": "yes"}');
let a = asA(data);

Play

We could go further, and make a generic factory function that can validate for any object type and we can also allow some extra things, like specifying a function, or allowing optional properties:

interface A {
  a: string
  opt?: string
  // b: number // error if you add b
}

function asOptional<T>(as: (s: unknown, errMsg?: string) => T) {
  return function (s: unknown, errMsg?: string): T | undefined {
    if (s === undefined) return s;
    return as(s);
  }
}

function asString(s: unknown, errMsg: string = ""): string {
  if (typeof s === "string") return s as string
  throw new Error(`${errMsg} '${s} is not a string`)
}

function asNumber(s: unknown, errMsg?: string): number {
  if (typeof s === "number") return s as number;
  throw new Error(`${errMsg} '${s} is not a string`)
}

type KeyValidators<T> = {
  [P in keyof T]-?: (s: unknown, errMsg?: string) => T[P]
}

function asFactory<T extends object>(keyValidators:KeyValidators<T>) {
  return function (data: unknown, errMsg: string = ""): T {
    console.log(data);
    if (typeof data === 'object' && data !== null) {
      let maybeT = data as T
      for (const key of Object.keys(keyValidators) as Array<keyof T>) {
        keyValidators[key](maybeT[key], errMsg + key + ":");
      }
      return maybeT;
    }
    throw new Error(errMsg + 'data is not an A');
  }
}

let data: unknown = JSON.parse('{"a": "yes"}');
const asA = asFactory<A>({
  a: asString,
  opt: asOptional(asString)
  /// b: asNumber
})
let a = asA(data);

interface B {
  a: A
}

const asB = asFactory<B>({
  a: asA
})

let data2: unknown = JSON.parse('{ "a": {"a": "yes"} }');
let b = asB(data2);
let berr = asB(data);

Playground Link

Answered By - Titian Cernicova-Dragomir