@flarum/cli 1.0.0 → 2.0.0-beta.12

package/lib/boilersmith/step-manager.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtomicStepManager = exports.StepManager = void 0;
+/* eslint-disable no-await-in-loop */
+const mem_fs_1 = require("mem-fs");
+const mem_fs_editor_1 = require("mem-fs-editor");
+const exposed_param_manager_1 = require("./exposed-param-manager");
+const formatDependencies = (strings) => strings.map(s => `"${s}"`).join(', ');
+class StepManager {
+    constructor() {
+        this.steps = [];
+        this.namedSteps = new Map();
+        this.exposedParams = new exposed_param_manager_1.ExposedParamManager();
+    }
+    /**
+     * A step is an incremental operation that updates the filesystem.
+     */
+    step(step, shouldRun = {}, dependencies = [], predefinedParams = {}, mapPaths = []) {
+        this.validateDependencies(step, dependencies, mapPaths);
+        this.steps = [...this.steps, { step, shouldRun, dependencies, predefinedParams, mapPaths }];
+        return this;
+    }
+    namedStep(name, step, shouldRun = {}, dependencies = [], predefinedParams = {}, mapPaths = []) {
+        if (this.namedSteps.has(name)) {
+            throw new Error(`Named steps must have unique names. A step with name "${name}" already exists.`);
+        }
+        this.validateDependencies(step, dependencies, mapPaths);
+        const newStep = { name, step, shouldRun, dependencies, predefinedParams, mapPaths };
+        this.steps = [...this.steps, newStep];
+        this.namedSteps.set(name, newStep);
+        return this;
+    }
+    atomicGroup(callback) {
+        const atomicCollection = new AtomicStepManager(this.namedSteps, this.exposedParams);
+        callback(atomicCollection);
+        this.steps = [...this.steps, atomicCollection];
+        return this;
+    }
+    validateDependencies(step, dependencies, mapPaths) {
+        const missingDependencySteps = dependencies.map(dep => dep.sourceStep).filter(stepName => !this.namedSteps.has(stepName));
+        if (missingDependencySteps.length > 0) {
+            throw new Error(`Step of type "${step.type}" depends on nonexistent named steps ${formatDependencies(missingDependencySteps)}`);
+        }
+        const missingDependencyParams = [];
+        const missingDependencyParamSteps = [];
+        for (const dependency of dependencies) {
+            const sourceStep = this.namedSteps.get(dependency.sourceStep);
+            if (!(sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.step.exposes.includes(dependency.exposedName)) && dependency.exposedName !== '__succeeded') {
+                missingDependencyParamSteps.push(sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.name);
+                missingDependencyParams.push(dependency.exposedName);
+            }
+            if (mapPaths.length === 0 && (sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.mapPaths.length)) {
+                throw new Error(`Non path-mapped step of type "${step.type}" may not depend on path-mapped step "${sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.name}".`);
+            }
+            const missingMapPathsDeps = mapPaths.filter(p => sourceStep && !sourceStep.mapPaths.includes(p));
+            if (sourceStep && (missingMapPathsDeps === null || missingMapPathsDeps === void 0 ? void 0 : missingMapPathsDeps.length) && sourceStep.mapPaths.length > 0) {
+                throw new Error(`Step of type "${step.type}" (A) depends on named step: "${sourceStep.name}" (B), but is mapped across some paths that (B) is not: "${missingMapPathsDeps.join(', ')}"`);
+            }
+        }
+        if (missingDependencyParamSteps.length > 0) {
+            throw new Error(`Step of type "${step.type}" depends on nonexistent exposed params ${formatDependencies(missingDependencyParams)} from named steps ${formatDependencies(missingDependencyParamSteps)}`);
+        }
+    }
+    async run(paths, io, providers, dry = false) {
+        if (dry && this.steps.some(s => !(s instanceof AtomicStepManager) && !s.step.composable)) {
+            throw new Error('Cannot dry run, as this step manager has non-composable steps.');
+        }
+        const stepNames = [];
+        const checkAndRun = async (step, packagePath) => {
+            const shouldRun = await this.stepShouldRun(step, io, packagePath);
+            if (!shouldRun)
+                return;
+            const fs = await this.runStep(step, paths, io, providers, packagePath);
+            if (!dry) {
+                await this.commit(fs);
+            }
+            stepNames.push(packagePath ? `${step.step.type} (${packagePath})` : step.step.type);
+        };
+        try {
+            for (const storedStep of this.steps) {
+                if (storedStep instanceof AtomicStepManager) {
+                    const res = await storedStep.run(paths, io, providers);
+                    if (!res.succeeded) {
+                        throw new Error(res.error);
+                    }
+                    stepNames.push(...res.stepsRan);
+                }
+                else if (storedStep.mapPaths.length > 0) {
+                    for (const path of storedStep.mapPaths) {
+                        await checkAndRun(storedStep, path);
+                    }
+                }
+                else {
+                    await checkAndRun(storedStep);
+                }
+            }
+        }
+        catch (error) {
+            return {
+                succeeded: false,
+                error: error instanceof Error ? error.message : String(error),
+                errorTrace: error instanceof Error ? error.stack : undefined,
+                stepsRan: stepNames,
+                messages: io.getOutput(),
+            };
+        }
+        return {
+            succeeded: true,
+            stepsRan: stepNames,
+            messages: io.getOutput(),
+        };
+    }
+    async stepShouldRun(storedStep, io, packagePath) {
+        let allDependenciesRan = true;
+        let noRequiredNonFalsyDependenciesAreFalsy = true;
+        for (const dep of storedStep.dependencies) {
+            const sourceStep = this.namedSteps.get(dep.sourceStep);
+            const sourcePackagePath = (sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.mapPaths.length) ? packagePath : undefined;
+            if (!this.exposedParams.stepRan(dep.sourceStep, sourcePackagePath))
+                allDependenciesRan = false;
+            if (dep.exposedName !== '__succeeded' && dep.dontRunIfFalsy && !this.exposedParams.get(dep.sourceStep, dep.exposedName, sourcePackagePath)) {
+                noRequiredNonFalsyDependenciesAreFalsy = false;
+            }
+        }
+        if (!allDependenciesRan || !noRequiredNonFalsyDependenciesAreFalsy)
+            return false;
+        if (!storedStep.shouldRun.optional)
+            return true;
+        const promptConfirm = await io.newInstance({ context: 'Confirm Step' }, []).getParam({
+            name: 'execute_step',
+            message: storedStep.shouldRun.confirmationMessage || `Run step of type "${storedStep.step.type}"?`,
+            initial: storedStep.shouldRun.default || false,
+            type: 'confirm',
+        });
+        return promptConfirm;
+    }
+    async runStep(storedStep, paths, io, providers, packagePath, fs = (0, mem_fs_1.create)()) {
+        const initial = storedStep.dependencies.reduce((initial, dep) => {
+            const sourceStep = this.namedSteps.get(dep.sourceStep);
+            let depValue;
+            depValue =
+                dep.exposedName === '__succeeded' ?
+                    this.exposedParams.stepRan(dep.sourceStep, packagePath) :
+                    this.exposedParams.get(dep.sourceStep, dep.exposedName, (sourceStep === null || sourceStep === void 0 ? void 0 : sourceStep.mapPaths.length) ? packagePath : undefined);
+            if (dep.modifier) {
+                depValue = dep.modifier(depValue);
+            }
+            initial[dep.consumedName || dep.exposedName] = depValue;
+            return initial;
+        }, {});
+        const cloned = io.newInstance(Object.assign(Object.assign({}, initial), storedStep.predefinedParams), io.getOutput());
+        const stepPaths = packagePath ? paths.onMonorepoSub(packagePath) : paths;
+        const newFs = await storedStep.step.run(fs, stepPaths, cloned, providers);
+        if (storedStep.name) {
+            this.exposedParams.add(storedStep.name, storedStep.step.getExposed(stepPaths, io), packagePath);
+        }
+        return newFs;
+    }
+    async commit(fs) {
+        return new Promise((resolve, _reject) => {
+            (0, mem_fs_editor_1.create)(fs).commit(err => {
+                if (err) {
+                    throw new Error(err);
+                }
+                resolve(true);
+            });
+        });
+    }
+}
+exports.StepManager = StepManager;
+class AtomicStepManager extends StepManager {
+    constructor(parentNamedSteps = new Map(), parentExposedParams = new exposed_param_manager_1.ExposedParamManager()) {
+        super();
+        this.steps = [];
+        this.namedSteps = parentNamedSteps;
+        this.exposedParams = parentExposedParams;
+    }
+    step(step, shouldRun = {}, dependencies = [], predefinedParams = {}, mapPaths = []) {
+        if (!step.composable) {
+            throw new Error(`Step of type "${step.type}" is not composable, and cannot be added to an atomic group.`);
+        }
+        return super.step(step, shouldRun, dependencies, predefinedParams, mapPaths);
+    }
+    namedStep(name, step, shouldRun = {}, dependencies = [], predefinedParams = {}, mapPaths = []) {
+        if (!step.composable) {
+            throw new Error(`Step of type "${step.type}" is not composable, and cannot be added to an atomic group.`);
+        }
+        return super.namedStep(name, step, shouldRun, dependencies, predefinedParams, mapPaths);
+    }
+    atomicGroup(_callback) {
+        throw new Error("Atomic groups can't be nested.");
+    }
+    async run(paths, io, providers, dry = false) {
+        let fs = (0, mem_fs_1.create)();
+        const checkAndRun = async (step, packagePath) => {
+            const shouldRun = await this.stepShouldRun(step, io, packagePath);
+            if (!shouldRun)
+                return;
+            fs = await this.runStep(step, paths, io, providers, packagePath, fs);
+            stepNames.push(packagePath ? `${step.step.type} (${packagePath})` : step.step.type);
+        };
+        const stepNames = [];
+        try {
+            for (const storedStep of this.steps) {
+                if (storedStep.mapPaths.length > 0) {
+                    for (const path of storedStep.mapPaths) {
+                        await checkAndRun(storedStep, path);
+                    }
+                }
+                else {
+                    await checkAndRun(storedStep);
+                }
+            }
+        }
+        catch (error) {
+            return {
+                error: error instanceof Error ? error.message : String(error),
+                errorTrace: error instanceof Error ? error.stack : undefined,
+                succeeded: false,
+                stepsRan: [],
+                messages: io.getOutput(),
+            };
+        }
+        if (!dry) {
+            await this.commit(fs);
+        }
+        return {
+            succeeded: true,
+            stepsRan: stepNames,
+            messages: io.getOutput(),
+        };
+    }
+}
+exports.AtomicStepManager = AtomicStepManager;

package/lib/boilersmith/steps/stub-base.d.ts

@@ -0,0 +1,53 @@
+import { Store } from 'mem-fs';
+import { ParamDef, IO } from 'boilersmith/io';
+import { Paths } from 'boilersmith/paths';
+import { DefaultProviders, Step } from 'boilersmith/step-manager';
+import { Scaffolder } from 'boilersmith/scaffolding/scaffolder';
+interface UserProvidedParam extends Omit<ParamDef, 'type'> {
+    type: string;
+}
+export interface StubGenerationSchema {
+    /**
+     * A period-delimited subdirectory for where the stub should be
+     * located relative to the package root (IE `schema.root`).
+     */
+    recommendedSubdir: string;
+    /**
+     * Create the file in the recommended subdir regardless
+     * of the current requested dir.
+     */
+    forceRecommendedSubdir?: boolean;
+    /**
+     * Where should the file be created in relation to the extension root?
+     *
+     * Defaults to `./src`.
+     */
+    root?: string;
+    /**
+     * The relative path to the stub's source file relative to the
+     * `stubs` directory.
+     */
+    sourceFile: string;
+    params: UserProvidedParam[];
+}
+export declare abstract class BaseStubStep<Providers extends DefaultProviders, PN extends string = string, MN extends string = string> implements Step<Providers> {
+    protected stubDir: string;
+    protected scaffolder: Scaffolder<PN, MN>;
+    constructor(stubDir: string, scaffolder: Scaffolder<PN, MN>);
+    abstract type: string;
+    protected abstract defaultRoot: string;
+    protected abstract schema: StubGenerationSchema;
+    composable: boolean;
+    get exposes(): string[];
+    protected additionalExposes: string[];
+    get implicitParams(): string[];
+    protected additionalImplicitParams: string[];
+    protected params: Record<string, unknown>;
+    protected subdir: string;
+    run(fs: Store, paths: Paths, io: IO, _providers: Providers): Promise<Store>;
+    getExposed(_paths: Paths, _paramProvider: IO): Record<string, unknown>;
+    protected precompileParams(_fs: Store, _paths: Paths, _paramProvider: IO): Promise<Record<string, unknown>>;
+    protected compileParams(fs: Store, paths: Paths, io: IO): Promise<Record<string, unknown>>;
+    protected abstract getFileName(_fs: Store, _paths: Paths, io: IO): Promise<string>;
+}
+export {};

package/lib/boilersmith/steps/stub-base.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStubStep = void 0;
+const tslib_1 = require("tslib");
+const pick_deep_1 = (0, tslib_1.__importDefault)(require("pick-deep"));
+const mem_fs_editor_1 = require("mem-fs-editor");
+const clone_and_fill_1 = require("../utils/clone-and-fill");
+const node_path_1 = require("node:path");
+class BaseStubStep {
+    constructor(stubDir, scaffolder) {
+        this.composable = true;
+        this.additionalExposes = [];
+        this.additionalImplicitParams = [];
+        this.params = {};
+        this.stubDir = stubDir;
+        this.scaffolder = scaffolder;
+    }
+    get exposes() {
+        return this.additionalExposes;
+    }
+    get implicitParams() {
+        return [...this.additionalImplicitParams, 'extensionId'];
+    }
+    async run(fs, paths, io, _providers) {
+        const fsEditor = (0, mem_fs_editor_1.create)(fs);
+        this.params = await this.compileParams(fs, paths, io);
+        const newFileName = await this.getFileName(fs, paths, io);
+        const newFilePath = paths.package(this.schema.root || this.defaultRoot, this.subdir, newFileName);
+        const stub = (0, clone_and_fill_1.cloneAndFill)(this.schema.sourceFile, this.params);
+        fsEditor.copyTpl((0, node_path_1.resolve)(this.stubDir, stub), newFilePath, this.params);
+        return fs;
+    }
+    getExposed(_paths, _paramProvider) {
+        return (0, pick_deep_1.default)(this.params, this.exposes);
+    }
+    async precompileParams(_fs, _paths, _paramProvider) {
+        return {};
+    }
+    async compileParams(fs, paths, io) {
+        const params = await this.precompileParams(fs, paths, io);
+        const paramDefs = this.schema.params.filter(param => !this.implicitParams.includes(param.name) && !Object.keys(params).includes(param.name));
+        for (const paramDef of paramDefs) {
+            // eslint-disable-next-line no-await-in-loop
+            params[paramDef.name] = await io.getParam(paramDef);
+        }
+        for (const implicitParam of this.implicitParams) {
+            if (!params[implicitParam] && io.hasCached(implicitParam)) {
+                params[implicitParam] = io.cached()[implicitParam];
+            }
+        }
+        return params;
+    }
+}
+exports.BaseStubStep = BaseStubStep;

package/lib/{utils → boilersmith/utils}/clone-and-fill.js

@@ -16,10 +16,10 @@ function cloneAndFill(obj, params) {
         if (obj !== new Object(obj))
             return obj;
         const newObj = {};
-        Object.keys(obj).forEach(key => {
+        for (const key of Object.keys(obj)) {
             const value = obj[key];
             newObj[key] = recursiveCopyAndFill(value, params);
-        });
+        }
         return newObj;
     };
     return recursiveCopyAndFill(obj, params);

package/lib/boilersmith/utils/cond-format.d.ts

@@ -0,0 +1 @@
+export declare function condFormat(condition: boolean, format: (...args: string[]) => string, message: string | string[]): string;

package/lib/boilersmith/utils/cond-format.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.condFormat = void 0;
+function condFormat(condition, format, message) {
+    const args = Array.isArray(message) ? message : [message];
+    return condition ? format(...args) : args.join(' ');
+}
+exports.condFormat = condFormat;

package/lib/boilersmith/utils/json-leaf-paths.d.ts

@@ -0,0 +1,7 @@
+declare type JSONSchema = string | number | boolean | JSONSchemaObject | JSONSchemaArray | null;
+interface JSONSchemaObject {
+    [key: string]: JSONSchema;
+}
+declare type JSONSchemaArray = Array<JSONSchema>;
+export declare function jsonLeafPaths(obj: JSONSchema): string[];
+export {};

package/lib/boilersmith/utils/json-leaf-paths.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonLeafPaths = void 0;
+function inner(o, prefix) {
+    if (Array.isArray(o)) {
+        // Placed separately in case we eventually decide to support leaves in arrays.
+        return [prefix.join('.')];
+    }
+    if (o && typeof o === 'object') {
+        return Object.entries(o).flatMap(([k, v]) => inner(v, [...prefix, k]));
+    }
+    return [prefix.join('.')];
+}
+function jsonLeafPaths(obj) {
+    return inner(obj, []);
+}
+exports.jsonLeafPaths = jsonLeafPaths;

package/lib/boilersmith/utils/read-tpl.d.ts

@@ -0,0 +1,2 @@
+import { Data, Options } from 'ejs';
+export declare function readTpl(path: string, data: Data, options?: Options): string;

package/lib/boilersmith/utils/read-tpl.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTpl = void 0;
+const ejs_1 = require("ejs");
+const node_fs_1 = require("node:fs");
+function readTpl(path, data, options) {
+    const template = (0, node_fs_1.readFileSync)(path, 'utf8');
+    return (0, ejs_1.render)(template, data, Object.assign(Object.assign({ filename: path }, options), { async: false }));
+}
+exports.readTpl = readTpl;

package/lib/boilersmith/utils/rename-keys.d.ts

@@ -0,0 +1 @@
+export declare function renameKeys(obj: Record<string, unknown>, func: (key: string, val: unknown) => string): Record<string, unknown>;

package/lib/boilersmith/utils/rename-keys.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renameKeys = void 0;
+function renameKeys(obj, func) {
+    return Object.fromEntries(Object.entries(obj).map(([key, val]) => [func(key, val), val]));
+}
+exports.renameKeys = renameKeys;

package/lib/commands/audit/infra.d.ts

@@ -0,0 +1,16 @@
+import { StepManager } from 'boilersmith/step-manager';
+import BaseCommand from '../../base-command';
+import { FlarumProviders } from '../../providers';
+export default class AuditInfra extends BaseCommand {
+    static description: string;
+    static flags: {
+        fix: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        monorepo: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        name: string;
+        description: string;
+    }[];
+    protected steps(stepManager: StepManager<FlarumProviders>): StepManager<FlarumProviders>;
+    protected additionalPreRunChecks(extRoot: string): Promise<void>;
+}

package/lib/commands/audit/infra.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const base_command_1 = (0, tslib_1.__importDefault)(require("../../base-command"));
+const gen_ext_scaffolder_1 = require("../../steps/gen-ext-scaffolder");
+const core_1 = require("@oclif/core");
+class AuditInfra extends base_command_1.default {
+    steps(stepManager) {
+        this.dry = !this.flags.fix;
+        const mapPaths = this.flags.monorepo ? this.monorepoPaths({
+            includeCore: true,
+            includeExtensions: true,
+            includePhpPackages: false,
+            includeJSPackages: false,
+        }) : [];
+        stepManager.step((0, gen_ext_scaffolder_1.genExtScaffolder)().genAuditStep(!this.flags.fix), {}, [], {}, mapPaths);
+        return stepManager;
+    }
+    async additionalPreRunChecks(extRoot) {
+        const files = (0, gen_ext_scaffolder_1.genExtScaffolder)().moduleFiles(this.args.module);
+        await this.confirmOverrideFiles(extRoot, files, 'Infrastructure files already exist. Overwrite with the latest version?');
+    }
+}
+exports.default = AuditInfra;
+AuditInfra.description = 'Check for outdated config files, infrastructure, setup, etc.';
+AuditInfra.flags = Object.assign({ fix: core_1.Flags.boolean({ char: 'f', default: false }), monorepo: core_1.Flags.boolean({ char: 'm', default: false }) }, base_command_1.default.flags);
+AuditInfra.args = [...base_command_1.default.args];

package/lib/commands/infra.d.ts

@@ -0,0 +1,20 @@
+import { StepManager } from 'boilersmith/step-manager';
+import BaseCommand from '../base-command';
+import { FlarumProviders } from '../providers';
+export default class Infra extends BaseCommand {
+    static description: string;
+    static flags: {
+        monorepo: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: ({
+        name: string;
+        description: string;
+    } | {
+        name: string;
+        description: string;
+        required: boolean;
+        options: ("core" | "icon" | "admin" | "forum" | "js" | "jsCommon" | "css" | "locale" | "gitConf" | "githubActions" | "prettier" | "typescript" | "bundlewatch" | "backendTesting" | "editorConfig" | "styleci")[];
+    })[];
+    protected steps(stepManager: StepManager<FlarumProviders>): StepManager<FlarumProviders>;
+    protected additionalPreRunChecks(extRoot: string): Promise<void>;
+}

package/lib/commands/infra.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const composer_1 = require("../steps/misc/composer");
+const base_command_1 = (0, tslib_1.__importDefault)(require("../base-command"));
+const gen_ext_scaffolder_1 = require("../steps/gen-ext-scaffolder");
+const yarn_1 = require("../steps/misc/yarn");
+const core_1 = require("@oclif/core");
+class Infra extends base_command_1.default {
+    steps(stepManager) {
+        const module = this.args.module;
+        const mapPaths = this.flags.monorepo ? this.monorepoPaths({
+            includeCore: true,
+            includeExtensions: true,
+            includePhpPackages: false,
+            includeJSPackages: false,
+        }) : [];
+        stepManager
+            .namedStep('infra', (0, gen_ext_scaffolder_1.genExtScaffolder)().genInfraStep(this.args.module), {}, [], {}, mapPaths);
+        const JS_MODULES = ['js', 'prettier', 'typescript'];
+        const PHP_MODULES = ['backendTesting'];
+        if (!this.flags.monorepo && JS_MODULES.includes(module)) {
+            stepManager.step(new yarn_1.YarnInstall(), { optional: true, confirmationMessage: 'Run `yarn`? (recommended)', default: true }, [
+                {
+                    sourceStep: 'infra',
+                    exposedName: '__succeeded',
+                    dontRunIfFalsy: true,
+                },
+            ]);
+        }
+        if (!this.flags.monorepo && PHP_MODULES.includes(module)) {
+            stepManager.step(new composer_1.ComposerInstall(), { optional: true, confirmationMessage: 'Run `composer update`? (recommended)', default: true }, [
+                {
+                    sourceStep: 'infra',
+                    exposedName: '__succeeded',
+                    dontRunIfFalsy: true,
+                },
+            ]);
+        }
+        return stepManager;
+    }
+    async additionalPreRunChecks(extRoot) {
+        const files = (0, gen_ext_scaffolder_1.genExtScaffolder)().moduleFiles(this.args.module);
+        await this.confirmOverrideFiles(extRoot, files, 'Infrastructure files already exist. Overwrite with the latest version?');
+    }
+}
+exports.default = Infra;
+Infra.description = 'Add/Update infrastructure to the latest scaffolding for some module in an extension. For example, you can use this to add/update TypeScript, backend testing, GitHub Actions, and other features.';
+Infra.flags = Object.assign({ monorepo: core_1.Flags.boolean({ char: 'm', default: false }) }, base_command_1.default.flags);
+Infra.args = [{
+        name: 'module',
+        description: 'The name of the module to enable/update.',
+        required: true,
+        options: [...gen_ext_scaffolder_1.EXTENSION_MODULES],
+    }, ...base_command_1.default.args];

package/lib/commands/init.d.ts

@@ -1,16 +1,17 @@
-import { StepManager } from '../steps/step-manager';
+import { StepManager } from 'boilersmith/step-manager';
 import BaseCommand from '../base-command';
+import { FlarumProviders } from '../providers';
 export default class Init extends BaseCommand {
     static description: string;
     static flags: {
-        [x: string]: import("@oclif/command/lib/flags").IFlag<any>;
+        [x: string]: import("@oclif/core/lib/interfaces").CompletableFlag<any>;
     };
     static args: {
         name: string;
         description: string;
     }[];
     protected requireExistingExtension: boolean;
-    protected steps(stepManager: StepManager): StepManager;
+    protected steps(stepManager: StepManager<FlarumProviders>): StepManager<FlarumProviders>;
     protected welcomeMessage(): string;
     protected goodbyeMessage(): string;
     protected additionalPreRunChecks(extRoot: string): Promise<void>;

package/lib/commands/init.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const extension_skeleton_1 = require("../steps/init/extension-skeleton");
 const composer_1 = require("../steps/misc/composer");
 const yarn_1 = require("../steps/misc/yarn");
-const base_command_1 = tslib_1.__importDefault(require("../base-command"));
-const yosay_1 = tslib_1.__importDefault(require("yosay"));
+const base_command_1 = (0, tslib_1.__importDefault)(require("../base-command"));
+const yosay_1 = (0, tslib_1.__importDefault)(require("yosay"));
+const gen_ext_scaffolder_1 = require("../steps/gen-ext-scaffolder");
+const git_1 = require("../steps/misc/git");
 class Init extends base_command_1.default {
     constructor() {
         super(...arguments);
@@ -13,18 +14,19 @@ class Init extends base_command_1.default {
     }
     steps(stepManager) {
         return stepManager
-            .namedStep('skeleton', new extension_skeleton_1.ExtensionSkeleton(), {})
+            .namedStep('gitInit', new git_1.GitInit(), { optional: true, confirmationMessage: 'Run `git init`? (recommended)', default: true })
+            .namedStep('skeleton', (0, gen_ext_scaffolder_1.genExtScaffolder)().genInitStep())
             .step(new composer_1.ComposerInstall(), { optional: true, confirmationMessage: 'Run `composer install`? (recommended)', default: true })
             .step(new yarn_1.YarnInstall(), { optional: true, confirmationMessage: 'Run `yarn install`? (recommended)', default: true }, [
             {
                 sourceStep: 'skeleton',
-                exposedName: 'useJs',
+                exposedName: 'modules.js',
                 dontRunIfFalsy: true,
             },
         ]);
     }
     welcomeMessage() {
-        return yosay_1.default('Welcome to a Flarum extension generator\n\n- Flarum Team');
+        return (0, yosay_1.default)('Welcome to a Flarum extension generator\n\n- Flarum Team');
     }
     goodbyeMessage() {
         return 'Extension generation complete! Visit https://docs.flarum.org/extend to learn more about Flarum extension development.';

package/lib/commands/make/backend/api-controller.d.ts

@@ -1,13 +1,14 @@
-import { StepManager } from '../../../steps/step-manager';
+import { StepManager } from 'boilersmith/step-manager';
 import BaseCommand from '../../../base-command';
+import { FlarumProviders } from '../../../providers';
 export default class ApiController extends BaseCommand {
     static description: string;
     static flags: {
-        [x: string]: import("@oclif/command/lib/flags").IFlag<any>;
+        [x: string]: import("@oclif/core/lib/interfaces").CompletableFlag<any>;
     };
     static args: {
         name: string;
         description: string;
     }[];
-    protected steps(stepManager: StepManager): StepManager;
+    protected steps(stepManager: StepManager<FlarumProviders>): StepManager<FlarumProviders>;
 }

package/lib/commands/make/backend/api-controller.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const base_command_1 = tslib_1.__importDefault(require("../../../base-command"));
+const base_command_1 = (0, tslib_1.__importDefault)(require("../../../base-command"));
 const api_controller_1 = require("../../../steps/stubs/backend/api-controller");
 const route_1 = require("../../../steps/extenders/route");
+const gen_ext_scaffolder_1 = require("../../../steps/gen-ext-scaffolder");
 class ApiController extends base_command_1.default {
     steps(stepManager) {
         return stepManager
             .atomicGroup(stepManager => {
             stepManager
-                .namedStep('apiController', new api_controller_1.GenerateApiControllerStub())
+                .namedStep('apiController', new api_controller_1.GenerateApiControllerStub(this.STUB_PATH, (0, gen_ext_scaffolder_1.genExtScaffolder)()))
                 .step(new route_1.GenerateRoutesExtender(), { optional: true, confirmationMessage: 'Generate corresponding extender?', default: true }, [
                 {
                     sourceStep: 'apiController',