@flarum/cli 2.0.0-beta.9 → 3.0.0

package/lib/steps/locale/base.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setNested = exports.LocaleStep = void 0;
+const tslib_1 = require("tslib");
+const mem_fs_editor_1 = require("mem-fs-editor");
+const path_1 = require("path");
+const yaml_1 = tslib_1.__importDefault(require("yaml"));
+class LocaleStep {
+    getExposed() {
+        return {};
+    }
+    constructor(scaffolder) {
+        this.type = 'Generate key-value locale pair';
+        this.composable = true;
+        this.exposes = [];
+        this.scaffolder = scaffolder;
+    }
+    async run(fs, paths, io, _providers) {
+        const fsEditor = (0, mem_fs_editor_1.create)(fs);
+        this.params = await this.compileParams(fs, paths, io);
+        let path;
+        if (fsEditor.exists(paths.package('resources/locale/en.yml'))) {
+            path = paths.package('resources/locale/en.yml');
+        }
+        else {
+            path = paths.package('locale/en.yml');
+            // Ensure locale/en.yml exists
+            if (!fsEditor.exists(path)) {
+                const stubFilePath = (0, path_1.resolve)(__dirname, `../../../boilerplate/skeleton/extension/locale/en.yml`);
+                fsEditor.copyTpl(stubFilePath, path, { params: this.params });
+            }
+        }
+        const doc = yaml_1.default.parseDocument(fsEditor.read(path));
+        const key = this.params.key.split('.')[0] === this.params.extensionId ? this.params.key : `${this.params.extensionId}.${this.params.key}`;
+        const keys = key.split('.');
+        const keyPath = [];
+        try {
+            // eslint-disable-next-line guard-for-in
+            for (const i in keys) {
+                const k = keys[i];
+                if (doc.hasIn(keyPath) && doc.getIn(keyPath) !== null) {
+                    keyPath.push(k);
+                }
+                else {
+                    const remainingKeyPath = keys.slice(Number.parseInt(i, 10));
+                    const remainingAsNestedObject = {};
+                    setNested(remainingKeyPath.join('.'), this.params.value, remainingAsNestedObject);
+                    doc.setIn(keyPath, remainingAsNestedObject);
+                    break;
+                }
+            }
+            if (keyPath.join('.') === key) {
+                doc.setIn(keyPath, this.params.value);
+            }
+        }
+        catch (_a) {
+            // Do nothing
+        }
+        fsEditor.write(path, doc.toString({
+            lineWidth: 200,
+        }));
+        return fs;
+    }
+    async compileParams(fs, paths, io) {
+        const params = {};
+        params.extensionId = await this.scaffolder.templateParamVal('extensionId', fs, paths, io);
+        params.key = await io.getParam({
+            name: 'key',
+            type: 'text',
+            message: 'The nested key of the locale (e.g. `forum.custom_modal.title`).',
+        });
+        params.value = await io.getParam({
+            name: 'value',
+            type: 'text',
+            message: 'The value of the locale.',
+        });
+        return params;
+    }
+}
+exports.LocaleStep = LocaleStep;
+/**
+ * nested key format, e.g: forum.custom_model.title
+ * obj: forum: { custom_modal: title: '' }
+ */
+function setNested(key, value, object) {
+    const keys = key.split('.');
+    let current = object;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const k = keys[i];
+        if (!current[k]) {
+            current[k] = {};
+        }
+        current = current[k];
+    }
+    current[keys[keys.length - 1]] = value;
+}
+exports.setNested = setNested;

package/lib/steps/misc/composer.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComposerInstall = void 0;
-const node_child_process_1 = require("node:child_process");
+const child_process_1 = require("child_process");
 class ComposerInstall {
     constructor() {
         this.type = 'Run composer install/update';
@@ -9,7 +9,7 @@ class ComposerInstall {
         this.exposes = [];
     }
     async run(fs, paths, _paramProvider, _providers) {
-        (0, node_child_process_1.execSync)('composer update', { cwd: paths.package('') });
+        (0, child_process_1.execSync)('composer update', { cwd: paths.package('') });
         return fs;
     }
     getExposed() {

package/lib/steps/misc/git.d.ts

@@ -5,7 +5,7 @@ import { DefaultProviders, Step } from 'boilersmith/step-manager';
 export declare class GitInit implements Step {
     type: string;
     composable: boolean;
-    run(fs: Store, _paths: Paths, _paramProvider: IO, _providers: DefaultProviders): Promise<Store>;
+    run(fs: Store, paths: Paths, _paramProvider: IO, _providers: DefaultProviders): Promise<Store>;
     exposes: never[];
     getExposed(): Record<string, unknown>;
 }

package/lib/steps/misc/git.js

@@ -2,15 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitInit = void 0;
 const tslib_1 = require("tslib");
-const simple_git_1 = (0, tslib_1.__importDefault)(require("simple-git"));
+const simple_git_1 = tslib_1.__importDefault(require("simple-git"));
 class GitInit {
     constructor() {
         this.type = 'Run git init';
         this.composable = false;
         this.exposes = [];
     }
-    async run(fs, _paths, _paramProvider, _providers) {
-        (0, simple_git_1.default)().init();
+    async run(fs, paths, _paramProvider, _providers) {
+        (0, simple_git_1.default)(paths.package()).init();
         return fs;
     }
     getExposed() {

package/lib/steps/misc/npm.d.ts

@@ -0,0 +1,11 @@
+import { Store } from 'mem-fs';
+import { IO } from 'boilersmith/io';
+import { Paths } from 'boilersmith/paths';
+import { DefaultProviders, Step } from 'boilersmith/step-manager';
+export declare class NpmInstall implements Step {
+    type: string;
+    composable: boolean;
+    run(fs: Store, paths: Paths, _paramProvider: IO, _providers: DefaultProviders): Promise<Store>;
+    exposes: never[];
+    getExposed(): Record<string, unknown>;
+}

package/lib/steps/misc/npm.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NpmInstall = void 0;
+const child_process_1 = require("child_process");
+class NpmInstall {
+    constructor() {
+        this.type = 'Run npm install';
+        this.composable = false;
+        this.exposes = [];
+    }
+    async run(fs, paths, _paramProvider, _providers) {
+        (0, child_process_1.execSync)('npm install', { cwd: paths.package('js') });
+        return fs;
+    }
+    getExposed() {
+        return {};
+    }
+}
+exports.NpmInstall = NpmInstall;

package/lib/steps/misc/yarn.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YarnInstall = void 0;
-const node_child_process_1 = require("node:child_process");
+const child_process_1 = require("child_process");
 class YarnInstall {
     constructor() {
         this.type = 'Run yarn install';
@@ -9,7 +9,7 @@ class YarnInstall {
         this.exposes = [];
     }
     async run(fs, paths, _paramProvider, _providers) {
-        (0, node_child_process_1.execSync)('yarn install', { cwd: paths.package('js') });
+        (0, child_process_1.execSync)('yarn install', { cwd: paths.package('js') });
         return fs;
     }
     getExposed() {

package/lib/steps/monorepo/create.d.ts

@@ -0,0 +1,19 @@
+import { Store } from 'mem-fs';
+import { IO } from 'boilersmith/io';
+import { Paths } from 'boilersmith/paths';
+import { Step } from 'boilersmith/step-manager';
+import { FlarumProviders } from '../../providers';
+import { Scaffolder } from 'boilersmith/scaffolding/scaffolder';
+import { ExtensionModules, ExtensionParams } from '../gen-ext-scaffolder';
+import { CommitResult } from 'simple-git';
+export declare function commitAll(cwd: string, message: string | string[]): Promise<CommitResult>;
+export declare class MonorepoCreate implements Step<FlarumProviders> {
+    type: string;
+    composable: boolean;
+    protected monorepoConfPath?: string;
+    protected scaffolder: Scaffolder<ExtensionParams, ExtensionModules>;
+    constructor(scaffolder: Scaffolder<ExtensionParams, ExtensionModules>, monorepoConfPath?: string);
+    run(fs: Store, paths: Paths, io: IO, providers: FlarumProviders): Promise<Store>;
+    exposes: never[];
+    getExposed(): Record<string, unknown>;
+}

package/lib/steps/monorepo/create.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonorepoCreate = exports.commitAll = void 0;
+const tslib_1 = require("tslib");
+/* eslint-disable no-await-in-loop */
+const child_process_1 = require("child_process");
+const monorepo_1 = require("../../utils/monorepo");
+const cond_format_1 = require("boilersmith/utils/cond-format");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const simple_git_1 = tslib_1.__importDefault(require("simple-git"));
+const mem_fs_editor_1 = require("mem-fs-editor");
+const commit_async_1 = require("boilersmith/utils/commit-async");
+const validation_1 = require("../../utils/validation");
+async function addGitPackage(cwd, path, remote, mainBranch = 'main') {
+    const tmpDir = (0, fs_1.mkdtempSync)((0, path_1.resolve)((0, os_1.tmpdir)(), `${path.replace('/', '_')}-`));
+    (0, child_process_1.execSync)(`git clone ${remote} ${tmpDir} --verbose --branch ${mainBranch} --single-branch`, { cwd });
+    (0, child_process_1.execSync)(`git filter-repo --to-subdirectory-filter ${path}`, { cwd: tmpDir });
+    if (mainBranch) {
+        await (0, simple_git_1.default)(tmpDir).checkout(mainBranch);
+    }
+    await (0, simple_git_1.default)(tmpDir).branch(['REWRITE']);
+    await (0, simple_git_1.default)(tmpDir).checkout('REWRITE');
+    // Merge from remote
+    const remoteName = path.replace('/', '_').replace('-', '_');
+    await (0, simple_git_1.default)(cwd).addRemote(remoteName, tmpDir);
+    (0, child_process_1.execSync)(`git fetch ${remoteName}`, { cwd });
+    (0, child_process_1.execSync)(`git merge ${remoteName}/REWRITE --allow-unrelated-histories --no-edit`, { cwd });
+    await (0, simple_git_1.default)(cwd).removeRemote(remoteName);
+    (0, fs_1.rmSync)(tmpDir, { recursive: true, force: true });
+}
+function makeRunCommitStep(cwd, fs, io, paths, providers) {
+    return async function (packagePaths, step, message) {
+        for (const path of packagePaths) {
+            await step.run(fs, paths.onMonorepoSub((0, path_1.resolve)(cwd, path), cwd), io, providers);
+        }
+        await (0, commit_async_1.commitAsync)(fs);
+        await commitAll(cwd, message);
+    };
+}
+async function getMonorepoConf(io, monorepoConfPath) {
+    var _a;
+    if (monorepoConfPath) {
+        return JSON.parse((0, fs_1.readFileSync)(monorepoConfPath, 'utf8'));
+    }
+    const packages = { extensions: [], composer: [], npm: [] };
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const confirm = await io.getParam({
+            name: 'confirm',
+            type: 'confirm',
+            initial: true,
+            message: 'Add another package to monorepo?',
+        }, true);
+        if (!confirm)
+            break;
+        const packageType = (await io.getParam({
+            name: 'packageType',
+            message: 'Package Type',
+            type: 'select',
+            choices: [
+                { title: 'Flarum Extension', value: 'extensions' },
+                { title: 'Composer PHP Package', value: 'composer' },
+                { title: 'NPM JS/TS Package', value: 'npm' },
+                { title: 'Flarum Core', value: 'core' },
+            ],
+            validate: (value) => value !== 'core' || !packages.core || 'A core package has already been specified.',
+        }, true));
+        const packageName = await io.getParam({
+            name: 'name',
+            message: 'Package Name (used to generate subdirectory path)',
+            type: 'text',
+            validate: validation_1.Validator.fileName,
+        }, true);
+        const gitRemote = await io.getParam({
+            name: 'remote',
+            message: 'Git remote (e.g. git@github.com:flarum/core.git)',
+            type: 'text',
+            validate: validation_1.Validator.gitRepo,
+        }, true);
+        const packageInfo = {
+            name: packageName,
+            gitRemote,
+        };
+        if (packageType === 'core') {
+            packages.core = packageInfo;
+        }
+        else {
+            const typePackages = (_a = packages[packageType]) !== null && _a !== void 0 ? _a : [];
+            typePackages.push(packageInfo);
+            packages[packageType] = typePackages;
+        }
+    }
+    return { packages };
+}
+async function commitAll(cwd, message) {
+    await (0, simple_git_1.default)(cwd).add('.');
+    return (0, simple_git_1.default)(cwd).commit(message);
+}
+exports.commitAll = commitAll;
+class MonorepoCreate {
+    constructor(scaffolder, monorepoConfPath) {
+        this.type = 'Create a monorepo of Flarum extensions';
+        this.composable = false;
+        this.exposes = [];
+        this.scaffolder = scaffolder;
+        this.monorepoConfPath = monorepoConfPath;
+    }
+    async run(fs, paths, io, providers) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const target = (_a = paths.requestedDir()) !== null && _a !== void 0 ? _a : paths.package('flarum_monorepo');
+        const confirmTarget = await io.getParam({
+            name: 'confirmTarget',
+            message: `Create monorepo in directory: "${(0, cond_format_1.condFormat)(io.supportsAnsiColor, chalk_1.default.dim, target)}" (will be overwritten)?`,
+            type: 'confirm',
+            initial: true,
+        });
+        if (!confirmTarget) {
+            io.error('Target not confirmed', true);
+            return fs;
+        }
+        const conf = await getMonorepoConf(io, this.monorepoConfPath ? paths.cwd(this.monorepoConfPath) : undefined);
+        const runCommitStep = makeRunCommitStep(target, fs, io, paths, providers);
+        (0, fs_1.rmSync)(target, { recursive: true, force: true });
+        (0, fs_1.mkdirSync)(target);
+        await (0, simple_git_1.default)(target).init();
+        for (const lib of (_b = conf.packages.npm) !== null && _b !== void 0 ? _b : []) {
+            await addGitPackage(target, (0, monorepo_1.npmPath)(lib.name), lib.gitRemote, lib.mainBranch);
+        }
+        for (const lib of (_c = conf.packages.composer) !== null && _c !== void 0 ? _c : []) {
+            await addGitPackage(target, (0, monorepo_1.composerPath)(lib.name), lib.gitRemote, lib.mainBranch);
+        }
+        for (const ext of (_d = conf.packages.extensions) !== null && _d !== void 0 ? _d : []) {
+            await addGitPackage(target, (0, monorepo_1.extensionPath)(ext.name), ext.gitRemote, ext.mainBranch);
+        }
+        const corePkg = conf.packages.core;
+        if (corePkg) {
+            await addGitPackage(target, (0, monorepo_1.corePath)(corePkg.name), corePkg.gitRemote, corePkg.mainBranch);
+        }
+        const npmPaths = (_f = (_e = conf.packages.npm) === null || _e === void 0 ? void 0 : _e.map((lib) => (0, monorepo_1.npmPath)(lib.name))) !== null && _f !== void 0 ? _f : [];
+        const composerPaths = (_h = (_g = conf.packages.composer) === null || _g === void 0 ? void 0 : _g.map((lib) => (0, monorepo_1.composerPath)(lib.name))) !== null && _h !== void 0 ? _h : [];
+        const flarumPaths = (_k = (_j = conf.packages.extensions) === null || _j === void 0 ? void 0 : _j.map((ext) => (0, monorepo_1.extensionPath)(ext.name))) !== null && _k !== void 0 ? _k : [];
+        if (corePkg) {
+            flarumPaths.push((0, monorepo_1.corePath)(corePkg.name));
+        }
+        flarumPaths.forEach((path) => {
+            (0, fs_1.rmSync)((0, path_1.resolve)(target, path, '.github'), { force: true, recursive: true });
+        });
+        [...npmPaths, ...composerPaths, ...flarumPaths].forEach((path) => {
+            (0, fs_1.rmSync)((0, path_1.resolve)(target, path, '.styleci.yml'), { force: true });
+        });
+        await commitAll(target, [
+            'chore: remove centralizable repo config',
+            '- Remove .github conf folder from Flarum packages',
+            '- Remove styleci config from all packages',
+        ]);
+        (0, mem_fs_editor_1.create)(fs).writeJSON((0, path_1.resolve)(target, 'flarum-monorepo.json'), conf);
+        await (0, commit_async_1.commitAsync)(fs);
+        await commitAll(target, 'chore: add monorepo config file');
+        [...composerPaths, ...flarumPaths].forEach((path) => {
+            const cwd = (0, path_1.resolve)(target, path);
+            const relRepoPath = path.includes('/') ? '../../*/*' : './../*/*';
+            (0, child_process_1.execSync)(`composer config repositories.0 path "${relRepoPath}"`, { cwd });
+            (0, child_process_1.execSync)('composer config minimum-stability dev', { cwd });
+            (0, child_process_1.execSync)('composer config prefer-stable true', { cwd });
+            const composerJsonPath = (0, path_1.resolve)(cwd, 'composer.json');
+            const composerJson = (0, fs_1.readFileSync)(composerJsonPath);
+            (0, fs_1.writeFileSync)(composerJsonPath, composerJson.toString().replace('"dev-master": "1.x-dev"', '"dev-main": "1.x-dev"'));
+        });
+        [...composerPaths, ...flarumPaths].forEach((path) => {
+            const cwd = (0, path_1.resolve)(target, path);
+            (0, child_process_1.execSync)('composer install --dry-run --no-interaction --no-ansi --no-progress --no-scripts --no-autoloader', { cwd });
+        });
+        await commitAll(target, 'chore: set up composer path repos');
+        (0, mem_fs_editor_1.create)(fs).writeJSON((0, path_1.resolve)(target, 'flarum-monorepo.json'), conf);
+        await (0, commit_async_1.commitAsync)(fs);
+        await commitAll(target, 'chore: add monorepo config file');
+        await runCommitStep(flarumPaths, this.scaffolder.genAuditStep(false), 'chore: flarum-cli audit infra --fix');
+        return fs;
+    }
+    getExposed() {
+        return {};
+    }
+}
+exports.MonorepoCreate = MonorepoCreate;

package/lib/steps/monorepo/split.d.ts

@@ -0,0 +1,14 @@
+import { IO } from 'boilersmith/io';
+import { Paths } from 'boilersmith/paths';
+import { Step } from 'boilersmith/step-manager';
+import { Store } from 'mem-fs';
+import { FlarumProviders } from '../../providers';
+export declare class MonorepoSplit implements Step<FlarumProviders> {
+    type: string;
+    composable: boolean;
+    exposes: never[];
+    force?: boolean;
+    constructor(force: boolean);
+    run(fs: Store, paths: Paths, io: IO, _providers: FlarumProviders): Promise<Store>;
+    getExposed(): Record<string, unknown>;
+}

package/lib/steps/monorepo/split.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonorepoSplit = void 0;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const simple_git_1 = tslib_1.__importDefault(require("simple-git"));
+const monorepo_1 = require("../../utils/monorepo");
+async function addRemote(cwd, name, remote) {
+    try {
+        await (0, simple_git_1.default)(cwd).addRemote(name, remote);
+        await (0, simple_git_1.default)(cwd).fetch(name);
+    }
+    catch (_a) {
+        // ignore, remote already exists.
+    }
+}
+async function splitAndPush(cwd, splitExecPath, splitPath, remoteName, remoteBranch, force = false) {
+    const currBranch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { cwd }).toString().trim();
+    const sha1 = (0, child_process_1.execSync)(`${splitExecPath} --prefix=${splitPath}`, { cwd, stdio: ['pipe', 'pipe', 'ignore'] })
+        .toString()
+        .trim();
+    const branch = remoteBranch || 'main';
+    const pushArgs = `${remoteName} "${sha1}:refs/heads/${branch}"`;
+    if (force) {
+        (0, child_process_1.execSync)(`git push --force ${pushArgs}`, { cwd });
+    }
+    else {
+        const tmpBranch = `${remoteName}-tmp`;
+        (0, child_process_1.execSync)(`git switch -c ${tmpBranch} ${sha1}`, { cwd });
+        (0, child_process_1.execSync)(`git pull ${remoteName} ${branch} --rebase`, { cwd });
+        (0, child_process_1.execSync)(`git push ${pushArgs}`, { cwd });
+        (0, child_process_1.execSync)(`git switch ${currBranch}`, { cwd });
+    }
+}
+async function cleanupBranchAndRemote(cwd, name) {
+    await (0, simple_git_1.default)(cwd).removeRemote(name);
+    const tmpBranch = `${name}-tmp`;
+    (0, child_process_1.execSync)(`git branch -D ${tmpBranch}`, { cwd });
+}
+class MonorepoSplit {
+    constructor(force) {
+        this.type = 'Split monorepo changes to the respective cloned repos.';
+        this.composable = false;
+        this.exposes = [];
+        this.force = force;
+    }
+    async run(fs, paths, io, _providers) {
+        var _a, _b, _c, _d;
+        const platform = process.platform;
+        if (platform !== 'linux' && platform !== 'darwin') {
+            io.error(`Your platform, "${platform}", is not supported. Split can only be run on linux and mac`, true);
+            return fs;
+        }
+        if (this.force && !(await io.getParam({ type: 'confirm', name: 'confirm', initial: false, message: 'Are you sure you want to force split?' }))) {
+            io.error('Decided not to force push', true);
+            return fs;
+        }
+        const splitExec = (0, path_1.resolve)(__dirname, `../../../bin/splitsh-lite-${platform}`);
+        const target = (_a = paths.requestedDir()) !== null && _a !== void 0 ? _a : paths.package();
+        await (0, simple_git_1.default)(target).pull();
+        const conf = (0, monorepo_1.getMonorepoConf)(fs, paths);
+        const corePkg = conf.packages.core;
+        const clean = [];
+        try {
+            // Add Remotes
+            for (const lib of (_b = conf.packages.npm) !== null && _b !== void 0 ? _b : []) {
+                await addRemote(target, lib.name, lib.gitRemote);
+                await splitAndPush(target, splitExec, (0, monorepo_1.npmPath)(lib.name), lib.name, lib.mainBranch, this.force);
+                clean.push(lib.name);
+            }
+            for (const lib of (_c = conf.packages.composer) !== null && _c !== void 0 ? _c : []) {
+                await addRemote(target, lib.name, lib.gitRemote);
+                await splitAndPush(target, splitExec, (0, monorepo_1.composerPath)(lib.name), lib.name, lib.mainBranch, this.force);
+                clean.push(lib.name);
+            }
+            for (const ext of (_d = conf.packages.extensions) !== null && _d !== void 0 ? _d : []) {
+                await addRemote(target, ext.name, ext.gitRemote);
+                await splitAndPush(target, splitExec, (0, monorepo_1.extensionPath)(ext.name), ext.name, ext.mainBranch, this.force);
+                clean.push(ext.name);
+            }
+            if (corePkg) {
+                await addRemote(target, corePkg.name, corePkg.gitRemote);
+                await splitAndPush(target, splitExec, (0, monorepo_1.corePath)(corePkg.name), corePkg.name, corePkg.mainBranch, this.force);
+                clean.push(corePkg.name);
+            }
+        }
+        finally {
+            for (const name of clean) {
+                await cleanupBranchAndRemote(target, name);
+            }
+        }
+        return fs;
+    }
+    getExposed() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.MonorepoSplit = MonorepoSplit;

package/lib/steps/stubs/backend/advanced-api-resource.d.ts

@@ -0,0 +1,13 @@
+import { IO } from 'boilersmith/io';
+import { Paths } from 'boilersmith/paths';
+import { BasePhpStubStep } from '../php-base';
+import { Store } from 'mem-fs';
+import { StubGenerationSchema } from 'boilersmith/steps/stub-base';
+export declare class GenerateAdvancedApiResourceStub extends BasePhpStubStep {
+    type: string;
+    protected additionalExposes: string[];
+    protected additionalImplicitParams: string[];
+    protected phpClassParams: string[];
+    protected schema: StubGenerationSchema;
+    protected compileParams(fs: Store, paths: Paths, io: IO): Promise<Record<string, unknown>>;
+}

package/lib/steps/stubs/backend/advanced-api-resource.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateAdvancedApiResourceStub = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const validation_1 = require("../../../utils/validation");
+const model_name_1 = require("../../../utils/model-name");
+const php_base_1 = require("../php-base");
+class GenerateAdvancedApiResourceStub extends php_base_1.BasePhpStubStep {
+    constructor() {
+        super(...arguments);
+        this.type = 'Generate Api Resource Class';
+        this.additionalExposes = ['className', 'modelClass', 'modelClassName', 'modelType'];
+        this.additionalImplicitParams = ['modelType'];
+        this.phpClassParams = ['modelClass'];
+        this.schema = {
+            recommendedSubdir: 'Api/Resource',
+            sourceFile: 'backend/advanced-api-resource.php',
+            params: [
+                {
+                    name: 'className',
+                    type: 'text',
+                    message: 'Resource class name',
+                    validate: validation_1.Validator.className,
+                },
+                {
+                    name: 'classNamespace',
+                    type: 'text',
+                    message: 'Class Namespace',
+                },
+                {
+                    name: 'modelClass',
+                    type: 'text',
+                    message: `Model Class (${chalk_1.default.dim('Vendor\\Path\\Model')})`,
+                    validate: validation_1.Validator.class,
+                },
+                {
+                    name: 'modelClassName',
+                    type: 'text',
+                    message: 'Model class name',
+                },
+                {
+                    name: 'modelType',
+                    type: 'text',
+                    message: 'Model type',
+                },
+                {
+                    name: 'endpoints',
+                    type: 'multiselect',
+                    message: 'Endpoints',
+                    choices: [
+                        { title: 'index', value: 'index', selected: true },
+                        { title: 'show', value: 'show', selected: true },
+                        { title: 'create', value: 'create', selected: true },
+                        { title: 'update', value: 'update', selected: true },
+                        { title: 'delete', value: 'delete', selected: true },
+                    ],
+                },
+                {
+                    name: 'relations',
+                    type: 'multiselect',
+                    message: 'Relations',
+                },
+            ],
+        };
+    }
+    async compileParams(fs, paths, io) {
+        const params = await super.compileParams(fs, paths, io);
+        const interfaceMap = {
+            list: 'Resource\\Contracts\\Listable',
+            show: 'Resource\\Contracts\\Findable',
+            create: 'Resource\\Contracts\\Creatable',
+            update: 'Resource\\Contracts\\Updatable',
+            delete: 'Resource\\Contracts\\Deletable',
+        };
+        params.modelType || (params.modelType = (0, model_name_1.pluralKebabCaseModel)(params.modelClassName));
+        params.interfaces = params.endpoints.map((endpoint) => interfaceMap[endpoint]);
+        return params;
+    }
+}
+exports.GenerateAdvancedApiResourceStub = GenerateAdvancedApiResourceStub;

package/lib/steps/stubs/backend/{api-serializer.d.ts → api-resource.d.ts}

@@ -3,7 +3,7 @@ import { Paths } from 'boilersmith/paths';
 import { Validator } from '../../../utils/validation';
 import { BasePhpStubStep } from '../php-base';
 import { Store } from 'mem-fs';
-export declare class GenerateApiSerializerStub extends BasePhpStubStep {
+export declare class GenerateApiResourceStub extends BasePhpStubStep {
     type: string;
     protected additionalExposes: string[];
     protected additionalImplicitParams: string[];
@@ -19,7 +19,7 @@ export declare class GenerateApiSerializerStub extends BasePhpStubStep {
         } | {
             name: string;
             type: string;
-            message?: undefined;
+            message: string;
             validate?: undefined;
         })[];
     };