@flarum/cli 1.0.0 → 2.0.0-beta.12

package/lib/base-command.js

@@ -1,25 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocationType = void 0;
 const tslib_1 = require("tslib");
-const command_1 = require("@oclif/command");
-const cli_ux_1 = tslib_1.__importDefault(require("cli-ux"));
-const path_1 = require("path");
-const prompts_1 = tslib_1.__importDefault(require("prompts"));
-const globby_1 = tslib_1.__importDefault(require("globby"));
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const param_provider_1 = require("./provider/param-provider");
-const step_manager_1 = require("./steps/step-manager");
-const path_provider_1 = require("./provider/path-provider");
-const php_provider_1 = require("./provider/php-provider");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-class BaseCommand extends command_1.Command {
+const core_1 = require("@oclif/core");
+const cli_ux_1 = (0, tslib_1.__importDefault)(require("cli-ux"));
+const node_path_1 = require("node:path");
+const globby_1 = (0, tslib_1.__importDefault)(require("globby"));
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const io_1 = require("boilersmith/io");
+const step_manager_1 = require("boilersmith/step-manager");
+const paths_1 = require("boilersmith/paths");
+const php_provider_1 = require("./providers/php-provider");
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const errors_1 = require("@oclif/errors");
+var LocationType;
+(function (LocationType) {
+    LocationType[LocationType["FLARUM_EXTENSION"] = 0] = "FLARUM_EXTENSION";
+    LocationType[LocationType["FLARUM_CORE"] = 1] = "FLARUM_CORE";
+    LocationType[LocationType["FLARUM_MONOREPO"] = 2] = "FLARUM_MONOREPO";
+})(LocationType = exports.LocationType || (exports.LocationType = {}));
+class BaseCommand extends core_1.Command {
     constructor() {
         super(...arguments);
+        this.STUB_PATH = (0, node_path_1.resolve)(__dirname, '../boilerplate/stubs/');
+        this.dry = false;
         this.requireExistingExtension = true;
     }
     async run() {
-        const { args } = this.parse(this.constructor);
+        const { args, flags } = await this.parse(this.constructor);
+        this.args = args;
+        this.flags = flags;
         const path = args.path;
         const welcomeMessage = this.welcomeMessage();
         if (welcomeMessage) {
@@ -27,24 +38,65 @@ class BaseCommand extends command_1.Command {
         }
         let extRoot;
         if (this.requireExistingExtension) {
-            extRoot = await this.getFlarumExtensionRoot(path || process.cwd());
+            const rootData = await this.getFlarumExtensionRoot(path || process.cwd());
+            extRoot = rootData.path;
+            this.locationType = rootData.type;
             await this.confirmExtDir(extRoot);
         }
         else {
             extRoot = path || process.cwd();
         }
         await this.additionalPreRunChecks(extRoot);
-        const pathProvider = new path_provider_1.PathFsProvider({
+        const paths = new paths_1.NodePaths({
             requestedDir: path,
-            ext: extRoot,
+            package: extRoot,
         });
-        const phpProvider = new php_provider_1.PhpSubsystemProvider(path_1.resolve(__dirname, '../php-subsystem/index.php'));
-        const completed = await this.steps(new step_manager_1.StepManager())
-            .run(pathProvider, param_provider_1.paramProviderFactory, phpProvider);
+        const phpProvider = new php_provider_1.PhpSubsystemProvider((0, node_path_1.resolve)(__dirname, '../php-subsystem/index.php'));
+        const out = await this.steps(new step_manager_1.StepManager())
+            .run(paths, this.genIO(), { php: phpProvider }, this.dry);
+        const errorMessages = out.messages.filter(m => m.type === 'error');
         this.log('\n\n');
-        this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.green('Success! The following steps were completed:'))));
-        completed.forEach(stepName => this.log(`- ${chalk_1.default.dim(stepName)}`));
+        if (out.succeeded && errorMessages.length === 0) {
+            this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.green('Success! The following steps were completed:'))));
+        }
+        else if (out.succeeded) {
+            this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.yellow('All steps completed, but with some errors:'))));
+            for (const message of errorMessages) {
+                this.log(chalk_1.default.dim(chalk_1.default.red(message.message)));
+            }
+            this.log(chalk_1.default.bold(chalk_1.default.yellow('The steps that completed were:')));
+        }
+        else if (out.error === 'EEXIT: 0') {
+            this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.red('Exiting.'))));
+            if (out.stepsRan.length > 0) {
+                this.log(chalk_1.default.bold(chalk_1.default.yellow('Before the exit, the following steps were completed:')));
+            }
+        }
+        else {
+            this.log(chalk_1.default.bold(chalk_1.default.underline(chalk_1.default.red('Error occurred, and could not complete:'))));
+            this.log(chalk_1.default.red(out.error));
+            if (out.errorTrace) {
+                this.log(chalk_1.default.dim(chalk_1.default.red(out.errorTrace)));
+            }
+            if (out.stepsRan.length > 0) {
+                this.log('');
+                this.log(chalk_1.default.bold(chalk_1.default.yellow('Before the error, the following steps were completed:')));
+            }
+        }
+        for (const stepName of out.stepsRan)
+            this.log(`- ${chalk_1.default.dim(stepName)}`);
         this.log('');
+        const nonErrorMessages = out.messages.filter(m => m.type !== 'error');
+        if (nonErrorMessages.length > 0) {
+            this.log('');
+            this.log('The following messages were generated during execution:');
+            for (const message of nonErrorMessages) {
+                this.log(message.message);
+            }
+        }
+        if (!out.succeeded || errorMessages.length > 0) {
+            this.exit(1);
+        }
         const goodbyeMessage = this.goodbyeMessage();
         if (goodbyeMessage) {
             this.log(goodbyeMessage);
@@ -62,43 +114,76 @@ class BaseCommand extends command_1.Command {
     // ----------------------------------------------------------------
     // Confirmation
     // ----------------------------------------------------------------
+    genIO() {
+        return new io_1.PromptsIO({}, [], this.flags['no-interaction'], errors_1.exit);
+    }
+    monorepoPaths(options) {
+        try {
+            const monorepoConfig = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(process.cwd(), 'flarum-monorepo.json'));
+            const contents = JSON.parse(monorepoConfig.toString());
+            return [
+                ...(options.includeCore ? [contents.packages.core] : []),
+                ...(options.includeExtensions ? contents.packages.extensions : []),
+                ...(options.includePhpPackages ? contents.packages.composerPackages : []),
+                ...(options.includeJSPackages ? contents.packages.npmPackages : []),
+            ];
+        }
+        catch (_a) {
+            this.error('Could not run monorepo command: `flarum-monorepo.json` file is missing or invalid.');
+        }
+    }
+    isFlarumCore(path) {
+        try {
+            const composerJsonPath = (0, node_path_1.resolve)(path, 'composer.json');
+            const val = JSON.parse((0, node_fs_1.readFileSync)(composerJsonPath, 'utf8'));
+            return val.name === 'flarum/core';
+        }
+        catch (_a) {
+            return false;
+        }
+    }
     async getFlarumExtensionRoot(currDir) {
-        let currPath = path_1.resolve(currDir);
+        let currPath = (0, node_path_1.resolve)(currDir);
         while (currPath !== '/') {
-            if (fs_1.existsSync(path_1.resolve(currPath, 'composer.json')) && fs_1.existsSync(path_1.resolve(currPath, 'extend.php'))) {
-                return currPath;
+            if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(currPath, 'flarum-monorepo.json'))) {
+                return { path: currPath, type: LocationType.FLARUM_MONOREPO };
+            }
+            if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(currPath, 'composer.json')) && (0, node_fs_1.existsSync)((0, node_path_1.resolve)(currPath, 'extend.php'))) {
+                return { path: currPath, type: LocationType.FLARUM_EXTENSION };
+            }
+            if (this.isFlarumCore(currPath)) {
+                return { path: currPath, type: LocationType.FLARUM_CORE };
             }
-            currPath = path_1.resolve(currPath, '..');
+            currPath = (0, node_path_1.resolve)(currPath, '..');
         }
-        this.error(`${path_1.resolve(currDir)} is not located in a valid Flarum extension! Flarum extensions must contain (at a minimum) 'extend.php' and 'composer.json' files.`);
+        this.error(`${(0, node_path_1.resolve)(currDir)} is not located in a valid Flarum package!
+- Flarum extensions must contain (at a minimum) 'extend.php' and 'composer.json' files.
+- Flarum core must contain a 'composer.json' file with the name 'flarum/core'.
+- Flarum monorepos must have a valid 'flarum-monorepo.json' file`);
     }
     async confirmExtDir(extRoot) {
-        const response = await prompts_1.default([
-            {
-                name: 'verify',
-                type: 'confirm',
-                message: `Work in Flarum extension located at ${path_1.resolve(extRoot)}?`,
-                initial: true,
-            },
-        ], param_provider_1.PROMPTS_OPTIONS);
-        if (!response.verify)
+        const verify = await this.genIO().getParam({
+            name: 'verify',
+            type: 'confirm',
+            message: `Work in Flarum package located at ${(0, node_path_1.resolve)(extRoot)}?`,
+            initial: true,
+        });
+        if (!verify)
             this.exit();
     }
     async ensureComposerInstallRan(extRoot) {
-        if (fs_1.existsSync(path_1.resolve(extRoot, 'vendor/flarum/core/composer.json')))
+        if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(extRoot, 'vendor/flarum/core/composer.json')))
             return;
         this.log("This command requires `composer install` to have been ran in your extension's root directory.");
-        const response = await prompts_1.default([
-            {
-                name: 'composer',
-                type: 'confirm',
-                message: 'Would you like me to take care of that for you?',
-                initial: true,
-            },
-        ], param_provider_1.PROMPTS_OPTIONS);
-        if (response.composer) {
+        const composer = await this.genIO().getParam({
+            name: 'composer',
+            type: 'confirm',
+            message: 'Would you like me to take care of that for you?',
+            initial: true,
+        });
+        if (composer) {
             cli_ux_1.default.action.start('Installing composer packages');
-            child_process_1.execSync('composer install', { cwd: extRoot });
+            (0, node_child_process_1.execSync)('composer install', { cwd: extRoot });
             cli_ux_1.default.action.stop();
         }
         else {
@@ -111,29 +196,30 @@ class BaseCommand extends command_1.Command {
      * If user says no, will exit and not return anything.
      */
     async confirmOverrideFiles(dir, pattern, confirmationMessage) {
-        const files = await globby_1.default(path_1.resolve(dir, pattern));
+        const paths = Array.isArray(pattern) ? pattern : [pattern];
+        const files = await (0, globby_1.default)(paths.map(p => (0, node_path_1.resolve)(dir, p)));
         const empty = files.length === 0 || (files.length === 1 && files[0] === '.git');
         if (empty)
             return false;
-        const response = await prompts_1.default([
-            {
-                name: 'overwrite',
-                type: 'confirm',
-                message: confirmationMessage,
-            },
-        ], param_provider_1.PROMPTS_OPTIONS);
-        if (response.overwrite === false)
+        const overwrite = await this.genIO().getParam({
+            name: 'overwrite',
+            type: 'confirm',
+            message: confirmationMessage,
+            initial: true,
+        });
+        if (overwrite === false)
             this.exit();
         return true;
     }
     async deleteFiles(dir, pattern) {
-        const pathsToDelete = await globby_1.default(path_1.resolve(dir, pattern));
-        pathsToDelete.forEach(fs_1.unlinkSync);
+        const pathsToDelete = await (0, globby_1.default)((0, node_path_1.resolve)(dir, pattern));
+        pathsToDelete.forEach(node_fs_1.unlinkSync);
     }
 }
 exports.default = BaseCommand;
 BaseCommand.flags = {
-    help: command_1.flags.help({ char: 'h' }),
+    'no-interaction': core_1.Flags.boolean({ char: 'n', description: 'Do not ask any interactive questions, assume defaults. When impossible, error.', default: false }),
+    help: core_1.Flags.help({ char: 'h' }),
 };
 BaseCommand.args = [
     {

package/lib/boilersmith/exposed-param-manager.d.ts

@@ -0,0 +1,8 @@
+export declare class ExposedParamManager {
+    protected stepsRan: Set<string>;
+    protected exposedParams: Map<string, unknown>;
+    stepRan(stepName: string, packagePath?: string): boolean;
+    has(stepName: string, paramName: string, packagePath?: string): boolean;
+    get<T = unknown>(stepName: string, paramName: string, packagePath?: string): T;
+    add(stepName: string, params: Record<string, unknown>, packagePath?: string): void;
+}

package/lib/boilersmith/exposed-param-manager.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExposedParamManager = void 0;
+function ranKey(stepName, packagePath = '') {
+    return JSON.stringify([stepName, packagePath]);
+}
+function paramKey(stepName, paramName, packagePath = '') {
+    return JSON.stringify([stepName, paramName, packagePath]);
+}
+class ExposedParamManager {
+    constructor() {
+        this.stepsRan = new Set();
+        this.exposedParams = new Map();
+    }
+    stepRan(stepName, packagePath) {
+        return this.stepsRan.has(ranKey(stepName, packagePath));
+    }
+    has(stepName, paramName, packagePath) {
+        return this.exposedParams.has(paramKey(stepName, paramName, packagePath));
+    }
+    get(stepName, paramName, packagePath) {
+        return this.exposedParams.get(paramKey(stepName, paramName, packagePath));
+    }
+    add(stepName, params, packagePath) {
+        this.stepsRan.add(ranKey(stepName, packagePath));
+        Object.entries(params).forEach(([paramName, value]) => {
+            this.exposedParams.set(paramKey(stepName, paramName, packagePath), value);
+        });
+    }
+}
+exports.ExposedParamManager = ExposedParamManager;

package/lib/boilersmith/io.d.ts

@@ -0,0 +1,54 @@
+import { PromptObject } from 'prompts';
+export declare type ParamDef<N extends string = string> = Omit<PromptObject<N>, 'name'> & {
+    name: N;
+};
+export declare type Message = {
+    type: 'info' | 'warning' | 'error';
+    message: string;
+};
+export interface IO {
+    supportsAnsiColor: boolean;
+    /**
+     * Prompt the user for some input data.
+     */
+    getParam<T>(param: ParamDef): Promise<T>;
+    /**
+     * Check if some data has already been prompted for.
+     */
+    hasCached(name: string): boolean;
+    /**
+     * Get all cached params.
+     */
+    cached(): Record<string, unknown>;
+    info(message: string, immediate: boolean): void;
+    warning(message: string, immediate: boolean): void;
+    error(message: string, immediate: boolean): void;
+    /**
+     * Get all messages that have been logged non-immediately.
+     */
+    getOutput(): Message[];
+    newInstance(cache: Record<string, unknown>, messages: Message[]): IO;
+}
+declare type OnCancel = () => void;
+export declare class PromptsIO implements IO {
+    supportsAnsiColor: boolean;
+    private cache;
+    private messages;
+    private noInteraction;
+    private onCancel?;
+    private prev?;
+    constructor(initial?: Record<string, unknown>, messages?: Message[], noInteraction?: boolean, onCancel?: OnCancel);
+    getParam<T>(paramDef: ParamDef): Promise<T>;
+    hasCached(name: string): boolean;
+    /**
+     * @internal
+     */
+    cached(): Record<string, unknown>;
+    info(message: string, immediate: boolean): void;
+    warning(message: string, immediate: boolean): void;
+    error(message: string, immediate: false): void;
+    error(message: string, immediate: true): never;
+    getOutput(): Message[];
+    newInstance(cache: Record<string, unknown>, messages: Message[]): PromptsIO;
+}
+export {};

package/lib/boilersmith/io.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptsIO = void 0;
+const tslib_1 = require("tslib");
+const prompts_1 = (0, tslib_1.__importDefault)(require("prompts"));
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+class PromptsIO {
+    constructor(initial = {}, messages = [], noInteraction = false, onCancel = () => {
+        throw new Error('EEXIT: 0');
+    }) {
+        this.supportsAnsiColor = true;
+        this.cache = new Map();
+        this.cache = new Map(Object.entries(initial));
+        this.messages = messages;
+        this.noInteraction = noInteraction;
+        this.onCancel = onCancel;
+    }
+    async getParam(paramDef) {
+        var _a, _b, _c;
+        const paramName = paramDef.name;
+        if (this.cache.has(paramName)) {
+            return this.cache.get(paramName);
+        }
+        let resValue;
+        if (this.noInteraction) {
+            if (paramDef.initial && paramDef.initial instanceof Function) {
+                resValue = paramDef.initial((_a = this.prev) === null || _a === void 0 ? void 0 : _a.val, this.cache, (_b = this.prev) === null || _b === void 0 ? void 0 : _b.prompt);
+            }
+            else if (paramDef.type === 'confirm' || paramDef.type === 'toggle') {
+                resValue = ((_c = paramDef.initial) !== null && _c !== void 0 ? _c : false);
+            }
+            else if ('initial' in paramDef) {
+                resValue = paramDef.initial;
+            }
+            else {
+                return this.error(`No-Interaction mode is on, but input is required for param "${paramName}".`, true);
+            }
+        }
+        else {
+            const res = (await (0, prompts_1.default)(paramDef, {
+                onCancel: this.onCancel,
+            }));
+            resValue = res[paramName];
+        }
+        this.cache.set(paramName, resValue);
+        this.prev = {
+            val: resValue,
+            prompt: paramDef,
+        };
+        return resValue;
+    }
+    hasCached(name) {
+        return this.cache.has(name);
+    }
+    /**
+     * @internal
+     */
+    cached() {
+        return [...this.cache].reduce((obj, [key, value]) => {
+            obj[key] = value;
+            return obj;
+        }, {});
+    }
+    info(message, immediate) {
+        if (immediate) {
+            console.log(message);
+        }
+        else {
+            this.messages.push({ type: 'info', message });
+        }
+    }
+    warning(message, immediate) {
+        const formatted = `${chalk_1.default.yellow('Warning:')} ${message}`;
+        if (immediate) {
+            console.log(formatted);
+        }
+        else {
+            this.messages.push({ type: 'warning', message: formatted });
+        }
+    }
+    error(message, immediate) {
+        const formatted = `${chalk_1.default.red('Error:')} ${message}`;
+        if (immediate) {
+            throw new Error(message);
+        }
+        else {
+            this.messages.push({ type: 'error', message: formatted });
+        }
+    }
+    getOutput() {
+        return this.messages;
+    }
+    newInstance(cache, messages) {
+        return new PromptsIO(cache, messages, this.noInteraction, this.onCancel);
+    }
+}
+exports.PromptsIO = PromptsIO;

package/lib/boilersmith/paths.d.ts

@@ -0,0 +1,22 @@
+export interface Paths {
+    cwd(...path: string[]): string;
+    package(...path: string[]): string;
+    requestedDir(...path: string[]): string | null;
+    monorepo(...path: string[]): string | null;
+    onMonorepoSub(packagePath: string): Paths;
+}
+declare type InternalPaths = {
+    package: string;
+    monorepo?: string | null;
+    requestedDir?: string | null;
+};
+export declare class NodePaths implements Paths {
+    protected paths: InternalPaths;
+    constructor(paths: InternalPaths);
+    cwd(...path: string[]): string;
+    package(...path: string[]): string;
+    requestedDir(...path: string[]): string | null;
+    monorepo(...path: string[]): string | null;
+    onMonorepoSub(packagePath: string): NodePaths;
+}
+export {};

package/lib/boilersmith/paths.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodePaths = void 0;
+const node_path_1 = require("node:path");
+class NodePaths {
+    constructor(paths) {
+        this.paths = paths;
+    }
+    cwd(...path) {
+        return (0, node_path_1.resolve)(process.cwd(), ...path);
+    }
+    package(...path) {
+        return (0, node_path_1.resolve)(this.paths.package, ...path);
+    }
+    requestedDir(...path) {
+        if (!this.paths.requestedDir)
+            return null;
+        return (0, node_path_1.resolve)(this.paths.requestedDir, ...path);
+    }
+    monorepo(...path) {
+        if (!this.paths.monorepo)
+            return null;
+        return (0, node_path_1.resolve)(this.paths.monorepo, ...path);
+    }
+    onMonorepoSub(packagePath) {
+        return new NodePaths(Object.assign(Object.assign({}, this.paths), { monorepo: this.paths.package, package: packagePath }));
+    }
+}
+exports.NodePaths = NodePaths;

package/lib/boilersmith/scaffolding/audit-step-factory.d.ts

@@ -0,0 +1,5 @@
+import { DefaultProviders, Step } from '../step-manager';
+import { Module, ModuleStatusCache } from './module';
+import { TemplateParam } from './template-param';
+import { ExcludeScaffoldingFunc } from './scaffolder';
+export declare function auditStepFactory<MN extends string, Providers extends DefaultProviders>(dry: boolean, scaffoldDir: string, modules: Module<MN>[], templateParams: TemplateParam[], excludeScaffoldingFunc?: ExcludeScaffoldingFunc, moduleStatusCache?: ModuleStatusCache<MN>): Step<Providers>;

package/lib/boilersmith/scaffolding/audit-step-factory.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditStepFactory = void 0;
+const tslib_1 = require("tslib");
+const mem_fs_1 = require("mem-fs");
+const rename_keys_1 = require("../utils/rename-keys");
+const module_1 = require("./module");
+const template_param_1 = require("./template-param");
+const cond_format_1 = require("boilersmith/utils/cond-format");
+const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
+const node_fs_1 = require("node:fs");
+function auditStepFactory(dry, scaffoldDir, modules, templateParams, excludeScaffoldingFunc, moduleStatusCache) {
+    let modulesEnabled;
+    return {
+        type: 'Audit for outdated infrastructure files or config.',
+        composable: true,
+        async run(_fs, paths, io, _providers) {
+            const paramVals = await (0, template_param_1.currParamValues)(templateParams, _fs, paths, io);
+            modulesEnabled = await (0, module_1.currModulesEnabled)(modules, _fs, paths, moduleStatusCache);
+            const actionableModules = modules.filter(m => m.updatable && modulesEnabled[m.name] && (!m.togglable || !m.dependsOn.some(dep => !modulesEnabled[dep])));
+            io.info((0, cond_format_1.condFormat)(io.supportsAnsiColor, m => chalk_1.default.yellow(chalk_1.default.bold(chalk_1.default.underline(m))), `Auditing infrastructure for ${actionableModules.length} enabled modules:`), true);
+            for (const m of modules) {
+                if (actionableModules.includes(m)) {
+                    io.info((0, cond_format_1.condFormat)(io.supportsAnsiColor, m => chalk_1.default.dim(chalk_1.default.green(m)), `✓ ${m.name}: ${m.shortDescription}`), true);
+                }
+                else if (m.updatable) {
+                    io.info((0, cond_format_1.condFormat)(io.supportsAnsiColor, m => chalk_1.default.dim(chalk_1.default.red(m)), `𐄂 ${m.name}: ${m.shortDescription} (disabled)`), true);
+                }
+            }
+            for (const m of actionableModules) {
+                const fs = dry ? (0, mem_fs_1.create)() : _fs;
+                const excludeScaffolding = excludeScaffoldingFunc ? excludeScaffoldingFunc(fs, paths) : [];
+                (0, module_1.applyModule)(m, modulesEnabled, paramVals, scaffoldDir, fs, paths, excludeScaffolding, true);
+                if (dry) {
+                    const filesWithChanges = fs
+                        .all()
+                        .filter(f => f.state && f.state !== 'deleted')
+                        .filter(f => { var _a; return !(0, node_fs_1.existsSync)(f.path) || (0, node_fs_1.readFileSync)(f.path, 'utf8').toString() !== ((_a = f.contents) === null || _a === void 0 ? void 0 : _a.toString()); });
+                    if (filesWithChanges.length > 0) {
+                        io.error(`Module ${m.name} has ${filesWithChanges.length} changed files: ${filesWithChanges
+                            .map(f => f.path.replace(paths.package() + '/', ''))
+                            .join(', ')}`, false);
+                    }
+                }
+            }
+            if (!dry) {
+                for (const m of modules) {
+                    if (moduleStatusCache && m.updatable && (actionableModules.includes(m) || m.togglable)) {
+                        (0, module_1.setModuleValue)(m, actionableModules.includes(m), _fs, paths, moduleStatusCache);
+                    }
+                }
+            }
+            return _fs;
+        },
+        exposes: modules.map(m => `modules.${m.name}`),
+        getExposed(_paths, _paramProvider) {
+            return (0, rename_keys_1.renameKeys)(modulesEnabled, k => `modules.${k}`);
+        },
+    };
+}
+exports.auditStepFactory = auditStepFactory;

package/lib/boilersmith/scaffolding/infra-step-factory.d.ts

@@ -0,0 +1,5 @@
+import { DefaultProviders, Step } from '../step-manager';
+import { Module, ModuleStatusCache } from './module';
+import { TemplateParam } from './template-param';
+import { ExcludeScaffoldingFunc } from './scaffolder';
+export declare function infraStepFactory<MN extends string, Providers extends DefaultProviders>(scaffoldDir: string, moduleName: string, modules: Module<MN>[], templateParams: TemplateParam[], excludeScaffoldingFunc?: ExcludeScaffoldingFunc, moduleStatusCache?: ModuleStatusCache<MN>): Step<Providers>;

package/lib/boilersmith/scaffolding/infra-step-factory.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.infraStepFactory = void 0;
+const module_1 = require("./module");
+const template_param_1 = require("./template-param");
+function infraStepFactory(scaffoldDir, moduleName, modules, templateParams, excludeScaffoldingFunc, moduleStatusCache) {
+    const module = modules.find(m => m.name === moduleName);
+    if (!module) {
+        throw new Error(`Module ${moduleName} not found`);
+    }
+    return {
+        type: module.shortDescription,
+        composable: true,
+        async run(fs, paths, io, _providers) {
+            const paramVals = await (0, template_param_1.currParamValues)(templateParams, fs, paths, io);
+            const modulesEnabled = await (0, module_1.currModulesEnabled)(modules, fs, paths, moduleStatusCache);
+            if (!module.updatable) {
+                io.error(`${module.name} is not updatable.`, true);
+            }
+            const excludeScaffolding = excludeScaffoldingFunc ? excludeScaffoldingFunc(fs, paths) : [];
+            const initializing = !modulesEnabled[module.name];
+            (0, module_1.applyModule)(module, Object.assign(Object.assign({}, modulesEnabled), { [module.name]: true }), paramVals, scaffoldDir, fs, paths, excludeScaffolding, initializing);
+            if (moduleStatusCache) {
+                (0, module_1.setModuleValue)(module, true, fs, paths, moduleStatusCache);
+            }
+            return fs;
+        },
+        exposes: [],
+        getExposed(_paths, _paramProvider) {
+            return {};
+        },
+    };
+}
+exports.infraStepFactory = infraStepFactory;

package/lib/boilersmith/scaffolding/init-step-factory.d.ts

@@ -0,0 +1,5 @@
+import { DefaultProviders, Step } from '../step-manager';
+import { Module, ModuleStatusCache } from './module';
+import { TemplateParam } from './template-param';
+import { ExcludeScaffoldingFunc } from './scaffolder';
+export declare function initStepFactory<MN extends string, Providers extends DefaultProviders>(scaffoldDir: string, modules: Module<MN>[], templateParams: TemplateParam[], excludeScaffoldingFunc?: ExcludeScaffoldingFunc, moduleStatusCache?: ModuleStatusCache<MN>): Step<Providers>;