@znemz/cfn-include 2.1.20 → 2.1.21

package/index.js

@@ -26,6 +26,7 @@ const { lowerCamelCase, upperCamelCase } = require('./lib/utils');
 const { isOurExplicitFunction } = require('./lib/schema');
 const { getAwsPseudoParameters, buildResourceArn } = require('./lib/internals');
 const { cachedReadFile } = require('./lib/cache');
+const { createChildScope } = require('./lib/scope');
 
 /**
  * @param  {object} options
@@ -109,7 +110,8 @@ async function recurse({ base, scope, cft, rootTemplate, caller, ...opts }) {
   if (opts.doLog) {
     console.log({ base, scope, cft, rootTemplate, caller, ...opts });
   }
-  scope = _.clone(scope);
+  // Use Object.create() for O(1) child scope creation instead of O(n) clone
+  scope = createChildScope(scope);
   if (Array.isArray(cft)) {
     return Promise.all(cft.map((o) => recurse({ base, scope, cft: o, rootTemplate, caller: 'recurse:isArray', ...opts })));
   }
@@ -137,13 +139,14 @@ async function recurse({ base, scope, cft, rootTemplate, caller, ...opts }) {
         placeholder = '_';
       }
       return PromiseExt.mapX(recurse({ base, scope, cft: list, rootTemplate, caller: 'Fn::Map', ...opts }), (replace, key) => {
-        scope = _.clone(scope);
-        scope[placeholder] = replace;
+        // Use Object.create() for O(1) child scope creation instead of O(n) clone
+        const additions = { [placeholder]: replace };
         if (hasindex) {
-          scope[idx] = key;
+          additions[idx] = key;
         }
-        const replaced = findAndReplace(scope, _.cloneDeep(body));
-        return recurse({ base, scope, cft: replaced, rootTemplate, caller: 'Fn::Map', ...opts });
+        const childScope = createChildScope(scope, additions);
+        const replaced = findAndReplace(childScope, _.cloneDeep(body));
+        return recurse({ base, scope: childScope, cft: replaced, rootTemplate, caller: 'Fn::Map', ...opts });
       }).then((_cft) => {
         if (hassize) {
           _cft = findAndReplace({ [sz]: _cft.length }, _cft);
@@ -594,20 +597,23 @@ async function recurse({ base, scope, cft, rootTemplate, caller, ...opts }) {
 }
 
 function findAndReplace(scope, object) {
-  if (_.isString(object)) {
-    _.forEach(scope, function (replace, find) {
+  if (typeof object === 'string') {
+    // Use for...in to walk prototype chain (Object.create() based scopes)
+    for (const find in scope) {
       if (object === find) {
-        object = replace;
+        object = scope[find];
       }
-    });
+    }
   }
-  if (_.isString(object)) {
-    _.forEach(scope, function (replace, find) {
+  if (typeof object === 'string') {
+    // Use for...in to walk prototype chain (Object.create() based scopes)
+    for (const find in scope) {
+      const replace = scope[find];
       const regex = new RegExp(`\\\${${find}}`, 'g');
       if (find !== '_' && object.match(regex)) {
         object = object.replace(regex, replace);
       }
-    });
+    }
   }
   if (Array.isArray(object)) {
     object = object.map(_.bind(findAndReplace, this, scope));
@@ -615,7 +621,7 @@ function findAndReplace(scope, object) {
     object = _.mapKeys(object, function (value, key) {
       return findAndReplace(scope, key);
     });
-    _.keys(object).forEach(function (key) {
+    Object.keys(object).forEach(function (key) {
       if (key === 'Fn::Map') return;
       object[key] = findAndReplace(scope, object[key]);
     });

package/lib/scope.js

@@ -0,0 +1,58 @@
+/**
+ * Scope helper functions for lazy prototype-chain based scope management.
+ *
+ * Instead of _.clone(scope) which copies O(n) properties each time,
+ * we use Object.create(scope) which creates a child scope in O(1) time
+ * that inherits from the parent via the prototype chain.
+ */
+
+/**
+ * Create a child scope that inherits from the parent.
+ * Uses Object.create() for O(1) creation instead of cloning.
+ *
+ * @param {Object} parent - The parent scope to inherit from
+ * @param {Object} [additions={}] - Properties to add to the child scope
+ * @returns {Object} A new child scope with prototype chain to parent
+ */
+function createChildScope(parent, additions = {}) {
+  const child = Object.create(parent);
+  Object.assign(child, additions);
+  return child;
+}
+
+/**
+ * Convert a prototype-chain scope to a plain object.
+ * Uses for...in to walk the entire prototype chain.
+ *
+ * Useful when we need to pass scope to functions that don't
+ * walk the prototype chain (e.g., Object.keys, _.forEach).
+ *
+ * @param {Object} scope - The scope to flatten
+ * @returns {Object} A plain object with all inherited properties
+ */
+function scopeToObject(scope) {
+  const result = {};
+  for (const key in scope) {
+    result[key] = scope[key];
+  }
+  return result;
+}
+
+/**
+ * Iterate over all properties in a scope, including inherited ones.
+ * This is a replacement for _.forEach that walks the prototype chain.
+ *
+ * @param {Object} scope - The scope to iterate over
+ * @param {Function} callback - Function to call with (value, key)
+ */
+function forEachInScope(scope, callback) {
+  for (const key in scope) {
+    callback(scope[key], key);
+  }
+}
+
+module.exports = {
+  createChildScope,
+  scopeToObject,
+  forEachInScope,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@znemz/cfn-include",
-  "version": "2.1.20",
+  "version": "2.1.21",
   "description": "Preprocessor for CloudFormation templates with support for loops and flexible include statements",
   "keywords": [
     "aws",