JSON type

json.ts

type JsonPrimitives = string | number | boolean | String | Number | Boolean | null;
type NonJsonPrimitives = undefined | Function | symbol;

type SerializeType<T> = T extends JsonPrimitives
  ? T
  : T extends NonJsonPrimitives
  ? never
  : T extends { toJSON(): infer U }
  ? U
  : T extends []
  ? []
  : T extends [unknown, ...unknown[]]
  ? {
      [k in keyof T]: T[k] extends NonJsonPrimitives ? null : SerializeType<T[k]>;
    }
  : T extends (infer U)[]
  ? (U extends NonJsonPrimitives ? null : SerializeType<U>)[]
  : T extends object
  ? {
      [k in keyof T as T[k] extends NonJsonPrimitives ? never : k]: SerializeType<T[k]>;
    }
  : never;

interface Thing {
  keyForThing?: boolean;
  deepValue?: DeepValue;
}

interface DeepValue {
  something?: string;
}

interface SomethingInvalid {
  valid: Thing;
  invalid: () => {};
}

type Result = SerializeType<Thing>;

type Result2 = SerializeType<SomethingInvalid>;

async function getFromCache<T>(fetcher: () => Promise<T>): Promise<SerializeType<T>> {
  const result = await fetcher();
  return JSON.parse(JSON.stringify(result));
}