@flarum/cli 2.0.0-beta.9 → 3.0.0

package/lib/steps/js/base.js

@@ -2,46 +2,120 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseJsStep = void 0;
 const tslib_1 = require("tslib");
-const globby_1 = (0, tslib_1.__importDefault)(require("globby"));
+const globby_1 = tslib_1.__importDefault(require("globby"));
 const mem_fs_editor_1 = require("mem-fs-editor");
-const IMPORTS_REGEX = /((^import\s+(?:([\s\w*,{}]+)\s+from)?\s*["']?([\s\w./@\\-]+)\3?["']?\s*;?\s*)*)(.*)/m;
+const add_extenders_1 = tslib_1.__importDefault(require("../../utils/add-extenders"));
+const clone_and_fill_1 = require("boilersmith/utils/clone-and-fill");
+const gen_ext_scaffolder_1 = require("../gen-ext-scaffolder");
+const ast_1 = require("../../utils/ast");
+const path_1 = require("path");
+const pick_deep_1 = tslib_1.__importDefault(require("pick-deep"));
 const INIT_REGEX = /^(app\.initializers\.add\('[^']+',\s*\(\)\s*=>\s*{)$/m;
 class BaseJsStep {
     constructor() {
         this.composable = true;
         this.exposes = [];
     }
+    getExposed(_paths, _paramProvider) {
+        return (0, pick_deep_1.default)(this.params, this.exposes);
+    }
     async run(fs, paths, io, _providers) {
         const fsEditor = (0, mem_fs_editor_1.create)(fs);
-        const frontend = await io.getParam({ name: 'frontend', type: 'text' });
-        let frontends = [frontend];
-        if (frontend === 'common') {
-            frontends = ['admin', 'forum'];
-        }
-        for (const frontend of frontends) {
-            const fsSrcFilePaths = globby_1.default.sync(paths.package(`js/src/${frontend}/*.{js,jsx,ts,tsx}`));
-            fsSrcFilePaths.forEach(async (match) => {
-                /**
-                 * @TODO look into using https://esprima.org/ instead
-                 */
-                const currContents = fsEditor.read(match);
-                const imports = await this.getImports(frontend, paths, io);
-                const definition = await this.getDefinition(io);
-                const newContents = currContents
-                    .replace(INIT_REGEX, `$1\n  ${definition}\n`)
-                    .replace(IMPORTS_REGEX, `$1${imports}\n\n$5`);
-                fsEditor.write(match, newContents);
-            });
+        this.params = await this.compileParams(io);
+        const extender = (this.schema && (0, clone_and_fill_1.cloneAndFill)(this.schema.extenderDef, this.params)) || null;
+        const frontend = await io.getParam({
+            name: 'frontend',
+            message: 'Frontend',
+            type: 'text',
+            choices: ['forum', 'admin', 'api'].map((type) => ({
+                title: type,
+                value: type.toLowerCase(),
+            })),
+        });
+        this.ensureFrontendFilesExist(paths, fsEditor);
+        this.params = Object.assign(Object.assign({}, this.params), (await (0, gen_ext_scaffolder_1.genExtScaffolder)().templateParamVals(fs, paths, io)));
+        const fsSrcFilePaths = globby_1.default.sync(paths.package(`js/src/${frontend}/*.{js,jsx,ts,tsx}`));
+        const definition = await this.getDefinition(frontend, paths, io);
+        for (const match of fsSrcFilePaths) {
+            if (match.includes('extend.') && extender) {
+                (0, add_extenders_1.default)(match, [extender], frontend);
+            }
+            if (!definition)
+                continue;
+            const currContents = fsEditor.read(match);
+            // skip if no INIT_REGEX is found
+            if (!INIT_REGEX.test(currContents)) {
+                continue;
+            }
+            let newContents = currContents.replace(INIT_REGEX, `$1\n  ${definition.code}\n`);
+            const imports = definition.imports;
+            if (imports) {
+                const ast = (0, ast_1.parseCode)(newContents);
+                (0, ast_1.applyImports)(ast, frontend, imports);
+                // eslint-disable-next-line no-await-in-loop
+                newContents = await (0, ast_1.generateCode)(ast);
+            }
+            fsEditor.write(match, newContents);
         }
         return fs;
     }
-    importPath(frontend, classNamespace) {
-        let path = `../${classNamespace}`;
-        path = path.replace(`../${frontend}/`, './');
-        return path;
+    async compileParams(io) {
+        var _a;
+        const params = {};
+        const paramDefs = (_a = this.schema) === null || _a === void 0 ? void 0 : _a.params;
+        if (!paramDefs) {
+            return params;
+        }
+        for (const paramDef of paramDefs) {
+            // eslint-disable-next-line no-await-in-loop
+            params[paramDef.name] = await io.getParam(paramDef);
+        }
+        return params;
     }
-    getExposed(_paths, _paramProvider) {
-        return {};
+    ensureFrontendFilesExist(paths, fsEditor) {
+        const extensions = ['js', 'ts', 'jsx', 'tsx'];
+        const fileNames = ['index', 'extend'];
+        for (const frontend of ['admin', 'forum', 'common']) {
+            const existingFilesMatchingNames = [];
+            for (const fileName of fileNames) {
+                for (const extension of extensions) {
+                    const filePath = paths.package(`js/src/${frontend}/${fileName}.${extension}`);
+                    if (!existingFilesMatchingNames.includes(fileName) && fsEditor.exists(filePath)) {
+                        existingFilesMatchingNames.push(fileName);
+                    }
+                }
+            }
+            for (const fileName of fileNames) {
+                if (!existingFilesMatchingNames.includes(fileName)) {
+                    const stubFilePath = (0, path_1.resolve)(__dirname, `../../../boilerplate/skeleton/extension/js/src/${frontend}/${fileName}.js`);
+                    fsEditor.copyTpl(stubFilePath, paths.package(`js/src/${frontend}/${fileName}.js`), { params: this.params });
+                }
+            }
+            for (const fileName of fileNames) {
+                for (const extension of extensions) {
+                    const filePath = paths.package(`js/src/${frontend}/${fileName}.${extension}`);
+                    let contents = '';
+                    if (!fsEditor.exists(filePath)) {
+                        continue;
+                    }
+                    contents = fsEditor.read(filePath);
+                    if (fsEditor.exists(filePath) &&
+                        fileName === 'index' &&
+                        frontend !== 'common' &&
+                        !contents.includes("export { default as extend } from './extend';")) {
+                        fsEditor.write(filePath, `export { default as extend } from './extend';\n${contents}`);
+                    }
+                    if (fsEditor.exists(filePath) &&
+                        fileName === 'extend' &&
+                        frontend !== 'common' &&
+                        !contents.includes("import commonExtend from '../common/extend';")) {
+                        contents = `import commonExtend from '../common/extend';\n${contents}`;
+                        contents.replace('export default [', 'export default [...commonExtend,');
+                        fsEditor.write(filePath, contents);
+                    }
+                }
+            }
+        }
     }
 }
 exports.BaseJsStep = BaseJsStep;

package/lib/steps/js/model.d.ts

@@ -1,10 +1,7 @@
-import { IO } from 'boilersmith/io';
-import { Paths } from 'boilersmith/paths';
 import { BaseJsStep } from './base';
-export declare class GenerateModelDefinition extends BaseJsStep {
+import { ExtenderGenerationSchema } from '../extenders/base';
+export declare class GenerateModelExtender extends BaseJsStep {
     type: string;
-    protected getDefinition(io: IO): Promise<string>;
-    protected getImports(frontend: string, paths: Paths, io: IO): Promise<string>;
-    exposes: never[];
-    getExposed(_paths: Paths, _paramProvider: IO): Record<string, unknown>;
+    protected schema: ExtenderGenerationSchema;
+    protected getDefinition(): Promise<null>;
 }

package/lib/steps/js/model.js

@@ -1,27 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenerateModelDefinition = void 0;
+exports.GenerateModelExtender = void 0;
 const base_1 = require("./base");
-class GenerateModelDefinition extends base_1.BaseJsStep {
+const php_provider_1 = require("../../providers/php-provider");
+const model_name_1 = require("../../utils/model-name");
+class GenerateModelExtender extends base_1.BaseJsStep {
     constructor() {
         super(...arguments);
-        this.type = 'Generate JS Model Definition';
-        this.exposes = [];
+        this.type = 'Generate JS Model Extender';
+        this.schema = {
+            extenderDef: {
+                extender: {
+                    className: 'flarum/common/extenders/Store',
+                },
+                methodCalls: [
+                    {
+                        methodName: 'add',
+                        args: [
+                            {
+                                type: php_provider_1.ExpressionType.SCALAR,
+                                value: '${modelType}',
+                            },
+                            {
+                                type: php_provider_1.ExpressionType.CLASS_CONST,
+                                value: '${className}',
+                            },
+                        ],
+                    },
+                ],
+            },
+            params: [
+                {
+                    name: 'className',
+                    message: 'Class name',
+                    type: 'text',
+                },
+                {
+                    name: 'modelType',
+                    message: 'Model type',
+                    type: 'text',
+                    initial: (_prev, params) => {
+                        return (0, model_name_1.pluralKebabCaseModel)(params.get('className'));
+                    },
+                },
+            ],
+        };
     }
-    async getDefinition(io) {
-        const className = await io.getParam({ name: 'className', type: 'text' });
-        let modelType = await io.getParam({ name: 'modelType', type: 'text' });
-        modelType = modelType.includes('-') ? `['${modelType}']` : `.${modelType}`;
-        return `app.store.models${modelType} = ${className};`;
-    }
-    async getImports(frontend, paths, io) {
-        const className = await io.getParam({ name: 'className', type: 'text' });
-        const classNamespace = await io.getParam({ name: 'classNamespace', type: 'text' });
-        const importPath = this.importPath(frontend, classNamespace);
-        return `import ${className} from '${importPath}';`;
-    }
-    getExposed(_paths, _paramProvider) {
-        return {};
+    async getDefinition() {
+        return Promise.resolve(null);
     }
 }
-exports.GenerateModelDefinition = GenerateModelDefinition;
+exports.GenerateModelExtender = GenerateModelExtender;

package/lib/steps/js/notification.d.ts

@@ -0,0 +1,7 @@
+import { BaseJsStep } from './base';
+import { ExtenderGenerationSchema } from '../extenders/base';
+export declare class GenerateNotificationExtender extends BaseJsStep {
+    type: string;
+    protected schema: ExtenderGenerationSchema;
+    protected getDefinition(): Promise<null>;
+}

package/lib/steps/js/notification.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateNotificationExtender = void 0;
+const tslib_1 = require("tslib");
+const base_1 = require("./base");
+const php_provider_1 = require("../../providers/php-provider");
+const validation_1 = require("../../utils/validation");
+const string_1 = tslib_1.__importDefault(require("string"));
+class GenerateNotificationExtender extends base_1.BaseJsStep {
+    constructor() {
+        super(...arguments);
+        this.type = 'Generate JS Notification Extender';
+        this.schema = {
+            extenderDef: {
+                extender: {
+                    className: 'flarum/common/extenders/Notification',
+                },
+                methodCalls: [
+                    {
+                        methodName: 'add',
+                        args: [
+                            {
+                                type: php_provider_1.ExpressionType.SCALAR,
+                                value: '${type}',
+                            },
+                            {
+                                type: php_provider_1.ExpressionType.CLASS_CONST,
+                                value: '${className}',
+                            },
+                        ],
+                    },
+                ],
+            },
+            params: [
+                {
+                    name: 'className',
+                    message: 'Class name',
+                    type: 'text',
+                    validate: validation_1.Validator.module,
+                },
+                {
+                    name: 'type',
+                    message: 'Notification type',
+                    type: 'text',
+                    initial: (_prev, params) => {
+                        return (0, string_1.default)(params.get('className'))
+                            .camelize()
+                            .toString();
+                    },
+                },
+            ],
+        };
+    }
+    async getDefinition() {
+        return Promise.resolve(null);
+    }
+}
+exports.GenerateNotificationExtender = GenerateNotificationExtender;

package/lib/steps/js/post-type.d.ts

@@ -0,0 +1,8 @@
+import { BaseJsStep } from './base';
+import { ExtenderGenerationSchema } from '../extenders/base';
+export declare class GeneratePostTypeExtender extends BaseJsStep {
+    type: string;
+    exposes: string[];
+    protected schema: ExtenderGenerationSchema;
+    protected getDefinition(): Promise<null>;
+}

package/lib/steps/js/post-type.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratePostTypeExtender = void 0;
+const tslib_1 = require("tslib");
+const base_1 = require("./base");
+const php_provider_1 = require("../../providers/php-provider");
+const validation_1 = require("../../utils/validation");
+const string_1 = tslib_1.__importDefault(require("string"));
+class GeneratePostTypeExtender extends base_1.BaseJsStep {
+    constructor() {
+        super(...arguments);
+        this.type = 'Generate JS Post Type Extender';
+        this.exposes = ['type'];
+        this.schema = {
+            extenderDef: {
+                extender: {
+                    className: 'flarum/common/extenders/PostTypes',
+                },
+                methodCalls: [
+                    {
+                        methodName: 'add',
+                        args: [
+                            {
+                                type: php_provider_1.ExpressionType.SCALAR,
+                                value: '${type}',
+                            },
+                            {
+                                type: php_provider_1.ExpressionType.CLASS_CONST,
+                                value: '${className}',
+                            },
+                        ],
+                    },
+                ],
+            },
+            params: [
+                {
+                    name: 'className',
+                    message: 'Class name',
+                    type: 'text',
+                    validate: validation_1.Validator.module,
+                },
+                {
+                    name: 'type',
+                    message: 'Post type',
+                    type: 'text',
+                    initial: (_prev, params) => {
+                        return (0, string_1.default)(params.get('className'))
+                            .camelize()
+                            .toString()
+                            .replace(/Post$/, '');
+                    },
+                },
+            ],
+        };
+    }
+    async getDefinition() {
+        return Promise.resolve(null);
+    }
+}
+exports.GeneratePostTypeExtender = GeneratePostTypeExtender;

package/lib/steps/js/routes.d.ts

@@ -0,0 +1,7 @@
+import { BaseJsStep } from './base';
+import { ExtenderGenerationSchema } from '../extenders/base';
+export declare class GenerateRoutesExtender extends BaseJsStep {
+    type: string;
+    protected schema: ExtenderGenerationSchema;
+    protected getDefinition(): Promise<null>;
+}

package/lib/steps/js/routes.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateRoutesExtender = void 0;
+const tslib_1 = require("tslib");
+const base_1 = require("./base");
+const php_provider_1 = require("../../providers/php-provider");
+const validation_1 = require("../../utils/validation");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+class GenerateRoutesExtender extends base_1.BaseJsStep {
+    constructor() {
+        super(...arguments);
+        this.type = 'Generate JS Model Extender';
+        this.schema = {
+            extenderDef: {
+                extender: {
+                    className: 'flarum/common/extenders/Routes',
+                },
+                methodCalls: [
+                    {
+                        methodName: 'add',
+                        args: [
+                            {
+                                type: php_provider_1.ExpressionType.SCALAR,
+                                value: '${routeName}',
+                            },
+                            {
+                                type: php_provider_1.ExpressionType.SCALAR,
+                                value: '${routePath}',
+                            },
+                            {
+                                type: php_provider_1.ExpressionType.CLASS_CONST,
+                                value: '${className}',
+                            },
+                        ],
+                    },
+                ],
+            },
+            params: [
+                {
+                    name: 'routeName',
+                    message: 'Route name (unique)',
+                    type: 'text',
+                    validate: validation_1.Validator.routeName,
+                },
+                {
+                    name: 'routePath',
+                    message: `Route Path (${chalk_1.default.dim('/pathName')})`,
+                    type: 'text',
+                },
+                {
+                    name: 'className',
+                    message: 'Class name',
+                    type: 'text',
+                    validate: validation_1.Validator.module,
+                },
+            ],
+        };
+    }
+    async getDefinition() {
+        return Promise.resolve(null);
+    }
+}
+exports.GenerateRoutesExtender = GenerateRoutesExtender;

package/lib/steps/js/search-driver-locale.d.ts

@@ -0,0 +1,8 @@
+import { IO } from 'boilersmith/io';
+import { Paths } from 'boilersmith/paths';
+import { BaseJsStep, InitializerDefinition } from './base';
+export declare class GenerateSearchDriverLocaleDefinition extends BaseJsStep {
+    type: string;
+    protected schema: null;
+    protected getDefinition(frontend: string, _paths: Paths, io: IO): Promise<InitializerDefinition | null>;
+}

package/lib/steps/js/search-driver-locale.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateSearchDriverLocaleDefinition = void 0;
+const base_1 = require("./base");
+class GenerateSearchDriverLocaleDefinition extends base_1.BaseJsStep {
+    constructor() {
+        super(...arguments);
+        this.type = 'Generate Search Driver Locale Definition';
+        this.schema = null;
+    }
+    async getDefinition(frontend, _paths, io) {
+        if (frontend !== 'admin') {
+            return null;
+        }
+        const driverName = await io.getParam({ name: 'driverName', message: 'Unique driver name', type: 'text' });
+        return {
+            code: `
+        extend(AdvancedPage.prototype, 'driverLocale', function (locale) {
+          locale.search['${driverName}'] = app.translator.trans('${this.params.extensionId}.admin.advanced.search.driver_options.${driverName}', {}, true);
+        });`,
+            imports: [
+                {
+                    name: 'AdvancedPage',
+                    path: 'flarum/admin/components/AdvancedPage',
+                    defaultImport: true,
+                },
+                {
+                    name: 'extend',
+                    path: 'flarum/common/extend',
+                    defaultImport: false,
+                },
+            ],
+        };
+    }
+}
+exports.GenerateSearchDriverLocaleDefinition = GenerateSearchDriverLocaleDefinition;

package/lib/steps/js/search-gambit.d.ts

@@ -0,0 +1,7 @@
+import { BaseJsStep } from './base';
+import { ExtenderGenerationSchema } from '../extenders/base';
+export declare class GenerateSearchGambitExtender extends BaseJsStep {
+    type: string;
+    protected schema: ExtenderGenerationSchema;
+    protected getDefinition(): Promise<null>;
+}

package/lib/steps/js/search-gambit.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateSearchGambitExtender = void 0;
+const base_1 = require("./base");
+const php_provider_1 = require("../../providers/php-provider");
+const validation_1 = require("../../utils/validation");
+class GenerateSearchGambitExtender extends base_1.BaseJsStep {
+    constructor() {
+        super(...arguments);
+        this.type = 'Generate JS Gambit Extender';
+        this.schema = {
+            extenderDef: {
+                extender: {
+                    className: 'flarum/common/extenders/Search',
+                },
+                methodCalls: [
+                    {
+                        methodName: 'gambit',
+                        args: [
+                            {
+                                type: php_provider_1.ExpressionType.SCALAR,
+                                value: '${modelType}',
+                            },
+                            {
+                                type: php_provider_1.ExpressionType.CLASS_CONST,
+                                value: '${className}',
+                            },
+                        ],
+                    },
+                ],
+            },
+            params: [
+                {
+                    name: 'modelType',
+                    message: 'Type of the model (e.g. posts, users)',
+                    type: 'text',
+                },
+                {
+                    name: 'className',
+                    message: 'Class name',
+                    type: 'text',
+                    validate: validation_1.Validator.module,
+                },
+            ],
+        };
+    }
+    async getDefinition() {
+        return Promise.resolve(null);
+    }
+}
+exports.GenerateSearchGambitExtender = GenerateSearchGambitExtender;

package/lib/steps/locale/base.d.ts

@@ -0,0 +1,32 @@
+import { Store } from 'mem-fs';
+import { IO, ParamDef } from 'boilersmith/io';
+import { Paths } from 'boilersmith/paths';
+import { ExtenderDef } from '../../providers/php-provider';
+import { Step } from 'boilersmith/step-manager';
+import { FlarumProviders } from '../../providers';
+import { Scaffolder } from 'boilersmith/scaffolding/scaffolder';
+import { ExtensionModules, ExtensionParams } from '../gen-ext-scaffolder';
+interface UserProvidedParam extends Omit<ParamDef, 'type'> {
+    type: string;
+}
+export interface ExtenderGenerationSchema {
+    extenderDef: ExtenderDef;
+    params: UserProvidedParam[];
+}
+export declare class LocaleStep implements Step<FlarumProviders> {
+    type: string;
+    composable: boolean;
+    exposes: never[];
+    getExposed(): Record<string, unknown>;
+    protected params: Record<string, unknown>;
+    protected scaffolder: Scaffolder<ExtensionParams, ExtensionModules>;
+    constructor(scaffolder: Scaffolder<ExtensionParams, ExtensionModules>);
+    run(fs: Store, paths: Paths, io: IO, _providers: FlarumProviders): Promise<Store>;
+    protected compileParams(fs: Store, paths: Paths, io: IO): Promise<Record<string, unknown>>;
+}
+/**
+ * nested key format, e.g: forum.custom_model.title
+ * obj: forum: { custom_modal: title: '' }
+ */
+export declare function setNested(key: string, value: string, object: Record<string, any>): void;
+export {};