vona-cli-set-api 1.0.8 → 1.0.11

package/dist/lib/bean/cli.tools.metadata.js

@@ -1,15 +1,17 @@
+import path from 'node:path';
 import { BeanCliBase } from '@cabloy/cli';
+import { getOnionMetasMeta, getOnionScenesMeta } from '@cabloy/module-info';
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
 import fse from 'fs-extra';
-import path from 'path';
-import { generateBeans } from './toolsMetadata/generateBeans.js';
-import { generateAtoms } from './toolsMetadata/generateAtoms.js';
-import { generateControllers } from './toolsMetadata/generateControllers.js';
-import { generateEntities } from './toolsMetadata/generateEntities.js';
-import { generateModels } from './toolsMetadata/generateModels.js';
-import { generateServices } from './toolsMetadata/generateServices.js';
-import { generateConfig, generateConstant, generateError, generateLocale } from './toolsMetadata/generateConfig.js';
-import { generateScope } from './toolsMetadata/generateScope.js';
-import { generateMonkey, generateMain } from './toolsMetadata/generateMonkey.js';
+import { generateBeanGenerals } from "./toolsMetadata/generateBeanGenerals.js";
+import { generateBeans } from "./toolsMetadata/generateBeans.js";
+import { generateConfig, generateConstant, generateError, generateLocale } from "./toolsMetadata/generateConfig.js";
+import { generateMetadataCustom } from "./toolsMetadata/generateMetadataCustom.js";
+import { generateMain, generateMonkey } from "./toolsMetadata/generateMonkey.js";
+import { generateOnions } from "./toolsMetadata/generateOnions.js";
+import { generateScope } from "./toolsMetadata/generateScope.js";
+import { generateScopeResources } from "./toolsMetadata/generateScopeResources.js";
+import { generateScopeResourcesMeta } from "./toolsMetadata/generateScopeResourcesMeta.js";
 export class CliToolsMetadata extends BeanCliBase {
     async execute() {
         const { argv } = this.context;
@@ -49,22 +51,49 @@ export class CliToolsMetadata extends BeanCliBase {
         await this.helper.ensureDir(metaDir);
         // relativeNameCapitalize
         const relativeNameCapitalize = this.helper.stringToCapitalize(moduleName, '-');
+        // onionScenesMeta
+        const onionScenesMeta = getOnionScenesMeta(this.modulesMeta.modules);
         // content
         let content = '';
         // beans
-        content += await generateBeans(moduleName, modulePath);
-        // atoms
-        content += await generateAtoms(moduleName, modulePath);
-        // controllers
-        content += await generateControllers(moduleName, modulePath);
-        // entities
-        content += await generateEntities(moduleName, modulePath);
-        // models
-        const contentModels = await generateModels(moduleName, modulePath);
-        content += contentModels;
-        // services
-        const contentServices = await generateServices(moduleName, modulePath);
-        content += contentServices;
+        content += await generateBeans(onionScenesMeta, moduleName, modulePath);
+        // onions
+        const scopeResources = {};
+        for (const sceneName in onionScenesMeta) {
+            const sceneMeta = onionScenesMeta[sceneName];
+            // general
+            content += await generateOnions(sceneName, sceneMeta, moduleName, modulePath);
+            // scope resources
+            if (sceneMeta.scopeResource) {
+                const contentScopeResource = await generateScopeResources(sceneName, sceneMeta, moduleName, modulePath);
+                if (contentScopeResource) {
+                    content += contentScopeResource;
+                    scopeResources[sceneName] = `IModule${toUpperCaseFirstChar(sceneName)}`;
+                }
+            }
+            // bean generals
+            if (sceneMeta.beanGeneral) {
+                content += await generateBeanGenerals(sceneName, sceneMeta, moduleName, modulePath);
+            }
+            // metas
+            if (sceneName === 'meta') {
+                const onionMetasMeta = getOnionMetasMeta(this.modulesMeta.modules);
+                for (const metaName in onionMetasMeta) {
+                    const metaMeta = onionMetasMeta[metaName];
+                    if (metaMeta.scopeResource) {
+                        const contentScopeResourceMeta = await generateScopeResourcesMeta(metaName, metaMeta, sceneName, sceneMeta, moduleName, modulePath);
+                        if (contentScopeResourceMeta) {
+                            content += contentScopeResourceMeta;
+                            scopeResources[metaName] = `Meta${toUpperCaseFirstChar(metaName)}`;
+                        }
+                    }
+                }
+            }
+            // metadata custom
+            if (sceneMeta.metadataCustom) {
+                content += await generateMetadataCustom(this, sceneName, sceneMeta, moduleName, modulePath);
+            }
+        }
         // config
         const contentConfig = await generateConfig(modulePath);
         content += contentConfig;
@@ -82,14 +111,14 @@ export class CliToolsMetadata extends BeanCliBase {
         // main
         content += await generateMain(modulePath);
         // scope
-        content += await generateScope(moduleName, relativeNameCapitalize, {
+        content += await generateScope(moduleName, relativeNameCapitalize, scopeResources, {
             config: contentConfig,
             errors: contentErrors,
             locales: contentLocales,
             constants: contentConstants,
-            services: contentServices,
-            models: contentModels,
         });
+        // patch
+        content = this._generatePatch(content);
         // empty
         if (!content.trim()) {
             content = 'export {};';
@@ -102,31 +131,41 @@ export class CliToolsMetadata extends BeanCliBase {
         // index
         await this._generateIndex(modulePath);
     }
+    _generatePatch(content) {
+        if (!content)
+            return content;
+        if (content.includes('TypeEntityOptionsFields')) {
+            content = `import type { TypeEntityOptionsFields } from 'vona-module-a-openapi';\n${content}`;
+        }
+        if (content.includes('TypeControllerOptionsActions')) {
+            content = `import type { TypeControllerOptionsActions } from 'vona-module-a-openapi';\n${content}`;
+        }
+        return content;
+    }
     async _generateThis(moduleName, relativeNameCapitalize, modulePath) {
         const thisDest = path.join(modulePath, 'src/.metadata/this.ts');
         if (fse.existsSync(thisDest))
             return;
         const content = `export const __ThisModule__ = '${moduleName}';
-export { ScopeModule${relativeNameCapitalize} as ScopeModule } from './index.js';
+export { ScopeModule${relativeNameCapitalize} as ScopeModule } from './index.ts';
 `;
         // save
         await fse.writeFile(thisDest, content);
     }
     async _generateIndex(modulePath) {
-        const jsExport = "export * from './.metadata/index.js';";
+        const jsExport = "export * from './.metadata/index.ts';";
         const jsFile = path.join(modulePath, 'src/index.ts');
         let jsContent;
         if (fse.existsSync(jsFile)) {
             jsContent = (await fse.readFile(jsFile)).toString();
-            if (jsContent.indexOf(jsExport) > -1)
+            if (jsContent.includes(jsExport))
                 return;
-            jsContent = jsExport + '\n' + jsContent;
+            jsContent = `${jsExport}\n${jsContent}`;
             jsContent = jsContent.replace('export {};\n', '');
         }
         else {
-            jsContent = jsExport + '\n';
+            jsContent = `${jsExport}\n`;
         }
         await fse.writeFile(jsFile, jsContent);
     }
 }
-//# sourceMappingURL=cli.tools.metadata.js.map

package/dist/lib/bean/toolsBin/configUtils.d.ts

@@ -0,0 +1,7 @@
+import type { VonaConfigMeta } from '@cabloy/module-info';
+import type { VonaBinConfigOptions } from './types.ts';
+import { glob } from '@cabloy/module-glob';
+export declare function createConfigUtils(configMeta: VonaConfigMeta, configOptions: VonaBinConfigOptions): {
+    loadEnvs: () => NodeJS.ProcessEnv;
+    loadModulesMeta: () => ReturnType<typeof glob>;
+};

package/dist/lib/bean/toolsBin/configUtils.js

@@ -0,0 +1,56 @@
+import os from 'node:os';
+import path from 'node:path';
+import * as dotenv from '@cabloy/dotenv';
+import { glob } from '@cabloy/module-glob';
+import { getEnvMeta, getNodeEnv } from "../../utils.js";
+export function createConfigUtils(configMeta, configOptions) {
+    let __modulesMeta;
+    return {
+        loadEnvs: __loadEnvs,
+        loadModulesMeta: __loadModulesMeta,
+    };
+    //////////////////////////////
+    function __loadEnvs() {
+        const meta = getEnvMeta(configMeta);
+        const envDir = path.join(configOptions.appDir, 'env');
+        const envs = dotenv.loadEnvs(meta, envDir, '.env');
+        const res = Object.assign({
+            NODE_ENV: getNodeEnv(meta.mode),
+        }, envs, {
+            META_FLAVOR: meta.flavor,
+            META_MODE: meta.mode,
+        });
+        if (configOptions.workers !== undefined) {
+            res.SERVER_WORKERS = configOptions.workers.toString();
+        }
+        // maybe empty string
+        if (!res.SERVER_WORKERS) {
+            if (meta.mode === 'prod') {
+                res.SERVER_WORKERS = os.cpus().length.toString();
+            }
+            else {
+                res.SERVER_WORKERS = '1';
+            }
+        }
+        for (const key of ['NODE_ENV', 'SERVER_WORKERS', 'META_FLAVOR', 'META_MODE']) {
+            if (res[key] !== false) {
+                process.env[key] = res[key];
+            }
+        }
+        // ok
+        return res;
+    }
+    async function __loadModulesMeta() {
+        const meta = getEnvMeta(configMeta);
+        // modules
+        __modulesMeta = await glob({
+            projectMode: 'vona',
+            projectPath: configOptions.appDir,
+            disabledModules: process.env.PROJECT_DISABLED_MODULES,
+            disabledSuites: process.env.PROJECT_DISABLED_SUITES,
+            log: false,
+            meta,
+        });
+        return __modulesMeta;
+    }
+}

package/dist/lib/bean/toolsBin/dbReset.d.ts

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

package/dist/lib/bean/toolsBin/dbReset.js

@@ -0,0 +1,8 @@
+import { closeApp, createGeneralApp } from 'vona-core';
+const argv = process.argv.slice(2);
+const projectPath = argv[0];
+await dbResetRun(projectPath);
+async function dbResetRun(projectPath) {
+    await createGeneralApp(projectPath);
+    await closeApp();
+}

package/dist/lib/bean/toolsBin/demo.d.ts

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

package/dist/lib/bean/toolsBin/demo.js

@@ -0,0 +1,41 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import path from 'node:path';
+import fse from 'fs-extra';
+import { closeApp, createGeneralApp, pathToHref } from 'vona-core';
+import parser from 'yargs-parser';
+const __template = `import type { IArgv, VonaApplication } from 'vona';
+
+export async function main(app: VonaApplication, _argv: IArgv) {}
+`;
+const projectPath = process.argv[2];
+const argv = parser(process.argv.slice(3));
+let mainFile;
+if (argv._[0]?.endsWith('.ts')) {
+    mainFile = argv._[0];
+    argv._ = argv._.slice(1);
+}
+else {
+    mainFile = 'index.ts';
+}
+await demoRun(projectPath);
+async function demoRun(projectPath) {
+    // create
+    const app = await createGeneralApp(projectPath, { SERVER_LISTEN_DISABLE: 'true' });
+    // demo
+    const demoFile = path.join(projectPath, `src/backend/demo/${mainFile}`);
+    if (!fse.existsSync(demoFile)) {
+        await fse.outputFile(demoFile, __template);
+    }
+    // run
+    const demoInstance = await import(__rewriteRelativeImportExtension(pathToHref(demoFile)));
+    await demoInstance.main(app, argv);
+    // close
+    await closeApp();
+}

package/dist/lib/bean/toolsBin/generateEntryFiles.d.ts

@@ -0,0 +1,4 @@
+import type { glob } from '@cabloy/module-glob';
+import type { VonaConfigMeta } from '@cabloy/module-info';
+import type { VonaBinConfigOptions } from './types.ts';
+export declare function generateEntryFiles(configMeta: VonaConfigMeta, configOptions: VonaBinConfigOptions, modulesMeta: Awaited<ReturnType<typeof glob>>, env: NodeJS.ProcessEnv): Promise<void>;

package/dist/lib/bean/toolsBin/generateEntryFiles.js

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { getEnvFiles } from '@cabloy/dotenv';
+import chalk from 'chalk';
+import fse from 'fs-extra';
+import { copyTemplateFile, getEnvMeta, resolveTemplatePath } from "../../utils.js";
+export async function generateEntryFiles(configMeta, configOptions, modulesMeta, env) {
+    // config
+    await __generateConfig();
+    // modules meta
+    await __generateModulesMeta();
+    // env
+    await __generateEnvJson();
+    // app
+    await __generateApp();
+    //////////////////////////////
+    async function __generateConfig() {
+        // check config
+        let configDir = path.join(configOptions.appDir, 'src/backend/config');
+        if (!fse.existsSync(configDir)) {
+            // eslint-disable-next-line
+            console.log(chalk.red('path not found: src/backend/config\n'));
+            process.exit(0);
+        }
+        // meta
+        const meta = getEnvMeta(configMeta);
+        configDir = path.join(configOptions.appDir, 'src/backend/config/config');
+        const files = getEnvFiles(meta, configDir, 'config', '.ts');
+        const filenames = files.map(item => path.basename(item));
+        const imports = [];
+        const constNames = [];
+        for (const filename of filenames) {
+            const parts = filename.split('.');
+            let constName = parts[0];
+            for (let index = 1; index < parts.length - 1; index++) {
+                constName += parts[index].charAt(0).toUpperCase() + parts[index].substring(1);
+            }
+            imports.push(`import ${constName} from '../src/backend/config/config/${filename}';`);
+            constNames.push(constName);
+        }
+        const contentDest = `${imports.join('\n')}\nexport default [${constNames.join(', ')}];`;
+        // output
+        const fileDest = path.join(configOptions.appDir, configOptions.runtimeDir, 'config.ts');
+        fse.ensureFileSync(fileDest);
+        fse.writeFileSync(fileDest, contentDest, 'utf-8');
+    }
+    async function __generateApp() {
+        const templates = [['app/bootstrap.ejs', 'bootstrap.ts'], ['app/app.ejs', 'app.ts']];
+        for (const [templateSrc, templateDest] of templates) {
+            const fileSrc = resolveTemplatePath(templateSrc);
+            const fileDest = path.join(configOptions.appDir, configOptions.runtimeDir, templateDest);
+            await fse.ensureDir(path.join(configOptions.appDir, configOptions.runtimeDir));
+            const vars = {
+                appMonkey: fse.existsSync(path.join(configOptions.appDir, 'src/backend/config/monkey.ts')),
+            };
+            await copyTemplateFile(fileSrc, fileDest, vars);
+        }
+    }
+    async function __generateModulesMeta() {
+        // modules
+        const { modules, modulesArray } = modulesMeta;
+        const moduleNames = modulesArray.map(item => item.info.relativeName);
+        // src
+        const fileSrc = resolveTemplatePath('app/vona-modules-meta.ejs');
+        const fileDest = path.join(configOptions.appDir, configOptions.runtimeDir, 'modules-meta.ts');
+        await fse.ensureDir(path.join(configOptions.appDir, configOptions.runtimeDir));
+        await copyTemplateFile(fileSrc, fileDest, { modules, moduleNames });
+    }
+    async function __generateEnvJson() {
+        const contentDest = `export default ${JSON.stringify(env, null, 2)} as unknown as NodeJS.ProcessEnv;\n`;
+        // output
+        const fileDest = path.join(configOptions.appDir, configOptions.runtimeDir, 'env.ts');
+        fse.ensureFileSync(fileDest);
+        fse.writeFileSync(fileDest, contentDest, 'utf-8');
+    }
+}

package/dist/lib/bean/toolsBin/generateVonaMeta.d.ts

@@ -0,0 +1,10 @@
+import type { VonaConfigMeta } from '@cabloy/module-info';
+import type { VonaBinConfigOptions } from './types.ts';
+export declare function generateVonaMeta(configMeta: VonaConfigMeta, configOptions: VonaBinConfigOptions): Promise<{
+    env: NodeJS.ProcessEnv;
+    modulesMeta: {
+        suites: Record<string, import("@cabloy/module-info").ISuite>;
+        modules: Record<string, import("@cabloy/module-info").IModule>;
+        modulesArray: import("@cabloy/module-info").IModule[];
+    };
+}>;

package/dist/lib/bean/toolsBin/generateVonaMeta.js

@@ -0,0 +1,17 @@
+import { createConfigUtils } from "./configUtils.js";
+import { generateEntryFiles } from "./generateEntryFiles.js";
+export async function generateVonaMeta(configMeta, configOptions) {
+    // config utils
+    const configUtils = createConfigUtils(configMeta, configOptions);
+    // env
+    const env = configUtils.loadEnvs();
+    // modulesMeta
+    const modulesMeta = await configUtils.loadModulesMeta();
+    // generateEntryFiles
+    await generateEntryFiles(configMeta, configOptions, modulesMeta, env);
+    // ok
+    return {
+        env,
+        modulesMeta,
+    };
+}

package/dist/lib/bean/toolsBin/test.d.ts

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

package/dist/lib/bean/toolsBin/test.js

@@ -0,0 +1,121 @@
+import { createWriteStream } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { run } from 'node:test';
+import { sleep } from '@cabloy/utils';
+import TableClass from 'cli-table3';
+import fse from 'fs-extra';
+import { globby } from 'globby';
+import { lcov, tap } from 'node:test/reporters';
+import { closeApp, createGeneralApp } from 'vona-core';
+import whyIsNodeRunning from 'why-is-node-running';
+import { resolveTemplatePath } from "../../utils.js";
+const argv = process.argv.slice(2);
+const projectPath = argv[0];
+const coverage = argv[1] === 'true';
+const patterns = (argv[2] || '').split(',');
+await testRun(projectPath, coverage, patterns);
+async function testRun(projectPath, coverage, patterns) {
+    // patterns ignore
+    const patternsIgnore = (!coverage && process.env.TEST_PATTERNS_IGNORE) ? process.env.TEST_PATTERNS_IGNORE.split(',') : undefined;
+    // files
+    const files = await globby(patterns, {
+        cwd: projectPath,
+        ignore: patternsIgnore,
+    });
+    if (process.env.TEST_ONLY === 'true') {
+        files.push(resolveTemplatePath('test/done-only.test.ts'));
+    }
+    else {
+        files.push(resolveTemplatePath('test/done.test.ts'));
+    }
+    // concurrency
+    let concurrency = 1;
+    if (process.env.TEST_CONCURRENCY === 'true') {
+        concurrency = os.cpus().length;
+    }
+    else if (process.env.TEST_CONCURRENCY === 'false') {
+        concurrency = 1;
+    }
+    else {
+        concurrency = Number.parseInt(process.env.TEST_CONCURRENCY);
+    }
+    // coverage
+    let coverageIncludeGlobs = [];
+    if (coverage) {
+        if (fse.existsSync(path.join(projectPath, 'packages-vona/vona-core'))) {
+            coverageIncludeGlobs = coverageIncludeGlobs.concat(['packages-vona/vona-core/**/*.ts', 'src/module-vendor/**/*.ts', 'src/suite-vendor/**/*.ts']);
+        }
+        else {
+            coverageIncludeGlobs = coverageIncludeGlobs.concat(['src/module/**/*.ts', 'src/suite/**/*.ts']);
+        }
+    }
+    const coverageExcludeGlobs = [
+        'src/module/*/cli/**/*.ts',
+        'src/module/*/templates/**/*.ts',
+        'src/suite/*/modules/*/cli/**/*.ts',
+        'src/suite/*/modules/*/templates/**/*.ts',
+        'src/module-vendor/*/cli/**/*.ts',
+        'src/module-vendor/*/templates/**/*.ts',
+        'src/suite-vendor/*/modules/*/cli/**/*.ts',
+        'src/suite-vendor/*/modules/*/templates/**/*.ts',
+    ];
+    return new Promise(resolve => {
+        const testStream = run({
+            isolation: 'none',
+            concurrency,
+            only: process.env.TEST_ONLY === 'true',
+            coverage,
+            coverageIncludeGlobs,
+            coverageExcludeGlobs,
+            cwd: projectPath,
+            files,
+            setup: async () => {
+                await createGeneralApp(projectPath);
+            },
+        })
+            .on('test:coverage', data => {
+            outputCoverageReport(data.summary.totals);
+        })
+            .on('test:summary', async () => {
+            resolve(undefined);
+        })
+            .on('test:pass', async (t) => {
+            if (t.name === '---done---') {
+                await closeApp();
+                // handles
+                if (process.env.TEST_WHYISNODERUNNING === 'true') {
+                    await sleep(2000);
+                    const handles = process._getActiveHandles();
+                    if (handles.length > 3) {
+                        whyIsNodeRunning();
+                    }
+                }
+            }
+        });
+        if (coverage) {
+            const reporterDir = path.join(projectPath, 'coverage');
+            fse.ensureDirSync(reporterDir);
+            const reporter = createWriteStream(path.join(reporterDir, 'lcov.info'));
+            testStream.compose(lcov)
+                .pipe(reporter);
+        }
+        else {
+            testStream.compose(tap)
+                .pipe(process.stdout);
+        }
+    });
+}
+function outputCoverageReport(totals) {
+    // table
+    const table = new TableClass({
+        head: ['', 'Total', 'Covered', 'Percent'],
+        colWidths: [15, 15, 15, 25],
+    });
+    table.push(['Lines', totals.totalLineCount, totals.coveredLineCount, totals.coveredLinePercent]);
+    table.push(['Branches', totals.totalBranchCount, totals.coveredBranchCount, totals.coveredBranchPercent]);
+    table.push(['Functions', totals.totalFunctionCount, totals.coveredFunctionCount, totals.coveredFunctionPercent]);
+    // eslint-disable-next-line
+    console.log(table.toString());
+}
+;

package/dist/lib/bean/toolsBin/types.d.ts

@@ -0,0 +1,5 @@
+export interface VonaBinConfigOptions {
+    appDir: string;
+    runtimeDir: string;
+    workers?: number;
+}

package/dist/lib/bean/toolsBin/types.js

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

package/dist/lib/bean/toolsMetadata/generateBeanGenerals.d.ts

@@ -0,0 +1,2 @@
+import type { OnionSceneMeta } from '@cabloy/module-info';
+export declare function generateBeanGenerals(sceneName: string, sceneMeta: OnionSceneMeta, moduleName: string, modulePath: string): Promise<string>;

package/dist/lib/bean/toolsMetadata/generateBeanGenerals.js

@@ -0,0 +1,33 @@
+import { globBeanFiles } from "./utils.js";
+export async function generateBeanGenerals(sceneName, sceneMeta, moduleName, modulePath) {
+    const globFiles = await globBeanFiles(sceneName, sceneMeta, moduleName, modulePath);
+    if (globFiles.length === 0)
+        return '';
+    //
+    const contentImports = [];
+    const contentRecords = [];
+    for (const globFile of globFiles) {
+        const { fileNameJSRelative, className, beanName, isIgnore } = globFile;
+        const beanFullName = `${moduleName}.${sceneName}.${beanName}`;
+        if (isIgnore)
+            continue;
+        if (!sceneMeta.scopeResource) {
+            contentImports.push(`import type { ${className} } from '${fileNameJSRelative}';`);
+        }
+        contentRecords.push(`'${beanFullName}': ${className};`);
+    }
+    if (contentRecords.length === 0)
+        return '';
+    // combine
+    const content = `/** ${sceneName}: begin */
+${contentImports.join('\n')}
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    ${contentRecords.join('\n')}
+  }
+}
+/** ${sceneName}: end */
+`;
+    return content;
+}

package/dist/lib/bean/toolsMetadata/generateBeans.d.ts

@@ -1,2 +1,2 @@
-export declare function generateBeans(moduleName: string, modulePath: string): Promise<string>;
-//# sourceMappingURL=generateBeans.d.ts.map
+import type { OnionScenesMeta } from '@cabloy/module-info';
+export declare function generateBeans(onionScenesMeta: OnionScenesMeta, moduleName: string, modulePath: string): Promise<string>;

package/dist/lib/bean/toolsMetadata/generateBeans.js

@@ -1,33 +1,51 @@
-import path from 'path';
-import eggBornUtils from 'egg-born-utils';
-export async function generateBeans(moduleName, modulePath) {
-    const pattern = `${modulePath}/src/bean/*.ts`;
-    const files = await eggBornUtils.tools.globbyAsync(pattern);
+import path from 'node:path';
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
+import { globby } from 'globby';
+import { checkIgnoreOfParts, getScopeModuleName } from "./utils.js";
+// todo: remove
+export async function generateBeans(onionScenesMeta, moduleName, modulePath) {
+    const scopeModuleName = getScopeModuleName(moduleName);
+    // ignore
+    const ignore = Object.keys(onionScenesMeta).map(item => `**/${item}.*.ts`);
+    // files
+    const files = await globby('src/bean/*.ts', { ignore, cwd: modulePath });
     if (files.length === 0)
         return '';
     files.sort();
     const contentExports = [];
+    const contentScopes = [];
     const contentImports = [];
     const contentRecordsGlobal = [];
     const contentRecordsGeneral = [];
     for (const file of files) {
         const fileName = path.basename(file);
+        if (fileName.startsWith('_'))
+            continue;
         const parts = fileName.split('.').slice(0, -1);
         if (parts.length < 2)
             continue;
         const isIgnore = checkIgnoreOfParts(parts);
         const isBeanGlobal = parts[0] === 'bean';
-        const fileNameJS = fileName.replace('.ts', '.js');
-        let className = parts.map(item => item.charAt(0).toUpperCase() + item.substring(1)).join('');
+        // const sceneName = parts.slice(0, -1).join('.');
+        // const beanName = parts[parts.length - 1];
+        // const beanNameCapitalize = toUpperCaseFirstChar(beanName);
+        const fileNameJS = fileName; // fileName.replace('.ts', '.js');
+        const className = parts.map(item => toUpperCaseFirstChar(item)).join('');
         const beanFullName = isBeanGlobal ? parts[1] : `${moduleName}.${parts.join('.')}`;
-        if (className === 'BeanBase')
-            className = 'BeanBase2';
         contentExports.push(`export * from '../bean/${fileNameJS}';`);
-        contentImports.push(`import { ${className} } from '../bean/${fileNameJS}';`);
+        // ignore virtual
+        contentScopes.push(`
+        export interface ${className} {
+          /** @internal */
+          get scope(): ${scopeModuleName};
+        }`);
+        if (isBeanGlobal || !isIgnore) {
+            contentImports.push(`import type { ${className} } from '../bean/${fileNameJS}';`);
+        }
         if (isBeanGlobal && !isIgnore) {
             contentRecordsGlobal.push(`'${beanFullName}': ${className};`);
         }
-        else {
+        if ((isBeanGlobal && isIgnore) || (!isBeanGlobal && !isIgnore)) {
             contentRecordsGeneral.push(`'${beanFullName}': ${className};`);
         }
     }
@@ -43,18 +61,12 @@ declare module 'vona' {
 
   export interface IBeanRecordGeneral {
     ${contentRecordsGeneral.join('\n')}
-  }  
+  }
+}
+declare module 'vona-module-${moduleName}' {
+  ${contentScopes.join('\n')} 
 }
 /** beans: end */
 `;
     return content;
 }
-function checkIgnoreOfParts(parts) {
-    const indexLast = parts.length - 1;
-    if (parts[indexLast].endsWith('_')) {
-        parts[indexLast] = parts[indexLast].substring(0, parts[indexLast].length - 1);
-        return true;
-    }
-    return false;
-}
-//# sourceMappingURL=generateBeans.js.map