@znemz/cfn-include 2.1.19 → 2.1.21

package/index.js

@@ -1,8 +1,7 @@
 const url = require('url');
 const path = require('path');
-const { readFile } = require('fs/promises');
 const _ = require('lodash');
-const { globSync } = require('glob');
+const { glob } = require('glob');
 const Promise = require('bluebird');
 const sortObject = require('@znemz/sort-object');
 const { S3Client, GetObjectCommand } = require('@aws-sdk/client-s3');
@@ -26,6 +25,8 @@ const replaceEnv = require('./lib/replaceEnv');
 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
@@ -60,7 +61,7 @@ module.exports = async function (options) {
   const base = parseLocation(options.url);
   const scope = options.scope || {};
   if (base.relative) throw new Error('url cannot be relative');
-  template = _.isUndefined(template)
+  template = !template
     ? fnInclude({ base, scope, cft: options.url, ...options })
     : template;
   // Resolve template if it's a promise to extract the root template for reference lookups
@@ -109,8 +110,9 @@ async function recurse({ base, scope, cft, rootTemplate, caller, ...opts }) {
   if (opts.doLog) {
     console.log({ base, scope, cft, rootTemplate, caller, ...opts });
   }
-  scope = _.clone(scope);
-  if (_.isArray(cft)) {
+  // 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 })));
   }
   if (_.isPlainObject(cft)) {
@@ -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);
@@ -175,24 +178,24 @@ async function recurse({ base, scope, cft, rootTemplate, caller, ...opts }) {
     }
     if (cft['Fn::Flatten']) {
       return recurse({ base, scope, cft: cft['Fn::Flatten'], rootTemplate, caller: 'Fn::Flatten', ...opts }).then(function (json) {
-        return _.flatten(json);
+        return json.flat();
       });
     }
     if (cft['Fn::FlattenDeep']) {
       return recurse({ base, scope, cft: cft['Fn::FlattenDeep'], rootTemplate, caller: 'Fn::FlattenDeep', ...opts }).then(
         function (json) {
-          return _.flattenDeep(json);
+          return json.flat(Infinity);
         },
       );
     }
     if (cft['Fn::Uniq']) {
       return recurse({ base, scope, cft: cft['Fn::Uniq'], rootTemplate, caller: 'Fn::Uniq', ...opts }).then(function (json) {
-        return _.uniq(json);
+        return [...new Set(json)];
       });
     }
     if (cft['Fn::Compact']) {
       return recurse({ base, scope, cft: cft['Fn::Compact'], rootTemplate, caller: 'Fn::Compact', ...opts }).then(function (json) {
-        return _.compact(json);
+        return json.filter(Boolean);
       });
     }
     if (cft['Fn::Concat']) {
@@ -269,7 +272,7 @@ async function recurse({ base, scope, cft, rootTemplate, caller, ...opts }) {
     }
     if (cft['Fn::Filenames']) {
       return recurse({ base, scope, cft: cft['Fn::Filenames'], rootTemplate, caller: 'Fn::Filenames', ...opts }).then(
-        function (json) {
+        async function (json) {
           json = _.isPlainObject(json) ? { ...json } : { location: json };
           if (json.doLog) {
 
@@ -284,7 +287,7 @@ async function recurse({ base, scope, cft, rootTemplate, caller, ...opts }) {
             const absolute = location.relative
               ? path.join(path.dirname(base.path), location.host, location.path || '')
               : [location.host, location.path].join('');
-            const globs = globSync(absolute).sort();
+            const globs = (await glob(absolute)).sort();
             if (json.omitExtension) {
               return globs.map((f) => path.basename(f, path.extname(f)));
             }
@@ -587,35 +590,38 @@ async function recurse({ base, scope, cft, rootTemplate, caller, ...opts }) {
     );
   }
 
-  if (_.isUndefined(cft)) {
+  if (cft === undefined) {
     return null;
   }
   return replaceEnv(cft, opts.inject, opts.doEnv);
 }
 
 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 (_.isArray(object)) {
+  if (Array.isArray(object)) {
     object = object.map(_.bind(findAndReplace, this, scope));
   } else if (_.isPlainObject(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]);
     });
@@ -632,7 +638,7 @@ function interpolate(lines, context) {
         const match = _line.match(/^{{(\w+)}}$/);
         const value = match ? context[match[1]] : undefined;
         if (!match) return _line;
-        if (_.isUndefined(value)) {
+        if (value === undefined) {
           return '';
         }
         return value;
@@ -661,7 +667,7 @@ function fnIncludeOptsFromArray(cft, opts) {
 function fnIncludeOpts(cft, opts) {
   if (_.isPlainObject(cft)) {
     cft = _.merge(cft, _.cloneDeep(opts));
-  } else if (_.isArray(cft)) {
+  } else if (Array.isArray(cft)) {
     cft = fnIncludeOptsFromArray(cft, opts);
   } else {
     // should be string{
@@ -730,11 +736,11 @@ async function fnInclude({ base, scope, cft, ...opts }) {
 
     handleInjectSetup();
     if (isGlob(cft, absolute)) {
-      const paths = globSync(absolute).sort();
+      const paths = (await glob(absolute)).sort();
       const template = yaml.load(paths.map((_p) => `- Fn::Include: file://${_p}`).join('\n'));
       return recurse({ base, scope, cft: template, rootTemplate: template, ...opts });
     }
-    body = readFile(absolute).then(String).then(procTemplate);
+    body = cachedReadFile(absolute).then(procTemplate);
     absolute = `${location.protocol}://${absolute}`;
   } else if (location.protocol === 's3') {
     const basedir = pathParse(base.path).dir;
@@ -829,7 +835,7 @@ async function handleIncludeBody({ scope, args, body, absolute }) {
             return temp;
           }
           // once fully recursed we can query the resultant template
-          const query = _.isString(args.query)
+          const query = typeof args.query === 'string'
             ? replaceEnv(args.query, args.inject, args.doEnv)
             : await recurse({
               base: parseLocation(absolute),
@@ -858,7 +864,7 @@ async function handleIncludeBody({ scope, args, body, absolute }) {
             lines = interpolate(lines, args.context);
           }
           return {
-            'Fn::Join': ['', _.flatten(lines)],
+            'Fn::Join': ['', lines.flat()],
           };
         });
       }

package/lib/cache.js

@@ -0,0 +1,34 @@
+/**
+ * File content cache to avoid redundant disk I/O.
+ */
+
+const { readFile } = require('fs/promises');
+
+// File content cache to avoid re-reading the same files
+const fileCache = new Map();
+
+/**
+ * Read a file with caching to avoid redundant disk I/O
+ * @param {string} absolutePath - Absolute path to the file
+ * @returns {Promise<string>} File content as a string
+ */
+async function cachedReadFile(absolutePath) {
+  if (fileCache.has(absolutePath)) {
+    return fileCache.get(absolutePath);
+  }
+  const content = await readFile(absolutePath, 'utf8');
+  fileCache.set(absolutePath, content);
+  return content;
+}
+
+/**
+ * Clear the file cache (useful for testing)
+ */
+function clearFileCache() {
+  fileCache.clear();
+}
+
+module.exports = {
+  cachedReadFile,
+  clearFileCache,
+};

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.19",
+  "version": "2.1.21",
   "description": "Preprocessor for CloudFormation templates with support for loops and flexible include statements",
   "keywords": [
     "aws",