@contrail/transform-data 1.3.0-alpha.0 → 1.3.0-alpha.2

package/.claude/settings.local.json

@@ -1,8 +1,5 @@
 {
   "permissions": {
-    "allow": [
-      "Bash(npx jest --no-coverage)",
-      "Bash(git checkout:*)"
-    ]
+    "allow": ["Bash(npx jest --no-coverage)", "Bash(git checkout:*)"]
   }
 }

package/lib/common/index.d.ts

@@ -0,0 +1 @@
+export * from './object-path-util';

package/lib/common/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./object-path-util"), exports);

package/lib/common/object-path-util.d.ts

@@ -0,0 +1,24 @@
+export declare class ObjectPathUtil {
+    static parseKeyParts(key: string, nestedDelimiter: string | undefined): string[];
+    static getValueAtPath({ obj, pathParts, nestedDelimiter, }: {
+        obj: Record<string, unknown>;
+        pathParts: string[];
+        nestedDelimiter: string | undefined;
+    }): {
+        value: unknown;
+        isExistingPath: boolean;
+    };
+    static setValueAtPath({ obj, pathParts, value, options, }: {
+        obj: Record<string, unknown>;
+        pathParts: string[];
+        value: unknown;
+        options: {
+            shouldOverwrite: boolean;
+        };
+    }): void;
+    private static expandArraySegments;
+    static isArrayIndexPart(part: string): boolean;
+    static getArrayIndex(part: string): number;
+    private static ensureArrayFilledTo;
+    static traversePath(obj: any, parts: string[]): any;
+}

package/lib/common/object-path-util.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectPathUtil = void 0;
+class ObjectPathUtil {
+    static parseKeyParts(key, nestedDelimiter) {
+        if (!nestedDelimiter || !key.includes(nestedDelimiter)) {
+            return ObjectPathUtil.expandArraySegments(key);
+        }
+        const parts = key.split(nestedDelimiter);
+        const expanded = [];
+        for (const part of parts) {
+            expanded.push(...ObjectPathUtil.expandArraySegments(part));
+        }
+        return expanded;
+    }
+    static getValueAtPath({ obj, pathParts, nestedDelimiter, }) {
+        if (!nestedDelimiter || pathParts.length === 1) {
+            const propertyKey = pathParts[0];
+            return { value: obj[propertyKey], isExistingPath: obj.hasOwnProperty(propertyKey) };
+        }
+        let current = obj;
+        for (const key of pathParts) {
+            const isPathBroken = current == null || typeof current !== 'object';
+            if (isPathBroken) {
+                return { value: undefined, isExistingPath: false };
+            }
+            const isArrayIndex = ObjectPathUtil.isArrayIndexPart(key);
+            if (isArrayIndex) {
+                const idx = ObjectPathUtil.getArrayIndex(key);
+                const isIndexOutOfBounds = !Array.isArray(current) || idx >= current.length;
+                if (isIndexOutOfBounds) {
+                    return { value: undefined, isExistingPath: false };
+                }
+                current = current[idx];
+                continue;
+            }
+            const isPropertyMissing = !Object.prototype.hasOwnProperty.call(current, key);
+            if (isPropertyMissing) {
+                return { value: undefined, isExistingPath: false };
+            }
+            current = current[key];
+        }
+        return { value: current, isExistingPath: true };
+    }
+    static setValueAtPath({ obj, pathParts, value, options, }) {
+        let current = obj;
+        let pathHasArrayIndex = false;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            const key = pathParts[i];
+            const isCurrentPartArrayIndex = ObjectPathUtil.isArrayIndexPart(key);
+            if (isCurrentPartArrayIndex) {
+                pathHasArrayIndex = true;
+                const idx = ObjectPathUtil.getArrayIndex(key);
+                ObjectPathUtil.ensureArrayFilledTo(current, idx);
+                current = current[idx];
+                continue;
+            }
+            const isNextPartArrayIndex = ObjectPathUtil.isArrayIndexPart(pathParts[i + 1]);
+            const needsInitialization = current[key] == null || typeof current[key] !== 'object';
+            const needsArrayConversion = isNextPartArrayIndex && !Array.isArray(current[key]);
+            if (needsInitialization || needsArrayConversion) {
+                current[key] = isNextPartArrayIndex ? [] : {};
+            }
+            current = current[key];
+        }
+        const finalKey = pathParts[pathParts.length - 1];
+        const isFinalKeyArrayIndex = ObjectPathUtil.isArrayIndexPart(finalKey);
+        if (isFinalKeyArrayIndex) {
+            const idx = ObjectPathUtil.getArrayIndex(finalKey);
+            ObjectPathUtil.ensureArrayFilledTo(current, idx);
+            current[idx] = value;
+            return;
+        }
+        const shouldWriteProperty = pathHasArrayIndex || !Object.prototype.hasOwnProperty.call(current, finalKey);
+        if (shouldWriteProperty || options.shouldOverwrite) {
+            current[finalKey] = value;
+        }
+    }
+    static expandArraySegments(segment) {
+        const results = [];
+        const regex = /\[(\d+)\]/g;
+        let lastIndex = 0;
+        let match;
+        while ((match = regex.exec(segment)) !== null) {
+            if (match.index > lastIndex) {
+                results.push(segment.slice(lastIndex, match.index));
+            }
+            results.push(`[${match[1]}]`);
+            lastIndex = regex.lastIndex;
+        }
+        if (lastIndex === 0) {
+            return [segment];
+        }
+        if (lastIndex < segment.length) {
+            results.push(segment.slice(lastIndex));
+        }
+        return results;
+    }
+    static isArrayIndexPart(part) {
+        return /^\[\d+\]$/.test(part);
+    }
+    static getArrayIndex(part) {
+        return parseInt(part.slice(1, -1), 10);
+    }
+    static ensureArrayFilledTo(arr, index) {
+        while (arr.length <= index) {
+            arr.push({});
+        }
+    }
+    static traversePath(obj, parts) {
+        let current = obj;
+        for (const part of parts) {
+            const isPathBroken = current == null || typeof current !== 'object';
+            if (isPathBroken) {
+                return null;
+            }
+            const isArrayIndex = ObjectPathUtil.isArrayIndexPart(part);
+            if (isArrayIndex) {
+                const idx = ObjectPathUtil.getArrayIndex(part);
+                const isIndexOutOfBounds = !Array.isArray(current) || idx >= current.length;
+                if (isIndexOutOfBounds) {
+                    return null;
+                }
+                current = current[idx];
+                continue;
+            }
+            const isPropertyMissing = !(part in current);
+            if (isPropertyMissing) {
+                return null;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+}
+exports.ObjectPathUtil = ObjectPathUtil;

package/lib/index.d.ts

@@ -5,3 +5,4 @@ export * from './processor';
 export * from './rekey';
 export * from './remove';
 export * from './value-function';
+export * from './common';

package/lib/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./processor"), exports);
 __exportStar(require("./rekey"), exports);
 __exportStar(require("./remove"), exports);
 __exportStar(require("./value-function"), exports);
+__exportStar(require("./common"), exports);

package/lib/rekey/rekey-transformer.d.ts

@@ -1,12 +1,4 @@
 export declare class RekeyTransformer {
     static transformData(csvJSON: any[], federatedMappings: Record<string, string>, deleteOldKey?: boolean, rekeyKeepMissingValues?: boolean, nestedDelimiter?: string | undefined): void;
     static transformObject(row: any, federatedMappings: Record<string, string>, deleteOldKey?: boolean, rekeyKeepMissingValues?: boolean, nestedDelimiter?: string | undefined): void;
-    private static parseKeyParts;
-    private static setValueAtPath;
-    private static getValueAtPath;
-    private static expandArraySegments;
-    private static isArrayIndexPart;
-    private static getArrayIndex;
-    private static ensureArrayFilledTo;
-    private static traversePath;
 }

package/lib/rekey/rekey-transformer.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RekeyTransformer = void 0;
+const object_path_util_1 = require("../common/object-path-util");
 class RekeyTransformer {
     static transformData(csvJSON, federatedMappings, deleteOldKey = false, rekeyKeepMissingValues = false, nestedDelimiter = undefined) {
         for (const row of csvJSON) {
@@ -9,37 +10,47 @@ class RekeyTransformer {
     }
     static transformObject(row, federatedMappings, deleteOldKey = false, rekeyKeepMissingValues = false, nestedDelimiter = undefined) {
         for (const [newKey, oldKey] of Object.entries(federatedMappings)) {
-            const newKeyParts = RekeyTransformer.parseKeyParts(newKey, nestedDelimiter);
-            const oldKeyParts = RekeyTransformer.parseKeyParts(oldKey, nestedDelimiter);
-            const { value: oldValue, isExistingPath: doesOldKeyExist } = RekeyTransformer.getValueAtPath({
+            const newKeyParts = object_path_util_1.ObjectPathUtil.parseKeyParts(newKey, nestedDelimiter);
+            const oldKeyParts = object_path_util_1.ObjectPathUtil.parseKeyParts(oldKey, nestedDelimiter);
+            const { value: oldValue, isExistingPath: doesOldKeyExist } = object_path_util_1.ObjectPathUtil.getValueAtPath({
                 obj: row,
                 pathParts: oldKeyParts,
                 nestedDelimiter,
             });
             if (doesOldKeyExist) {
-                RekeyTransformer.setValueAtPath({ obj: row, pathParts: newKeyParts, value: oldValue });
+                object_path_util_1.ObjectPathUtil.setValueAtPath({
+                    obj: row,
+                    pathParts: newKeyParts,
+                    value: oldValue,
+                    options: { shouldOverwrite: false },
+                });
             }
             else if (rekeyKeepMissingValues) {
-                RekeyTransformer.setValueAtPath({ obj: row, pathParts: newKeyParts, value: undefined });
+                object_path_util_1.ObjectPathUtil.setValueAtPath({
+                    obj: row,
+                    pathParts: newKeyParts,
+                    value: undefined,
+                    options: { shouldOverwrite: false },
+                });
             }
         }
         if (deleteOldKey) {
             for (const oldKey of Object.values(federatedMappings)) {
-                const oldKeyParts = RekeyTransformer.parseKeyParts(oldKey, nestedDelimiter);
+                const oldKeyParts = object_path_util_1.ObjectPathUtil.parseKeyParts(oldKey, nestedDelimiter);
                 const isNestedPath = oldKeyParts.length > 1;
                 if (!isNestedPath) {
                     delete row[oldKey];
                     continue;
                 }
-                let current = RekeyTransformer.traversePath(row, oldKeyParts.slice(0, -1));
+                let current = object_path_util_1.ObjectPathUtil.traversePath(row, oldKeyParts.slice(0, -1));
                 const isPathNonExistent = current == null || typeof current !== 'object';
                 if (isPathNonExistent) {
                     continue;
                 }
                 const finalPart = oldKeyParts[oldKeyParts.length - 1];
-                const isFinalPartArrayIndex = RekeyTransformer.isArrayIndexPart(finalPart);
+                const isFinalPartArrayIndex = object_path_util_1.ObjectPathUtil.isArrayIndexPart(finalPart);
                 if (isFinalPartArrayIndex) {
-                    const idx = RekeyTransformer.getArrayIndex(finalPart);
+                    const idx = object_path_util_1.ObjectPathUtil.getArrayIndex(finalPart);
                     if (Array.isArray(current) && idx < current.length) {
                         current[idx] = undefined;
                     }
@@ -51,135 +62,5 @@ class RekeyTransformer {
             }
         }
     }
-    static parseKeyParts(key, nestedDelimiter) {
-        if (!nestedDelimiter || !key.includes(nestedDelimiter)) {
-            return RekeyTransformer.expandArraySegments(key);
-        }
-        const parts = key.split(nestedDelimiter);
-        const expanded = [];
-        for (const part of parts) {
-            expanded.push(...RekeyTransformer.expandArraySegments(part));
-        }
-        return expanded;
-    }
-    static setValueAtPath({ obj, pathParts, value, }) {
-        let current = obj;
-        let pathHasArrayIndex = false;
-        for (let i = 0; i < pathParts.length - 1; i++) {
-            const key = pathParts[i];
-            const isCurrentPartArrayIndex = RekeyTransformer.isArrayIndexPart(key);
-            if (isCurrentPartArrayIndex) {
-                pathHasArrayIndex = true;
-                const idx = RekeyTransformer.getArrayIndex(key);
-                RekeyTransformer.ensureArrayFilledTo(current, idx);
-                current = current[idx];
-                continue;
-            }
-            const isNextPartArrayIndex = RekeyTransformer.isArrayIndexPart(pathParts[i + 1]);
-            const needsInitialization = current[key] == null || typeof current[key] !== 'object';
-            const needsArrayConversion = isNextPartArrayIndex && !Array.isArray(current[key]);
-            if (needsInitialization || needsArrayConversion) {
-                current[key] = isNextPartArrayIndex ? [] : {};
-            }
-            current = current[key];
-        }
-        const finalKey = pathParts[pathParts.length - 1];
-        const isFinalKeyArrayIndex = RekeyTransformer.isArrayIndexPart(finalKey);
-        if (isFinalKeyArrayIndex) {
-            const idx = RekeyTransformer.getArrayIndex(finalKey);
-            RekeyTransformer.ensureArrayFilledTo(current, idx);
-            current[idx] = value;
-            return;
-        }
-        const shouldWriteProperty = pathHasArrayIndex || !Object.prototype.hasOwnProperty.call(current, finalKey);
-        if (shouldWriteProperty) {
-            current[finalKey] = value;
-        }
-    }
-    static getValueAtPath({ obj, pathParts, nestedDelimiter, }) {
-        if (!nestedDelimiter || pathParts.length === 1) {
-            const propertyKey = pathParts[0];
-            return { value: obj[propertyKey], isExistingPath: obj.hasOwnProperty(propertyKey) };
-        }
-        let current = obj;
-        for (const key of pathParts) {
-            const isPathBroken = current == null || typeof current !== 'object';
-            if (isPathBroken) {
-                return { value: undefined, isExistingPath: false };
-            }
-            const isArrayIndex = RekeyTransformer.isArrayIndexPart(key);
-            if (isArrayIndex) {
-                const idx = RekeyTransformer.getArrayIndex(key);
-                const isIndexOutOfBounds = !Array.isArray(current) || idx >= current.length;
-                if (isIndexOutOfBounds) {
-                    return { value: undefined, isExistingPath: false };
-                }
-                current = current[idx];
-                continue;
-            }
-            const isPropertyMissing = !Object.prototype.hasOwnProperty.call(current, key);
-            if (isPropertyMissing) {
-                return { value: undefined, isExistingPath: false };
-            }
-            current = current[key];
-        }
-        return { value: current, isExistingPath: true };
-    }
-    static expandArraySegments(segment) {
-        const results = [];
-        const regex = /\[(\d+)\]/g;
-        let lastIndex = 0;
-        let match;
-        while ((match = regex.exec(segment)) !== null) {
-            if (match.index > lastIndex) {
-                results.push(segment.slice(lastIndex, match.index));
-            }
-            results.push(`[${match[1]}]`);
-            lastIndex = regex.lastIndex;
-        }
-        if (lastIndex === 0) {
-            return [segment];
-        }
-        if (lastIndex < segment.length) {
-            results.push(segment.slice(lastIndex));
-        }
-        return results;
-    }
-    static isArrayIndexPart(part) {
-        return /^\[\d+\]$/.test(part);
-    }
-    static getArrayIndex(part) {
-        return parseInt(part.slice(1, -1), 10);
-    }
-    static ensureArrayFilledTo(arr, index) {
-        while (arr.length <= index) {
-            arr.push({});
-        }
-    }
-    static traversePath(obj, parts) {
-        let current = obj;
-        for (const part of parts) {
-            const isPathBroken = current == null || typeof current !== 'object';
-            if (isPathBroken) {
-                return null;
-            }
-            const isArrayIndex = RekeyTransformer.isArrayIndexPart(part);
-            if (isArrayIndex) {
-                const idx = RekeyTransformer.getArrayIndex(part);
-                const isIndexOutOfBounds = !Array.isArray(current) || idx >= current.length;
-                if (isIndexOutOfBounds) {
-                    return null;
-                }
-                current = current[idx];
-                continue;
-            }
-            const isPropertyMissing = !(part in current);
-            if (isPropertyMissing) {
-                return null;
-            }
-            current = current[part];
-        }
-        return current;
-    }
 }
 exports.RekeyTransformer = RekeyTransformer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/transform-data",
-  "version": "1.3.0-alpha.0",
+  "version": "1.3.0-alpha.2",
   "description": "Libraries for transforming data",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",