@contrail/transform-data 1.1.4 → 1.2.0

package/lib/map-file/map-file-util.js

@@ -98,6 +98,7 @@ class MapFileUtil {
                     processor: step['processor'],
                     rekeyDelete: step['rekeyDelete'],
                     rekeyKeepMissingValues: step['rekeyKeepMissingValues'],
+                    rekeyNestedDelimiter: step['rekeyNestedDelimiter'],
                 };
                 for (const mapping of [
                     'conditionalTransformDefinitions',

package/lib/processor/process-interfaces.d.ts

@@ -13,6 +13,7 @@ export interface TransformTask {
     rekeyTransformers?: Record<string, string>;
     rekeyDelete?: boolean;
     rekeyKeepMissingValues?: boolean;
+    rekeyNestedDelimiter?: string;
     removeKeys?: string[];
     dependencies?: object;
 }

package/lib/processor/transform-processor.js

@@ -17,7 +17,7 @@ class TransformProcessor {
                     morph_transformer_1.MorphTransformer.transformData(rows, transformTask.functionTransformers, transformTask.dependencies);
                     break;
                 case 'REKEY':
-                    rekey_1.RekeyTransformer.transformData(rows, transformTask.rekeyTransformers, transformTask.rekeyDelete, transformTask.rekeyKeepMissingValues);
+                    rekey_1.RekeyTransformer.transformData(rows, transformTask.rekeyTransformers, transformTask.rekeyDelete, transformTask.rekeyKeepMissingValues, transformTask.rekeyNestedDelimiter);
                     break;
                 case 'REMOVE':
                     remove_1.RemoveTransformer.transformData(rows, transformTask.removeKeys);

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

@@ -1,4 +1,7 @@
 export declare class RekeyTransformer {
-    static transformData(csvJSON: any[], federatedMappings: Record<string, string>, deleteOldKey?: boolean, rekeyKeepMissingValues?: boolean): void;
-    static transformObject(row: any, federatedMappings: Record<string, string>, deleteOldKey?: boolean, rekeyKeepMissingValues?: boolean): void;
+    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;
 }

package/lib/rekey/rekey-transformer.js

@@ -2,25 +2,83 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RekeyTransformer = void 0;
 class RekeyTransformer {
-    static transformData(csvJSON, federatedMappings, deleteOldKey = false, rekeyKeepMissingValues = false) {
+    static transformData(csvJSON, federatedMappings, deleteOldKey = false, rekeyKeepMissingValues = false, nestedDelimiter = undefined) {
         for (const row of csvJSON) {
-            RekeyTransformer.transformObject(row, federatedMappings, deleteOldKey, rekeyKeepMissingValues);
+            RekeyTransformer.transformObject(row, federatedMappings, deleteOldKey, rekeyKeepMissingValues, nestedDelimiter);
         }
     }
-    static transformObject(row, federatedMappings, deleteOldKey = false, rekeyKeepMissingValues = false) {
-        const keys = Object.keys(row);
+    static transformObject(row, federatedMappings, deleteOldKey = false, rekeyKeepMissingValues = false, nestedDelimiter = undefined) {
         for (const [newKey, oldKey] of Object.entries(federatedMappings)) {
-            if (!row[newKey]) {
-                if (rekeyKeepMissingValues || keys.includes(oldKey)) {
-                    row[newKey] = row[oldKey];
-                }
+            const newKeyParts = RekeyTransformer.parseKeyParts(newKey, nestedDelimiter);
+            const oldKeyParts = RekeyTransformer.parseKeyParts(oldKey, nestedDelimiter);
+            const { value: oldValue, isExistingPath: doesOldKeyExist } = RekeyTransformer.getValueAtPath({
+                obj: row,
+                pathParts: oldKeyParts,
+                nestedDelimiter,
+            });
+            if (doesOldKeyExist) {
+                RekeyTransformer.setValueAtPath({ obj: row, pathParts: newKeyParts, value: oldValue });
+            }
+            else if (rekeyKeepMissingValues) {
+                RekeyTransformer.setValueAtPath({ obj: row, pathParts: newKeyParts, value: undefined });
             }
         }
         if (deleteOldKey) {
             for (const oldKey of Object.values(federatedMappings)) {
-                delete row[oldKey];
+                if (nestedDelimiter && oldKey.includes(nestedDelimiter)) {
+                    const oldKeyParts = RekeyTransformer.parseKeyParts(oldKey, nestedDelimiter);
+                    let current = row;
+                    for (let i = 0; i < oldKeyParts.length - 1; i++) {
+                        if (current == null || typeof current !== 'object' || !(oldKeyParts[i] in current)) {
+                            current = null;
+                            break;
+                        }
+                        current = current[oldKeyParts[i]];
+                    }
+                    if (current && oldKeyParts[oldKeyParts.length - 1] in current) {
+                        delete current[oldKeyParts[oldKeyParts.length - 1]];
+                    }
+                }
+                else {
+                    delete row[oldKey];
+                }
+            }
+        }
+    }
+    static parseKeyParts(key, nestedDelimiter) {
+        if (!nestedDelimiter || !key.includes(nestedDelimiter)) {
+            return [key];
+        }
+        const parts = key.split(nestedDelimiter);
+        return parts;
+    }
+    static setValueAtPath({ obj, pathParts, value, }) {
+        let current = obj;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            const key = pathParts[i];
+            if (current[key] == null || typeof current[key] !== 'object') {
+                current[key] = {};
+            }
+            current = current[key];
+        }
+        const finalKey = pathParts[pathParts.length - 1];
+        if (!Object.prototype.hasOwnProperty.call(current, finalKey)) {
+            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) {
+            if (current == null || typeof current !== 'object' || !Object.prototype.hasOwnProperty.call(current, key)) {
+                return { value: undefined, isExistingPath: false };
             }
+            current = current[key];
         }
+        return { value: current, isExistingPath: true };
     }
 }
 exports.RekeyTransformer = RekeyTransformer;

package/package.json

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