@akemona-org/strapi-generate 3.7.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015-present Strapi Solutions SAS
+
+Portions of the Strapi software are licensed as follows:
+
+* All software that resides under an "ee/" directory (the “EE Software”), if that directory exists, is licensed under the license defined in "ee/LICENSE".
+
+* All software outside of the above-mentioned directories or restrictions above is available under the "MIT Expat" license as set forth below.
+
+MIT Expat License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# strapi-generate
+
+[![npm version](https://img.shields.io/npm/v/strapi-generate.svg)](https://www.npmjs.org/package/strapi-generate)
+[![npm downloads](https://img.shields.io/npm/dm/strapi-generate.svg)](https://www.npmjs.org/package/strapi-generate)
+[![npm dependencies](https://david-dm.org/strapi/strapi-generate.svg)](https://david-dm.org/strapi/strapi-generate)
+[![Build status](https://travis-ci.org/strapi/strapi-generate.svg?branch=master)](https://travis-ci.org/strapi/strapi-generate)
+[![Slack status](https://slack.strapi.io/badge.svg)](https://slack.strapi.io)
+
+Master of ceremonies for generators in the Strapi CLI.
+
+Usage:
+
+```bash
+$ strapi generate:something
+```
+
+## Resources
+
+- [License](LICENSE)
+
+## Links
+
+- [Strapi website](https://strapi.akemona.com/)
+- [Strapi community on Slack](https://slack.strapi.io)
+- [Strapi news on Twitter](https://twitter.com/strapijs)

package/lib/generate.js

@@ -0,0 +1,188 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+// Node.js core.
+const path = require('path');
+const util = require('util');
+
+// Public node modules.
+const _ = require('lodash');
+const async = require('async');
+const reportback = require('reportback')();
+
+// Local dependencies.
+const pathRegexp = require('./util').pathRegexp;
+const generateTarget = require('./target');
+
+/**
+ * Run a generator given an existing scope
+ *
+ * @param {Object} generator
+ * @param {Object} scope
+ * @param {Switchback} cb
+ */
+
+/* eslint-disable prefer-template */
+function generate(generator, scope, cb) {
+  const sb = reportback.extend(cb, {
+    error: cb.error,
+    invalid: cb.invalid,
+    alreadyExists: 'error',
+  });
+
+  // Resolve string shorthand for generator defs
+  // to `{ generator: 'originalDef' }`.
+  if (typeof generator === 'string') {
+    const generatorName = generator;
+    generator = {
+      generator: generatorName,
+    };
+  }
+
+  // Run the generator's `before()` method proceeding.
+  generator.before(
+    scope,
+    reportback.extend({
+      error: sb.error,
+      invalid: sb.invalid,
+      success: () => {
+        // Process all of the generator's targets concurrently.
+        async.each(
+          Object.keys(generator.targets),
+          (keyPath, asyncEachCb) => {
+            const asyncEachSb = reportback.extend(asyncEachCb);
+
+            // Create a new scope object for this target,
+            // with references to the important bits of the original
+            // (depth will be passed-by-value, but that's what we want).
+            // Then generate the target, passing along a reference to
+            // the base `generate` method to allow for recursive generators.
+            const target = generator.targets[keyPath];
+            if (!target) {
+              return asyncEachSb(
+                new Error(
+                  'Error: Invalid target: {"' + keyPath + '": ' + util.inspect(target) + '}'
+                )
+              );
+            }
+
+            // Input tolerance.
+            if (keyPath === '') {
+              keyPath = '.';
+            }
+
+            // Interpret `keyPath` using Express's parameterized route conventions,
+            // first parsing params, then replacing them with their proper values from scope.
+            const params = [];
+            pathRegexp(keyPath, params);
+            let err;
+            const parsedKeyPath = _.reduce(
+              params,
+              (memoKeyPath, param) => {
+                if (err) {
+                  return false;
+                }
+
+                try {
+                  const paramMatchExpr = ':' + param.name;
+                  let actualParamValue = scope[param.name];
+                  if (!actualParamValue) {
+                    err = new Error(
+                      'generator error:\n' +
+                        'A scope variable (`' +
+                        param.name +
+                        '`) was referenced in target: `' +
+                        memoKeyPath +
+                        '`,\n' +
+                        'but `' +
+                        param.name +
+                        "` does not exist in the generator's scope."
+                    );
+                    return false;
+                  }
+                  actualParamValue = String(actualParamValue);
+
+                  return memoKeyPath.replace(paramMatchExpr, actualParamValue);
+                } catch (e) {
+                  err = new Error('Error: Could not parse target key ' + memoKeyPath);
+                  err.message = e;
+                  return false;
+                }
+              },
+              keyPath
+            );
+            if (!parsedKeyPath) {
+              return asyncEachSb(err);
+            }
+
+            // Create path from `rootPath` to `keyPath` to use as the `rootPath`
+            // for any generators or helpers in this target
+            // (use a copy so that child generators don't mutate the scope).
+            const targetScope = _.merge({}, scope, {
+              rootPath: path.resolve(scope.rootPath, parsedKeyPath),
+
+              // Include reference to original keypath for error reporting.
+              keyPath,
+            });
+
+            // If `target` is an array, run each item.
+            if (_.isArray(target)) {
+              async.eachSeries(
+                target,
+                (targetItem, asyncEachSeriesCb) => {
+                  generateTarget(
+                    {
+                      target: targetItem,
+                      parent: generator,
+                      scope: _.cloneDeep(targetScope),
+                      recursiveGenerate: generate,
+                    },
+                    asyncEachSeriesCb
+                  );
+                },
+                asyncEachSb
+              );
+              return;
+            }
+
+            // Otherwise, just run the single target generator/helper.
+            generateTarget(
+              {
+                target,
+                parent: generator,
+                scope: targetScope,
+                recursiveGenerate: generate,
+              },
+              asyncEachSb
+            );
+          },
+
+          err => {
+            // Expose a `error` handler in generators.
+            if (err) {
+              const errorFn =
+                generator.error ||
+                function defaultError(err, scope, _cb) {
+                  return _cb(err);
+                };
+              return errorFn(err, scope, sb);
+            }
+
+            // Expose a `after` handler in generators (on success only).
+            const afterFn =
+              generator.after ||
+              function defaultAfter(scope, _cb) {
+                return _cb();
+              };
+            return afterFn(scope, sb);
+          }
+        );
+      },
+    })
+  );
+}
+
+module.exports = generate;

package/lib/helpers/copy/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+// Node.js core.
+const path = require('path');
+
+// Public node modules.
+const _ = require('lodash');
+const fs = require('fs-extra');
+const reportback = require('reportback')();
+
+// Local dependencies.
+const fileHelper = require('../file');
+
+/**
+ * Copy file from one place to another
+ */
+
+module.exports = function (options, cb) {
+  cb = reportback.extend(cb, {
+    alreadyExists: 'error',
+    invalid: 'error'
+  });
+
+  // Compute the canonical path to copy from
+  // given its relative path from its source generator's
+  // `templates` directory.
+  const absSrcPath = path.resolve(options.templatesDirectory, options.templatePath);
+
+  fs.readFile(absSrcPath, 'utf8', (err, contents) => {
+    if (err) {
+      return cb.error(err);
+    }
+
+    return fileHelper(_.merge(options, {
+      contents
+    }), cb);
+  });
+};

package/lib/helpers/file/index.js

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+// Node.js core.
+const path = require('path');
+
+// Public node modules.
+const _ = require('lodash');
+const async = require('async');
+const fs = require('fs-extra');
+const reportback = require('reportback')();
+
+/**
+ * Generate a file using the specified string
+ */
+
+/* eslint-disable prefer-template */
+module.exports = function (options, cb) {
+
+  // Provide default values for switchback.
+  cb = reportback.extend(cb, {
+    alreadyExists: 'error'
+  });
+
+  // Provide defaults and validate required options.
+  _.defaults(options, {
+    force: false
+  });
+
+  const missingOpts = _.difference([
+    'contents',
+    'rootPath'
+  ], Object.keys(options));
+
+  if (missingOpts.length) {
+    return cb.invalid(missingOpts);
+  }
+
+  // In case we ended up here with a relative path,
+  // resolve it using the process's CWD
+  const rootPath = path.resolve(process.cwd(), options.rootPath);
+
+  // Only override an existing file if `options.force` is true.
+  fs.exists(rootPath, exists => {
+    if (exists && !options.force) {
+      return cb.alreadyExists('Something else already exists at `' + rootPath + '`.');
+    }
+
+    // Don't actually write the file if this is a dry run.
+    if (options.dry) {
+      return cb.success();
+    }
+
+    async.series([
+      function deleteExistingFileIfNecessary(cb) {
+        if (!exists) {
+          return cb();
+        }
+        return fs.remove(rootPath, cb);
+      },
+      function writeToDisk(cb) {
+        fs.outputFile(rootPath, options.contents, cb);
+      }
+    ], cb);
+  });
+};

package/lib/helpers/folder/index.js

@@ -0,0 +1,81 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+// Node.js core.
+const path = require('path');
+
+// Public node modules.
+const _ = require('lodash');
+const fs = require('fs-extra');
+const reportback = require('reportback')();
+
+/**
+ * Generate a folder
+ */
+/* eslint-disable prefer-template */
+module.exports = function (options, cb) {
+
+  // Provide default values for cb.
+  cb = reportback.extend(cb, {
+    alreadyExists: 'error',
+    invalid: 'error'
+  });
+
+  // Provide defaults and validate required options.
+  _.defaults(options, {
+    force: false,
+    gitkeep: false
+  });
+
+  const missingOpts = _.difference([
+    'rootPath'
+  ], Object.keys(options));
+
+  if (missingOpts.length) {
+    return cb.invalid(missingOpts);
+  }
+
+  const rootPath = path.resolve(process.cwd(), options.rootPath);
+
+  // Only override an existing folder if `options.force` is true.
+  fs.lstat(rootPath, err => {
+    const exists = !(err && err.code === 'ENOENT');
+    if (exists && err) {
+      return cb.error(err);
+    }
+
+    if (exists && !options.force) {
+      return cb.alreadyExists('Something else already exists at `' + rootPath + '`.');
+    }
+
+    if (exists) {
+      fs.remove(rootPath, err => {
+        if (err) {
+          return cb.error(err);
+        }
+        _afterwards_();
+      });
+    } else {
+      _afterwards_();
+    }
+
+    function _afterwards_() {
+
+      // Don't actually write the directory if this is a dry run.
+      if (options.dry) {
+        return cb.success();
+      }
+
+      // Create the directory.
+      fs.mkdirs(rootPath, err => {
+        if (err) {
+          return cb.error(err);
+        }
+        return cb.success();
+      });
+    }
+  });
+};

package/lib/helpers/jsonfile/index.js

@@ -0,0 +1,70 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+// Node.js core.
+const path = require('path');
+
+// Public node modules.
+const _ = require('lodash');
+const fs = require('fs-extra');
+const reportback = require('reportback')();
+
+/**
+ * Generate a JSON file
+ */
+
+/* eslint-disable prefer-template */
+module.exports = function (options, handlers) {
+
+  // Provide default values for handlers.
+  handlers = reportback.extend(handlers, {
+    alreadyExists: 'error'
+  });
+
+  // Provide defaults and validate required options.
+  _.defaults(options, {
+    force: false
+  });
+
+  const missingOpts = _.difference([
+    'rootPath',
+    'data'
+  ], Object.keys(options));
+
+  if (missingOpts.length) {
+    return handlers.invalid(missingOpts);
+  }
+
+  const rootPath = path.resolve(process.cwd(), options.rootPath);
+
+  // Only override an existing file if `options.force` is true.
+  fs.exists(rootPath, exists => {
+    if (exists && !options.force) {
+      return handlers.alreadyExists('Something else already exists at `' + rootPath + '`.');
+    }
+
+    if (exists) {
+      fs.remove(rootPath, err => {
+        if (err) {
+          return handlers.error(err);
+        }
+        _afterwards_();
+      });
+    } else {
+      _afterwards_();
+    }
+
+    function _afterwards_() {
+      fs.outputJSON(rootPath, options.data, {spaces: 2}, err => {
+        if (err) {
+          return handlers.error(err);
+        } else {
+          handlers.success();
+        }
+      });
+    }
+  });
+};

package/lib/helpers/template/index.js

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+// Node.js core.
+const path = require('path');
+
+// Public node modules.
+const _ = require('lodash');
+const fs = require('fs-extra');
+const reportback = require('reportback')();
+
+// Local dependencies.
+const fileHelper = require('../file');
+
+/**
+ * Read a dynamic template, compile it using scope.
+ * Then use `file` helper to write it to its destination.
+ */
+
+module.exports = function (options, cb) {
+  cb = reportback.extend(cb, {
+    noTemplate: 'error',
+    alreadyExists: 'error'
+  });
+
+  // Compute the canonical path to a template
+  // given its relative path from its source generator's
+  // `templates` directory.
+  if (_.isFunction(options.templatesDirectory)) {
+    options.templatesDirectory = options.templatesDirectory(options);
+  }
+
+  const absTemplatePath = path.resolve(options.templatesDirectory, options.templatePath);
+
+  fs.readFile(absTemplatePath, 'utf8', (err, contents) => {
+    if (err) {
+      err = err instanceof Error ? err : new Error(err);
+      err.message = `Template error: ${err.message}`;
+      err.path = absTemplatePath;
+      if (err.code === 'ENOENT') {
+        return cb.noTemplate(err);
+      } else {
+        return cb(err);
+      }
+    }
+
+    try {
+      const compiled = _.template(contents, {
+        interpolate: /<%=([\s\S]+?)%>/g
+      });
+      contents = compiled(options);
+
+      // With Lodash templates, HTML entities are escaped by default.
+      // Default assumption is we don't want that, so we'll reverse it.
+      if (!options.escapeHTMLEntities) {
+        contents = _.unescape(contents);
+      }
+    } catch (e) {
+      return cb(e);
+    }
+
+    return fileHelper(_.merge(options, {
+      contents
+    }), cb);
+  });
+};

package/lib/index.js

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+// Public node modules.
+const reportback = require('reportback')();
+
+// Logger.
+const logger = require('@akemona-org/strapi-utils').logger;
+
+// Local dependencies.
+const generate = require('./generate');
+const generateTarget = require('./target');
+
+/* eslint-disable prefer-template */
+/**
+ * Generate module(s)
+ *
+ * @param {Object} scope
+ * @param {Function} cb
+ *
+ * @return {[Type]}
+ */
+
+module.exports = (scope, cb) => {
+  cb = cb || {};
+  cb = reportback.extend(cb, {
+    error: cb.error,
+    success: () => {},
+    notStrapiApp: () => {},
+    alreadyExists: () => {
+      return cb.error();
+    },
+  });
+
+  // Use configured module name for this `generatorType` if applicable.
+  const module = 'strapi-generate-' + scope.generatorType;
+  let generator;
+
+  function throwIfModuleNotFoundError(error, module) {
+    const isModuleNotFoundError =
+      error && error.code === 'MODULE_NOT_FOUND' && error.message.match(new RegExp(module));
+    if (!isModuleNotFoundError) {
+      logger.error('Invalid `' + scope.generatorType + '` generator.');
+      throw error;
+    } else {
+      return error;
+    }
+  }
+
+  // Try to require the module or throw if error.
+  try {
+    generator = require('../../' + module);
+  } catch (error) {
+    throwIfModuleNotFoundError(error, module);
+  }
+
+  if (!generator) {
+    return logger.error('No generator called `' + scope.generatorType + '` found.');
+  }
+
+  generate(generator, scope, cb);
+};
+
+module.exports.generateTarget = generateTarget;

package/lib/target.js

@@ -0,0 +1,318 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+/* eslint-disable prefer-template */
+// Node.js core.
+const path = require('path');
+const util = require('util');
+
+// Public node modules.
+const _ = require('lodash');
+const async = require('async');
+const report = require('reportback')();
+
+// Local dependencies.
+const folderHelper = require('./helpers/folder');
+const templateHelper = require('./helpers/template');
+const jsonFileHelper = require('./helpers/jsonfile');
+const copyHelper = require('./helpers/copy');
+
+/**
+ * generateTarget()
+ *
+ * @param {Object} options
+ */
+
+function generateTarget(options, cb) {
+  const sb = report.extend(cb);
+
+  // Options.
+  let target = options.target;
+  let scope = options.scope;
+  const parentGenerator = options.parent;
+  const recursiveGenerate = options.recursiveGenerate;
+
+  const maxResolves = 5;
+  let _resolves = 0;
+
+  async.until(
+    () => {
+      return isValidTarget(target) || ++_resolves > maxResolves;
+    },
+    asyncCb => {
+      parseTarget(target, scope, (err, resolvedTarget) => {
+        if (err) {
+          return asyncCb(err);
+        }
+        target = resolvedTarget;
+        return asyncCb();
+      });
+    },
+    err => {
+      if (err) {
+        return sb(err);
+      }
+      if (!isValidTarget(target)) {
+        return sb(
+          new Error(
+            'Generator Error :: Could not resolve target `' +
+              scope.rootPath +
+              '` (probably a recursive loop)'
+          )
+        );
+      }
+
+      // Pass down parent Generator's template directory abs path.
+      scope.templatesDirectory = parentGenerator.templatesDirectory;
+
+      if (target.copy) {
+        scope = mergeSubtargetScope(
+          scope,
+          typeof target.copy === 'string'
+            ? {
+                templatePath: target.copy,
+              }
+            : target.copy
+        );
+        return copyHelper(scope, sb);
+      }
+
+      if (target.folder) {
+        scope = mergeSubtargetScope(scope, target.folder);
+        return folderHelper(scope, sb);
+      }
+
+      if (target.template) {
+        scope = mergeSubtargetScope(
+          scope,
+          typeof target.template === 'string'
+            ? {
+                templatePath: target.template,
+              }
+            : target.template
+        );
+
+        return templateHelper(scope, sb);
+      }
+
+      if (target.jsonfile) {
+        if (typeof target.jsonfile === 'object') {
+          scope = mergeSubtargetScope(scope, target.jsonfile);
+        } else if (typeof target.jsonfile === 'function') {
+          scope = _.merge(scope, {
+            data: target.jsonfile(scope),
+          });
+        }
+        return jsonFileHelper(scope, sb);
+      }
+
+      // If we made it here, this must be a recursive generator.
+      // Now that the generator definition has been resolved,
+      // call this method recursively on it, passing along our
+      // callback.
+      if (++scope._depth > scope.maxHops) {
+        return sb(
+          new Error(
+            '`maxHops` (' +
+              scope.maxHops +
+              ') exceeded! There is probably a recursive loop in one of your generators.'
+          )
+        );
+      }
+      return recursiveGenerate(target, scope, sb);
+    }
+  );
+}
+
+module.exports = generateTarget;
+
+/**
+ * @param {[Type]} scope Description
+ * @param {[Type]} subtarget Description
+ * @return {[Type]} Description
+ */
+
+function mergeSubtargetScope(scope, subtarget) {
+  return _.merge(scope, _.isObject(subtarget) ? subtarget : {});
+}
+
+/**
+ * Known helpers
+ *
+ * @type {Array}
+ */
+
+const knownHelpers = ['folder', 'template', 'jsonfile', 'file', 'copy'];
+
+function targetIsHelper(target) {
+  return _.some(target, (subTarget, key) => {
+    return _.includes(knownHelpers, key);
+  });
+}
+
+/**
+ * @param {String|Object} target Description
+ * @param {Object} scope Description
+ * @param {Function} cb Description
+ * @return {[type]} Description
+ */
+
+function parseTarget(target, scope, cb) {
+  if (typeof target === 'string') {
+    target = {
+      generator: target,
+    };
+  }
+
+  // Interpret generator definition.
+  if (targetIsHelper(target)) {
+    return cb(null, target);
+  }
+
+  if (target.generator) {
+    // Normalize the subgenerator reference.
+    let subGeneratorRef;
+    if (typeof target.generator === 'string') {
+      subGeneratorRef = {
+        module: target.generator,
+      };
+    } else if (typeof target.generator === 'object') {
+      subGeneratorRef = target.generator;
+    }
+
+    if (!subGeneratorRef) {
+      return cb(
+        new Error(
+          'Generator Error :: Invalid subgenerator referenced for target `' + scope.rootPath + '`'
+        )
+      );
+    }
+
+    // Now normalize the sub-generator.
+    let subGenerator;
+
+    // No `module` means we'll treat this subgenerator as an inline generator definition.
+    if (!subGeneratorRef.module) {
+      subGenerator = subGeneratorRef;
+      if (subGenerator) {
+        return cb(null, subGenerator);
+      }
+    }
+
+    // Otherwise, we'll attempt to load this subgenerator.
+    if (typeof subGeneratorRef.module === 'string') {
+      // Lookup the generator by name if a `module` was specified
+      // This allows the module for a given generator to be
+      // overridden.
+      const configuredReference = scope.modules && scope.modules[subGeneratorRef.module];
+
+      // Refers to a configured module.
+      // If this generator type is explicitly set to `false`,
+      // disable the generator.
+      if (configuredReference) {
+        return cb(null, configuredReference);
+      } else if (configuredReference === false) {
+        return cb(null);
+      }
+
+      // If `configuredReference` is undefined, continue on
+      // and try to require the module.
+    }
+
+    // At this point, `subGeneratorRef.module` should be a string,
+    // and the best guess at the generator module we're going
+    // to get.
+    const module = subGeneratorRef.module;
+    let requireError;
+
+    // Try requiring it directly as a path.
+    try {
+      subGenerator = require(module);
+    } catch (e0) {
+      requireError = e0;
+    }
+
+    // Try the scope's `rootPath`.
+    if (!subGenerator) {
+      try {
+        const asDependencyInRootPath = path.resolve(scope.rootPath, 'node_modules', module);
+        subGenerator = require(asDependencyInRootPath);
+      } catch (e1) {
+        requireError = e1;
+      }
+    }
+
+    // Try the current working directory.
+    if (!subGenerator) {
+      try {
+        subGenerator = require(path.resolve(process.cwd(), 'node_modules', module));
+      } catch (e1) {
+        requireError = e1;
+      }
+    }
+
+    // If we couldn't find a generator using the configured module,
+    // try requiring `strapi-generate-<module>` to get the core generator.
+    if (!subGenerator && !module.match(/^strapi-generate-/)) {
+      try {
+        if (process.mainModule.filename.indexOf('yarn') !== -1) {
+          subGenerator = require(path.resolve(
+            process.mainModule.paths[2],
+            'strapi-generate-' + module
+          ));
+        } else {
+          subGenerator = require(path.resolve(
+            process.mainModule.paths[1],
+            'strapi-generate-' + module
+          ));
+        }
+      } catch (e1) {
+        requireError = e1;
+      }
+    }
+
+    // If we were able to find it, send it back!
+    if (subGenerator) {
+      return cb(null, subGenerator);
+    }
+
+    // But if we still can't find it, give up.
+    return cb(
+      new Error(
+        'Error: Failed to load `' +
+          subGeneratorRef.module +
+          '`...' +
+          (requireError ? ' (' + requireError + ')' : '') +
+          ''
+      )
+    );
+  }
+
+  return cb(
+    new Error(
+      'Unrecognized generator syntax in `targets["' +
+        scope.keyPath +
+        '"]` ::\n' +
+        util.inspect(target)
+    )
+  );
+}
+
+/**
+ *
+ * @param {[Type]} target Description
+ * @return {Boolean} Description
+ */
+
+function isValidTarget(target) {
+  let ok = typeof target === 'object';
+
+  // Is using a helper.
+  // Or is another generator def.
+  ok = ok && (targetIsHelper(target) || _.has(target, 'targets'));
+
+  return ok;
+}

package/lib/util.js

@@ -0,0 +1,62 @@
+'use strict';
+
+/**
+ * From Express core: (MIT License)
+ *
+ * Normalize the given path string,
+ * returning a regular expression.
+ *
+ * An empty array should be passed,
+ * which will contain the placeholder
+ * key names. For example "/user/:id" will
+ * then contain ["id"].
+ *
+ * @param  {String|RegExp|Array} path
+ * @param  {Array} keys
+ * @param  {Boolean} sensitive
+ * @param  {Boolean} strict
+ * @return {RegExp}
+ * @api private
+ */
+
+/* eslint-disable prefer-template */
+/* eslint-disable no-useless-escape */
+const pathRegexp = (path, keys, sensitive, strict) => {
+  if (toString.call(path) === '[object RegExp]') {
+    return path;
+  }
+  if (Array.isArray(path)) {
+    path = '(' + path.join('|') + ')';
+  }
+  path = path
+    .concat(strict ? '' : '/?')
+    .replace(/\/\(/g, '(?:/')
+    .replace(
+      /(\/)?(\.)?:(\w+)(?:(\(.*?\)))?(\?)?(\*)?/g,
+      (_, slash, format, key, capture, optional, star) => {
+        keys.push({
+          name: key,
+          optional: !!optional,
+        });
+        slash = slash || '';
+        return (
+          '' +
+          (optional ? '' : slash) +
+          '(?:' +
+          (optional ? slash : '') +
+          (format || '') +
+          (capture || (format && '([^/.]+?)') || '([^/]+?)') +
+          ')' +
+          (optional || '') +
+          (star ? '(/*)?' : '')
+        );
+      }
+    )
+    .replace(/([\/.])/g, '\\$1')
+    .replace(/\*/g, '(.*)');
+  return new RegExp('^' + path + '$', sensitive ? '' : 'i');
+};
+
+module.exports = {
+  pathRegexp,
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@akemona-org/strapi-generate",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "3.7.0",
+  "description": "Master of ceremonies for the Strapi generators.",
+  "homepage": "https://strapi.akemona.com",
+  "keywords": [
+    "generate",
+    "generator",
+    "strapi"
+  ],
+  "main": "./lib/index.js",
+  "directories": {
+    "lib": "./lib"
+  },
+  "scripts": {
+    "test": "echo \"no tests yet\""
+  },
+  "dependencies": {
+    "@akemona-org/strapi-utils": "3.7.0",
+    "async": "^2.6.2",
+    "fs-extra": "^9.1.0",
+    "lodash": "4.17.21",
+    "reportback": "^2.0.2"
+  },
+  "author": {
+    "name": "Akemona team",
+    "email": "strapi@akemona.com",
+    "url": "https://strapi.akemona.com"
+  },
+  "maintainers": [
+    {
+      "name": "Akemona team",
+      "email": "strapi@akemona.com",
+      "url": "https://strapi.akemona.com"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/akemona/strapi.git"
+  },
+  "bugs": {
+    "url": "https://github.com/akemona/strapi/issues"
+  },
+  "engines": {
+    "node": ">=10.16.0 <=14.x.x",
+    "npm": ">=6.0.0"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "gitHead": "129a8d6191b55810fd66448dcc47fee829df986c"
+}