Customize toJSON() for custom serialization logic about sequelize HOT 6 CLOSED

function maskEmail(value: string): string {
    return value.replace(/(?<=.).(?=[^@]*?.@)/g, "*");
}

class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
    @Attribute(DataTypes.INTEGER)
    @PrimaryKey
    declare id: number;

    @Attribute(DataTypes.STRING)
    @NotNull
    @JsonField({serializer: maskEmail})
    declare email: string;

    @Attribute(DataTypes.STRING)
    @NotNull
    @JsonField(false)
    declare password: string;
}

const jsonthis = new Jsonthis({sequelize});  // Here's where all the magic happens!

const user = await User.create({
    id: 1,
    email: "[email protected]",
    password: "s3cret"
});

console.log(user.toJSON());
// {
//   id: 1,
//   email: 'j******[email protected]',
//   updatedAt: 2024-04-13T18:00:20.909Z,
//   createdAt: 2024-04-13T18:00:20.909Z
// }

import {InferAttributes, InferCreationAttributes, Model} from "@sequelize/core";
import {camelCase, snakeCase} from "case-anything";

export type ToJsonOptions = {
    keepNulls?: boolean;  // Whether to keep null values or not (default is false).
    case?: "camel" | "snake";  // The case to use for field names, default is to keep field name as is.
}

export type JsonFieldOptions = {
    visible?: boolean; // Whether the column is visible or not (default is true).
    serializer?: (value: any) => any;  // The custom serializer function for the column.
}

class JsonSchema {
    hiddenFields: Set<string> = new Set();
    serializers: Map<string, (value: any) => any> = new Map();

    static getOrCreate(target: Function): JsonSchema {
        return target["__json_schema"] = target["__json_schema"] || new JsonSchema();
    }

    static get(target: unknown): JsonSchema | undefined {
        return (target instanceof Function) ? target["__json_schema"] : undefined;
    }
}

export const JsonField = function (visible?: boolean | JsonFieldOptions, options?: JsonFieldOptions): Function {
    return function JsonField(target: Object, propertyName: PropertyKey): void {
        options = options || {};

        if (typeof visible === "object") {
            options = visible;
        } else if (typeof visible === "boolean") {
            options.visible = visible;
        }

        const key = propertyName.toString();
        const schema = JsonSchema.getOrCreate(target.constructor);
        if (options.visible === false) schema.hiddenFields.add(key);
        if (options.serializer) schema.serializers.set(key, options.serializer);
    }
}

export default abstract class JsonModel<M extends Model> extends Model<InferAttributes<M>, InferCreationAttributes<M>> {
    toJSON(options?: ToJsonOptions): object {
        return toJSON(this.get(), this.constructor, options);
    }
}

function isNull(value: any): boolean {
    return value === null || value === undefined;
}

function toJSON(modelData: object, modelClass: Function, options?: ToJsonOptions): { [key: string]: any } {
    const schema = JsonSchema.get(modelClass);
    const json: { [key: string]: any } = {};

    for (const name in modelData) {
        if (schema?.hiddenFields.has(name)) continue;

        let value: any = modelData[name];
        let key = name;

        switch (options?.case) {
            case "camel":
                key = camelCase(name);
                break;
            case "snake":
                key = snakeCase(name);
                break;
        }

        if (isNull(value)) {
            if (!options?.keepNulls) continue;
            json[key] = null;
        } else {
            const serializer = schema?.serializers.get(name);

            if (serializer) {
                json[key] = serializer(value);
            } else if (Array.isArray(value)) {
                json[key] = value.map(obj => toJSON(obj, obj?.constructor, options));
            } else if (value instanceof Model) {
                json[key] = toJSON(value.get(), value.constructor, options);
            } else {
                json[key] = value;
            }
        }
    }

    return json;
}

class User extends JsonModel<User> {
    @Attribute(DataTypes.STRING)
    @JsonField({serializer: (value: string) => value.substring(0, 9) + "********"})
    declare email: string;

    @Attribute(DataTypes.STRING)
    @JsonField(false)
    declare password: string;
}

[...]

const user = await User.create({
    email: "[email protected]",
    password: "top-secret-password"
});

console.log(user.get({plain: true}));
// {
//   id: 1,
//   email: '[email protected]',
//   password: 'top-secret-password',
//   updatedAt: 2024-04-12T15:38:49.740Z,
//   createdAt: 2024-04-12T15:38:49.740Z
// }
console.log(user.toJSON());
// {
//   id: 1,
//   email: 'john.doe@********',
//   updatedAt: 2024-04-12T15:38:49.740Z,
//   createdAt: 2024-04-12T15:38:49.740Z
// }

class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
    @Attribute(DataTypes.STRING)
    @JsonField({serializer: (value: string) => value.substring(0, 9) + "********"})
    declare email: string;

    @Attribute(DataTypes.STRING)
    @JsonField(false)
    declare password: string;
}