@pristine-ts/data-mapping-common 0.0.283

package/dist/types/nodes/data-mapping.leaf.d.ts

@@ -0,0 +1,92 @@
+import { DataMappingNodeTypeEnum } from "../enums/data-mapping-node-type.enum";
+import { DataNormalizerUniqueKey } from "../types/data-normalizer-unique-key.type";
+import { DataMappingBuilder } from "../builders/data-mapping.builder";
+import { DataMappingNode } from "./data-mapping.node";
+import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
+export declare class DataMappingLeaf {
+    private readonly root;
+    readonly parent: DataMappingNode | DataMappingBuilder;
+    readonly type: DataMappingNodeTypeEnum;
+    /**
+     * This property represents the property referenced in the `source` object.
+     */
+    sourceProperty: string;
+    /**
+     * This property represents the property referenced in the `destination` object.
+     */
+    destinationProperty: string;
+    /**
+     * This property contains an array of Normalizers to apply sequentially when mapping this property.
+     */
+    normalizers: {
+        key: DataNormalizerUniqueKey;
+        options: any;
+    }[];
+    /**
+     * This property contains an array of Normalizers that must be excluded from normalizers defined by parents.
+     */
+    excludedNormalizers: Set<DataNormalizerUniqueKey>;
+    /**
+     * This method specified whether it's possible that this element not be present in the `source` object.
+     */
+    isOptional: boolean;
+    constructor(root: DataMappingBuilder, parent: DataMappingNode | DataMappingBuilder, type?: DataMappingNodeTypeEnum);
+    /**
+     * This is a setter for `sourceProperty`.
+     * @param sourceProperty
+     */
+    setSourceProperty(sourceProperty: string): DataMappingLeaf;
+    /**
+     * This is a setter for `destinationProperty`.
+     * @param destinationProperty
+     */
+    setDestinationProperty(destinationProperty: string): DataMappingLeaf;
+    /**
+     * This is a setter for `isOptional`.
+     * @param isOptional
+     */
+    setIsOptional(isOptional: boolean): DataMappingLeaf;
+    /**
+     * This methods adds a normalizer but checks that this normalizer hasn't been added already (either at the root) or
+     * directly on this leaf.
+     *
+     * @param normalizerUniqueKey
+     * @param options
+     */
+    addNormalizer(normalizerUniqueKey: DataNormalizerUniqueKey, options?: any): DataMappingLeaf;
+    /**
+     * This method simply returns whether the normalizer was already added to this node.
+     * @param normalizerUniqueKey
+     */
+    hasNormalizer(normalizerUniqueKey: DataNormalizerUniqueKey): boolean;
+    /**
+     * This method adds a normalizer that must be excluded from the normalizers applied at a higher level.à
+     * @param normalizerUniqueKey
+     */
+    excludeNormalizer(normalizerUniqueKey: DataNormalizerUniqueKey): DataMappingLeaf;
+    /**
+     * This method adds this node to its parent and returns the parent.
+     */
+    end(): DataMappingNode | DataMappingBuilder;
+    /**
+     * This method maps the `sourceProperty` from the `source` object and maps it to the `destinationProperty` of the
+     * `destination` object while applying the normalizers.
+     *
+     * @param source
+     * @param destination
+     * @param normalizersMap
+     */
+    map(source: any, destination: any, normalizersMap: {
+        [key in DataNormalizerUniqueKey]: DataNormalizerInterface<any, any>;
+    }): Promise<void>;
+    /**
+     * This method imports a schema.
+     *
+     * @param schema
+     */
+    import(schema: any): void;
+    /**
+     * This method exports this node.
+     */
+    export(): any;
+}

package/dist/types/nodes/data-mapping.node.d.ts

@@ -0,0 +1,104 @@
+import { DataMappingNodeTypeEnum } from "../enums/data-mapping-node-type.enum";
+import { DataMappingLeaf } from "./data-mapping.leaf";
+import { DataMappingBuilder } from "../builders/data-mapping.builder";
+import { BaseDataMappingNode } from "./base-data-mapping.node";
+import { DataNormalizerUniqueKey } from "../types/data-normalizer-unique-key.type";
+import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
+import { ClassConstructor } from "class-transformer";
+export declare class DataMappingNode extends BaseDataMappingNode {
+    readonly root: DataMappingBuilder;
+    readonly parent: DataMappingNode | DataMappingBuilder;
+    readonly type: DataMappingNodeTypeEnum;
+    /**
+     * This property represents the property referenced in the `source` object.
+     */
+    sourceProperty: string;
+    /**
+     * This property represents the property referenced in the `destination` object.
+     */
+    destinationProperty: string;
+    /**
+     * This method specified whether it's possible that this element not be present in the `source` object.
+     */
+    isOptional: boolean;
+    /**
+     * IMPORTANT: This property is not serializable. It will be lost during the export.
+     */
+    destinationType?: ClassConstructor<any>;
+    constructor(root: DataMappingBuilder, parent: DataMappingNode | DataMappingBuilder, type?: DataMappingNodeTypeEnum);
+    /**
+     * This is a setter for `sourceProperty`.
+     * @param sourceProperty
+     */
+    setSourceProperty(sourceProperty: string): DataMappingNode;
+    /**
+     * This is a setter for `destinationProperty`.
+     * @param destinationProperty
+     */
+    setDestinationProperty(destinationProperty: string): DataMappingNode;
+    /**
+     * This is a setter for `destinationType`.
+     * @param destinationType
+     */
+    setDestinationType(destinationType: ClassConstructor<any>): DataMappingNode;
+    /**
+     * This is a setter for `isOptional`.
+     * @param isOptional
+     */
+    setIsOptional(isOptional: boolean): DataMappingNode;
+    /**
+     * This property creates a new DataMappingLeaf and returns it. It doesn't add it yet. To do so, the `end()` method
+     * must be called.
+     */
+    add(): DataMappingLeaf;
+    /**
+     * This method adds a nesting level. This should be used when the property contains an object and you want to map
+     * this object into another object.
+     */
+    addNestingLevel(): DataMappingNode;
+    /**
+     * This method adds an array of Scalar allowing you to apply the normalizer on each scalar in the array. The
+     * `sourceProperty` and `destinationProperty` correspond to the name of the property that is an array. But, the
+     * values in the array will be normalized using the normalizer.
+     *
+     */
+    addArrayOfScalar(): DataMappingLeaf;
+    /**
+     * This method adds an array of objects allowing to define a node for each property in the object. Each object in
+     * the array will be treated as being the same.
+     */
+    addArrayOfObjects(): DataMappingNode;
+    /**
+     * This method adds this node to its parent and returns the parent.
+     */
+    end(): DataMappingNode | DataMappingBuilder;
+    /**
+     * This method maps the `sourceProperty` from the `source` object and maps it to the `destinationProperty` of the
+     * `destination` object while applying the normalizers.
+     *
+     * @param source
+     * @param destination
+     * @param normalizersMap
+     */
+    map(source: any, destination: any, normalizersMap: {
+        [key in DataNormalizerUniqueKey]: DataNormalizerInterface<any, any>;
+    }): Promise<void>;
+    /**
+     * This method imports a schema.
+     *
+     * @param schema
+     */
+    import(schema: any): void;
+    /**
+     * This method exports this node.
+     */
+    export(): {
+        _type: DataMappingNodeTypeEnum;
+        sourceProperty: string;
+        destinationProperty: string;
+        isOptional: boolean;
+        nodes: {
+            [x: string]: DataMappingLeaf | DataMappingNode;
+        };
+    };
+}

package/dist/types/nodes/nodes.d.ts

@@ -0,0 +1,3 @@
+export * from "./base-data-mapping.node";
+export * from "./data-mapping.leaf";
+export * from "./data-mapping.node";

package/dist/types/normalizer-options/base-normalizer.options.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class BaseNormalizerOptions {
+    shouldThrowIfTypeIsNotString: boolean;
+    constructor(options?: Partial<BaseNormalizerOptions>);
+}

package/dist/types/normalizer-options/date-normalizer.options.d.ts

@@ -0,0 +1,12 @@
+export declare class DateNormalizerOptions {
+    /**
+     * This property specifies whether an invalid date should return undefined or a date object.
+     */
+    returnUndefinedOnInvalidDate: boolean;
+    /**
+     * This property specifies if a number should be treated as being in seconds or not. Since JS Date expects a
+     * timestamp in milliseconds, if the number is in seconds, it will be multiplied by 1000.
+     */
+    treatNumbers: "milliseconds" | "seconds";
+    constructor(options?: Partial<DateNormalizerOptions>);
+}

package/dist/types/normalizer-options/lowercase-normalizer.options.d.ts

@@ -0,0 +1,4 @@
+import { BaseNormalizerOptions } from "./base-normalizer.options";
+export declare class LowercaseNormalizerOptions extends BaseNormalizerOptions {
+    constructor(options?: Partial<LowercaseNormalizerOptions>);
+}

package/dist/types/normalizer-options/normalizer-options.d.ts

@@ -0,0 +1,5 @@
+export * from "./base-normalizer.options";
+export * from "./date-normalizer.options";
+export * from "./lowercase-normalizer.options";
+export * from "./number-normalizer.options";
+export * from "./string-normalizer.options";

package/dist/types/normalizer-options/number-normalizer.options.d.ts

@@ -0,0 +1,8 @@
+export declare class NumberNormalizerOptions {
+    /**
+     * This property specifies whether an undefined value should be ignored and simply returned or treated as a potential string
+     * and return an empty string `""`.
+     */
+    ignoreUndefined: boolean;
+    constructor(options?: Partial<NumberNormalizerOptions>);
+}

package/dist/types/normalizer-options/string-normalizer.options.d.ts

@@ -0,0 +1,12 @@
+export declare class StringNormalizerOptions {
+    /**
+     * This property specifies whether an undefined value should be ignored and simply returned or treated as a potential string
+     * and return an empty string `""`.
+     */
+    ignoreUndefined: boolean;
+    /**
+     * This represents the format of the date that the normalizer should use when outputting a date object to a string.
+     */
+    dateFormat?: string;
+    constructor(options?: Partial<StringNormalizerOptions>);
+}

package/dist/types/normalizers/date.normalizer.d.ts

@@ -0,0 +1,6 @@
+import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
+import { DateNormalizerOptions } from "../normalizer-options/date-normalizer.options";
+export declare class DateNormalizer implements DataNormalizerInterface<Date | undefined, DateNormalizerOptions> {
+    getUniqueKey(): string;
+    normalize(source: any, options?: DateNormalizerOptions): Date | undefined;
+}

package/dist/types/normalizers/lowercase.normalizer.d.ts

@@ -0,0 +1,7 @@
+import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
+import { DataNormalizerUniqueKey } from "../types/data-normalizer-unique-key.type";
+import { LowercaseNormalizerOptions } from "../normalizer-options/lowercase-normalizer.options";
+export declare class LowercaseNormalizer implements DataNormalizerInterface<string, LowercaseNormalizerOptions> {
+    getUniqueKey(): DataNormalizerUniqueKey;
+    normalize(source: any, options?: LowercaseNormalizerOptions): string;
+}

package/dist/types/normalizers/normalizers.d.ts

@@ -0,0 +1,4 @@
+export * from "./date.normalizer";
+export * from "./lowercase.normalizer";
+export * from "./number.normalizer";
+export * from "./string.normalizer";

package/dist/types/normalizers/number.normalizer.d.ts

@@ -0,0 +1,6 @@
+import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
+import { NumberNormalizerOptions } from "../normalizer-options/number-normalizer.options";
+export declare class NumberNormalizer implements DataNormalizerInterface<number | undefined, NumberNormalizerOptions> {
+    getUniqueKey(): string;
+    normalize(source: any, options?: NumberNormalizerOptions): number | undefined;
+}

package/dist/types/normalizers/string.normalizer.d.ts

@@ -0,0 +1,6 @@
+import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
+import { StringNormalizerOptions } from "../normalizer-options/string-normalizer.options";
+export declare class StringNormalizer implements DataNormalizerInterface<string | undefined, StringNormalizerOptions> {
+    getUniqueKey(): string;
+    normalize(source: any, options?: StringNormalizerOptions): string | undefined;
+}

package/dist/types/options/auto-data-mapping-builder.options.d.ts

@@ -0,0 +1,11 @@
+export declare class AutoDataMappingBuilderOptions {
+    /**
+     * This property is used to specify the default value for the `ìsOptional` property in the builder.
+     *
+     * It will not override the `isNullable` metadata for the property.
+     *
+     * Default value is `false`.
+     */
+    isOptionalDefaultValue: boolean;
+    constructor(options?: Partial<AutoDataMappingBuilderOptions>);
+}

package/dist/types/types/data-mapping-interceptor-unique-key.type.d.ts

@@ -0,0 +1 @@
+export type DataMappingInterceptorUniqueKeyType = string;

package/dist/types/types/data-normalizer-unique-key.type.d.ts

@@ -0,0 +1 @@
+export type DataNormalizerUniqueKey = string;

package/dist/types/types/types.d.ts

@@ -0,0 +1,2 @@
+export * from "./data-normalizer-unique-key.type";
+export * from "./data-mapping-interceptor-unique-key.type";

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@pristine-ts/data-mapping-common",
+  "version": "0.0.283",
+  "description": "",
+  "module": "dist/lib/esm/data-mapping-common.js",
+  "main": "dist/lib/cjs/data-mapping-common.js",
+  "types": "dist/types/data-mapping-common.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.cjs.json",
+    "prepublish": "npm run build",
+    "test": "jest",
+    "test:cov": "jest --coverage"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@pristine-ts/class-validator": "^1.0.25",
+    "@pristine-ts/metadata": "~1.0.8",
+    "class-transformer": "^0.5.1",
+    "date-fns": "^3.3.1",
+    "tsyringe": "^4.8.0"
+  },
+  "jest": {
+    "transform": {
+      ".(ts|tsx)": "ts-jest"
+    },
+    "globals": {
+      "ts-jest": {
+        "tsconfig": {
+          "strictNullChecks": false
+        }
+      }
+    },
+    "testEnvironment": "node",
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js"
+    ],
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/test/"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "branches": 90,
+        "functions": 95,
+        "lines": 95,
+        "statements": 95
+      }
+    },
+    "collectCoverageFrom": [
+      "src/*.{js,ts}"
+    ],
+    "setupFilesAfterEnv": [
+      "jest-extended/all"
+    ]
+  },
+  "gitHead": "254a9e6fced4061de95b183ac16ba8281557bf23"
+}

package/readme.md

@@ -0,0 +1 @@
+# Data Mapping module.