Feature Request - type conversions

[DellanX]

Is your feature request related to a problem? Please describe.

I have some code to convert a type (User) into a more obscure type (PublicUser). The two classes are basically the same, except that PublicUser does not have an email field.

Now, I am adding in some tests and realize that my process may be something that could be moved into TypeManager.

Describe the solution you'd like

Ideally, I could list two types, and the field data from the original object would be applied to the newly created converted representation, which the non-applicable fields removed. I figure this process could also take in an object to populate any new fields.

Describe alternatives you've considered

My current process is pretty simple. I serialize the original object, then deserialize it into the target type via TypeManager. That said, I still have to manually scrub the undesired fields.

Additional context

To be honest, all I really need is a way to get a property list so that I can make my convertType helper automatically scrub the undesired fields. That said, I figured I'd ask about adding convertType into TypeManager.

[dpimonov]

Hi DellanX,

Sorry for the late reply, and thanks a lot for your detailed description! 😊

The feature you are looking for is actually already supported. The TypeManager can work with multiple serialization groups. By default, all examples use a single static shared instance, but there is more flexibility than that - you can create several type managers, each with its own serialization layer. This is useful, for example, if you have one User class but need to produce different DTOs without creating extra classes.

The usual way to achieve this is by using a TypeConfiguration, but there are several approaches you can take. The first step is to create two TypeManager instances (two separate serialization layers) for your class hierarchy. You can do that with:

const publicTypeManager = TypeManager.clone();

This creates a new instance based on your current static configuration. Next, you can apply a new configuration that overrides the default one. For example, using TypeConfiguration:

export class PublicUserConfiguration implements TypeConfiguration<User> 
{
    public configure(typeMetadata: TypeMetadata<User>): void 
    {
        typeMetadata.configurePropertyMetadata('email')
            .isSerializable(false);
    }
}

publicTypeManager.applyTypeConfiguration(User, new PublicUserConfiguration());

Alternatively, you can configure the metadata directly without creating a separate TypeConfiguration class:

publicTypeManager.configureTypeMetadata(User)
    .configurePropertyMetadata('email')
    .isSerializable(false);

Now, when you call serialize using this new publicTypeManager instance, the email property will be excluded from the result object.

When you extract type metadata, you basically get access to a reflection-like API for your type. You can inspect property names, check configured data types, or reconfigure metadata as needed.

Also, check out the options available on the type itself - afterDeserializeCallback, beforeSerializeCallback, and serializer. Depending on how exactly you use PublicUser, one of these might fit your use case better.

If you have any questions or run into issues while implementing this, feel free to ask - I will be happy to help! 😊

[DellanX]

No worries, I have been slammed as well.

Ah, I see, and it looks like one more reason for me to move away from declarators (which keeps getting put on the backburner)

Here is the current code I use:

export function convertModel<TIn extends Identifiable, TOut extends Identifiable>(
    adapter: JsonApiAdapter,
    inType: new () => TIn,
    outType: new () => TOut,
    model: TIn | null | undefined
): TOut | null | undefined {
    if (model === null) return null;
    if (model === undefined) return undefined;
    const metadataIn: TypeMetadata<TIn> = TypeManager.extractTypeMetadata(inType);
    const metadataOut: TypeMetadata<TOut> = TypeManager.extractTypeMetadata(outType);
    const serialized = adapter.createEntityDocumentObject<TIn>(metadataIn, model);
    if (serialized && serialized.data && 'type' in serialized.data && typeof serialized.data.type === 'string') {
        serialized.data.type = getType(outType);
    }
    const output = adapter.createDocumentObjectEntity<TOut>(metadataOut, serialized);
    return output;
}

The main value I am working towards, is a parameterized function for translating a generic model into outType

I think I could use your first snippet once I move away from declarators, and I have some form of LUT to grab the configuration class.