ts-serializable 3.0.8 → 3.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ts-serializable",
-    "version": "3.0.8",
+    "version": "3.0.12",
     "description": "Serialization and deserializtion for classes",
     "main": "./dist/index.js",
     "type": "module",
@@ -10,7 +10,7 @@
         "reflect-metadata": ">=0.1.0"
     },
     "devDependencies": {
-        "@labeg/code-style": "^2.0.52",
+        "@labeg/code-style": "^2.0.58",
         "@types/chai": "^4.3.4",
         "@types/mocha": "^10.0.0",
         "chai": "^4.3.7",

package/src/classes/Serializable.ts

@@ -1,271 +0,0 @@
-/* eslint-disable no-prototype-builtins */
-/* eslint-disable @typescript-eslint/no-unnecessary-condition */
-/* eslint-disable complexity */
-/* eslint-disable max-lines-per-function */
-/* eslint-disable max-statements */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-
-import type {AcceptedTypes} from "../models/AcceptedType.js";
-import {SerializationSettings} from "../models/SerializationSettings.js";
-
-/**
- * Class how help you deserialize object to classes.
- *
- * @export
- * @class Serializable
- */
-export class Serializable {
-
-    /**
-     * Global setting for serialization and deserialization
-     *
-     * @static
-     * @type {SerializationSettings}
-     * @memberof Serializable
-     */
-    public static defaultSettings: SerializationSettings = new SerializationSettings();
-
-    /**
-     * Deserialize object from static method.
-     *
-     * Example:
-     * const obj: MyObject = MyObject.fromJSON({...data});
-     *
-     * @static
-     * @param {object} json
-     * @returns {object}
-     * @memberof Serializable
-     */
-    public static fromJSON<T extends Serializable>(
-        this: new () => T,
-        json: object,
-        settings?: Partial<SerializationSettings>
-    ): T {
-        return new this().fromJSON(json, settings);
-    }
-
-    /**
-     * Fill property of current model by data from json.
-     *
-     * Example:
-     * const obj: MyObject = new MyObject().fromJSON({...data});
-     *
-     * @param {object} ujson
-     * @returns {this}
-     * @memberof Serializable
-     */
-    public fromJSON (json: object, settings?: Partial<SerializationSettings>): this {
-        const unknownJson: unknown = json;
-
-        if (
-            unknownJson === null ||
-            Array.isArray(unknownJson) ||
-            typeof unknownJson !== "object"
-        ) {
-            this.onWrongType(String(unknownJson), "is not object", unknownJson);
-            return this;
-        }
-
-        // eslint-disable-next-line guard-for-in
-        for (const thisProp in this) {
-            // Naming strategy and jsonName decorator
-            let jsonProp: string = this.getJsonPropertyName(thisProp, settings);
-
-            // For deep copy
-            if (!unknownJson?.hasOwnProperty(jsonProp) && unknownJson?.hasOwnProperty(thisProp)) {
-                jsonProp = thisProp;
-            }
-
-            if (
-                unknownJson?.hasOwnProperty(jsonProp) &&
-                this.hasOwnProperty(thisProp) &&
-                Reflect.hasMetadata("ts-serializable:jsonTypes", this.constructor.prototype, thisProp)
-            ) {
-                const acceptedTypes: AcceptedTypes[] = Reflect.getMetadata(
-                    "ts-serializable:jsonTypes",
-                    this.constructor.prototype,
-                    thisProp
-                ) as [];
-                const jsonValue: unknown = Reflect.get(unknownJson, jsonProp) as unknown;
-                const extractedValue = this.deserializeProperty(thisProp, acceptedTypes, jsonValue, settings);
-                Reflect.set(this, thisProp, extractedValue);
-            }
-        }
-
-        return this;
-    }
-
-    /**
-     * Process serialization for @jsonIgnore decorator
-     *
-     * @returns {object}
-     * @memberof Serializable
-     */
-    public toJSON (): Record<string, unknown> {
-        const fromJson: this = {...this};
-        const toJson: Record<string, unknown> = {};
-
-        for (const prop in fromJson) {
-            // Json.hasOwnProperty(prop) - preserve for deserialization for other classes with methods
-            if (fromJson.hasOwnProperty(prop) && this.hasOwnProperty(prop)) {
-                if (Reflect.getMetadata("ts-serializable:jsonIgnore", this.constructor.prototype, prop) !== true) {
-                    const toProp = this.getJsonPropertyName(prop);
-                    Reflect.set(toJson, toProp, Reflect.get(fromJson, prop));
-                }
-            }
-        }
-
-        return toJson;
-    }
-
-    /**
-     * Process exceptions from wrong types.
-     * By default just print warning in console, but can by override for drop exception or logging to backend.
-     *
-     * @protected
-     * @param {string} prop
-     * @param {string} message
-     * @param {(unknown)} jsonValue
-     * @memberof Serializable
-     */
-    protected onWrongType (prop: string, message: string, jsonValue: unknown): void {
-        // eslint-disable-next-line no-console
-        console.error(`${this.constructor.name}.fromJSON: json.${prop} ${message}:`, jsonValue);
-    }
-
-    /**
-     * //todo: write jsdoc
-     *
-     * @private
-     * @param {object} object
-     * @param {string} prop
-     * @param {AcceptedTypes[]} acceptedTypes
-     * @param {(unknown)} jsonValue
-     * @returns {(Object | null | void)}
-     * @memberof Serializable
-     */
-    protected deserializeProperty (
-        prop: string,
-        acceptedTypes: AcceptedTypes[],
-        jsonValue: unknown,
-        settings?: Partial<SerializationSettings>
-    ): unknown {
-        for (const acceptedType of acceptedTypes) { // Type Symbol is not a property
-            if (// Null
-                acceptedType === null &&
-                jsonValue === null
-            ) {
-                return null;
-            } else if (// Void, for deep copy classes only, json don't have void type
-                acceptedType === void 0 &&
-                jsonValue === void 0
-            ) {
-                return void 0;
-            } else if (// Boolean, Boolean
-                acceptedType === Boolean &&
-                (typeof jsonValue === "boolean" || jsonValue instanceof Boolean)
-            ) {
-                return Boolean(jsonValue);
-            } else if (// Number, Number
-                acceptedType === Number &&
-                (typeof jsonValue === "number" || jsonValue instanceof Number)
-            ) {
-                return Number(jsonValue);
-            } else if (// String, String
-                acceptedType === String &&
-                (typeof jsonValue === "string" || jsonValue instanceof String)
-            ) {
-                return String(jsonValue);
-            } else if (// Object, Object
-                acceptedType === Object &&
-                (typeof jsonValue === "object")
-            ) {
-                return Object(jsonValue);
-            } else if (// Date
-                acceptedType === Date &&
-                (typeof jsonValue === "string" || jsonValue instanceof String || jsonValue instanceof Date)
-            ) {
-                // 0 year, 0 month, 0 days, 0 hours, 0 minutes, 0 seconds
-                let unicodeTime: number = new Date("0000-01-01T00:00:00.000").getTime();
-
-                if (typeof jsonValue === "string") {
-                    unicodeTime = Date.parse(jsonValue);
-                } else if (jsonValue instanceof String) {
-                    unicodeTime = Date.parse(String(jsonValue));
-                } else if (jsonValue instanceof Date) {
-                    unicodeTime = jsonValue.getTime();
-                }
-                if (isNaN(unicodeTime)) { // Preserve invalid time
-                    this.onWrongType(prop, "is invalid date", jsonValue);
-                }
-
-                return new Date(unicodeTime);
-            } else if (// Array
-                Array.isArray(acceptedType) &&
-                Array.isArray(jsonValue)
-            ) {
-                if (acceptedType[0] === void 0) {
-                    this.onWrongType(prop, "invalid type", jsonValue);
-                }
-
-                return jsonValue.map((arrayValue: unknown) => this.deserializeProperty(
-                    prop,
-                    acceptedType,
-                    arrayValue,
-                    settings
-                ));
-            } else if (// Serializable
-                acceptedType !== null &&
-                acceptedType !== void 0 &&
-                !Array.isArray(acceptedType) &&
-                (
-                    acceptedType.prototype instanceof Serializable ||
-                    Boolean(Reflect.getMetadata("ts-serializable:jsonObjectExtended", acceptedType))
-                ) &&
-                jsonValue !== null &&
-                jsonValue !== void 0 &&
-                typeof jsonValue === "object" && !Array.isArray(jsonValue)
-            ) {
-                const TypeConstructor: new () => Serializable = acceptedType as new () => Serializable;
-
-                return new TypeConstructor().fromJSON(jsonValue, settings);
-            } else if (// Instance any other class, not Serializable, for parse from other classes instance
-                acceptedType instanceof Function &&
-                jsonValue instanceof acceptedType
-            ) {
-                return jsonValue;
-            }
-        }
-
-        // Process wrong type and return default value
-        this.onWrongType(prop, "is invalid", jsonValue);
-
-        return Reflect.get(this, prop);
-    }
-
-    protected getJsonPropertyName (thisProperty: string, settings?: Partial<SerializationSettings>): string {
-        if (Reflect.hasMetadata("ts-serializable:jsonName", this.constructor.prototype, thisProperty)) {
-            return Reflect.getMetadata("ts-serializable:jsonName", this.constructor.prototype, thisProperty) as string;
-        }
-
-        if (settings?.namingStrategy) {
-            return settings.namingStrategy.toJsonName(thisProperty);
-        }
-
-        if (Reflect.hasMetadata("ts-serializable:jsonObject", this.constructor)) {
-            const objectSettings: Partial<SerializationSettings> = Reflect.getMetadata(
-                "ts-serializable:jsonObject",
-                this.constructor
-            ) as Partial<SerializationSettings>;
-            return objectSettings.namingStrategy?.toJsonName(thisProperty) ?? thisProperty;
-        }
-
-        if (Serializable.defaultSettings.namingStrategy) {
-            const {namingStrategy} = Serializable.defaultSettings;
-            return namingStrategy.toJsonName(thisProperty) ?? thisProperty;
-        }
-
-        return thisProperty;
-    }
-
-}

package/src/decorators/JsonIgnore.ts

@@ -1,6 +0,0 @@
-export const jsonIgnore = (): PropertyDecorator => (
-    target: object,
-    propertyKey: string | symbol
-): void => {
-    Reflect.defineMetadata("ts-serializable:jsonIgnore", true, target, propertyKey);
-};

package/src/decorators/JsonName.ts

@@ -1,6 +0,0 @@
-export const jsonName = (jsonPropertyName: string): PropertyDecorator => (
-    target: object,
-    propertyKey: string | symbol
-): void => {
-    Reflect.defineMetadata("ts-serializable:jsonName", jsonPropertyName, target, propertyKey);
-};

package/src/decorators/JsonObject.ts

@@ -1,29 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/unbound-method */
-/* eslint-disable max-statements */
-import type {SerializationSettings} from "../models/SerializationSettings.js";
-import {Serializable} from "../classes/Serializable.js";
-
-export const jsonObject = (
-    settings?: Partial<SerializationSettings>,
-    extend?: boolean
-): ClassDecorator => (target: object): void => {
-    if (extend === true) {
-        Reflect.set(target, "defaultSettings", Serializable.defaultSettings);
-        Reflect.set(target, "fromJSON", Serializable.fromJSON);
-
-        Reflect.set((target as any).prototype, "fromJSON", (Serializable.prototype as any).fromJSON);
-        Reflect.set((target as any).prototype, "deserializeProperty", (Serializable.prototype as any).deserializeProperty);
-        Reflect.set((target as any).prototype, "getJsonPropertyName", (Serializable.prototype as any).getJsonPropertyName);
-        Reflect.set((target as any).prototype, "onWrongType", (Serializable.prototype as any).onWrongType);
-        Reflect.set((target as any).prototype, "toJSON", (Serializable.prototype as any).toJSON);
-
-        Reflect.defineMetadata("ts-serializable:jsonObjectExtended", true, target);
-    }
-
-    if (settings) {
-        Reflect.defineMetadata("ts-serializable:jsonObject", settings, target);
-    }
-};

package/src/decorators/JsonProperty.ts

@@ -1,8 +0,0 @@
-import type {AcceptedTypes} from "./../models/AcceptedType.js";
-
-export const jsonProperty = (...args: AcceptedTypes[]): PropertyDecorator => (
-    target: object,
-    propertyKey: string | symbol
-): void => {
-    Reflect.defineMetadata("ts-serializable:jsonTypes", args, target, propertyKey);
-};

package/src/enums/DateFormatHandling.ts

@@ -1,4 +0,0 @@
-export enum DateFormatHandling {
-    IsoDateFormat = 0,
-    MicrosoftDateFormat = 1 // Not supported yet
-}

package/src/enums/DefaultValueHandling.ts

@@ -1,6 +0,0 @@
-export enum DefaultValueHandling {
-    Include = 0,
-    Ignore = 1, // Not supported yet
-    Populate = 2, // Not supported yet
-    IgnoreAndPopulate = 3 // Not supported yet
-}

package/src/enums/LogLevels.ts

@@ -1,9 +0,0 @@
-export enum LogLevels {
-    Trace = 0,
-    Debug = 1,
-    Information = 2,
-    Warning = 3,
-    Error = 4,
-    Critical = 5,
-    None = 6
-}

package/src/enums/MissingMemberHandling.ts

@@ -1,4 +0,0 @@
-export enum MissingMemberHandling {
-    Ignore = 0,
-    Error = 1 // Not supported yet
-}

package/src/enums/NullValueHandling.ts

@@ -1,4 +0,0 @@
-export enum NullValueHandling {
-    Include = 0,
-    Ignore = 1 // Not supported yet
-}

package/src/enums/ReferenceLoopHandling.ts

@@ -1,5 +0,0 @@
-export enum ReferenceLoopHandling {
-    Error = 0,
-    Ignore = 1,
-    Serialize = 2
-}

package/src/index.ts

@@ -1,25 +0,0 @@
-// Decoratore
-export {jsonIgnore} from "./decorators/JsonIgnore.js";
-export {jsonName} from "./decorators/JsonName.js";
-export {jsonObject} from "./decorators/JsonObject.js";
-export {jsonProperty} from "./decorators/JsonProperty.js";
-
-// Base class
-export {Serializable} from "./classes/Serializable.js";
-
-// Enums
-export {DateFormatHandling} from "./enums/DateFormatHandling.js";
-export {DefaultValueHandling} from "./enums/DefaultValueHandling.js";
-export {MissingMemberHandling} from "./enums/MissingMemberHandling.js";
-export {NullValueHandling} from "./enums/NullValueHandling.js";
-export {ReferenceLoopHandling} from "./enums/ReferenceLoopHandling.js";
-export {LogLevels} from "./enums/LogLevels.js";
-
-// Settings
-export {SerializationSettings} from "./models/SerializationSettings.js";
-
-// Naming strategies
-export type {INamingStrategy} from "./naming-strategies/INamingStrategy.js";
-export {SnakeCaseNamingStrategy} from "./naming-strategies/SnakeCaseNamingStrategy.js";
-export {PascalCaseNamingStrategy} from "./naming-strategies/PascalCaseNamingStrategy.js";
-export {KebabCaseNamingStrategy} from "./naming-strategies/KebabCaseNamingStrategy.js";

package/src/models/AcceptedType.ts

@@ -1,22 +0,0 @@
-/* eslint-disable @typescript-eslint/no-invalid-void-type */
-/* eslint-disable @typescript-eslint/no-type-alias */
-
-export type AcceptedType =
-    BooleanConstructor |
-    DateConstructor |
-    NumberConstructor |
-    ObjectConstructor |
-    StringConstructor |
-
-    // Extended deserialization
-    SymbolConstructor |
-    (new (...args: unknown[]) => object) |
-    null |
-    void;
-    // Add ArrayBufferConstructor, MapConstructor, RegExpConstructor and many others...
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-interface IRecursiveArray<T> extends Array<IRecursiveArray<T> | T> {
-}
-
-export type AcceptedTypes = AcceptedType | IRecursiveArray<AcceptedType>;

package/src/models/SerializationSettings.ts

@@ -1,27 +0,0 @@
-
-import {LogLevels} from "../enums/LogLevels.js";
-import {DefaultValueHandling} from "../enums/DefaultValueHandling.js";
-import {NullValueHandling} from "../enums/NullValueHandling.js";
-import {ReferenceLoopHandling} from "../enums/ReferenceLoopHandling.js";
-import {MissingMemberHandling} from "../enums/MissingMemberHandling.js";
-import {DateFormatHandling} from "../enums/DateFormatHandling.js";
-import type {INamingStrategy} from "../naming-strategies/INamingStrategy.js";
-
-// From newtonsoft https://www.newtonsoft.com/json/help/html/SerializationSettings.htm
-export class SerializationSettings {
-
-    public dateFormatHandling: DateFormatHandling = DateFormatHandling.IsoDateFormat;
-
-    public missingMemberHandling: MissingMemberHandling = MissingMemberHandling.Ignore;
-
-    public referenceLoopHandling: ReferenceLoopHandling = ReferenceLoopHandling.Serialize;
-
-    public nullValueHandling: NullValueHandling = NullValueHandling.Include;
-
-    public defaultValueHandling: DefaultValueHandling = DefaultValueHandling.Ignore;
-
-    public namingStrategy: INamingStrategy | null = null;
-
-    public logLevel: LogLevels = LogLevels.Warning;
-
-}

package/src/naming-strategies/INamingStrategy.ts

@@ -1,6 +0,0 @@
-export interface INamingStrategy {
-
-    fromJsonName: (name: string) => string;
-    toJsonName: (name: string) => string;
-
-}

package/src/naming-strategies/KebabCaseNamingStrategy.ts

@@ -1,19 +0,0 @@
-import type {INamingStrategy} from "./INamingStrategy.js";
-
-export class KebabCaseNamingStrategy implements INamingStrategy {
-
-    public fromJsonName (name: string): string {
-        return name.replace(
-            /-\w/gu,
-            (group: string) => group[1].toUpperCase()
-        );
-    }
-
-    public toJsonName (name: string): string {
-        return name
-            .split(/(?=[A-Z])/u)
-            .join("-")
-            .toLowerCase();
-    }
-
-}

package/src/naming-strategies/PascalCaseNamingStrategy.ts

@@ -1,13 +0,0 @@
-import type {INamingStrategy} from "./INamingStrategy.js";
-
-export class PascalCaseNamingStrategy implements INamingStrategy {
-
-    public fromJsonName (name: string): string {
-        return name.slice(0, 1).toLowerCase() + name.slice(1, name.length);
-    }
-
-    public toJsonName (name: string): string {
-        return name.slice(0, 1).toUpperCase() + name.slice(1, name.length);
-    }
-
-}

package/src/naming-strategies/SnakeCaseNamingStrategy.ts

@@ -1,19 +0,0 @@
-import type {INamingStrategy} from "./INamingStrategy.js";
-
-export class SnakeCaseNamingStrategy implements INamingStrategy {
-
-    public fromJsonName (name: string): string {
-        return name.replace(
-            /_\w/gu,
-            (group: string) => group[1].toUpperCase()
-        );
-    }
-
-    public toJsonName (name: string): string {
-        return name
-            .split(/(?=[A-Z])/u)
-            .join("_")
-            .toLowerCase();
-    }
-
-}