Simple Desgin

[brillout]

Hi @aenario !

I'm curious; what do you think of a Babel plugin that would transpile this:

type Todo = {
  userId: number;
  id: number;
  title: string;
  completed: boolean;
}

const resp = await fetch("https://jsonplaceholder.typicode.com/todos/1");

const data = await resp.json();

assert(data typeof Todo);

to that:

const __TodoType = {
  userId: Number;
  id: Number;
  title: String;
  completed: Boolean;
};
const __isTodoType = obj => (
  obj &&
  obj.constructor === Object &&
  Object.keys(obj).length === Object.keys(__TodoType).length &&
  Object.entries(obj)
    .every(([prop, val]) =>
      __TodoType[prop] && val &&
      __TodoType[prop] === val.constructor)
);

const resp = await fetch("https://jsonplaceholder.typicode.com/todos/1");

const data = await resp.json();

assert(__isTodoType(data));

[aenario]

HI @brillout !

I actually was working on something similar last week :
parse package

However the implementation is different : it uses the reflect transformer to transform this code:

interface Jedi {
    master: Jedi | null,
    name: string,
    fullyTrained: boolean
}

let jediJson = `
    {
        "master": {
            "name": Obiwan,
            "fullyTrained": true
        },
        "name": "Luke"
        "fullyTrained": false
    }
`

const j: Jedi = parse<Jedi>(jediJson)

into

let jediJson = `
    {
        "master": {
            "name": Obiwan,
            "fullyTrained": true
        },
        "name": "Luke"
        "fullyTrained": false
    }
`

const j = parse({
  type: "interface", 
  name: "Jedi", 
   members: [
    {
       "name": "master",
       "type": {type: "union", /*...*/}
    },
    {
         "name":"name",
         "type":{type: "string"}
     },
    {
         "name":"fullyTrained",
         "type":{type: "boolean"}
     },
})(jediJson)

Then the cast is done at runtime in a big-ol-switch (https://github.com/aenario/tsmirror/blob/master/packages/parse/src/index.ts#L20)

Your idea is interesting as it will be more efficient (generating the cast code at compile time instead), however it requires adding the possibility for another plugin to hook into the reflect transformer. My issue with that is that I hoped to keep the transformer as minimal as possible in the hope of someday having it included in typescript.

Alternatively, it can be implemented as a separate typescript transformer (not a babel plugin, as types are not available to babel after the typescript compiler went through), but this was already done in : https://github.com/woutervh-/typescript-is

[brillout]

Neat... Is there a way to use a custom JSON deserializer? E.g. I'm using https://github.com/brillout/json-s instead of JSON.

Or maybe even entirely decoupling serialization and type checking. So that the user can simply type check whatever and whenever he wants and use whatever serialization tool he wants.

Actually, in my experience, the serialization is usually done by a library, so that I need to be able to type check only.

Nice job btw., love it.

[aenario]

Yep, it could be a good idea to have three packages

• check : confirm a value match a type
• cast : Transform a value into the type (essentially for class)
• parse, which is actually not that usefull, as it's essentially cast<Type>(JSON.parse(str))