Discriminator-based deserializer with strong typing

Question

Discriminator-based deserializer with strong typing

Seeking advice on how to effectively utilize TypeScript for strongly typing a function that operates similarly to the following example:

function createDeserializer(typeDeserializers) {
    return (data) => {
        const deserializer = typeDeserializers[data.__type];
        <br>return deserializer(data);
    }
}

I would like to achieve something along these lines:

const personDeserializer = createDeserializer({
    'employee': (data) => new Employee(data),
    'customer': (data) => new Customer(data)
});

const person1 = personDeserializer({ __type: 'employee', ... });
const person2 = personDeserializer({ __type: 'customer', ... });

// TypeScript should recognize that person1 is an 'Employee' instance, and person2 is a 'Customer' instance.

I believe I may need to implement some kind of key mapping within the typeDeserializers property and somehow relate it to the return value, but I'm somewhat unsure of how to proceed.

typescript

Answer 1

Answer №1

Here is the code snippet for creating and using deserializers in TypeScript:

class Employee {
    constructor(data: any) {
        Object.assign(this, data);
    }
    position: string;
}
class Customer {
    constructor(data: any) {
        Object.assign(this, data);
    }
    clv: number;
}

type DeserializerTypes = { [n in string]: (data: {}) => {} };

function createDeserializer<DS extends DeserializerTypes>(typeDeserializers: DS) {
    return <T extends keyof DS>(data: { __type: T }): ReturnType<DS[T]> => {
        const deserializer = typeDeserializers[data.__type];
        return deserializer(data) as ReturnType<DS[T]>;
    }
}

const personDeserializer = createDeserializer({
    'employee': (data) => new Employee(data),
    'customer': (data) => new Customer(data)
});

const person1 = personDeserializer({ __type: 'employee' }); // inferred as Employee
const person2 = personDeserializer({ __type: 'customer' }); // inferred as Customer

console.log(person1.position);
console.log(1000 + person2.clv);

If you want to include properties in deserializer arguments and still have TypeScript infer the exact type, you can modify the code like this:

function createDeserializer<DS extends DeserializerTypes>(typeDeserializers: DS) {
    return <T extends keyof DS, D extends { __type: T }>(data: D): ReturnType<DS[D['__type']]> => {
        const deserializer = typeDeserializers[data.__type];
        return deserializer(data) as ReturnType<DS[T]>;
    }
}

const personDeserializer = createDeserializer({
    'employee': (data) => new Employee(data),
    'customer': (data) => new Customer(data)
});

const person1 = personDeserializer({ __type: 'employee', position: 'a' });
const person2 = personDeserializer({ __type: 'customer', clv: 12 }); 

console.log(person1.position);
console.log(1000 + person2.clv);

Answer 2

Here is the code snippet for creating and using deserializers in TypeScript:

class Employee {
    constructor(data: any) {
        Object.assign(this, data);
    }
    position: string;
}
class Customer {
    constructor(data: any) {
        Object.assign(this, data);
    }
    clv: number;
}

type DeserializerTypes = { [n in string]: (data: {}) => {} };

function createDeserializer<DS extends DeserializerTypes>(typeDeserializers: DS) {
    return <T extends keyof DS>(data: { __type: T }): ReturnType<DS[T]> => {
        const deserializer = typeDeserializers[data.__type];
        return deserializer(data) as ReturnType<DS[T]>;
    }
}

const personDeserializer = createDeserializer({
    'employee': (data) => new Employee(data),
    'customer': (data) => new Customer(data)
});

const person1 = personDeserializer({ __type: 'employee' }); // inferred as Employee
const person2 = personDeserializer({ __type: 'customer' }); // inferred as Customer

console.log(person1.position);
console.log(1000 + person2.clv);

If you want to include properties in deserializer arguments and still have TypeScript infer the exact type, you can modify the code like this:

function createDeserializer<DS extends DeserializerTypes>(typeDeserializers: DS) {
    return <T extends keyof DS, D extends { __type: T }>(data: D): ReturnType<DS[D['__type']]> => {
        const deserializer = typeDeserializers[data.__type];
        return deserializer(data) as ReturnType<DS[T]>;
    }
}

const personDeserializer = createDeserializer({
    'employee': (data) => new Employee(data),
    'customer': (data) => new Customer(data)
});

const person1 = personDeserializer({ __type: 'employee', position: 'a' });
const person2 = personDeserializer({ __type: 'customer', clv: 12 }); 

console.log(person1.position);
console.log(1000 + person2.clv);

Discriminator-based deserializer with strong typing

Answer №1

Similar questions

The specified class is not found in the type 'ILineOptions' for fabricjs

Exporting a class from an index.ts file may result in a problem where the injected constructor is

Is using $timeout still considered the most efficient method for waiting on an Angular directive template to load?

Include a new module in the declarations NgModule utilizing ts-morph

Is there a way to transfer data to a different component in React without relying on a hierarchical parent-child relationship?

Is there a way to invoke a client-side function from the server?

The pipe operator in Angular is failing to function as intended

What methods can I use to make sure the right side of my React form is properly aligned for a polished appearance?

Incorporating TypeScript seamlessly into your current Create React App project without the need to modify any existing code or files

The Kubernetes cluster unexpectedly closes down following a period of processing

Combining properties from one array with another in typescript: A step-by-step guide

Is OnPush Change Detection failing to detect state changes?

What causes TypeScript to overlook the generic constraint within a function?

Issues with Testing Angular 7 Components with RouterTestingModule and Accessing getCurrentNavigation()

Discover the combined type of values from a const enum in Typescript

What methods are typically used for testing functions that return HTTP observables?

Using the spread operator in the console.log function is successful, but encountering issues when attempting to assign or return it in a

The API endpoint returns a 404 not found error on NextJS 14 in the production environment, while it functions correctly on the local

Execute a function that handles errors

"What is the significance of the .default property in scss modules when used with typescript