@lab900/typescript-serializer/lib/serialize/serialize.js

JSON serialization/deserialization of Typescript objects

import { primitiveDeserializer } from './serializers/primitive.deserializer';
import { dateDeserializer } from './serializers/date.deserializer';
import { getEntityMetadata } from '../metadata';
export class Serialize {
    static convertSingleValue(sourceObject, type, propertyKey) {
        if (Array.isArray(sourceObject)) {
            return Serialize.convertArray(sourceObject, type, propertyKey);
        }
        const serializer = Serialize.strategy.get(type);
        if (serializer !== undefined) {
            return serializer(sourceObject, type, propertyKey);
        }
        if (typeof sourceObject === 'object') {
            return Serialize.convertObject(sourceObject, type, propertyKey);
        }
        return sourceObject;
    }
    static convertObject(sourceObject, propertyType, propertyKey) {
        if (typeof sourceObject !== 'object' || sourceObject === null) {
            return;
        }
        if (propertyType === undefined) {
            console.error('Please provide a valid type');
            return;
        }
        const rootMetadata = getEntityMetadata(propertyType.prototype);
        let sourceObjectWithSerializedProperties = {};
        if (!rootMetadata.length) {
            sourceObjectWithSerializedProperties = Object.assign({}, sourceObject);
        }
        else {
            rootMetadata.forEach((metaData) => {
                const { key, name, type, arrayType, serializer, serializerOptions, includeEmpty } = metaData;
                const jsonKey = (serializerOptions === null || serializerOptions === void 0 ? void 0 : serializerOptions.attributeName) || name || key;
                const objectValue = sourceObject === null || sourceObject === void 0 ? void 0 : sourceObject[key];
                const jsonType = Array.isArray(objectValue) ? arrayType : type;
                if (serializerOptions === null || serializerOptions === void 0 ? void 0 : serializerOptions.exclude) {
                    return;
                }
                if (objectValue !== null && objectValue !== 'undefined') {
                    let revivedValue;
                    if (serializer) {
                        revivedValue = serializer(objectValue);
                    }
                    else if (!jsonType) {
                        console.error(`No valid type present for ${jsonType}`);
                        return;
                    }
                    else {
                        revivedValue = Serialize.convertSingleValue(objectValue, jsonType, key);
                    }
                    if (includeEmpty || (revivedValue !== null && typeof revivedValue !== 'undefined')) {
                        sourceObjectWithSerializedProperties[jsonKey] = revivedValue;
                    }
                }
            });
        }
        return sourceObjectWithSerializedProperties;
    }
    static convertArray(sourceObject, type, key) {
        if (!Array.isArray(sourceObject)) {
            return [];
        }
        return sourceObject.map((element) => {
            try {
                return Serialize.convertSingleValue(element, type, key);
            }
            catch (e) {
                console.error(`Could not serialize ${key} as array of ${type}.`);
                return [];
            }
        });
    }
    static instantiateType(ctor) {
        return new ctor();
    }
}
Serialize.strategy = new Map([
    [Number, primitiveDeserializer],
    [String, primitiveDeserializer],
    [Boolean, primitiveDeserializer],
    [Date, dateDeserializer],
]);