@pristine-ts/data-mapping 0.0.277

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

@@ -0,0 +1,15 @@
+import { DataMappingNode } from "./data-mapping.node";
+import { DataMappingLeaf } from "./data-mapping.leaf";
+export declare abstract class BaseDataMappingNode {
+    nodes: {
+        [sourceProperty in string]: DataMappingNode | DataMappingLeaf;
+    };
+    /**
+     * This method is called by the node itself to tell its parent that it has been build and is ready to be added.
+     * We use this mechanism to force the `end()` method on the leaf to be called so we can do some validations before
+     * adding it to the tree.
+     *
+     * @param node
+     */
+    addNode(node: DataMappingLeaf | DataMappingNode): void;
+}

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,94 @@
+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";
+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;
+    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 `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?: BaseNormalizerOptions);
+}

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?: LowercaseNormalizerOptions);
+}

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

@@ -0,0 +1,2 @@
+export * from "./base-normalizer.options";
+export * from "./lowercase-normalizer.options";

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 @@
+export * from "./lowercase.normalizer";

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,68 @@
+{
+  "name": "@pristine-ts/data-mapping",
+  "version": "0.0.277",
+  "description": "",
+  "module": "dist/lib/esm/data-mapping.module.js",
+  "main": "dist/lib/cjs/data-mapping.module.js",
+  "types": "dist/types/data-mapping.module.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.22",
+    "@pristine-ts/common": "^0.0.277",
+    "@pristine-ts/logging": "^0.0.277",
+    "@pristine-ts/metadata": "~1.0.2",
+    "class-transformer": "^0.5.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": "8282d5272a93ffb4fb7e35c6ce7a36dbab5da5b2"
+}

package/readme.md

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