vona-cli-set-api 1.0.8 → 1.0.11

package/cli/templates/create/project/basic/boilerplate/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "references": [],
+  "include": [".vona/**/*.ts", "src/backend/package.json", "src/backend/config", "src/backend/demo", "src/backend/typing"],
+  "exclude": [],
+  "ts-node": {
+    "swc": true
+  }
+}

package/cli/templates/create/suite/_package.json

@@ -1,9 +1,9 @@
 {
   "name": "vona-suite-<%=argv.name%>",
+  "type": "module",
   "version": "5.0.0",
   "title": "<%=argv.suiteInfo.relativeName%>",
-  "type": "module",
-  "files": ["dist"],
+  "files": [],
   "description": "<%=argv.description%>",
   "author": "<%=argv.author%>",
   "dependencies": {}

package/cli/templates/create/suite/_tsconfig.json

@@ -1,6 +1,6 @@
 {
   "extends": "./tsconfig.base",
   "compilerOptions": {},
-  "exclude": ["modules"],
-  "references": []
+  "references": [],
+  "exclude": ["modules"]
 }

package/cli/templates/create/test/boilerplate/{{name}}.test.ts

@@ -0,0 +1,11 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('<%=argv.name%>.test.ts', () => {
+  it('action:<%=argv.name%>', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      assert.equal(app.ctx.instanceName, '');
+    });
+  });
+});

package/cli/templates/init/config/boilerplate/config/config.ts

@@ -0,0 +1,5 @@
+import type { VonaApplication } from 'vona';
+
+export function config(_app: VonaApplication) {
+  return {};
+}

package/cli/templates/init/constant/boilerplate/config/constants.ts

@@ -0,0 +1 @@
+export const constants = {} as const;

package/cli/templates/init/error/boilerplate/config/errors.ts

@@ -0,0 +1 @@
+export enum Errors {}

package/cli/templates/init/locale/boilerplate/config/locale/en-us.ts

@@ -0,0 +1 @@
+export default {};

package/cli/templates/init/locale/boilerplate/config/locale/zh-cn.ts

@@ -0,0 +1 @@
+export default {};

package/cli/templates/init/main/boilerplate/main.ts

@@ -1,4 +1,5 @@
-import { BeanSimple, IModuleMain } from 'vona';
+import type { IModuleMain } from 'vona';
+import { BeanSimple } from 'vona';
 
 export class Main extends BeanSimple implements IModuleMain {
   async moduleLoading() {}

package/cli/templates/init/monkey/boilerplate/monkey.ts

@@ -1,4 +1,6 @@
-import { BeanSimple, IModule, IMonkeyModule } from 'vona';
+import type { IModule } from '@cabloy/module-info';
+import type { IMonkeyModule } from 'vona';
+import { BeanSimple } from 'vona';
 
 export class Monkey extends BeanSimple implements IMonkeyModule {
   async moduleLoading(_module: IModule) {}

package/cli/templates/tools/crud/boilerplate/src/controller/{{resourceName}}.ts_

@@ -0,0 +1,43 @@
+import type { TableIdentity } from 'vona-module-a-database';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import type { Dto<%=argv.resourceNameCapitalize%>Update } from '../dto/<%=argv.resourceName%>Update.ts';
+import { BeanBase } from 'vona';
+import { Api, Arg, v } from 'vona-module-a-openapi';
+import { Controller, Web } from 'vona-module-a-web';
+import { Dto<%=argv.resourceNameCapitalize%>Create } from '../dto/<%=argv.resourceName%>Create.ts';
+import { Entity<%=argv.resourceNameCapitalize%> } from '../entity/<%=argv.resourceName%>.ts';
+
+export interface IControllerOptions<%=argv.resourceNameCapitalize%> extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptions<%=argv.resourceNameCapitalize%>>('<%=argv.resourceName%>')
+export class Controller<%=argv.resourceNameCapitalize%> extends BeanBase {
+  @Web.post()
+  @Api.body(v.object(Entity<%=argv.resourceNameCapitalize%>))
+  async create(@Arg.body() <%=argv.resourceName%>: Dto<%=argv.resourceNameCapitalize%>Create): Promise<Entity<%=argv.resourceNameCapitalize%>> {
+    return await this.scope.service.<%=argv.resourceName%>.create(<%=argv.resourceName%>);
+  }
+
+  @Web.get()
+  @Api.body(v.array(v.object(Entity<%=argv.resourceNameCapitalize%>)))
+  async findAll(): Promise<Entity<%=argv.resourceNameCapitalize%>[]> {
+    return await this.scope.service.<%=argv.resourceName%>.findAll();
+  }
+
+  @Web.get(':id')
+  @Api.body(v.object(Entity<%=argv.resourceNameCapitalize%>))
+  async findOne(@Arg.param('id') id: TableIdentity): Promise<Entity<%=argv.resourceNameCapitalize%>> {
+    const <%=argv.resourceName%> = await this.scope.service.<%=argv.resourceName%>.findOne(id);
+    if (!<%=argv.resourceName%>) this.app.throw(404);
+    return <%=argv.resourceName%>;
+  }
+
+  @Web.patch(':id')
+  async update(@Arg.param('id') id: TableIdentity, @Arg.body() <%=argv.resourceName%>: Dto<%=argv.resourceNameCapitalize%>Update) {
+    return await this.scope.service.<%=argv.resourceName%>.update(id, <%=argv.resourceName%>);
+  }
+
+  @Web.delete(':id')
+  async remove(@Arg.param('id') id: TableIdentity) {
+    return await this.scope.service.<%=argv.resourceName%>.remove(id);
+  }
+}

package/cli/templates/tools/crud/boilerplate/src/dto/{{resourceName}}Create.ts_

@@ -0,0 +1,9 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { ClassMapped } from 'vona';
+import { Dto } from 'vona-module-a-web';
+import { Entity<%=argv.resourceNameCapitalize%> } from '../entity/<%=argv.resourceName%>.ts';
+
+export interface IDtoOptions<%=argv.resourceNameCapitalize%>Create extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptions<%=argv.resourceNameCapitalize%>Create>()
+export class Dto<%=argv.resourceNameCapitalize%>Create extends ClassMapped.pick(Entity<%=argv.resourceNameCapitalize%>, ['name', 'description']) {}

package/cli/templates/tools/crud/boilerplate/src/dto/{{resourceName}}Update.ts_

@@ -0,0 +1,9 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { ClassMapped } from 'vona';
+import { Dto } from 'vona-module-a-web';
+import { Dto<%=argv.resourceNameCapitalize%>Create } from './<%=argv.resourceName%>Create.ts';
+
+export interface IDtoOptions<%=argv.resourceNameCapitalize%>Update extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptions<%=argv.resourceNameCapitalize%>Update>()
+export class Dto<%=argv.resourceNameCapitalize%>Update extends ClassMapped.partial(Dto<%=argv.resourceNameCapitalize%>Create) {}

package/cli/templates/tools/crud/boilerplate/src/entity/{{resourceName}}.ts_

@@ -0,0 +1,15 @@
+import type { IDecoratorEntityOptions } from 'vona-module-a-database';
+import { Entity, EntityBase } from 'vona-module-a-database';
+import { Api, v } from 'vona-module-a-openapi';
+import { $locale } from '../.metadata/index.ts';
+
+export interface IEntityOptions<%=argv.resourceNameCapitalize%> extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptions<%=argv.resourceNameCapitalize%>>('<%=argv.moduleResourceName%>')
+export class Entity<%=argv.resourceNameCapitalize%> extends EntityBase {
+  @Api.field(v.openapi({ title: $locale('Name') }), v.min(3))
+  name: string;
+
+  @Api.field(v.openapi({ title: $locale('Description') }), v.optional())
+  description?: string;
+}

package/cli/templates/tools/crud/boilerplate/src/model/{{resourceName}}.ts_

@@ -0,0 +1,5 @@
+import { BeanModelBase, Model } from 'vona-module-a-database';
+import { Entity<%=argv.resourceNameCapitalize%> } from '../entity/<%=argv.resourceName%>.ts';
+
+@Model({ entity: Entity<%=argv.resourceNameCapitalize%> })
+export class Model<%=argv.resourceNameCapitalize%> extends BeanModelBase<Entity<%=argv.resourceNameCapitalize%>> {}

package/cli/templates/tools/crud/boilerplate/src/service/{{resourceName}}.ts_

@@ -0,0 +1,32 @@
+import type { TableIdentity } from 'vona-module-a-database';
+import type { Dto<%=argv.resourceNameCapitalize%>Create } from '../dto/<%=argv.resourceName%>Create.ts';
+import type { Dto<%=argv.resourceNameCapitalize%>Update } from '../dto/<%=argv.resourceName%>Update.ts';
+import type { Entity<%=argv.resourceNameCapitalize%> } from '../entity/<%=argv.resourceName%>.ts';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-web';
+
+@Service()
+export class Service<%=argv.resourceNameCapitalize%> extends BeanBase {
+  async create(<%=argv.resourceName%>: Dto<%=argv.resourceNameCapitalize%>Create): Promise<Entity<%=argv.resourceNameCapitalize%>> {
+    return await this.scope.model.<%=argv.resourceName%>.insert(<%=argv.resourceName%>);
+  }
+
+  async findAll(): Promise<Entity<%=argv.resourceNameCapitalize%>[]> {
+    return await this.scope.model.<%=argv.resourceName%>.select();
+  }
+
+  async findOne(id: TableIdentity): Promise<Entity<%=argv.resourceNameCapitalize%> | undefined> {
+    return await this.scope.model.<%=argv.resourceName%>.get({ id });
+  }
+
+  async update(id: TableIdentity, <%=argv.resourceName%>: Dto<%=argv.resourceNameCapitalize%>Update) {
+    return await this.scope.model.<%=argv.resourceName%>.update({
+      ...<%=argv.resourceName%>,
+      id,
+    });
+  }
+
+  async remove(id: TableIdentity) {
+    return await this.scope.model.<%=argv.resourceName%>.delete({ id });
+  }
+}

package/cli/templates/tools/crud/boilerplate/test/{{resourceName}}.test.ts_

@@ -0,0 +1,46 @@
+import type { Dto<%=argv.resourceNameCapitalize%>Create, Dto<%=argv.resourceNameCapitalize%>Update, Entity<%=argv.resourceNameCapitalize%> } from 'vona-module-<%=argv.moduleInfo.relativeName%>';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { catchError } from '@cabloy/utils';
+import { app } from 'vona-mock';
+
+describe('<%=argv.resourceName%>.test.ts', () => {
+  it('action:<%=argv.resourceName%>', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // data
+      const data: Dto<%=argv.resourceNameCapitalize%>Create = {
+        name: '__Tom__',
+        description: 'This is a test',
+      };
+      const dataUpdate: Dto<%=argv.resourceNameCapitalize%>Update = {
+        name: '__TomNew__',
+        description: 'This is a test',
+      };
+      // login
+      await app.bean.passport.signinMock();
+      // create
+      const <%=argv.resourceName%>: Entity<%=argv.resourceNameCapitalize%> = await app.bean.executor.performAction('post', '<%=argv.moduleActionPathRaw%>', { body: data });
+      assert.equal(<%=argv.resourceName%>.name, data.name);
+      // findAll
+      const <%=argv.resourceName%>s: Entity<%=argv.resourceNameCapitalize%>[] = await app.bean.executor.performAction('get', '<%=argv.moduleActionPathRaw%>');
+      assert.equal(<%=argv.resourceName%>s.findIndex(item => item.name === data.name) > -1, true);
+      // update
+      await app.bean.executor.performAction('patch', '<%=argv.moduleActionPathRaw%>/:id', {
+        params: { id: <%=argv.resourceName%>.id },
+        body: dataUpdate,
+      });
+      // findOne
+      const <%=argv.resourceName%>One: Entity<%=argv.resourceNameCapitalize%> = await app.bean.executor.performAction('get', '<%=argv.moduleActionPathRaw%>/:id', { params: { id: <%=argv.resourceName%>.id } });
+      assert.equal(<%=argv.resourceName%>One.name, dataUpdate.name);
+      // delete
+      await app.bean.executor.performAction('delete', '<%=argv.moduleActionPathRaw%>/:id', { params: { id: <%=argv.resourceName%>One.id } });
+      // findOne
+      const [_, err] = await catchError(() => {
+        return app.bean.executor.performAction('get', '<%=argv.moduleActionPathRaw%>/:id', { params: { id: <%=argv.resourceName%>One.id } });
+      });
+      assert.equal(err?.code, 404);
+      // logout
+      await app.bean.passport.signout();
+    });
+  });
+});

package/cli/templates/tools/crud/snippets/1-package.json.ts

@@ -0,0 +1,16 @@
+import { metadataCustomSnippet } from '@cabloy/cli';
+
+declare module '@cabloy/cli' {
+  interface ICommandArgv {
+    fileVersion: number;
+  }
+}
+
+export default metadataCustomSnippet({
+  file: 'package.json',
+  language: 'json',
+  async transform({ ast, argv }) {
+    argv.fileVersion = ast.vonaModule.fileVersion = 1 + (ast.vonaModule.fileVersion ?? 0);
+    return ast;
+  },
+});

package/cli/templates/tools/crud/snippets/2-meta.version.ts

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import { metadataCustomSnippet } from '@cabloy/cli';
+import { catchError } from '@cabloy/utils';
+
+declare module '@cabloy/cli' {
+  interface ICommandArgv {
+    module: string;
+  }
+}
+
+const __snippet_update = `if (options.version === <%=argv.fileVersion%>) {
+  const entity<%=argv.resourceNameCapitalize%> = this.scope.entity.<%=argv.resourceName%>;
+  await this.bean.model.createTable(entity<%=argv.resourceNameCapitalize%>.$table, table => {
+    table.basicFields();
+    table.string(entity<%=argv.resourceNameCapitalize%>.$column('name'), 50);
+    table.string(entity<%=argv.resourceNameCapitalize%>.$column('description'), 255);
+  });
+}`;
+
+export default metadataCustomSnippet({
+  file: 'src/bean/meta.version.ts',
+  language: 'gogo',
+  init: async ({ cli, argv, targetFile }) => {
+    await catchError(() => {
+      return cli.helper.invokeCli([
+        ':create:bean',
+        'meta',
+        'version',
+        `--module=${argv.module}`,
+      ], { cwd: argv.projectPath });
+    });
+    return fs.readFileSync(targetFile).toString('utf8');
+  },
+  async transform({ cli, ast }) {
+    // update
+    ast.replace('async update(_options: IMetaVersionUpdateOptions) {$$$1}', 'async update(options: IMetaVersionUpdateOptions) {$$$1}');
+    const code = await cli.template.renderContent({ content: __snippet_update });
+    ast.replace('async update($$$0) {$$$1}', `async update($$$0) {$$$1 \n ${code}}`);
+    // ok
+    return ast;
+  },
+});

package/cli/templates/tools/crud/snippets/3-en-us.ts

@@ -0,0 +1,27 @@
+import fs from 'node:fs';
+import { metadataCustomSnippet } from '@cabloy/cli';
+import { catchError } from '@cabloy/utils';
+import { locale_transform } from '../utils.ts';
+
+declare module '@cabloy/cli' {
+  interface ICommandArgv {
+    module: string;
+    resourceNameCapitalize: string;
+  }
+}
+
+export default metadataCustomSnippet({
+  file: 'src/config/locale/en-us.ts',
+  language: 'gogo',
+  init: async ({ cli, argv, targetFile }) => {
+    await catchError(() => {
+      return cli.helper.invokeCli([':init:locale', argv.module], {
+        cwd: argv.projectPath,
+      });
+    });
+    return fs.readFileSync(targetFile).toString('utf8');
+  },
+  async transform({ ast, argv }) {
+    return locale_transform({ ast, argv });
+  },
+});

package/cli/templates/tools/crud/snippets/4-zh-cn.ts

@@ -0,0 +1,10 @@
+import { metadataCustomSnippet } from '@cabloy/cli';
+import { locale_transform } from '../utils.ts';
+
+export default metadataCustomSnippet({
+  file: 'src/config/locale/zh-cn.ts',
+  language: 'gogo',
+  async transform({ ast, argv }) {
+    return locale_transform({ ast, argv });
+  },
+});

package/cli/templates/tools/crud/utils.ts

@@ -0,0 +1,20 @@
+const __names = ['Name', 'Description'];
+
+export async function locale_transform({ ast, argv }) {
+  const names = __names.concat(argv.resourceNameCapitalize);
+  const nodes = ast.find('export default {$$$0}');
+  for (const name of names) {
+    const node = nodes.match.$$$0.find(node => {
+      return (node as any).key.name === name;
+    });
+    if (!node) {
+      const code = `${name}: '${name}',`;
+      ast.replace(
+        'export default {$$$0}',
+        `export default { $$$0, \n ${code}}`,
+      );
+    }
+  }
+  // ok
+  return ast;
+}

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export * from './lib/beans.js';
-export * from './lib/commands.js';
-//# sourceMappingURL=index.d.ts.map
+export * from './lib/beans.ts';
+export * from './lib/commands.ts';
+export * from './lib/utils.ts';

package/dist/index.js

@@ -1,3 +1,3 @@
-export * from './lib/beans.js';
-export * from './lib/commands.js';
-//# sourceMappingURL=index.js.map
+export * from "./lib/beans.js";
+export * from "./lib/commands.js";
+export * from "./lib/utils.js";

package/dist/lib/bean/cli.bin.build.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 {
+        workers?: number;
+        flavor?: VonaMetaFlavor;
+    }
+}
+export declare class CliBinBuild extends BeanCliBase {
+    execute(): Promise<void>;
+    _build(projectPath: string): Promise<void>;
+    _assets(projectPath: string, modulesMeta: Awaited<ReturnType<typeof glob>>): Promise<void>;
+    _rollup(projectPath: string, env: NodeJS.ProcessEnv): Promise<void>;
+}

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

@@ -0,0 +1,139 @@
+import path from 'node:path';
+import { BeanCliBase } from '@cabloy/cli';
+import aliasImport from '@rollup/plugin-alias';
+import babelImport from '@rollup/plugin-babel';
+import commonjsImport from '@rollup/plugin-commonjs';
+import jsonImport from '@rollup/plugin-json';
+import resolveImport from '@rollup/plugin-node-resolve';
+import replaceImport from '@rollup/plugin-replace';
+import terserImport from '@rollup/plugin-terser';
+import fse from 'fs-extra';
+import { rimraf } from 'rimraf';
+import { rollup } from 'rollup';
+import { generateConfigDefine } from "../utils.js";
+import { generateVonaMeta } from "./toolsBin/generateVonaMeta.js";
+const commonjs = commonjsImport;
+const resolve = resolveImport;
+// const swc = swcImport as any as typeof swcImport.default;
+const json = jsonImport;
+const babel = babelImport;
+const terser = terserImport;
+const alias = aliasImport;
+const replace = replaceImport;
+export class CliBinBuild extends BeanCliBase {
+    async execute() {
+        const { argv } = this.context;
+        // super
+        await super.execute();
+        const projectPath = argv.projectPath;
+        await this._build(projectPath);
+    }
+    async _build(projectPath) {
+        const { argv } = this.context;
+        const mode = 'prod';
+        const flavor = argv.flavor || 'normal';
+        const configMeta = { flavor, mode };
+        const configOptions = {
+            appDir: projectPath,
+            runtimeDir: '.vona',
+            workers: argv.workers,
+        };
+        const { env, modulesMeta } = await generateVonaMeta(configMeta, configOptions);
+        await rimraf(path.join(projectPath, 'dist'));
+        await this._rollup(projectPath, env);
+        await this._assets(projectPath, modulesMeta);
+        await rimraf(path.join(projectPath, '.vona'));
+    }
+    async _assets(projectPath, modulesMeta) {
+        const assetsPath = path.join(projectPath, 'dist/assets');
+        for (const relativeName in modulesMeta.modules) {
+            const module = modulesMeta.modules[relativeName];
+            if (!module.package.files)
+                continue;
+            for (const scene of module.package.files) {
+                if (['dist', 'cli', 'test'].includes(scene))
+                    continue;
+                const scenePath = path.join(module.root, scene);
+                if (fse.existsSync(scenePath)) {
+                    const destPath = path.join(assetsPath, scene, relativeName);
+                    await fse.copy(scenePath, destPath);
+                }
+            }
+        }
+    }
+    async _rollup(projectPath, env) {
+        const aliasEntries = [];
+        for (const name of ['better-sqlite3', 'mysql', 'oracledb', 'pg-native', 'pg-query-stream', 'sqlite3', 'tedious', 'cloudflare:sockets']) {
+            aliasEntries.push({ find: name, replacement: 'vona-shared' });
+        }
+        const replaceValues = generateConfigDefine(env, ['NODE_ENV', 'META_MODE', 'META_FLAVOR']);
+        const plugins = [
+            alias({
+                entries: aliasEntries,
+            }),
+            resolve({
+                preferBuiltins: true,
+            }),
+            replace({
+                values: replaceValues,
+                preventAssignment: false,
+            }),
+            json(),
+            commonjs(),
+            babel({
+                include: '**/*.ts',
+                extensions: ['.ts', '.tsx'],
+                babelHelpers: 'bundled',
+                skipPreflightCheck: true,
+                babelrc: false,
+                configFile: false,
+                plugins: [
+                    ['babel-plugin-zova-bean-module', { brandName: 'vona' }],
+                    ['babel-plugin-transform-typescript-metadata'],
+                    ['@babel/plugin-proposal-decorators', { version: 'legacy' }],
+                    ['@babel/plugin-transform-class-properties', { loose: true }],
+                    ['@babel/plugin-transform-typescript'],
+                ],
+            }),
+        ];
+        if (process.env.BUILD_MINIFY === 'true') {
+            plugins.push(terser({
+                keep_classnames: true,
+            }));
+        }
+        const inputOptions = {
+            input: path.join(projectPath, '.vona/bootstrap.ts'),
+            plugins,
+            onLog: (level, log, defaultHandler) => {
+                if (log.code === 'CIRCULAR_DEPENDENCY' && process.env.BUILD_LOG_CIRCULAR_DEPENDENCY === 'false')
+                    return;
+                if (log.code === 'THIS_IS_UNDEFINED' && log.message.includes('ramda/es/partialObject.js'))
+                    return;
+                if (log.code === 'EVAL' && log.message.includes('depd/index.js'))
+                    return;
+                if (log.code === 'EVAL' && log.message.includes('bluebird/js/release/util.js'))
+                    return;
+                defaultHandler(level, log);
+            },
+        };
+        const outputOption = {
+            dir: path.join(projectPath, 'dist'),
+            // file: path.join(projectPath, 'dist/index.js'),
+            format: 'esm',
+            sourcemap: process.env.BUILD_SOURCEMAP === 'true',
+            // https://github.com/rollup/rollup/issues/4166
+            inlineDynamicImports: process.env.BUILD_INLINEDYNAMICIMPORTS === 'true',
+        };
+        let bundle;
+        try {
+            bundle = await rollup(inputOptions);
+            await bundle.write(outputOption);
+        }
+        finally {
+            if (bundle) {
+                // closes the bundle
+                await bundle.close();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+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 {
+        flavor?: VonaMetaFlavor;
+    }
+}
+export declare class CliBinDbReset extends BeanCliBase {
+    execute(): Promise<void>;
+    _dbReset(projectPath: string): Promise<void>;
+    _run(projectPath: string, _modulesMeta: Awaited<ReturnType<typeof glob>>): Promise<void>;
+}

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

@@ -0,0 +1,46 @@
+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 CliBinDbReset extends BeanCliBase {
+    async execute() {
+        const { argv } = this.context;
+        // super
+        await super.execute();
+        const projectPath = argv.projectPath;
+        // test
+        await this._dbReset(projectPath);
+    }
+    async _dbReset(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) {
+        // testFile
+        let testFile = path.join(import.meta.dirname, './toolsBin/dbReset.ts');
+        if (!fse.existsSync(testFile)) {
+            testFile = path.join(import.meta.dirname, './toolsBin/dbReset.js');
+        }
+        // run
+        let args = [];
+        args = args.concat(['--experimental-transform-types', '--loader=ts-node/esm', testFile, projectPath]);
+        await this.helper.spawnExe({
+            cmd: 'node',
+            args,
+            options: {
+                cwd: projectPath,
+            },
+        });
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { VonaMetaFlavor } from '@cabloy/module-info';
+import { BeanCliBase } from '@cabloy/cli';
+declare module '@cabloy/cli' {
+    interface ICommandArgv {
+        flavor?: VonaMetaFlavor;
+    }
+}
+export declare class CliBinDemo extends BeanCliBase {
+    execute(): Promise<void>;
+    _demo(projectPath: string): Promise<void>;
+    _run(projectPath: string): Promise<void>;
+}