@karmaniverous/jsonmap 0.0.2

package/.env

@@ -0,0 +1 @@
+# Load with getdotenv: https://github.com/karmaniverous/get-dotenv

package/README.md

@@ -0,0 +1,142 @@
+# JsonMap
+
+`JsonMap` is a JSON mapping library, which facilitates the transformation of some input JSON object according to a set of rules.
+
+Installing `JsonMap` is easy:
+
+```bash
+npm install @karmaniverous/jsonmap
+```
+
+`JsonMap` is _hyper-generic_: you bring your own mapping functions, which may be async and may be combined into complex transformation logic.
+
+To do this, create a `lib` object, which combines your mapping function libraries into a single object. You can use async functions and organize this in any way that makes sense.
+
+For example:
+
+```js
+import _ from 'lodash';
+import numeral from 'numeral';
+
+const lib = { _, numeral };
+```
+
+You also need to create a `map` object. This is a [plain old Javascript object](https://masteringjs.io/tutorials/fundamentals/pojo) (POJO) that expresses your mapping rules.
+
+## Why?
+
+Mapping data from one form into another is a critical requirement of virtually every application.
+
+`JsonMap` decouples mapping structure from mapping logic... and drives that decoupling deep into the logic layer.
+
+The `lib` object contains the remaining logic that CAN'T be decoupled, and can be used consistently across your application.
+
+The `map` object is a [POJO](https://masteringjs.io/tutorials/fundamentals/pojo), which can easily be stored in a database yet does NOT express code as text and thus exposes a minimal threat surface.
+
+**This allows you to transform application logic into structured configuration data and write more generic, flexible applications.**
+
+## Usage
+
+The transformation output will reflect the structure of your `map` object and include any static values. To add mapping logic, use a structured value that consists of an object with a single `$` key, like this:
+
+```js
+const map = {
+  key1: 'static value passed directly to output',
+  // Structure passed directly to output.
+  key2: [
+    {
+      key2a: 'another static value',
+      // Value defined by mapping rule with an array of transformation objects.
+      // If there is only a single transformation object, no array is necessary.
+      key2b: {
+        $: [
+          // Each transformation object uses a special syntax to reference an
+          // object, a method to run on it, and an array of parameters to pass.
+          {
+            object: '$.lib._',
+            method: 'get',
+            params: ['$.input', 'dynamodb.NewImage.roundup.N'],
+          },
+          // The special syntax uses lodash-style paths. Its root object can
+          // reference the lib object ($.lib...), the transformation input
+          // ($.input...), the output generated so far ($.output...), or the
+          // outputs of previous transformation steps ($.[0]..., $.[1]...).
+          {
+            object: '$.lib',
+            method: 'numeral',
+            // If there is only a single param, no array is necessary.
+            params: '$[0]',
+          },
+          {
+            object: '$[0]',
+            method: 'format',
+            params: '$0,0.00',
+          },
+        ],
+      },
+    },
+  ],
+};
+```
+
+The transformation process is _generic_ and _asynchronous_. Feel free to use any function from any source in your `lib` object.
+
+Your `lib` object can also include locally defined or anonymous functions. Combined with the `$[i]...` syntax, this allows for complex branching transformation logic.
+
+Mapping objects are _recursive_. If a mapping object (i.e. `{ $: ... }`) renders another mapping object, it will be processed recursively until it does not.
+
+Input objects can contain data of any kind, including functions. These can be executed as methods of their parent objects using transformation steps.
+
+Once a `JsonMap` instance is configured, it can be executed against any input. Configure & execute a `JsonMap` instance like this:
+
+```js
+import { JsonMap } from '@karmaniverous/jsonmap';
+
+// Assumes lib & map are already defined as above.
+const jsonMap = new JsonMap(lib, map);
+
+// Assumes some input data object is already defined.
+const output = await jsonMap.transform(input);
+```
+
+# API Documentation
+
+<a name="JsonMap"></a>
+
+## JsonMap
+JsonMap class to apply transformations to a JSON object
+
+**Kind**: global class  
+
+* [JsonMap](#JsonMap)
+    * [new JsonMap(lib, map)](#new_JsonMap_new)
+    * [.transform(input)](#JsonMap+transform) ⇒ <code>object</code>
+
+<a name="new_JsonMap_new"></a>
+
+### new JsonMap(lib, map)
+Creates an instance of JsonMap.
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| lib | <code>object</code> | A collection of function libraries. |
+| map | <code>object</code> | The data mapping configuration. |
+
+<a name="JsonMap+transform"></a>
+
+### jsonMap.transform(input) ⇒ <code>object</code>
+Transforms the input data according to the map configuration.
+
+**Kind**: instance method of [<code>JsonMap</code>](#JsonMap)  
+**Returns**: <code>object</code> - - The transformed data.  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| input | <code>object</code> | The input data to be transformed. |
+
+
+---
+
+See more great templates and other tools on
+[my GitHub Profile](https://github.com/karmaniverous)!

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

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JsonMap = void 0;
+var _isNil2 = _interopRequireDefault(require("lodash/isNil"));
+var _parseInt2 = _interopRequireDefault(require("lodash/parseInt"));
+var _get2 = _interopRequireDefault(require("lodash/get"));
+var _isString2 = _interopRequireDefault(require("lodash/isString"));
+var _set2 = _interopRequireDefault(require("lodash/set"));
+var _last2 = _interopRequireDefault(require("lodash/last"));
+var _castArray2 = _interopRequireDefault(require("lodash/castArray"));
+var _isArray2 = _interopRequireDefault(require("lodash/isArray"));
+var _isObject2 = _interopRequireDefault(require("lodash/isObject"));
+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();
+/**
+ * JsonMap class to apply transformations to a JSON object
+ */
+class JsonMap {
+  /**
+   * Creates an instance of JsonMap.
+   *
+   * @param {object} lib - A collection of function libraries.
+   * @param {object} map - The data mapping configuration.
+   */
+  constructor(lib, map) {
+    _classPrivateMethodInitSpec(this, _resolvePath);
+    _classPrivateMethodInitSpec(this, _transform);
+    this.lib = lib;
+    this.map = map;
+  }
+
+  /**
+   * Transforms the input data according to the map configuration.
+   *
+   * @param {object} input - The input data to be transformed.
+   * @returns {object} - The transformed data.
+   */
+  async transform(input) {
+    // Sets the input data and initializes an empty output object
+    this.input = input;
+    this.output = {};
+
+    // Calls the #transform method to perform the transformation
+    return await _classPrivateMethodGet(this, _transform, _transform2).call(this, this.map, this.input, this.output);
+  }
+
+  /**
+   * Recursive function to handle transformations.
+   *
+   * @param {object} node - The current map node.
+   * @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.
+   * @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, _isObject2.default)(node) && '$' in node) {
+    // Retrieves the transformations to be applied (can be an array or a single object)
+    const transformations = (0, _isArray2.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, _castArray2.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);
+    }
+
+    // Sets the output at the specified path to the last result of the transformations & returns.
+    const last = (0, _last2.default)(results);
+    (0, _set2.default)(output, path, last);
+    return last;
+  }
+
+  // Checks if the current node is an object
+  if ((0, _isObject2.default)(node)) {
+    // Creates an empty array or object based on whether the current node is an array or not
+    const transformedNode = (0, _isArray2.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;
+
+      // 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, _set2.default)(output, path, transformedNode);
+    return transformedNode;
+  }
+
+  // Sets the output at the specified path to the current node & returns.
+  (0, _set2.default)(output, path, node);
+  return node;
+}
+function _resolvePath2(path, results) {
+  // If the path is not a string, return it as is
+  if (!(0, _isString2.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, _get2.default)(results, [results.length - 1 - (0, _parseInt2.default)(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 ? (0, _get2.default)(replacement, p.split('.')) : replacement;
+
+    // Returns the value if it exists, otherwise returns the original path
+    return (0, _isNil2.default)(value) ? path : value;
+  }
+
+  // Returns the path as is if it does not match any special patterns
+  return path;
+}

package/dist/default/lib/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "JsonMap", {
+  enumerable: true,
+  get: function () {
+    return _JsonMap.JsonMap;
+  }
+});
+var _JsonMap = require("./JsonMap/JsonMap.js");

package/dist/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/env/.env.dev

@@ -0,0 +1,2 @@
+# These are ENV-specific values. A version of this file should exist for 
+# every ENV supported by the project, named .env.ENV

package/env/dynamic.js

@@ -0,0 +1 @@
+() => ({});

package/lib/JsonMap/JsonMap.js

@@ -0,0 +1,162 @@
+import _ from 'lodash';
+
+/**
+ * JsonMap class to apply transformations to a JSON object
+ */
+class JsonMap {
+  /**
+   * Creates an instance of JsonMap.
+   *
+   * @param {object} lib - A collection of function libraries.
+   * @param {object} map - The data mapping configuration.
+   */
+  constructor(lib, map) {
+    this.lib = lib;
+    this.map = map;
+  }
+
+  /**
+   * Transforms the input data according to the map configuration.
+   *
+   * @param {object} input - The input data to be transformed.
+   * @returns {object} - The transformed data.
+   */
+  async transform(input) {
+    // Sets the input data and initializes an empty output object
+    this.input = input;
+    this.output = {};
+
+    // Calls the #transform method to perform the transformation
+    return await this.#transform(this.map, this.input, this.output);
+  }
+
+  /**
+   * Recursive function to handle transformations.
+   *
+   * @param {object} node - The current map node.
+   * @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.
+   * @private
+   */
+  async #transform(node, input, output, path = '') {
+    // Checks if the current node is an object and has a '$' key
+    if (_.isObject(node) && '$' in node) {
+      // Retrieves the transformations to be applied (can be an array or a single object)
+      const transformations = _.isArray(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 = this.#resolvePath(transformation.object, results);
+
+        // Resolves the parameter paths for the transformation
+        const params = await Promise.all(
+          _.castArray(transformation.params).map((param) =>
+            this.#resolvePath(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);
+      }
+
+      // Sets the output at the specified path to the last result of the transformations & returns.
+      const last = _.last(results);
+      _.set(output, path, last);
+      return last;
+    }
+
+    // Checks if the current node is an object
+    if (_.isObject(node)) {
+      // Creates an empty array or object based on whether the current node is an array or not
+      const transformedNode = _.isArray(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;
+
+        // 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
+        );
+      }
+
+      // Sets the output at the specified path to the transformedNode & returnsd.
+      _.set(output, path, transformedNode);
+      return transformedNode;
+    }
+
+    // Sets the output at the specified path to the current node & returns.
+    _.set(output, path, node);
+    return node;
+  }
+
+  /**
+   * Resolves the object/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.
+   * @private
+   */
+  #resolvePath(path, results) {
+    // If the path is not a string, return it as is
+    if (!_.isString(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 = _.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.split('.')) : replacement;
+
+        // Returns the value if it exists, otherwise returns the original path
+        return _.isNil(value) ? path : value;
+      }
+
+    // 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
+export { JsonMap };

package/lib/index.js

@@ -0,0 +1 @@
+export { JsonMap } from './JsonMap/JsonMap.js';

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@karmaniverous/jsonmap",
+  "version": "0.0.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/karmaniverous/jsonmap"
+  },
+  "author": "Jason G. Williscroft",
+  "bugs": {
+    "url": "https://github.com/karmaniverous/jsonmap/issues"
+  },
+  "description": "A hyper-generic JSON mapping library.",
+  "homepage": "https://github.com/karmaniverous/jsonmap#readme",
+  "keywords": [
+    "json",
+    "map",
+    "es6",
+    "javascript"
+  ],
+  "license": "BSD-3-Clause",
+  "dependencies": {
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.21.0",
+    "@babel/core": "^7.21.3",
+    "@babel/eslint-parser": "^7.21.3",
+    "@babel/plugin-syntax-import-assertions": "^7.20.0",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/register": "^7.21.0",
+    "@karmaniverous/get-dotenv": "^1.0.0",
+    "@types/node": "^18.15.5",
+    "babel-plugin-lodash": "^3.3.4",
+    "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-plugin-mocha": "^10.1.0",
+    "jsdoc-to-markdown": "^8.0.0",
+    "mocha": "^10.2.0",
+    "numeral": "^2.0.6",
+    "prettier": "^2.8.5",
+    "release-it": "^15.9.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "require": "./dist/default/lib/index.js"
+    }
+  },
+  "main": "./lib/index.js",
+  "mocha": {
+    "exclude": [
+      "./dist/**",
+      "./node_modules/**"
+    ],
+    "file": "./test/setup.js",
+    "require": [
+      "@babel/register"
+    ],
+    "spec": "./**/*.test.!(*.*)"
+  },
+  "release-it": {
+    "github": {
+      "release": true
+    },
+    "npm": {
+      "publish": true
+    }
+  },
+  "scripts": {
+    "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",
+    "test": "getdotenv -c \"mocha\" -p ./ ./env -d dev -y ./env/dynamic.js"
+  },
+  "type": "module"
+}

package/prompt.md

@@ -0,0 +1,227 @@
+Here is a usage example of a Javascript class called JsonMap that applies transformations to a JSON object. The class should exploit the lodash library where relevant.
+
+```js
+import _ from 'lodash';
+import numeral from 'numeral';
+import { JsonMap } from 'json-map';
+
+const fetchData = async (entityToken, entityId) => {
+  // This async code fetches data from an API.
+};
+
+// This object is a collection of function libraries.
+const lib = { _, fetchData, numeral, String };
+
+// This is the data mapping configuration.
+// The output will have the same structure as this object.
+const map = {
+  txn: {
+    txnId: {
+      /*
+      An object value with a single key of $ indicates a transformation.
+
+      A transformation is composed of steps. Each step is an object with 3 keys: object, method, and params. Each transformation step runs a method of an object, optionally passing it a parameter array.
+
+      If the $ value is an object, there is a single transformation step. Multiple steps can be collected into an array.
+      */
+      $: {
+        /*
+        The object property itentifies the object whose method will be run. The object is resolved using a special syntax:
+
+        $.lib refers to the JsonMap instance lib property.
+
+        $.input refers to the input data object. 
+        
+        $.output refers to the output object. The transformation is progressive, so the value currently being processed can refer to previously processed values.
+
+        $[i], where i is an integer, refers to the ith previous transformation step, so $[0] is the last step, $[1] is the one before that, and so on. This syntax should account for the fact that a previous step might return an object, in which case $[i] might be followed by path information, e.g. $[0].path.
+
+        Beyond these base objects, lodash-style path syntax applies. If none of the patterns above fits, then object should be treated as a string.
+        */
+        object: '$.lib._',
+
+        /*
+        The method property identifies the method that will be executed on object. It should be a string.
+        */
+        method: 'get',
+
+        /*
+        The params property is an array of values to be passed to method. These values should be resolved using the same syntax as object. If none of the special patterns fits, then the value should be treated as a string.
+        */
+        params: ['$.input', 'dynamodb.NewImage.txnId.S'],
+      },
+    },
+    roundup: {
+      $: [
+        {
+          object: '$.lib._',
+          method: 'get',
+          params: ['$.input', 'dynamodb.NewImage.roundup.N'],
+        },
+        {
+          object: '$.lib',
+          method: 'numeral',
+          // If there is only a single param, no array is necessary.
+          params: '$[0]',
+        },
+        {
+          object: '$[0]',
+          method: 'format',
+          params: ['$0,0.00'],
+        },
+      ],
+    },
+    // Static values & structures will simply be passed through to the output.
+    foo: 'bar',
+    baz: {
+      object: '$.lib.String',
+      method: 'toUpperCase',
+      params: '$.foo',
+    },
+    fetch: {
+      object: '$.lib',
+      // This is an async function that returns an object!
+      method: 'fetchData',
+      // The second parameter leverages a previously processed value.
+      params: ['txn', '$.output.txn.txnId'],
+    },
+  },
+};
+
+// This is some sample input data to be transformed.
+const input = {
+  eventID: 'e560bbcaee919e16a6a8ce8dc3fe97ab',
+  eventName: 'MODIFY',
+  eventVersion: '1.1',
+  eventSource: 'aws:dynamodb',
+  awsRegion: 'us-east-1',
+  dynamodb: {
+    ApproximateCreationDateTime: 1685071094,
+    Keys: {
+      entityPK: {
+        S: 'txn!',
+      },
+      entitySK: {
+        S: 'txnId#_tQ72mu5Iy2PYJ33c497g',
+      },
+    },
+    NewImage: {
+      txnUserIdPK: {
+        S: 'txn!|userId#Xmv51c7lYiiTIU22_UlCD',
+      },
+      created: {
+        N: '1685071087846',
+      },
+      netValue: {
+        N: '365.3',
+      },
+      methodId: {
+        S: 'KDvC6leEzkAAf8-akh_vO',
+      },
+      entityPK: {
+        S: 'txn!',
+      },
+      userId: {
+        S: 'Xmv51c7lYiiTIU22_UlCD',
+      },
+      entitySK: {
+        S: 'txnId#_tQ72mu5Iy2PYJ33c497g',
+      },
+      updater: {
+        S: 'api-txn-v0-bali',
+      },
+      merchantId: {
+        S: 'eQMZ2ikPmUd3cqrptbpna',
+      },
+      roundup: {
+        N: '0.7',
+      },
+      txnMerchantIdPK: {
+        S: 'txn!|merchantId#eQMZ2ikPmUd3cqrptbpna',
+      },
+      updated: {
+        N: '1685071094685',
+      },
+      txnId: {
+        S: '_tQ72mu5Iy2PYJ33c497g',
+      },
+      txnMethodIdPK: {
+        S: 'txn!|methodId#KDvC6leEzkAAf8-akh_vO',
+      },
+    },
+    OldImage: {
+      txnUserIdPK: {
+        S: 'txn!|userId#Xmv51c7lYiiTIU22_UlCD',
+      },
+      created: {
+        N: '1685071087846',
+      },
+      netValue: {
+        N: '429.74',
+      },
+      methodId: {
+        S: 'KDvC6leEzkAAf8-akh_vO',
+      },
+      entityPK: {
+        S: 'txn!',
+      },
+      userId: {
+        S: 'Xmv51c7lYiiTIU22_UlCD',
+      },
+      entitySK: {
+        S: 'txnId#_tQ72mu5Iy2PYJ33c497g',
+      },
+      updater: {
+        S: 'api-txn-v0-bali',
+      },
+      merchantId: {
+        S: 'eQMZ2ikPmUd3cqrptbpna',
+      },
+      roundup: {
+        N: '0.26',
+      },
+      txnMerchantIdPK: {
+        S: 'txn!|merchantId#eQMZ2ikPmUd3cqrptbpna',
+      },
+      updated: {
+        N: '1685071087846',
+      },
+      txnId: {
+        S: '_tQ72mu5Iy2PYJ33c497g',
+      },
+      txnMethodIdPK: {
+        S: 'txn!|methodId#KDvC6leEzkAAf8-akh_vO',
+      },
+    },
+    SequenceNumber: '31120900000000039175922358',
+    SizeBytes: 801,
+    StreamViewType: 'NEW_AND_OLD_IMAGES',
+  },
+  eventSourceARN:
+    'arn:aws:dynamodb:us-east-1:546652796775:table/api-txn-v0-bali/stream/2023-05-19T12:57:41.682',
+};
+
+// This initializes a JsonMap instance.
+const jsonMap = new JsonMap(lib, map);
+
+// This transforms the sample input data.
+const result = jsonMap.transform(input);
+
+// This is the result!
+// {
+//   txn: {
+//     txnId: '_tQ72mu5Iy2PYJ33c497g',
+//     roundup: '$0.70',
+//   },
+//   foo: 'bar',
+//   baz: 'BAR',
+//   fetch: {
+//     statusCode: 200,
+//     message: 'asynchronously fetched data!'
+//   }
+// }
+```
+
+The class should accommodate deep placement of transformations within the map object. It should also recursively account for transformation objects that resolve into transformation objects.
+
+Fully implement the JsonMap class with jsdoc comments.