@karmaniverous/jsonmap 0.0.7 → 0.2.0

package/README.md

@@ -46,6 +46,9 @@ const map = {
   bar: [
     {
       static: 'another static value',
+      // Keys starting with $ are available for progressive transformations but
+      // are not passed to the output object.
+      $remove: 'this should be removed from the output',
       // Value defined by a mapping rule expressing an array of transformation
       // objects. If there is only a single transformation object, no array is
       // necessary. The output of the last transformation step is returned as
@@ -53,10 +56,9 @@ const map = {
       dynamic: {
         $: [
           // Each transformation object uses a special syntax to reference an
-          // object, a method to run on it, and an array of parameters to pass.
+          // a method to run and an array of parameters to pass to it.
           {
-            object: '$.lib._',
-            method: 'get',
+            method: '$.lib._.get',
             params: ['$.input', 'dynamodb.NewImage.roundup.N'],
           },
           // The special syntax uses lodash-style paths. Its root object can
@@ -64,14 +66,12 @@ const map = {
           // ($.input...), the output generated so far ($.output...), or the
           // outputs of previous transformation steps ($.[0]..., $.[1]...).
           {
-            object: '$.lib',
-            method: 'numeral',
+            method: '$.lib.numeral',
             // If there is only a single param, no array is necessary.
             params: '$[0]',
           },
           {
-            object: '$[0]',
-            method: 'format',
+            method: '$[0].format',
             params: '$0,0.00',
           },
         ],
@@ -82,11 +82,11 @@ const map = {
   // previous output of the same mapping object.
   progressive: {
     $: {
-      object: '$.lib._',
-      method: 'toUpper',
+      method: '$.lib._.toUpper',
       params: '$.output.bar[0].static',
     },
   },
+  $remove: 'this should be removed from the output',
 };
 ```
 

package/dist/default/lib/JsonMap/JsonMap.js

@@ -5,20 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.JsonMap = void 0;
 var _lodash = _interopRequireDefault(require("lodash.castarray"));
-var _lodash2 = _interopRequireDefault(require("lodash.get"));
-var _lodash3 = _interopRequireDefault(require("lodash.isnil"));
-var _lodash4 = _interopRequireDefault(require("lodash.isarray"));
-var _lodash5 = _interopRequireDefault(require("lodash.isobject"));
-var _lodash6 = _interopRequireDefault(require("lodash.isstring"));
-var _lodash7 = _interopRequireDefault(require("lodash.last"));
-var _lodash8 = _interopRequireDefault(require("lodash.parseint"));
-var _lodash9 = _interopRequireDefault(require("lodash.set"));
+var _lodash2 = _interopRequireDefault(require("lodash.clonedeepwith"));
+var _lodash3 = _interopRequireDefault(require("lodash.get"));
+var _lodash4 = _interopRequireDefault(require("lodash.invoke"));
+var _lodash5 = _interopRequireDefault(require("lodash.isarray"));
+var _lodash6 = _interopRequireDefault(require("lodash.isobject"));
+var _lodash7 = _interopRequireDefault(require("lodash.isplainobject"));
+var _lodash8 = _interopRequireDefault(require("lodash.isstring"));
+var _lodash9 = _interopRequireDefault(require("lodash.mapvalues"));
+var _lodash10 = _interopRequireDefault(require("lodash.pickby"));
+var _lodash11 = _interopRequireDefault(require("lodash.set"));
+var _lodash12 = _interopRequireDefault(require("lodash.size"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
-function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
-function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
-var _transform = /*#__PURE__*/new WeakSet();
-var _resolvePath = /*#__PURE__*/new WeakSet();
+// npm imports
+
 /**
  * JsonMap class to apply transformations to a JSON object
  */
@@ -32,8 +32,6 @@ class JsonMap {
   constructor() {
     let map = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     let lib = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    _classPrivateMethodInitSpec(this, _resolvePath);
-    _classPrivateMethodInitSpec(this, _transform);
     this.map = map;
     this.lib = lib;
   }
@@ -42,7 +40,7 @@ class JsonMap {
    * Transforms the input data according to the map configuration.
    *
    * @param {object} input - The input data to be transformed.
-   * @returns {object} - The transformed data.
+   * @return {object} - The transformed data.
    */
   async transform(input) {
     // Sets the input data and initializes an empty output object
@@ -50,7 +48,11 @@ class JsonMap {
     this.output = {};
 
     // Calls the #transform method to perform the transformation
-    return await _classPrivateMethodGet(this, _transform, _transform2).call(this, this.map, this.input, this.output);
+    const result = await this.#transform(this.map, this.input, this.output);
+
+    // Recursively eliminate keys starting with $.
+    const deep = value => (0, _lodash7.default)(value) ? (0, _lodash9.default)((0, _lodash10.default)(value, (v, k) => /^[^$]/.test(k)), value => (0, _lodash2.default)(value, deep)) : undefined;
+    return (0, _lodash2.default)(result, deep);
   }
 
   /**
@@ -60,105 +62,129 @@ class JsonMap {
    * @param {object} input - The current input node.
    * @param {object} output - The current output node.
    * @param {string} path - The path to the current node.
-   * @returns {object} - The transformed node.
+   * @return {object} - The transformed node.
    * @private
    */
-}
-
-// Exports the JsonMap class as the default export of this module
-exports.JsonMap = JsonMap;
-async function _transform2(node, input, output) {
-  let path = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
-  // Checks if the current node is an object and has a '$' key
-  if ((0, _lodash5.default)(node) && '$' in node) {
-    // Retrieves the transformations to be applied (can be an array or a single object)
-    const transformations = (0, _lodash4.default)(node['$']) ? node['$'] : [node['$']];
-
-    // Array to store the results of the transformations
-    let results = [];
-
-    // Iterates over each transformation
-    for (const transformation of transformations) {
-      // Resolves the object path for the transformation
-      const object = _classPrivateMethodGet(this, _resolvePath, _resolvePath2).call(this, transformation.object, results);
-
-      // Resolves the parameter paths for the transformation
-      const params = await Promise.all((0, _lodash.default)(transformation.params).map(param => _classPrivateMethodGet(this, _resolvePath, _resolvePath2).call(this, param, results)));
-
-      // Calls the specified method on the resolved object with the resolved parameters
-      const result = await object[transformation.method](...params);
-
-      // Stores the result of the transformation
-      results.push(result);
+  async #transform(node, input, output) {
+    let path = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+    // Checks if the current node is an object and has a '$' key
+    if ((0, _lodash7.default)(node) && (0, _lodash12.default)(node) === 1 && '$' in node) {
+      // Retrieves the transformations to be applied (can be an array or a single object)
+      const transformations = (0, _lodash.default)(node['$']);
+
+      // Array to store the results of the transformations
+      let results = [];
+
+      // Iterates over each transformation
+      for (const transformation of transformations) {
+        // Resolves the object path for the transformation
+        const {
+          obj: methodObj,
+          path: methodPath
+        } = this.#resolvePath(transformation.method, results);
+
+        // Resolves the parameter paths for the transformation
+        const params = await Promise.all((0, _lodash.default)(transformation.params).map(param => {
+          const {
+            obj: paramObj,
+            path: paramPath
+          } = this.#resolvePath(param, results);
+          return paramObj ? paramPath ? (0, _lodash3.default)(paramObj, paramPath) : paramObj : paramPath;
+        }));
+
+        // Calls the specified method on the resolved object with the resolved parameters
+        const result = await (0, _lodash4.default)(methodObj, methodPath, ...params);
+
+        // Stores the result of the transformation
+        results.unshift(result);
+      }
+
+      // Sets the output at the specified path to the last result of the transformations & returns.
+      (0, _lodash11.default)(output, path, results[0]);
+      return results[0];
     }
 
-    // Sets the output at the specified path to the last result of the transformations & returns.
-    const lastResult = (0, _lodash7.default)(results);
-    (0, _lodash9.default)(output, path, lastResult);
-    return lastResult;
-  }
+    // Checks if the current node is an object
+    if ((0, _lodash6.default)(node)) {
+      // Creates an empty array or object based on whether the current node is an array or not
+      const transformedNode = (0, _lodash5.default)(node) ? [] : {};
 
-  // Checks if the current node is an object
-  if ((0, _lodash5.default)(node)) {
-    // Creates an empty array or object based on whether the current node is an array or not
-    const transformedNode = (0, _lodash4.default)(node) ? [] : {};
+      // Iterates over each key-value pair in the current node
+      for (const [key, value] of Object.entries(node)) {
+        // Constructs the current path by appending the current key to the previous path (if any)
+        const currentPath = path ? `${path}.${key}` : key;
 
-    // Iterates over each key-value pair in the current node
-    for (const [key, value] of Object.entries(node)) {
-      // Constructs the current path by appending the current key to the previous path (if any)
-      const currentPath = path ? `${path}.${key}` : key;
+        // Recursively calls #transform with the current value, input, output, and path
+        // Assigns the transformed value to the corresponding key in the transformedNode
+        transformedNode[key] = await this.#transform(value, input, output, currentPath);
+      }
 
-      // Recursively calls #transform with the current value, input, output, and path
-      // Assigns the transformed value to the corresponding key in the transformedNode
-      transformedNode[key] = await _classPrivateMethodGet(this, _transform, _transform2).call(this, value, input, output, currentPath);
+      // Sets the output at the specified path to the transformedNode & returnsd.
+      (0, _lodash11.default)(output, path, transformedNode);
+      return transformedNode;
     }
 
-    // Sets the output at the specified path to the transformedNode & returnsd.
-    (0, _lodash9.default)(output, path, transformedNode);
-    return transformedNode;
+    // Sets the output at the specified path to the current node & returns.
+    (0, _lodash11.default)(output, path, node);
+    return node;
   }
 
-  // Sets the output at the specified path to the current node & returns.
-  (0, _lodash9.default)(output, path, node);
-  return node;
-}
-function _resolvePath2(path, results) {
-  // If the path is not a string, return it as is
-  if (!(0, _lodash6.default)(path)) {
-    return path;
-  }
-
-  // Defines special patterns and their corresponding values for resolution
-  const specialPatterns = {
-    '$.lib': this.lib,
-    '$.input': this.input,
-    '$.output': this.output
-  };
-
-  // Checks if the path matches the pattern for accessing previous results
-  const match = path.match(/^\$\[(\d+)\](.*)$/);
-
-  // Retrieves the value from the previous results based on the index and any remaining path
-  if (match) {
-    const [, index, rest] = match;
-    const value = (0, _lodash2.default)(results, [results.length - 1 - (0, _lodash8.default)(index), ...(rest.length ? rest.split('.') : [])]);
-
-    // Returns the value if it exists, otherwise returns the original path
-    return value != null ? value : path;
-  }
+  /**
+   * @typedef {object} PathResolution
+   * @property {object} obj - The object to be used for the transformation.
+   * @property {string} path - The path to the value to be used for the transformation.
+   * @private
+   */
 
-  // Iterates over the special patterns
-  for (const [pattern, replacement] of Object.entries(specialPatterns)) if (path.startsWith(pattern)) {
-    // Removes the pattern from the beginning of the path
-    const p = path.slice(pattern.length + 1);
+  /**
+   * Resolves the method/params path for a transformation
+   *
+   * @param {string} path - The path to be resolved.
+   * @param {Array} results - The results from previous transformations.
+   * @return {PathResolution} - The resolved path.
+   * @private
+   */
+  #resolvePath(path, results) {
+    // If the path is not a string, return it as is
+    if (!(0, _lodash8.default)(path)) {
+      return path;
+    }
 
-    // Retrieves the value from the replacement object based on the remaining path
-    const value = p.length ? (0, _lodash2.default)(replacement, p) : replacement;
+    // Defines special patterns and their corresponding resolution functions
+    const patterns = {
+      '^\\$\\.(?<obj>lib|input|output)\\.?(?<path>.*)': _ref => {
+        let {
+          obj,
+          path
+        } = _ref;
+        return {
+          obj: this[obj],
+          path
+        };
+      },
+      '^\\$(?<path>\\[\\d+\\].*)': _ref2 => {
+        let {
+          path
+        } = _ref2;
+        return {
+          obj: results,
+          path
+        };
+      }
+    };
+
+    // Iterates over the special patterns
+    for (const [pattern, resolve] of Object.entries(patterns)) {
+      const match = path.match(pattern);
+      if (match) return resolve(match.groups);
+    }
 
-    // Returns the value if it exists, otherwise returns the original path
-    return (0, _lodash3.default)(value) ? path : value;
+    // Returns the path as is if it does not match any special patterns
+    return {
+      path
+    };
   }
+}
 
-  // Returns the path as is if it does not match any special patterns
-  return path;
-}
+// Exports the JsonMap class as the default export of this module
+exports.JsonMap = JsonMap;

package/lib/JsonMap/JsonMap.js

@@ -1,13 +1,16 @@
 // npm imports
 import castArray from 'lodash.castarray';
+import cloneDeepWith from 'lodash.clonedeepwith';
 import get from 'lodash.get';
-import isNil from 'lodash.isnil';
+import invoke from 'lodash.invoke';
 import isArray from 'lodash.isarray';
 import isObject from 'lodash.isobject';
+import isPlainObject from 'lodash.isplainobject';
 import isString from 'lodash.isstring';
-import last from 'lodash.last';
-import parseInt from 'lodash.parseint';
+import mapValues from 'lodash.mapvalues';
+import pickBy from 'lodash.pickby';
 import set from 'lodash.set';
+import size from 'lodash.size';
 
 /**
  * JsonMap class to apply transformations to a JSON object
@@ -28,7 +31,7 @@ class JsonMap {
    * Transforms the input data according to the map configuration.
    *
    * @param {object} input - The input data to be transformed.
-   * @returns {object} - The transformed data.
+   * @return {object} - The transformed data.
    */
   async transform(input) {
     // Sets the input data and initializes an empty output object
@@ -36,7 +39,18 @@ class JsonMap {
     this.output = {};
 
     // Calls the #transform method to perform the transformation
-    return await this.#transform(this.map, this.input, this.output);
+    const result = await this.#transform(this.map, this.input, this.output);
+
+    // Recursively eliminate keys starting with $.
+    const deep = (value) =>
+      isPlainObject(value)
+        ? mapValues(
+            pickBy(value, (v, k) => /^[^$]/.test(k)),
+            (value) => cloneDeepWith(value, deep)
+          )
+        : undefined;
+
+    return cloneDeepWith(result, deep);
   }
 
   /**
@@ -46,14 +60,14 @@ class JsonMap {
    * @param {object} input - The current input node.
    * @param {object} output - The current output node.
    * @param {string} path - The path to the current node.
-   * @returns {object} - The transformed node.
+   * @return {object} - The transformed node.
    * @private
    */
   async #transform(node, input, output, path = '') {
     // Checks if the current node is an object and has a '$' key
-    if (isObject(node) && '$' in node) {
+    if (isPlainObject(node) && size(node) === 1 && '$' in node) {
       // Retrieves the transformations to be applied (can be an array or a single object)
-      const transformations = isArray(node['$']) ? node['$'] : [node['$']];
+      const transformations = castArray(node['$']);
 
       // Array to store the results of the transformations
       let results = [];
@@ -61,26 +75,36 @@ class JsonMap {
       // Iterates over each transformation
       for (const transformation of transformations) {
         // Resolves the object path for the transformation
-        const object = this.#resolvePath(transformation.object, results);
+        const { obj: methodObj, path: methodPath } = this.#resolvePath(
+          transformation.method,
+          results
+        );
 
         // Resolves the parameter paths for the transformation
         const params = await Promise.all(
-          castArray(transformation.params).map((param) =>
-            this.#resolvePath(param, results)
-          )
+          castArray(transformation.params).map((param) => {
+            const { obj: paramObj, path: paramPath } = this.#resolvePath(
+              param,
+              results
+            );
+            return paramObj
+              ? paramPath
+                ? get(paramObj, paramPath)
+                : paramObj
+              : paramPath;
+          })
         );
 
         // Calls the specified method on the resolved object with the resolved parameters
-        const result = await object[transformation.method](...params);
+        const result = await invoke(methodObj, methodPath, ...params);
 
         // Stores the result of the transformation
-        results.push(result);
+        results.unshift(result);
       }
 
       // Sets the output at the specified path to the last result of the transformations & returns.
-      const lastResult = last(results);
-      set(output, path, lastResult);
-      return lastResult;
+      set(output, path, results[0]);
+      return results[0];
     }
 
     // Checks if the current node is an object
@@ -114,11 +138,18 @@ class JsonMap {
   }
 
   /**
-   * Resolves the object/method/params path for a transformation
+   * @typedef {object} PathResolution
+   * @property {object} obj - The object to be used for the transformation.
+   * @property {string} path - The path to the value to be used for the transformation.
+   * @private
+   */
+
+  /**
+   * Resolves the method/params path for a transformation
    *
    * @param {string} path - The path to be resolved.
    * @param {Array} results - The results from previous transformations.
-   * @return {string} - The resolved path.
+   * @return {PathResolution} - The resolved path.
    * @private
    */
   #resolvePath(path, results) {
@@ -127,43 +158,26 @@ class JsonMap {
       return path;
     }
 
-    // Defines special patterns and their corresponding values for resolution
-    const specialPatterns = {
-      '$.lib': this.lib,
-      '$.input': this.input,
-      '$.output': this.output,
+    // Defines special patterns and their corresponding resolution functions
+    const patterns = {
+      '^\\$\\.(?<obj>lib|input|output)\\.?(?<path>.*)': ({ obj, path }) => ({
+        obj: this[obj],
+        path,
+      }),
+      '^\\$(?<path>\\[\\d+\\].*)': ({ path }) => ({
+        obj: results,
+        path,
+      }),
     };
 
-    // Checks if the path matches the pattern for accessing previous results
-    const match = path.match(/^\$\[(\d+)\](.*)$/);
-
-    // Retrieves the value from the previous results based on the index and any remaining path
-    if (match) {
-      const [, index, rest] = match;
-      const value = get(results, [
-        results.length - 1 - parseInt(index),
-        ...(rest.length ? rest.split('.') : []),
-      ]);
-
-      // Returns the value if it exists, otherwise returns the original path
-      return value != null ? value : path;
-    }
-
     // Iterates over the special patterns
-    for (const [pattern, replacement] of Object.entries(specialPatterns))
-      if (path.startsWith(pattern)) {
-        // Removes the pattern from the beginning of the path
-        const p = path.slice(pattern.length + 1);
-
-        // Retrieves the value from the replacement object based on the remaining path
-        const value = p.length ? get(replacement, p) : replacement;
-
-        // Returns the value if it exists, otherwise returns the original path
-        return isNil(value) ? path : value;
-      }
+    for (const [pattern, resolve] of Object.entries(patterns)) {
+      const match = path.match(pattern);
+      if (match) return resolve(match.groups);
+    }
 
     // Returns the path as is if it does not match any special patterns
-    return path;
+    return { path };
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karmaniverous/jsonmap",
-  "version": "0.0.7",
+  "version": "0.2.0",
   "publishConfig": {
     "access": "public"
   },
@@ -23,36 +23,39 @@
   "license": "BSD-3-Clause",
   "dependencies": {
     "lodash.castarray": "^4.4.0",
+    "lodash.clonedeepwith": "^4.5.0",
     "lodash.get": "^4.4.2",
+    "lodash.invoke": "^4.5.2",
     "lodash.isarray": "^4.0.0",
-    "lodash.isnil": "^4.0.0",
     "lodash.isobject": "^3.0.2",
+    "lodash.isplainobject": "^4.0.6",
     "lodash.isstring": "^4.0.1",
-    "lodash.last": "^3.0.0",
-    "lodash.parseint": "^4.0.2",
-    "lodash.set": "^4.3.2"
+    "lodash.mapvalues": "^4.6.0",
+    "lodash.pickby": "^4.6.0",
+    "lodash.set": "^4.3.2",
+    "lodash.size": "^4.2.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.21.0",
-    "@babel/core": "^7.21.3",
-    "@babel/eslint-parser": "^7.21.3",
+    "@babel/cli": "^7.21.5",
+    "@babel/core": "^7.22.1",
+    "@babel/eslint-parser": "^7.21.8",
     "@babel/plugin-syntax-import-assertions": "^7.20.0",
-    "@babel/preset-env": "^7.20.2",
+    "@babel/preset-env": "^7.22.4",
     "@babel/register": "^7.21.0",
-    "@karmaniverous/get-dotenv": "^1.0.0",
-    "@types/node": "^18.15.5",
+    "@karmaniverous/get-dotenv": "^2.4.1",
+    "@types/node": "^20.2.5",
     "chai": "^4.3.7",
     "concat-md": "^0.5.1",
-    "eslint": "^8.36.0",
-    "eslint-config-standard": "^17.0.0",
-    "eslint-plugin-jsdoc": "^40.1.0",
+    "eslint": "^8.41.0",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-jsdoc": "^46.1.0",
     "eslint-plugin-mocha": "^10.1.0",
     "jsdoc-to-markdown": "^8.0.0",
     "lodash": "^4.17.21",
     "mocha": "^10.2.0",
     "numeral": "^2.0.6",
-    "prettier": "^2.8.5",
-    "release-it": "^15.9.0"
+    "prettier": "^2.8.8",
+    "release-it": "^15.10.3"
   },
   "exports": {
     ".": {
@@ -84,8 +87,8 @@
     "build": "babel lib -d dist/default/lib --delete-dir-on-start --config-file ./dist/default/.babelrc",
     "doc": "jsdoc2md -c doc/jsdoc.config.json -f lib/**/*.* -t doc/api-template.hbs > doc/2-api.jsdoc2.md && concat-md doc --hide-anchor-links > README.md",
     "lint": "eslint lib/**",
-    "package": "npm run lint && npm run test && npm run build && npm run doc",
-    "release": "npm run package && getdotenv -- release-it",
+    "prerelease": "npm run lint && npm run test && npm run build && npm run doc",
+    "release": "release-it",
     "test": "getdotenv -c \"mocha\" -p ./ ./env -d dev -y ./env/dynamic.js"
   },
   "type": "module"