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

JSON serialization/deserialization of Typescript objects

import { primitiveDeserializer } from './deserializers/primitive.deserializer';
import { dateDeserializer } from './deserializers/date.deserializer';
import { getEntityMetadata } from '../metadata';
export class Deserialize {
    static convertSingleValue(sourceObject, type, propertyKey) {
        if (Array.isArray(sourceObject)) {
            return Deserialize.convertArray(sourceObject, type, propertyKey);
        }
        const deserializer = Deserialize.strategy.get(type);
        if (deserializer !== undefined) {
            return deserializer(sourceObject, type, propertyKey);
        }
        else if (typeof sourceObject === 'object') {
            return Deserialize.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);
        if (!rootMetadata.length) {
            console.error('No entity metadata present');
            return;
        }
        const sourceObjectWithDeserializedProperties = {};
        rootMetadata.forEach((metaData) => {
            const { key, name, type, deserializer, arrayType, deserializerOptions, includeEmpty } = metaData;
            const jsonKey = (deserializerOptions === null || deserializerOptions === void 0 ? void 0 : deserializerOptions.attributeName) || name || key;
            const jsonValue = sourceObject === null || sourceObject === void 0 ? void 0 : sourceObject[jsonKey];
            const jsonType = Array.isArray(jsonValue) ? arrayType : type;
            if (deserializerOptions === null || deserializerOptions === void 0 ? void 0 : deserializerOptions.exclude) {
                return;
            }
            if (jsonValue !== null && jsonValue !== 'undefined') {
                let revivedValue;
                if (deserializer) {
                    revivedValue = deserializer(jsonValue);
                }
                else if (!jsonType) {
                    console.error(`No valid type present for ${jsonType}`);
                    return;
                }
                else {
                    revivedValue = Deserialize.convertSingleValue(jsonValue, jsonType, jsonKey);
                }
                if (includeEmpty || (revivedValue !== null && typeof revivedValue !== 'undefined')) {
                    sourceObjectWithDeserializedProperties[key] = revivedValue;
                }
            }
        });
        return Object.assign(Deserialize.instantiateType(propertyType), sourceObjectWithDeserializedProperties);
    }
    static convertArray(sourceObject, type, key) {
        if (!Array.isArray(sourceObject)) {
            return [];
        }
        return sourceObject.map((element) => {
            try {
                return Deserialize.convertSingleValue(element, type, key);
            }
            catch (e) {
                console.error(`Could not deserialize ${key} as array of ${type}.`);
                return [];
            }
        });
    }
    static instantiateType(ctor) {
        return new ctor();
    }
}
Deserialize.strategy = new Map([
    [Number, primitiveDeserializer],
    [String, primitiveDeserializer],
    [Boolean, primitiveDeserializer],
    [Date, dateDeserializer],
]);