@xcrap/transformer 0.0.1 → 0.0.4

package/dist/index.d.ts

@@ -2,15 +2,21 @@ export * from "./transforming-model";
 export * from "./transformer";
 export * from "./transformers";
 export * from "./validators";
+export type Data = {
+    local: Record<string, any>;
+    root: Record<string, any>;
+};
 export type SkipFunction = () => void;
 export type TransformOptions<T, R> = {
     key: string;
+    scope?: keyof Data;
     transformer: (value: T) => R | Promise<R>;
     condition?: (value: T) => boolean | Promise<boolean>;
 };
-export declare function transform<T extends any, R extends any>({ key, transformer, condition }: TransformOptions<T, R>): (data: Record<string, any>, skip: SkipFunction) => Promise<void | R>;
+export declare function transform<T extends any, R extends any>({ key, scope, transformer, condition }: TransformOptions<T, R>): (data: Data, skip: SkipFunction) => Promise<void | R>;
 export type GetOptions<T> = {
     key: string;
+    scope?: keyof Data;
     condition?: (value: T) => boolean | Promise<boolean>;
 };
-export declare function get<T extends any>({ key, condition }: GetOptions<T>): (data: Record<string, any>, skip: SkipFunction) => Promise<void | T>;
+export declare function get<T extends any>({ key, scope, condition }: GetOptions<T>): (data: Data, skip: SkipFunction) => Promise<void | T>;

package/dist/index.js

@@ -20,9 +20,10 @@ __exportStar(require("./transforming-model"), exports);
 __exportStar(require("./transformer"), exports);
 __exportStar(require("./transformers"), exports);
 __exportStar(require("./validators"), exports);
-function transform({ key, transformer, condition }) {
+function transform({ key, scope = "local", transformer, condition }) {
     return async (data, skip) => {
-        const value = data[key];
+        const scopedData = data[scope];
+        const value = scopedData[key];
         const isValid = condition ? await condition(value) : true;
         if (!isValid) {
             return skip();
@@ -31,9 +32,10 @@ function transform({ key, transformer, condition }) {
         return transformedValue;
     };
 }
-function get({ key, condition }) {
+function get({ key, scope = "local", condition }) {
     return async (data, skip) => {
-        const value = data[key];
+        const scopedData = data[scope];
+        const value = scopedData[key];
         const isValid = condition ? await condition(value) : true;
         if (!isValid) {
             return skip();

package/dist/transforming-model.d.ts

@@ -1,5 +1,5 @@
-import { SkipFunction } from ".";
-export type TransformerFunction = (data: Record<string, any>, skip: SkipFunction) => any | Promise<any>;
+import { Data, SkipFunction } from ".";
+export type TransformerFunction = (data: Data, skip: SkipFunction) => any | Promise<any>;
 export type TransformationModelShapeValueBase = TransformerFunction[];
 export type TransformationModelShapeNestedValue = {
     multiple?: boolean;
@@ -17,8 +17,8 @@ export declare class TransformingModel {
     private readonly fieldsToDelete;
     private readonly fieldsToAppend;
     constructor(shape: TransformingModelShape);
-    transform(data: Record<string, any>): Promise<Record<string, any>>;
-    transformValueBase(value: TransformationModelShapeValueBase, key: string, data: any): Promise<any>;
-    transformNestedValue(value: TransformationModelShapeNestedValue, data: any): Promise<any[] | Record<string, any>>;
+    transform(data: Record<string, any>, rootData?: Record<string, any>): Promise<Record<string, any>>;
+    transformValueBase(value: TransformationModelShapeValueBase, targetKey: string, data: Data): Promise<any>;
+    transformNestedValue(value: TransformationModelShapeNestedValue, localData: Record<string, any> | Record<string, any>[], rootData: Record<string, any>): Promise<Record<string, any> | Record<string, any>[]>;
     after({ delete: delete_, append }: TransformingModelAfterOptions): this;
 }

package/dist/transforming-model.js

@@ -7,48 +7,59 @@ class TransformingModel {
         this.fieldsToDelete = [];
         this.fieldsToAppend = {};
     }
-    async transform(data) {
-        const result = { ...data };
+    async transform(data, rootData) {
+        const internalData = {
+            local: { ...data },
+            root: rootData || { ...data }
+        };
         for (const key in this.shape) {
             const value = this.shape[key];
             if (Array.isArray(value)) {
-                result[key] = await this.transformValueBase(value, key, result);
+                internalData.local[key] = await this.transformValueBase(value, key, internalData);
             }
             else {
-                result[key] = await this.transformNestedValue(value, result);
+                internalData.local[key] = await this.transformNestedValue(value, internalData.local, internalData.root);
             }
         }
         for (const field of this.fieldsToDelete) {
-            delete result[field];
+            delete internalData.local[field];
         }
         for (const [key, value] of Object.entries(this.fieldsToAppend)) {
-            result[key] = value;
+            internalData.local[key] = value;
         }
-        return result;
+        return internalData.local;
     }
-    async transformValueBase(value, key, data) {
-        let result = data[key];
+    async transformValueBase(value, targetKey, data) {
+        let currentTransformedValue = data.local[targetKey];
         for (const transformer of value) {
-            let skiped = false;
+            let skipped = false;
             const skip = () => {
-                skiped = true;
+                skipped = true;
             };
-            let tempResult = await transformer({
-                ...data,
-                [key]: result
-            }, skip);
-            if (!skiped) {
-                result = tempResult;
+            const originalValueForThisIteration = currentTransformedValue;
+            const inputForTransformer = {
+                local: {
+                    ...data.local,
+                    [targetKey]: originalValueForThisIteration
+                },
+                root: data.root
+            };
+            let tempResult = await transformer(inputForTransformer, skip);
+            if (!skipped) {
+                currentTransformedValue = tempResult;
             }
         }
-        return result;
+        return currentTransformedValue;
     }
-    async transformNestedValue(value, data) {
+    async transformNestedValue(value, localData, rootData) {
         if (value.multiple) {
-            return await Promise.all(data.map(value.model.transform.bind(this)));
+            if (!Array.isArray(localData)) {
+                throw new Error("Input data for a 'multiple' nested model must be an array.");
+            }
+            return await Promise.all(localData.map((item) => value.model.transform(item, rootData)));
         }
         else {
-            return await value.model.transform(data);
+            return await value.model.transform({}, rootData);
         }
     }
     after({ delete: delete_, append }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xcrap/transformer",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "description": "Xcrap Transformer is the data transformation package extracted from the Web Scraping framework Xcrap.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",