@pristine-ts/data-mapping 0.0.277

package/dist/lib/esm/nodes/data-mapping.node.js

@@ -0,0 +1,198 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { DataMappingNodeTypeEnum } from "../enums/data-mapping-node-type.enum";
+import { DataMappingLeaf } from "./data-mapping.leaf";
+import { BaseDataMappingNode } from "./base-data-mapping.node";
+import { DataMappingSourcePropertyNotFoundError } from "../errors/data-mapping-source-property-not-found.error";
+import { ArrayDataMappingNodeInvalidSourcePropertyTypeError } from "../errors/array-data-mapping-node-invalid-source-property-type.error";
+export class DataMappingNode extends BaseDataMappingNode {
+    constructor(root, parent, type = DataMappingNodeTypeEnum.Node) {
+        super();
+        this.root = root;
+        this.parent = parent;
+        this.type = type;
+        /**
+         * This method specified whether it's possible that this element not be present in the `source` object.
+         */
+        this.isOptional = false;
+    }
+    /**
+     * This is a setter for `sourceProperty`.
+     * @param sourceProperty
+     */
+    setSourceProperty(sourceProperty) {
+        this.sourceProperty = sourceProperty;
+        return this;
+    }
+    /**
+     * This is a setter for `destinationProperty`.
+     * @param destinationProperty
+     */
+    setDestinationProperty(destinationProperty) {
+        this.destinationProperty = destinationProperty;
+        return this;
+    }
+    /**
+     * This is a setter for `isOptional`.
+     * @param isOptional
+     */
+    setIsOptional(isOptional) {
+        this.isOptional = isOptional;
+        return this;
+    }
+    /**
+     * 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() {
+        return new DataMappingLeaf(this.root, this);
+    }
+    /**
+     * 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() {
+        return new DataMappingNode(this.root, this);
+    }
+    /**
+     * 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() {
+        return new DataMappingLeaf(this.root, this, DataMappingNodeTypeEnum.ScalarArray);
+    }
+    /**
+     * 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() {
+        return new DataMappingNode(this.root, this, DataMappingNodeTypeEnum.ObjectArray);
+    }
+    /**
+     * This method adds this node to its parent and returns the parent.
+     */
+    end() {
+        // todo: Validate that we actually have all the properties needed (sourceProperty and destinationProperty) for example.
+        this.parent.addNode(this);
+        return this.parent;
+    }
+    /**
+     * 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, destination, normalizersMap) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (source.hasOwnProperty(this.sourceProperty) === false) {
+                if (this.isOptional) {
+                    return;
+                }
+                throw new DataMappingSourcePropertyNotFoundError("The property '" + this.sourceProperty + "' isn't found in the Source object and isn't marked as Optional. If you want to ignore this property, use the 'setIsOptional(true)' method in the builder.", this.sourceProperty);
+            }
+            const sourceElement = source[this.sourceProperty];
+            if (destination[this.destinationProperty] === undefined) {
+                if (this.type === DataMappingNodeTypeEnum.ObjectArray) {
+                    destination[this.destinationProperty] = [];
+                }
+                else {
+                    // todo: we need to get the expected Type of the `destination[this.destinationProperty]` and actually instantiate it.
+                    destination[this.destinationProperty] = {};
+                }
+            }
+            const destinationElement = destination[this.destinationProperty];
+            if (this.type === DataMappingNodeTypeEnum.ObjectArray) {
+                // This means that the source[propertyKey] contains an array of objects and each object should be mapped
+                const array = source[this.sourceProperty];
+                if (Array.isArray(array) === false) {
+                    throw new ArrayDataMappingNodeInvalidSourcePropertyTypeError(`According to your schema, the property '${this.sourceProperty}' in the source object must contain an Array of objects. Instead, it contains: '${typeof array}'.`, this.sourceProperty);
+                }
+                for (const element of array) {
+                    // todo: we need to get the expected Type of the object in the array in the Destination object
+                    const dest = {};
+                    for (const key in this.nodes) {
+                        if (this.nodes.hasOwnProperty(key) === false) {
+                            continue;
+                        }
+                        const node = this.nodes[key];
+                        yield node.map(element, dest, normalizersMap);
+                    }
+                    destinationElement.push(dest);
+                }
+                return;
+            }
+            // When the current node is not an array, we simply iterate
+            for (const key in this.nodes) {
+                if (this.nodes.hasOwnProperty(key) === false) {
+                    continue;
+                }
+                const node = this.nodes[key];
+                yield node.map(sourceElement, destinationElement, normalizersMap);
+            }
+        });
+    }
+    /**
+     * This method imports a schema.
+     *
+     * @param schema
+     */
+    import(schema) {
+        this.sourceProperty = schema.sourceProperty;
+        this.destinationProperty = schema.destinationProperty;
+        this.isOptional = schema.isOptional;
+        this.nodes = {};
+        const nodes = schema.nodes;
+        for (const key in nodes) {
+            if (nodes.hasOwnProperty(key) === false) {
+                continue;
+            }
+            const nodeInfo = nodes[key];
+            const type = nodeInfo["_type"];
+            switch (type) {
+                case DataMappingNodeTypeEnum.ScalarArray:
+                case DataMappingNodeTypeEnum.Leaf:
+                    const leaf = new DataMappingLeaf(this.root, this, type);
+                    leaf.import(nodeInfo);
+                    this.nodes[leaf.sourceProperty] = leaf;
+                    continue;
+                case DataMappingNodeTypeEnum.Node:
+                case DataMappingNodeTypeEnum.ObjectArray:
+                    const node = new DataMappingNode(this.root, this, type);
+                    node.import(nodeInfo);
+                    this.nodes[node.sourceProperty] = node;
+                    continue;
+            }
+        }
+    }
+    /**
+     * This method exports this node.
+     */
+    export() {
+        const nodes = this.nodes;
+        for (const key in nodes) {
+            if (nodes.hasOwnProperty(key) === false) {
+                continue;
+            }
+            nodes[key] = nodes[key].export();
+        }
+        return {
+            "_type": this.type,
+            "sourceProperty": this.sourceProperty,
+            "destinationProperty": this.destinationProperty,
+            "isOptional": this.isOptional,
+            "nodes": nodes,
+        };
+    }
+}
+//# sourceMappingURL=data-mapping.node.js.map

package/dist/lib/esm/nodes/data-mapping.node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-mapping.node.js","sourceRoot":"","sources":["../../../../src/nodes/data-mapping.node.ts"],"names":[],"mappings":"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"}

package/dist/lib/esm/nodes/nodes.js

@@ -0,0 +1,4 @@
+export * from "./base-data-mapping.node";
+export * from "./data-mapping.leaf";
+export * from "./data-mapping.node";
+//# sourceMappingURL=nodes.js.map

package/dist/lib/esm/nodes/nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.js","sourceRoot":"","sources":["../../../../src/nodes/nodes.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}

package/dist/lib/esm/normalizer-options/base-normalizer.options.js

@@ -0,0 +1,7 @@
+export class BaseNormalizerOptions {
+    constructor(options) {
+        var _a;
+        this.shouldThrowIfTypeIsNotString = (_a = options === null || options === void 0 ? void 0 : options.shouldThrowIfTypeIsNotString) !== null && _a !== void 0 ? _a : false;
+    }
+}
+//# sourceMappingURL=base-normalizer.options.js.map

package/dist/lib/esm/normalizer-options/base-normalizer.options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-normalizer.options.js","sourceRoot":"","sources":["../../../../src/normalizer-options/base-normalizer.options.ts"],"names":[],"mappings":"AAAA,MAAM,OAAgB,qBAAqB;IAGvC,YAAmB,OAA+B;;QAC9C,IAAI,CAAC,4BAA4B,GAAG,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,4BAA4B,mCAAI,KAAK,CAAC;IACvF,CAAC;CACJ"}

package/dist/lib/esm/normalizer-options/lowercase-normalizer.options.js

@@ -0,0 +1,7 @@
+import { BaseNormalizerOptions } from "./base-normalizer.options";
+export class LowercaseNormalizerOptions extends BaseNormalizerOptions {
+    constructor(options) {
+        super(options);
+    }
+}
+//# sourceMappingURL=lowercase-normalizer.options.js.map

package/dist/lib/esm/normalizer-options/lowercase-normalizer.options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowercase-normalizer.options.js","sourceRoot":"","sources":["../../../../src/normalizer-options/lowercase-normalizer.options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,qBAAqB,EAAC,MAAM,2BAA2B,CAAC;AAEhE,MAAM,OAAO,0BAA2B,SAAQ,qBAAqB;IACjE,YAAmB,OAAoC;QACnD,KAAK,CAAC,OAAO,CAAC,CAAC;IACnB,CAAC;CACJ"}

package/dist/lib/esm/normalizer-options/normalizer-options.js

@@ -0,0 +1,3 @@
+export * from "./base-normalizer.options";
+export * from "./lowercase-normalizer.options";
+//# sourceMappingURL=normalizer-options.js.map

package/dist/lib/esm/normalizer-options/normalizer-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizer-options.js","sourceRoot":"","sources":["../../../../src/normalizer-options/normalizer-options.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC"}

package/dist/lib/esm/normalizers/lowercase.normalizer.js

@@ -0,0 +1,30 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var LowercaseNormalizer_1;
+import { NormalizerInvalidSourceTypeError } from "../errors/normalizer-invalid-source-type.error";
+import { tag } from "@pristine-ts/common";
+import { injectable } from "tsyringe";
+let LowercaseNormalizer = LowercaseNormalizer_1 = class LowercaseNormalizer {
+    getUniqueKey() {
+        return LowercaseNormalizer_1.name;
+    }
+    normalize(source, options) {
+        if (typeof source !== "string") {
+            if (options && options.shouldThrowIfTypeIsNotString) {
+                throw new NormalizerInvalidSourceTypeError("The 'LowercaseNormalizer' expects the source value to be of type 'string'. Type '" + typeof source + "' was received.", this.getUniqueKey(), options, source, typeof source);
+            }
+            return source;
+        }
+        return source.toLowerCase();
+    }
+};
+LowercaseNormalizer = LowercaseNormalizer_1 = __decorate([
+    tag("DataNormalizerInterface"),
+    injectable()
+], LowercaseNormalizer);
+export { LowercaseNormalizer };
+//# sourceMappingURL=lowercase.normalizer.js.map

package/dist/lib/esm/normalizers/lowercase.normalizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowercase.normalizer.js","sourceRoot":"","sources":["../../../../src/normalizers/lowercase.normalizer.ts"],"names":[],"mappings":";;;;;;;AAEA,OAAO,EAAC,gCAAgC,EAAC,MAAM,gDAAgD,CAAC;AAEhG,OAAO,EAAC,GAAG,EAAC,MAAM,qBAAqB,CAAC;AACxC,OAAO,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AAI7B,IAAM,mBAAmB,2BAAzB,MAAM,mBAAmB;IAC5B,YAAY;QACR,OAAO,qBAAmB,CAAC,IAAI,CAAC;IACpC,CAAC;IAED,SAAS,CAAC,MAAW,EAAE,OAAoC;QACvD,IAAG,OAAO,MAAM,KAAK,QAAQ,EAAE;YAC3B,IAAG,OAAO,IAAI,OAAO,CAAC,4BAA4B,EAAE;gBAChD,MAAM,IAAI,gCAAgC,CAAC,mFAAmF,GAAG,OAAO,MAAM,GAAE,iBAAiB,EAAE,IAAI,CAAC,YAAY,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,MAAM,CAAC,CAAA;aAC1N;YAED,OAAO,MAAM,CAAC;SACjB;QAED,OAAO,MAAM,CAAC,WAAW,EAAE,CAAC;IAChC,CAAC;CACJ,CAAA;AAhBY,mBAAmB;IAF/B,GAAG,CAAC,yBAAyB,CAAC;IAC9B,UAAU,EAAE;GACA,mBAAmB,CAgB/B"}

package/dist/lib/esm/normalizers/normalizers.js

@@ -0,0 +1,2 @@
+export * from "./lowercase.normalizer";
+//# sourceMappingURL=normalizers.js.map

package/dist/lib/esm/normalizers/normalizers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizers.js","sourceRoot":"","sources":["../../../../src/normalizers/normalizers.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/dist/lib/esm/types/data-mapping-interceptor-unique-key.type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data-mapping-interceptor-unique-key.type.js.map

package/dist/lib/esm/types/data-mapping-interceptor-unique-key.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-mapping-interceptor-unique-key.type.js","sourceRoot":"","sources":["../../../../src/types/data-mapping-interceptor-unique-key.type.ts"],"names":[],"mappings":""}

package/dist/lib/esm/types/data-normalizer-unique-key.type.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data-normalizer-unique-key.type.js.map

package/dist/lib/esm/types/data-normalizer-unique-key.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-normalizer-unique-key.type.js","sourceRoot":"","sources":["../../../../src/types/data-normalizer-unique-key.type.ts"],"names":[],"mappings":""}

package/dist/lib/esm/types/types.js

@@ -0,0 +1,3 @@
+export * from "./data-normalizer-unique-key.type";
+export * from "./data-mapping-interceptor-unique-key.type";
+//# sourceMappingURL=types.js.map

package/dist/lib/esm/types/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/types/types.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,4CAA4C,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./data-mapping.builder";

package/dist/types/builders/data-mapping.builder.d.ts

@@ -0,0 +1,110 @@
+import { DataMappingNode } from "../nodes/data-mapping.node";
+import { DataNormalizerUniqueKey } from "../types/data-normalizer-unique-key.type";
+import { DataMappingInterceptorUniqueKeyType } from "../types/data-mapping-interceptor-unique-key.type";
+import { DataMappingLeaf } from "../nodes/data-mapping.leaf";
+import { BaseDataMappingNode } from "../nodes/base-data-mapping.node";
+export declare class DataMappingBuilder extends BaseDataMappingNode {
+    normalizers: {
+        key: DataNormalizerUniqueKey;
+        options: any;
+    }[];
+    beforeMappingInterceptors: {
+        key: DataMappingInterceptorUniqueKeyType;
+        options: any;
+    }[];
+    afterMappingInterceptors: {
+        key: DataMappingInterceptorUniqueKeyType;
+        options: any;
+    }[];
+    /**
+     * This method adds a normalizer to the root that will be applied on each node (unless they explicitly exclude to do
+     * so).
+     *
+     * @param normalizerUniqueKey
+     * @param options
+     */
+    addNormalizer(normalizerUniqueKey: DataNormalizerUniqueKey, options?: any): DataMappingBuilder;
+    /**
+     * This method returns whether there's a normalizer for the specified key or not.
+     *
+     * @param normalizerUniqueKey
+     */
+    hasNormalizer(normalizerUniqueKey: DataNormalizerUniqueKey): boolean;
+    /**
+     * This method adds an interceptor that will be executed **before** the object is mapped.
+     *
+     * @param key
+     * @param options
+     */
+    addBeforeMappingInterceptor(key: DataMappingInterceptorUniqueKeyType, options?: any): DataMappingBuilder;
+    /**
+     * This method returns whether a **before** interceptor already exists.
+     * @param key
+     */
+    hasBeforeMappingInterceptor(key: DataMappingInterceptorUniqueKeyType): boolean;
+    /**
+     * This method adds an interceptor that will be executed **after** the object is mapped.
+     *
+     * @param key
+     * @param options
+     */
+    addAfterMappingInterceptor(key: DataMappingInterceptorUniqueKeyType, options?: any): DataMappingBuilder;
+    /**
+     * This method returns whether a **after** interceptor already exists.
+     * @param key
+     */
+    hasAfterMappingInterceptor(key: DataMappingInterceptorUniqueKeyType): boolean;
+    /**
+     * 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 is called at the end just to make it nice since all the nodes will have one, it's nice
+     * that the builder has one too.
+     */
+    end(): DataMappingBuilder;
+    /**
+     * This method imports a schema.
+     *
+     * @param schema
+     */
+    import(schema: any): void;
+    /**
+     * This method exports this node.
+     */
+    export(): {
+        nodes: {
+            [x: string]: DataMappingLeaf | DataMappingNode;
+        };
+        normalizers: {
+            key: string;
+            options: any;
+        }[];
+        beforeMappingInterceptors: {
+            key: string;
+            options: any;
+        }[];
+        afterMappingInterceptors: {
+            key: string;
+            options: any;
+        }[];
+    };
+}

package/dist/types/data-mapping.module.d.ts

@@ -0,0 +1,12 @@
+import { ModuleInterface } from "@pristine-ts/common";
+export * from "./builders/builders";
+export * from "./enums/enums";
+export * from "./errors/errors";
+export * from "./interceptors/interceptors";
+export * from "./interfaces/interfaces";
+export * from "./mappers/mappers";
+export * from "./nodes/nodes";
+export * from "./normalizer-options/normalizer-options";
+export * from "./normalizers/normalizers";
+export * from "./types/types";
+export declare const DataMappingModule: ModuleInterface;

package/dist/types/data-mapping.module.keyname.d.ts

@@ -0,0 +1 @@
+export declare const DataMappingModuleKeyname: string;

package/dist/types/enums/data-mapping-node-type.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum DataMappingNodeTypeEnum {
+    ScalarArray = "DATA_MAPPING_NODE_SCALAR_ARRAY",
+    ObjectArray = "DATA_MAPPING_NODE_OBJECT_ARRAY",
+    Node = "DATA_MAPPING_NODE",
+    Leaf = "DATA_MAPPING_LEAF"
+}

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

@@ -0,0 +1 @@
+export * from "./data-mapping-node-type.enum";

package/dist/types/errors/array-data-mapping-node-invalid-source-property-type.error.d.ts

@@ -0,0 +1,7 @@
+import { LoggableError } from "@pristine-ts/common";
+/**
+ * This Error is thrown when a node is of type array but the `source[sourceProperty]` doesn't actually contain an array.
+ */
+export declare class ArrayDataMappingNodeInvalidSourcePropertyTypeError extends LoggableError {
+    constructor(message: string, sourceProperty: string);
+}

package/dist/types/errors/data-after-mapping-interceptor-already-added.error.d.ts

@@ -0,0 +1,8 @@
+import { LoggableError } from "@pristine-ts/common";
+import { DataMappingInterceptorUniqueKeyType } from "../types/data-mapping-interceptor-unique-key.type";
+/**
+ * This Error is thrown when the before row interceptor is added more than once to the builder.
+ */
+export declare class DataAfterMappingInterceptorAlreadyAddedError extends LoggableError {
+    constructor(message: string, uniqueKey: DataMappingInterceptorUniqueKeyType, options?: any);
+}

package/dist/types/errors/data-before-mapping-interceptor-already-added.error.d.ts

@@ -0,0 +1,8 @@
+import { LoggableError } from "@pristine-ts/common";
+import { DataMappingInterceptorUniqueKeyType } from "../types/data-mapping-interceptor-unique-key.type";
+/**
+ * This Error is thrown when the after row interceptor is added more than once to the builder.
+ */
+export declare class DataBeforeMappingInterceptorAlreadyAddedError extends LoggableError {
+    constructor(message: string, uniqueKey: DataMappingInterceptorUniqueKeyType, options?: any);
+}

package/dist/types/errors/data-mapping-interceptor-not-found.error.d.ts

@@ -0,0 +1,8 @@
+import { LoggableError } from "@pristine-ts/common";
+import { DataMappingInterceptorUniqueKeyType } from "../types/data-mapping-interceptor-unique-key.type";
+/**
+ * This Error is thrown if the Data Transformer Class is not found in the list of available interceptors. It might be missing a tag.
+ */
+export declare class DataMappingInterceptorNotFoundError extends LoggableError {
+    constructor(message: string, uniqueKey: DataMappingInterceptorUniqueKeyType, options?: any);
+}

package/dist/types/errors/data-mapping-source-property-not-found.error.d.ts

@@ -0,0 +1,7 @@
+import { LoggableError } from "@pristine-ts/common";
+/**
+ * This Error is thrown when a property isn't optional and should be found in the source object.
+ */
+export declare class DataMappingSourcePropertyNotFoundError extends LoggableError {
+    constructor(message: string, sourceProperty: string);
+}

package/dist/types/errors/data-normalizer-already-added.error.d.ts

@@ -0,0 +1,7 @@
+import { LoggableError } from "@pristine-ts/common";
+/**
+ * This Error is thrown when a normalizer is added more than once.
+ */
+export declare class DataNormalizerAlreadyAdded extends LoggableError {
+    constructor(message: string, normalizerUniqueKey: string, options?: any);
+}

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

@@ -0,0 +1,8 @@
+export * from "./array-data-mapping-node-invalid-source-property-type.error";
+export * from "./data-after-mapping-interceptor-already-added.error";
+export * from "./data-before-mapping-interceptor-already-added.error";
+export * from "./data-normalizer-already-added.error";
+export * from "./data-mapping-interceptor-not-found.error";
+export * from "./data-mapping-source-property-not-found.error";
+export * from "./normalizer-invalid-source-type.error";
+export * from "./undefined-source-property.error";

package/dist/types/errors/normalizer-invalid-source-type.error.d.ts

@@ -0,0 +1,7 @@
+import { LoggableError } from "@pristine-ts/common";
+/**
+ * This Error is thrown when an invalid source type is passed to the source type while the normalizer expects another type.
+ */
+export declare class NormalizerInvalidSourceTypeError extends LoggableError {
+    constructor(message: string, normalizerUniqueKey: string, options: any, source: any, sourceType: any);
+}

package/dist/types/errors/undefined-source-property.error.d.ts

@@ -0,0 +1,9 @@
+import { LoggableError } from "@pristine-ts/common";
+import { DataMappingLeaf } from "../nodes/data-mapping.leaf";
+import { DataMappingNode } from "../nodes/data-mapping.node";
+/**
+ * This Error is thrown when you are trying to add a Node which has an undefined sourceProperty value.
+ */
+export declare class UndefinedSourcePropertyError extends LoggableError {
+    constructor(node: DataMappingLeaf | DataMappingNode);
+}

package/dist/types/interceptors/default-data-mapping.interceptor.d.ts

@@ -0,0 +1,7 @@
+import { DataMappingInterceptorInterface } from "../interfaces/data-mapping-interceptor.interface";
+import { DataMappingInterceptorUniqueKeyType } from "../types/data-mapping-interceptor-unique-key.type";
+export declare class DefaultDataMappingInterceptor implements DataMappingInterceptorInterface {
+    afterMapping(row: any): Promise<any>;
+    beforeMapping(row: any): Promise<any>;
+    getUniqueKey(): DataMappingInterceptorUniqueKeyType;
+}

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

@@ -0,0 +1 @@
+export * from "./default-data-mapping.interceptor";

package/dist/types/interfaces/data-mapping-interceptor.interface.d.ts

@@ -0,0 +1,19 @@
+import { DataMappingInterceptorUniqueKeyType } from "../types/data-mapping-interceptor-unique-key.type";
+export interface DataMappingInterceptorInterface {
+    /**
+     * Every data mapping interceptor must define a unique key. Then, during the mapping, the schema can specify which
+     * interceptors must be called.
+     */
+    getUniqueKey(): DataMappingInterceptorUniqueKeyType;
+    /**
+     * This method is called before the row is being mapped and normalized. It allows you to combine fields for example if that's what you want.
+     * @param row
+     */
+    beforeMapping(row: any): Promise<any>;
+    /**
+     * This method is called after the row is being mapped and normalized. It can allow you to apply operations on each
+     * field or combine fields for example.
+     * @param row
+     */
+    afterMapping(row: any): Promise<any>;
+}

package/dist/types/interfaces/data-normalizer.interface.d.ts

@@ -0,0 +1,15 @@
+import { DataNormalizerUniqueKey } from "../types/data-normalizer-unique-key.type";
+export interface DataNormalizerInterface<T, R> {
+    /**
+     * Every data normalizer must define a unique key. Then, during the transformation, the schema can specify which
+     * normalizer it must use. Using the unique key, we can quickly (in O(1)) retrieve the normalizer.
+     */
+    getUniqueKey(): DataNormalizerUniqueKey;
+    /**
+     * This method takes the source property value, can receive options to control the behaviour (example, you might
+     * want to specify a number of significant digits or a data format) and returns the normalized value.
+     * @param source
+     * @param options
+     */
+    normalize(source: any, options?: R): T;
+}

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

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

package/dist/types/mappers/data.mapper.d.ts

@@ -0,0 +1,28 @@
+import { DataNormalizerInterface } from "../interfaces/data-normalizer.interface";
+import { DataMappingInterceptorInterface } from "../interfaces/data-mapping-interceptor.interface";
+import { DataMappingBuilder } from "../builders/data-mapping.builder";
+import { ClassConstructor } from "class-transformer";
+export declare class DataMapper {
+    private readonly dataNormalizers;
+    private readonly dataTransformerInterceptors;
+    private readonly dataNormalizersMap;
+    private readonly dataTransformerInterceptorsMap;
+    constructor(dataNormalizers: DataNormalizerInterface<any, any>[], dataTransformerInterceptors: DataMappingInterceptorInterface[]);
+    /**
+     * This method takes an array of source and maps each item.
+     *
+     * @param builder
+     * @param source
+     * @param destinationType
+     */
+    mapAll(builder: DataMappingBuilder, source: any[], destinationType?: ClassConstructor<any>): Promise<any[]>;
+    /**
+     * This method takes a builder, a source and maps it according to the builder. You can pass a `destinationType (optional)`
+     * that is an object that will be constructed.
+     *
+     * @param builder
+     * @param source
+     * @param destinationType
+     */
+    map(builder: DataMappingBuilder, source: any, destinationType?: ClassConstructor<any>): Promise<any>;
+}

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

@@ -0,0 +1 @@
+export * from "./data.mapper";