vona-cli-set-api 1.0.8 → 1.0.12

package/dist/lib/bean/cli.bin.demo.js

@@ -0,0 +1,50 @@
+import path from 'node:path';
+import { BeanCliBase } from '@cabloy/cli';
+import fse from 'fs-extra';
+import { generateVonaMeta } from "./toolsBin/generateVonaMeta.js";
+export class CliBinDemo extends BeanCliBase {
+    async execute() {
+        const { argv } = this.context;
+        // super
+        await super.execute();
+        const projectPath = argv.projectPath;
+        // test
+        await this._demo(projectPath);
+    }
+    async _demo(projectPath) {
+        const { argv } = this.context;
+        const mode = 'local';
+        const flavor = argv.flavor || 'normal';
+        const configMeta = { flavor, mode };
+        if (!fse.existsSync(path.join(projectPath, '.vona'))) {
+            const configOptions = {
+                appDir: projectPath,
+                runtimeDir: '.vona',
+                workers: 1,
+            };
+            await generateVonaMeta(configMeta, configOptions);
+        }
+        await this._run(projectPath);
+    }
+    async _run(projectPath) {
+        // testFile
+        let testFile = path.join(import.meta.dirname, './toolsBin/demo.ts');
+        if (!fse.existsSync(testFile)) {
+            testFile = path.join(import.meta.dirname, './toolsBin/demo.js');
+        }
+        // run
+        let args = [];
+        args = args.concat(['--experimental-transform-types', '--loader=ts-node/esm', testFile, projectPath]);
+        const pos = process.argv.indexOf(':bin:demo');
+        if (pos > -1) {
+            args = args.concat(process.argv.slice(pos + 1));
+        }
+        await this.helper.spawnExe({
+            cmd: 'node',
+            args,
+            options: {
+                cwd: projectPath,
+            },
+        });
+    }
+}

package/dist/lib/bean/cli.bin.dev.d.ts

@@ -0,0 +1,14 @@
+import type { glob } from '@cabloy/module-glob';
+import type { VonaMetaFlavor } from '@cabloy/module-info';
+import { BeanCliBase } from '@cabloy/cli';
+declare module '@cabloy/cli' {
+    interface ICommandArgv {
+        workers?: number;
+        flavor?: VonaMetaFlavor;
+    }
+}
+export declare class CliBinDev extends BeanCliBase {
+    execute(): Promise<void>;
+    _dev(projectPath: string): Promise<void>;
+    _run(projectPath: string, _modulesMeta: Awaited<ReturnType<typeof glob>>): Promise<unknown>;
+}

package/dist/lib/bean/cli.bin.dev.js

@@ -0,0 +1,53 @@
+import path from 'node:path';
+import { BeanCliBase } from '@cabloy/cli';
+import nodemon from 'nodemon';
+import { rimraf } from 'rimraf';
+import { generateVonaMeta } from "./toolsBin/generateVonaMeta.js";
+export class CliBinDev extends BeanCliBase {
+    async execute() {
+        const { argv } = this.context;
+        // super
+        await super.execute();
+        const projectPath = argv.projectPath;
+        // run
+        await this._dev(projectPath);
+    }
+    async _dev(projectPath) {
+        const { argv } = this.context;
+        const mode = 'local';
+        const flavor = argv.flavor || 'normal';
+        const configMeta = { flavor, mode };
+        const configOptions = {
+            appDir: projectPath,
+            runtimeDir: '.vona',
+            workers: argv.workers,
+        };
+        const { modulesMeta } = await generateVonaMeta(configMeta, configOptions);
+        await this._run(projectPath, modulesMeta);
+        await rimraf(path.join(projectPath, '.vona'));
+    }
+    async _run(projectPath, _modulesMeta) {
+        return new Promise((resolve, _reject) => {
+            nodemon({
+                script: '.vona/bootstrap.ts',
+                cwd: projectPath,
+                exec: 'node',
+                execArgs: ['--experimental-transform-types', '--loader=ts-node/esm'],
+                // signal: 'SIGHUP',
+            });
+            nodemon.on('quit', () => {
+                resolve(undefined);
+            }).on('restart', files => {
+                // eslint-disable-next-line
+                console.log('App restarted due to: ', files);
+            });
+        });
+        // await this.helper.spawnExe({
+        //   cmd: 'node',
+        //   args: ['--experimental-transform-types', '--loader=ts-node/esm', '.vona/bootstrap.ts'],
+        //   options: {
+        //     cwd: projectPath,
+        //   },
+        // });
+    }
+}

package/dist/lib/bean/cli.bin.test.d.ts

@@ -0,0 +1,15 @@
+import type { glob } from '@cabloy/module-glob';
+import type { VonaMetaFlavor } from '@cabloy/module-info';
+import { BeanCliBase } from '@cabloy/cli';
+declare module '@cabloy/cli' {
+    interface ICommandArgv {
+        coverage?: boolean;
+        flavor?: VonaMetaFlavor;
+    }
+}
+export declare class CliBinTest extends BeanCliBase {
+    execute(): Promise<void>;
+    _test(projectPath: string): Promise<void>;
+    _run(projectPath: string, modulesMeta: Awaited<ReturnType<typeof glob>>): Promise<void>;
+    _combineTestPatterns(projectPath: string, modulesMeta: Awaited<ReturnType<typeof glob>>): string[];
+}

package/dist/lib/bean/cli.bin.test.js

@@ -0,0 +1,67 @@
+import path from 'node:path';
+import { BeanCliBase } from '@cabloy/cli';
+import fse from 'fs-extra';
+import { rimraf } from 'rimraf';
+import { generateVonaMeta } from "./toolsBin/generateVonaMeta.js";
+export class CliBinTest extends BeanCliBase {
+    async execute() {
+        const { argv } = this.context;
+        // super
+        await super.execute();
+        const projectPath = argv.projectPath;
+        // test
+        await this._test(projectPath);
+    }
+    async _test(projectPath) {
+        const { argv } = this.context;
+        const mode = 'test';
+        const flavor = argv.flavor || 'normal';
+        const configMeta = { flavor, mode };
+        const configOptions = {
+            appDir: projectPath,
+            runtimeDir: '.vona',
+            workers: 1,
+        };
+        const { modulesMeta } = await generateVonaMeta(configMeta, configOptions);
+        await this._run(projectPath, modulesMeta);
+        await rimraf(path.join(projectPath, '.vona'));
+    }
+    async _run(projectPath, modulesMeta) {
+        const { argv } = this.context;
+        // globs
+        const patterns = this._combineTestPatterns(projectPath, modulesMeta);
+        // testFile
+        let testFile = path.join(import.meta.dirname, './toolsBin/test.ts');
+        if (!fse.existsSync(testFile)) {
+            testFile = path.join(import.meta.dirname, './toolsBin/test.js');
+        }
+        // run
+        let args = [];
+        if (argv.coverage) {
+            args.push('--experimental-test-coverage');
+        }
+        if (process.env.TEST_WHYISNODERUNNING === 'true') {
+            args.push('--import=why-is-node-running/include');
+        }
+        args = args.concat(['--experimental-transform-types', '--loader=ts-node/esm', testFile, projectPath, (!!argv.coverage).toString(), patterns.join(',')]);
+        await this.helper.spawnExe({
+            cmd: 'node',
+            args,
+            options: {
+                cwd: projectPath,
+            },
+        });
+    }
+    _combineTestPatterns(projectPath, modulesMeta) {
+        const patterns = [];
+        for (const moduleName in modulesMeta.modules) {
+            const module = modulesMeta.modules[moduleName];
+            const testDir = path.join(module.root, 'test');
+            if (fse.existsSync(testDir)) {
+                const relativePath = path.relative(projectPath, module.root);
+                patterns.push(`${relativePath}/test/**/*.ts`);
+            }
+        }
+        return patterns;
+    }
+}

package/dist/lib/bean/{cli.tools.build.d.ts → cli.bin.tsc.d.ts}

@@ -4,8 +4,7 @@ declare module '@cabloy/cli' {
         force: boolean;
     }
 }
-export declare class CliToolsBuild extends BeanCliBase {
+export declare class CliBinTsc extends BeanCliBase {
     execute(): Promise<void>;
-    _build(_projectPath: string, force: boolean): Promise<void>;
+    _tsc(projectPath: string, force: boolean): Promise<void>;
 }
-//# sourceMappingURL=cli.tools.build.d.ts.map

package/dist/lib/bean/{cli.tools.build.js → cli.bin.tsc.js}

@@ -1,41 +1,49 @@
 import { BeanCliBase } from '@cabloy/cli';
-export class CliToolsBuild extends BeanCliBase {
+export class CliBinTsc extends BeanCliBase {
     async execute() {
         const { argv } = this.context;
         // super
         await super.execute();
         const projectPath = argv.projectPath;
         const force = argv.force;
-        await this._build(projectPath, force);
+        await this._tsc(projectPath, force);
     }
-    async _build(_projectPath, force) {
+    async _tsc(projectPath, force) {
         // count
-        const count = Object.keys(this.modulesMeta.suites).length + this.modulesMeta.modulesArray.filter(item => !item.suite).length;
+        const count = 1 +
+            Object.keys(this.modulesMeta.suites).length + this.modulesMeta.modulesArray.filter(item => !item.suite).length;
         // begin
         let counter = 0;
         const timeBegin = new Date();
+        // eslint-disable-next-line
         console.log('===> build begin');
         // args
         const tscArgs = ['-b'];
         if (force) {
             tscArgs.push('--force');
         }
+        // tsc: project
+        // eslint-disable-next-line
+        console.log(`===>  ${++counter}/${count} project`);
+        await this.helper.processHelper.tsc(tscArgs, { cwd: projectPath });
         // suites
         for (const key in this.modulesMeta.suites) {
             const suite = this.modulesMeta.suites[key];
+            // eslint-disable-next-line
             console.log(`===>  ${++counter}/${count} suite: ${suite.info.originalName}`);
             await this.helper.processHelper.tsc(tscArgs, { cwd: suite.root });
         }
         // modules
         for (const module of this.modulesMeta.modulesArray) {
             if (!module.suite) {
+                // eslint-disable-next-line
                 console.log(`===>  ${++counter}/${count} module: ${module.info.originalName}`);
                 await this.helper.processHelper.tsc(tscArgs, { cwd: module.root });
             }
         }
         // end
         const timeEnd = new Date();
+        // eslint-disable-next-line
         console.log(`===> build end: ${(timeEnd.valueOf() - timeBegin.valueOf()) / 1000}s`);
     }
 }
-//# sourceMappingURL=cli.tools.build.js.map

package/dist/lib/bean/cli.create.bean.d.ts

@@ -1,5 +1,5 @@
+import type { IModuleInfo } from '@cabloy/module-info';
 import { BeanCliBase } from '@cabloy/cli';
-import { IModuleInfo } from '@cabloy/module-info';
 declare module '@cabloy/cli' {
     interface ICommandArgv {
         module: string;
@@ -8,11 +8,10 @@ declare module '@cabloy/cli' {
         sceneNameCapitalize: string;
         beanName: string;
         beanNameCapitalize: string;
-        decoratorName: string;
-        beanOptions: string;
+        moduleResourceName: string;
     }
 }
 export declare class CliCreateBean extends BeanCliBase {
     execute(): Promise<void>;
+    private _getBoilerplatesOrSnippets;
 }
-//# sourceMappingURL=cli.create.bean.d.ts.map

package/dist/lib/bean/cli.create.bean.js

@@ -1,11 +1,8 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { BeanCliBase } from '@cabloy/cli';
-import path from 'path';
-import fs from 'fs';
-import { __ThisSetName__ } from '../this.js';
-const __decorators = {
-    virtual: 'Virtual',
-    aop: 'Aop',
-};
+import { getOnionMetasMeta, getOnionScenesMeta } from '@cabloy/module-info';
+import { __ThisSetName__ } from "../this.js";
 export class CliCreateBean extends BeanCliBase {
     async execute() {
         const { argv } = this.context;
@@ -22,40 +19,57 @@ export class CliCreateBean extends BeanCliBase {
         // target dir
         const targetDir = await this.helper.ensureDir(_module.root);
         // scene name
-        const sceneName = argv.sceneName; // bean/summer.cache
-        const sceneParts = sceneName.split('.');
-        argv.sceneNameCapitalize = sceneParts.map(item => this.helper.firstCharToUpperCase(item)).join();
+        const sceneName = argv.sceneName;
+        argv.sceneNameCapitalize = this.helper.firstCharToUpperCase(sceneName);
+        // scene meta
+        // onionScenesMeta
+        const onionScenesMeta = getOnionScenesMeta(this.modulesMeta.modules);
+        const onionSceneMeta = onionScenesMeta[sceneName];
         // bean name
         const beanName = argv.beanName;
         argv.beanNameCapitalize = this.helper.firstCharToUpperCase(beanName);
-        // decoratorName
-        argv.decoratorName = __decorators[sceneName] || 'Bean';
-        // beanOptions
-        if (sceneName === 'aop') {
-            argv.beanOptions = "{ match: 'some-bean-name' }";
-        }
-        else if (sceneName === 'bean') {
-            argv.beanOptions = '';
-        }
-        else {
-            argv.beanOptions = `{ scene: '${sceneName}' }`;
-        }
+        // moduleResourceName
+        argv.moduleResourceName = this.helper.combineModuleNameAndResource(argv.moduleInfo.relativeName, argv.beanName);
         // directory
-        const beanDir = path.join(targetDir, 'src/bean');
-        const beanFile = path.join(beanDir, `${sceneName}.${beanName}.ts`);
+        const beanDir = path.join(targetDir, onionSceneMeta.sceneIsolate ? `src/${sceneName}` : 'src/bean');
+        const beanFile = path.join(beanDir, onionSceneMeta.sceneIsolate ? `${beanName}.ts` : `${sceneName}.${beanName}.ts`);
         if (fs.existsSync(beanFile)) {
             throw new Error(`${sceneName} bean exists: ${beanName}`);
         }
         await this.helper.ensureDir(beanDir);
-        // render boilerplate
+        // snippets/boilerplate
+        const snippets = this._getBoilerplatesOrSnippets('snippets');
+        const boilerplates = this._getBoilerplatesOrSnippets('boilerplate');
+        const snippetsName = snippets[`${sceneName}:${argv.beanName}`] || snippets[sceneName];
+        const boilerplateName = boilerplates[`${sceneName}:${argv.beanName}`] || boilerplates[sceneName];
+        // render
         await this.template.renderBoilerplateAndSnippets({
             targetDir: beanDir,
             setName: __ThisSetName__,
-            snippetsPath: null,
-            boilerplatePath: 'create/bean/boilerplate',
+            snippetsPath: snippetsName,
+            boilerplatePath: boilerplateName,
         });
         // tools.metadata
         await this.helper.invokeCli([':tools:metadata', moduleName], { cwd: argv.projectPath });
     }
+    _getBoilerplatesOrSnippets(type) {
+        const result = {};
+        // scenes
+        const onionScenesMeta = getOnionScenesMeta(this.modulesMeta.modules);
+        for (const sceneName in onionScenesMeta) {
+            const onionSceneMeta = onionScenesMeta[sceneName];
+            if (onionSceneMeta[type]) {
+                result[sceneName] = path.join(onionSceneMeta.module.root, onionSceneMeta[type]);
+            }
+        }
+        // metas
+        const onionMetasMeta = getOnionMetasMeta(this.modulesMeta.modules);
+        for (const sceneName in onionMetasMeta) {
+            const onionMetaMeta = onionMetasMeta[sceneName];
+            if (onionMetaMeta[type]) {
+                result[`meta:${sceneName}`] = path.join(onionMetaMeta.module.root, onionMetaMeta[type]);
+            }
+        }
+        return result;
+    }
 }
-//# sourceMappingURL=cli.create.bean.js.map

package/dist/lib/bean/cli.create.module.d.ts

@@ -1,5 +1,5 @@
+import type { IModuleInfo, ISuite } from '@cabloy/module-info';
 import { BeanCliBase } from '@cabloy/cli';
-import { IModuleInfo, ISuite } from '@cabloy/module-info';
 declare module '@cabloy/cli' {
     interface ICommandArgv {
         suite: string;
@@ -13,4 +13,3 @@ declare module '@cabloy/cli' {
 export declare class CliCreateModule extends BeanCliBase {
     execute(): Promise<void>;
 }
-//# sourceMappingURL=cli.create.module.d.ts.map

package/dist/lib/bean/cli.create.module.js

@@ -1,7 +1,7 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { BeanCliBase } from '@cabloy/cli';
-import fs from 'fs';
-import path from 'path';
-import { __ThisSetName__ } from '../this.js';
+import { __ThisSetName__ } from "../this.js";
 export class CliCreateModule extends BeanCliBase {
     async execute() {
         const { argv } = this.context;
@@ -67,4 +67,3 @@ export class CliCreateModule extends BeanCliBase {
         }
     }
 }
-//# sourceMappingURL=cli.create.module.js.map

package/dist/lib/bean/cli.create.project.d.ts

@@ -0,0 +1,26 @@
+import type { CmdOptions } from '@cabloy/cli';
+import { BeanCliBase } from '@cabloy/cli';
+import urllib from 'urllib';
+declare module '@cabloy/cli' {
+    interface ICommandArgv {
+        force: boolean;
+        template: string;
+        SERVER_KEYS: string;
+        SERVER_KEYS_PROD: string;
+        DATABASE_CLIENT_MYSQL_USER: string;
+        DATABASE_CLIENT_MYSQL_PASSWORD: string;
+        DATABASE_CLIENT_MYSQL_PASSWORD_ROOT: string;
+        DATABASE_CLIENT_PG_USER: string;
+        DATABASE_CLIENT_PG_PASSWORD: string;
+        DATABASE_CLIENT_PG_PASSWORD_ROOT: string;
+    }
+}
+export declare class CliCreateProject extends BeanCliBase {
+    httpClient: typeof urllib;
+    constructor(options: CmdOptions);
+    execute(): Promise<void>;
+    printUsage(targetDir: string): Promise<void>;
+    downloadBoilerplate(packageName: string): Promise<string>;
+    getPackageInfo(packageName: string, withFallback: boolean): Promise<any>;
+    curl(url: string, options: any): Promise<import("urllib").HttpClientResponse<any>>;
+}

package/dist/lib/bean/cli.create.project.js

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import { BeanCliBase } from '@cabloy/cli';
+import compressing from 'compressing';
+import fse from 'fs-extra';
+import randomize from 'randomatic';
+import { rimraf } from 'rimraf';
+import urllib from 'urllib';
+import * as uuid from 'uuid';
+import { __ThisSetName__ } from "../this.js";
+export class CliCreateProject extends BeanCliBase {
+    httpClient;
+    constructor(options) {
+        super(options);
+        this.httpClient = urllib;
+    }
+    async execute() {
+        const { argv } = this.context;
+        // super
+        await super.execute();
+        // project name
+        const projectName = argv.name;
+        // target dir
+        const targetDir = path.join(argv.projectPath, projectName);
+        if (!argv.force && fs.existsSync(targetDir)) {
+            throw new Error(`project exists: ${projectName}`);
+        }
+        fse.ensureDirSync(targetDir);
+        // vars
+        argv.SERVER_KEYS = `vona_${uuid.v4()}_${Date.now()}_${random(100, 10000)}`;
+        argv.SERVER_KEYS_PROD = `vona_${uuid.v4()}_${Date.now()}_${random(100, 10000)}`;
+        argv.DATABASE_CLIENT_MYSQL_USER = 'web_user';
+        argv.DATABASE_CLIENT_MYSQL_PASSWORD = randomize('*', 16, { exclude: '\\\'"$' });
+        argv.DATABASE_CLIENT_MYSQL_PASSWORD_ROOT = randomize('*', 16, { exclude: '\\\'"$' });
+        argv.DATABASE_CLIENT_PG_USER = 'web_user';
+        argv.DATABASE_CLIENT_PG_PASSWORD = randomize('*', 16, { exclude: '\\\'"$' });
+        argv.DATABASE_CLIENT_PG_PASSWORD_ROOT = randomize('*', 16, { exclude: '\\\'"$' });
+        // template
+        const template = argv.template;
+        // render project boilerplate
+        await this.template.renderBoilerplateAndSnippets({
+            targetDir,
+            setName: __ThisSetName__,
+            snippetsPath: null,
+            boilerplatePath: `create/project/${template}/boilerplate`,
+        });
+        // copy package.json
+        fse.copyFileSync(path.join(targetDir, 'package.original.json'), path.join(targetDir, 'package.json'));
+        // npm run init
+        await this.helper.spawnCmd({
+            cmd: 'npm',
+            args: ['run', 'init'],
+            options: { cwd: targetDir },
+        });
+        // done
+        await this.printUsage(targetDir);
+    }
+    async printUsage(targetDir) {
+        await this.console.log(`usage:
+      - cd ${targetDir}
+      - pnpm install
+      - npm run dev
+      - npm run test
+      - npm run build
+      - npm run start
+    `);
+    }
+    async downloadBoilerplate(packageName) {
+        const result = await this.getPackageInfo(packageName, false);
+        const tgzUrl = result.dist.tarball;
+        await this.console.log(`downloading ${tgzUrl}`);
+        const saveDir = path.join(os.tmpdir(), 'zova-project-boilerplate');
+        await rimraf(saveDir);
+        const response = await this.curl(tgzUrl, { streaming: true, followRedirect: true });
+        await compressing.tgz.uncompress(response.res, saveDir);
+        await this.console.log(`extract to ${saveDir}`);
+        return path.join(saveDir, '/package');
+    }
+    async getPackageInfo(packageName, withFallback) {
+        await this.console.log(`fetching npm info of ${packageName}`);
+        try {
+            const registry = await this.helper.getRegistry();
+            const result = await this.curl(`${registry}${packageName}/latest`, {
+                dataType: 'json',
+                followRedirect: true,
+                maxRedirects: 5,
+            });
+            if (result.status !== 200) {
+                const message = `npm info ${packageName} got error: ${result.status}, ${result.data.reason}`;
+                throw new Error(message);
+            }
+            return result.data;
+        }
+        catch (err) {
+            if (withFallback) {
+                await this.console.log(`use fallback from ${packageName}`);
+                const require = createRequire(import.meta.url);
+                return require(`${packageName}/package.json`);
+            }
+            throw err;
+        }
+    }
+    async curl(url, options) {
+        options = options || {};
+        if (!options.timeout) {
+            options.timeout = 30000;
+        }
+        return await this.httpClient.request(url, options);
+    }
+}
+function random(start, end) {
+    return Math.floor(Math.random() * (end - start) + start);
+}

package/dist/lib/bean/cli.create.suite.d.ts

@@ -1,5 +1,5 @@
+import type { IModuleInfo } from '@cabloy/module-info';
 import { BeanCliBase } from '@cabloy/cli';
-import { IModuleInfo } from '@cabloy/module-info';
 declare module '@cabloy/cli' {
     interface ICommandArgv {
         name: string;
@@ -9,4 +9,3 @@ declare module '@cabloy/cli' {
 export declare class CliCreateSuite extends BeanCliBase {
     execute(): Promise<void>;
 }
-//# sourceMappingURL=cli.create.suite.d.ts.map

package/dist/lib/bean/cli.create.suite.js

@@ -1,7 +1,7 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { BeanCliBase } from '@cabloy/cli';
-import fs from 'fs';
-import path from 'path';
-import { __ThisSetName__ } from '../this.js';
+import { __ThisSetName__ } from "../this.js";
 export class CliCreateSuite extends BeanCliBase {
     async execute() {
         const { argv } = this.context;
@@ -26,12 +26,8 @@ export class CliCreateSuite extends BeanCliBase {
         }
         targetDir = await this.helper.ensureDir(targetDir);
         // templateDir
-        const templateDir = this.template.resolveTemplatePath({
-            setName: __ThisSetName__,
-            path: 'create/suite',
-        });
+        const templateDir = this.template.resolveTemplatePath(__ThisSetName__, 'create/suite');
         // render
-        await this.template.renderDir({ targetDir, templateDir });
+        await this.template.renderDir(targetDir, templateDir);
     }
 }
-//# sourceMappingURL=cli.create.suite.js.map

package/dist/lib/bean/cli.create.test.d.ts

@@ -0,0 +1,15 @@
+import type { NameMeta } from '@cabloy/cli';
+import type { IModuleInfo } from '@cabloy/module-info';
+import { BeanCliBase } from '@cabloy/cli';
+declare module '@cabloy/cli' {
+    interface ICommandArgv {
+        module: string;
+        moduleInfo: IModuleInfo;
+        name: string;
+        nameCapitalize: string;
+        nameMeta: NameMeta;
+    }
+}
+export declare class CliCreateTest extends BeanCliBase {
+    execute(): Promise<void>;
+}

package/dist/lib/bean/cli.create.test.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { BeanCliBase } from '@cabloy/cli';
+import { __ThisSetName__ } from "../this.js";
+export class CliCreateTest extends BeanCliBase {
+    async execute() {
+        const { argv } = this.context;
+        // super
+        await super.execute();
+        // module name/info
+        const moduleName = argv.module;
+        argv.moduleInfo = this.helper.parseModuleInfo(moduleName);
+        // check if exists
+        const _module = this.helper.findModule(moduleName);
+        if (!_module) {
+            throw new Error(`module does not exist: ${moduleName}`);
+        }
+        // target dir
+        const targetDir = await this.helper.ensureDir(_module.root);
+        // name
+        argv.nameCapitalize = this.helper.firstCharToUpperCase(argv.name);
+        // nameMeta
+        argv.nameMeta = this.helper.parseNameMeta(argv.name, ['test']);
+        // directory
+        const testDir = path.join(targetDir, 'test');
+        const testFile = path.join(testDir, `${argv.name}.test.ts`);
+        if (fs.existsSync(testFile)) {
+            throw new Error(`test exists: ${testFile}`);
+        }
+        await this.helper.ensureDir(testDir);
+        // render boilerplate
+        await this.template.renderBoilerplateAndSnippets({
+            targetDir: testDir,
+            setName: __ThisSetName__,
+            snippetsPath: null,
+            boilerplatePath: 'create/test/boilerplate',
+        });
+    }
+}

package/dist/lib/bean/cli.default.list.d.ts

@@ -10,4 +10,3 @@ export declare class CliDefaultList extends BeanCliBase {
     _setShow({ setShow, groupWant, commandsAll }: any): Promise<void>;
     _combineCliFullName({ setShow, groupShow, commandName }: any): string;
 }
-//# sourceMappingURL=cli.default.list.d.ts.map

package/dist/lib/bean/cli.default.list.js

@@ -91,4 +91,3 @@ export class CliDefaultList extends BeanCliBase {
         return parts.join(':');
     }
 }
-//# sourceMappingURL=cli.default.list.js.map