vona-core 1.0.0 → 5.0.9

package/dist/lib/core/logger.d.ts

@@ -0,0 +1,22 @@
+import type { ILoggerClientChildRecord, ILoggerClientRecord, ILoggerOptionsClientInfo, LoggerLevel } from '../../types/interface/logger.ts';
+import * as Winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+import { BeanSimple } from '../bean/beanSimple.ts';
+declare const SymbolLoggerInstances: unique symbol;
+export declare class AppLogger extends BeanSimple {
+    private [SymbolLoggerInstances];
+    dispose(): Promise<void>;
+    get(clientName?: keyof ILoggerClientRecord): Winston.Logger;
+    child(childName?: keyof ILoggerClientChildRecord, clientName?: keyof ILoggerClientRecord): Winston.Logger;
+    getLevel(clientName?: keyof ILoggerClientRecord): LoggerLevel | undefined;
+    setLevel(level: LoggerLevel | boolean, clientName?: keyof ILoggerClientRecord): void;
+    private _createClient;
+    private _prepareConfigClient;
+    createTransportFile(fileName: string, clientInfo: ILoggerOptionsClientInfo, options: Winston.transports.FileTransportOptions | DailyRotateFile.DailyRotateFileTransportOptions): DailyRotateFile | Winston.transports.FileTransportInstance;
+}
+export declare function getLoggerClientLevel(clientName?: keyof ILoggerClientRecord): LoggerLevel | undefined;
+export declare function setLoggerClientLevel(level: LoggerLevel | boolean, clientName?: keyof ILoggerClientRecord): void;
+export declare const formatLoggerAxiosError: Winston.Logform.FormatWrap;
+export declare const formatLoggerFilter: Winston.Logform.FormatWrap;
+export declare const formatLoggerConsole: () => Winston.Logform.Format;
+export {};

package/dist/lib/core/logger.js

@@ -0,0 +1,147 @@
+import { isEmptyObject } from '@cabloy/utils';
+import chalk from 'chalk';
+import { LEVEL, MESSAGE } from 'triple-beam';
+import * as Winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+import { cast } from "../../types/utils/cast.js";
+import { BeanSimple } from "../bean/beanSimple.js";
+import { deepExtend } from "../utils/util.js";
+const SymbolLoggerInstances = Symbol('SymbolLoggerInstances');
+export class AppLogger extends BeanSimple {
+    [SymbolLoggerInstances] = {};
+    async dispose() {
+        for (const key in this[SymbolLoggerInstances]) {
+            const logger = this[SymbolLoggerInstances][key];
+            await _closeLogger(logger);
+        }
+    }
+    get(clientName) {
+        clientName = clientName || 'default';
+        if (!this[SymbolLoggerInstances][clientName]) {
+            this[SymbolLoggerInstances][clientName] = this._createClient(clientName);
+        }
+        return this[SymbolLoggerInstances][clientName];
+    }
+    child(childName, clientName) {
+        const logger = this.get(clientName);
+        if (!childName)
+            return logger;
+        return logger.child({ name: childName });
+    }
+    getLevel(clientName) {
+        return getLoggerClientLevel(clientName);
+    }
+    setLevel(level, clientName) {
+        setLoggerClientLevel(level, clientName);
+    }
+    _createClient(clientName) {
+        const configClient = this.app.config.logger.clients[clientName];
+        if (!configClient)
+            throw new Error(`logger client not found: ${clientName}`);
+        const configNode = deepExtend({}, this._prepareConfigClient(clientName, this.app.config.logger.default), this._prepareConfigClient(clientName, configClient));
+        const logger = Winston.createLogger(configNode);
+        logger.on('error', err => {
+            console.error(err);
+        });
+        return logger;
+    }
+    _prepareConfigClient(clientName, configClient) {
+        if (typeof configClient !== 'function')
+            return configClient;
+        return configClient.call(this.app, Winston, {
+            clientName,
+            level: () => getLoggerClientLevel(clientName),
+        });
+    }
+    createTransportFile(fileName, clientInfo, options) {
+        const configRotate = this.app.config.logger.rotate;
+        let optionsFile;
+        if (configRotate.enable) {
+            optionsFile = configRotate.options.call(this, fileName, Winston, clientInfo);
+        }
+        else {
+            optionsFile = { filename: `${fileName}.log` };
+        }
+        const _options = deepExtend({ dirname: this.app.config.server.loggerDir }, optionsFile, options);
+        if (configRotate.enable) {
+            const transport = new DailyRotateFile(_options);
+            transport.on('error', err => {
+                console.error(err);
+            });
+            return transport;
+        }
+        else {
+            return new Winston.transports.File(_options);
+        }
+    }
+}
+async function _closeLogger(logger) {
+    return new Promise(resolve => {
+        if (logger.__closed__)
+            return resolve(true);
+        logger.end(() => {
+            logger.__closed__ = true;
+            resolve(true);
+        });
+    });
+}
+export function getLoggerClientLevel(clientName) {
+    clientName = clientName || 'default';
+    const envName = `LOGGER_CLIENT_${clientName.toUpperCase()}`;
+    const level = process.env[envName];
+    if (level === 'false')
+        return;
+    if (level === 'true' || !level)
+        return 'info';
+    return level;
+}
+export function setLoggerClientLevel(level, clientName) {
+    clientName = clientName || 'default';
+    const envName = `LOGGER_CLIENT_${clientName.toUpperCase()}`;
+    process.env[envName] = level.toString();
+}
+export const formatLoggerAxiosError = Winston.format((einfo, { stack, cause }) => {
+    if ((einfo instanceof Error && einfo.constructor.name.includes('AxiosError')) || einfo.name === 'AxiosError') {
+        const info = Object.assign({}, einfo, {
+            level: einfo.level,
+            [LEVEL]: einfo[LEVEL] || einfo.level,
+            message: einfo.message,
+            [MESSAGE]: einfo[MESSAGE] || einfo.message,
+        });
+        if (stack)
+            info.stack = einfo.stack;
+        if (cause)
+            info.cause = einfo.cause;
+        info.message = `${info.message}: ${cast(info.config).url}`;
+        info[MESSAGE] = `${info[MESSAGE]}: ${cast(info.config).url}`;
+        delete info.config;
+        delete info.request;
+        delete info.response;
+        return info;
+    }
+    return einfo;
+});
+export const formatLoggerFilter = Winston.format((info, opts) => {
+    const level = typeof opts.level === 'function' ? opts.level() : opts.level;
+    if (!level)
+        return false;
+    if (opts.strict) {
+        if (Winston.config.npm.levels[info.level] === Winston.config.npm.levels[level])
+            return info;
+        return false;
+    }
+    if (Winston.config.npm.levels[info.level] <= Winston.config.npm.levels[level] || (opts.silly && info.level === 'silly'))
+        return info;
+    return false;
+});
+export const formatLoggerConsole = () => {
+    return Winston.format.printf(({ timestamp, level, stack, message, name, beanFullName, durationMs, ...meta }) => {
+        const textName = name ? ` ${chalk.cyan(`[${name}]`)}` : '';
+        const textBeanFullName = beanFullName ? ` ${chalk.gray(`[${beanFullName}]`)}` : '';
+        const textMeta = !isEmptyObject(meta) ? ` ${JSON.stringify(meta)}` : '';
+        const textMessage = ` ${message}`;
+        const textDurationMs = durationMs !== undefined ? ` ${chalk.cyan(`+${durationMs}ms`)}` : '';
+        const textStack = stack ? `\n${stack}` : '';
+        return `${timestamp} ${level}${textName}${textBeanFullName}${textMeta}${textMessage}${textDurationMs}${textStack}`;
+    });
+};

package/dist/lib/core/loggerDefault.d.ts

@@ -0,0 +1,3 @@
+import type { VonaAppInfo } from '../../types/application/app.ts';
+import type { ConfigLogger } from '../../types/interface/logger.ts';
+export declare function combineLoggerDefault(_appInfo: VonaAppInfo): ConfigLogger;

package/dist/lib/core/loggerDefault.js

@@ -0,0 +1,44 @@
+import { formatLoggerAxiosError, formatLoggerConsole, formatLoggerFilter } from "./logger.js";
+export function combineLoggerDefault(_appInfo) {
+    const configDefault = {
+        rotate: {
+            enable: false,
+            options(fileName) {
+                return {
+                    filename: `${fileName}-%DATE%.log`,
+                    datePattern: 'YYYY-MM-DD',
+                    maxSize: '20m',
+                    maxFiles: '7d',
+                };
+            },
+        },
+        default({ format, transports }, clientInfo) {
+            return {
+                format: format.combine(formatLoggerAxiosError({ stack: true }), format.errors({ stack: true }), format.splat(), format.timestamp()),
+                transports: [
+                    this.meta.logger.createTransportFile('error', clientInfo, {
+                        level: 'error',
+                        format: format.combine(format.json()),
+                    }),
+                    this.meta.logger.createTransportFile('http', clientInfo, {
+                        level: 'http',
+                        format: format.combine(formatLoggerFilter({ level: 'http', strict: true }), format.json()),
+                    }),
+                    this.meta.logger.createTransportFile('combined', clientInfo, {
+                        level: 'silly',
+                        format: format.combine(formatLoggerFilter({ level: clientInfo.level }), format.json()),
+                    }),
+                    new transports.Console({
+                        level: 'silly',
+                        format: format.combine(formatLoggerFilter({ level: clientInfo.level, silly: true }), format.colorize(), formatLoggerConsole()),
+                        forceConsole: true,
+                    }),
+                ],
+            };
+        },
+        clients: {
+            default: {},
+        },
+    };
+    return configDefault;
+}

package/dist/lib/core/meta.d.ts

@@ -0,0 +1,42 @@
+import type { IModule } from '@cabloy/module-info';
+import type { TypeModuleResourceLocaleModules, TypeModuleResourceLocales, VonaConfigEnv } from '../../types/index.ts';
+import type { AppMonkeyConstructable } from '../../types/interface/monkey.ts';
+import type { ErrorClass, IModuleLocaleText } from '../bean/index.ts';
+import type { AppMetadata } from './metadata.ts';
+import type { AppResource } from './resource.ts';
+import { BeanSimple } from '../bean/beanSimple.ts';
+import { AppLocale, BeanScopeContainer } from '../bean/index.ts';
+import { CtxCounter } from './ctxCounter.ts';
+import { AppLogger } from './logger.ts';
+export declare class AppMeta extends BeanSimple {
+    env: VonaConfigEnv;
+    ctxCounter: CtxCounter;
+    isProd: boolean;
+    isTest: boolean;
+    isLocal: boolean;
+    error: ErrorClass;
+    logger: AppLogger;
+    locale: AppLocale;
+    text: IModuleLocaleText;
+    scopeContainer: BeanScopeContainer;
+    appMonkey?: AppMonkeyConstructable;
+    resource: AppResource;
+    metadata: AppMetadata;
+    modules: Record<string, IModule>;
+    modulesArray: IModule[];
+    modulesMonkey: Record<string, IModule>;
+    constants: Record<string, any>;
+    locales: TypeModuleResourceLocales;
+    localeModules: TypeModuleResourceLocaleModules;
+    appReady: boolean;
+    appReadyInstances: Record<string, boolean>;
+    appStarted: boolean;
+    appStartError: Error;
+    appClose: boolean;
+    appClosed: boolean;
+    protected __init__(env: VonaConfigEnv): void;
+    private _prepareEnv;
+    waitAppStarted(): Promise<unknown>;
+    close(): Promise<any>;
+    private _closeInner;
+}

package/dist/lib/core/meta.js

@@ -0,0 +1,123 @@
+import cluster from 'node:cluster';
+import { EnumAppEvent } from "../../types/index.js";
+import { BeanSimple } from "../bean/beanSimple.js";
+import { AppLocale, BeanScopeContainer } from "../bean/index.js";
+import { CtxCounter } from "./ctxCounter.js";
+import { AppLogger } from "./logger.js";
+import { appMetadata } from "./metadata.js";
+import { appResource } from "./resource.js";
+const SymbolClosePromise = Symbol('SymbolClosePromise');
+export class AppMeta extends BeanSimple {
+    env;
+    ctxCounter;
+    isProd;
+    isTest;
+    isLocal;
+    error;
+    logger;
+    locale;
+    text;
+    scopeContainer;
+    appMonkey;
+    //
+    resource;
+    metadata;
+    //
+    modules;
+    modulesArray;
+    modulesMonkey;
+    //
+    constants;
+    locales;
+    localeModules;
+    //
+    appReady;
+    appReadyInstances;
+    //
+    appStarted;
+    appStartError;
+    //
+    appClose;
+    appClosed;
+    __init__(env) {
+        // env
+        this.env = env;
+        this._prepareEnv();
+        // ctxCounter
+        this.ctxCounter = new CtxCounter();
+        // appMonkey
+        this.appMonkey = this.app.options.AppMonkey;
+        // logger
+        this.logger = this.bean._newBean(AppLogger);
+        // locale
+        this.locale = this.bean._newBean(AppLocale);
+        // text
+        this.text = this.locale.createLocaleText();
+        // scopeContainer
+        this.scopeContainer = this.bean._newBean(BeanScopeContainer);
+        // resource
+        this.resource = appResource;
+        this.resource.app = this.app;
+        // metadata
+        this.metadata = appMetadata;
+    }
+    _prepareEnv() {
+        const mode = this.app.config.meta.mode;
+        this.isProd = mode === 'prod';
+        this.isTest = mode === 'test';
+        this.isLocal = mode === 'local';
+    }
+    async waitAppStarted() {
+        return new Promise((resolve, reject) => {
+            // check once
+            if (this.appStarted) {
+                resolve(true);
+            }
+            if (this.appStartError) {
+                reject(this.appStartError);
+            }
+            // listen
+            this.app.once(EnumAppEvent.AppStarted, () => {
+                resolve(true);
+            });
+            this.app.once(EnumAppEvent.AppStartError, err => {
+                reject(err);
+            });
+        });
+    }
+    async close() {
+        if (!this[SymbolClosePromise]) {
+            this[SymbolClosePromise] = this._closeInner();
+        }
+        return this[SymbolClosePromise];
+    }
+    async _closeInner() {
+        if (this.app.meta.env.SERVER_WORKERS !== '1') {
+            // disconnect
+            cluster.worker?.disconnect();
+        }
+        else {
+            // close server
+            if (this.app.server) {
+                this.app.server.close();
+                // maybe hang up using await
+                // await promisify(this.app.server.close).call(this.app.server);
+            }
+        }
+        // appClose
+        this.appClose = true;
+        // hook: appClose
+        await this.app.util.monkeyModule(this.app.meta.appMonkey, this.app.meta.modulesMonkey, 'appClose');
+        // ctx counter
+        await this.app.meta.ctxCounter.awaitUntilZero();
+        // appClosed
+        this.appClosed = true;
+        // hook: appClosed
+        await this.app.util.monkeyModule(this.app.meta.appMonkey, this.app.meta.modulesMonkey, 'appClosed');
+        // container dispose
+        await this.app.bean.dispose();
+        // logger dispose
+        await this.app.meta.logger.dispose();
+        // need not call process.exit
+    }
+}

package/dist/lib/core/metadata.d.ts

@@ -0,0 +1,15 @@
+import 'reflect-metadata';
+export type MetadataKey = symbol | string;
+export declare class AppMetadata {
+    defineMetadata<V>(metadataKey: MetadataKey, metadataValue: V, target: object, prop?: MetadataKey): void;
+    hasOwnMetadata(metadataKey: MetadataKey, target: object, prop?: MetadataKey): boolean;
+    hasMetadata(metadataKey: MetadataKey, target: object, prop?: MetadataKey): boolean;
+    getOwnMetadata<V>(metadataKey: MetadataKey, target: object, prop?: MetadataKey): V | undefined;
+    getMetadata<V>(metadataKey: MetadataKey, target: object, prop?: MetadataKey): V | undefined;
+    getOwnMetadataArray<Entry>(inherit: boolean, metadataKey: MetadataKey, target: object, prop?: MetadataKey): Array<Entry>;
+    getOwnMetadataMap<K extends PropertyKey, V>(inherit: boolean, metadataKey: MetadataKey, target: object, prop?: MetadataKey): Record<K, V>;
+    getDesignType(target: object, prop?: MetadataKey): unknown;
+    getDesignParamtypes(target: object, prop?: MetadataKey): unknown;
+    getDesignReturntype(target: object, prop?: MetadataKey): unknown;
+}
+export declare const appMetadata: AppMetadata;

package/dist/lib/core/metadata.js

@@ -0,0 +1,80 @@
+import { isUndefined } from '@cabloy/utils';
+import 'reflect-metadata';
+export class AppMetadata {
+    defineMetadata(metadataKey, metadataValue, target, prop) {
+        if (isUndefined(prop)) {
+            Reflect.defineMetadata(metadataKey, metadataValue, target);
+        }
+        else {
+            Reflect.defineMetadata(metadataKey, metadataValue, target, prop);
+        }
+    }
+    hasOwnMetadata(metadataKey, target, prop) {
+        if (isUndefined(prop))
+            return Reflect.hasOwnMetadata(metadataKey, target);
+        return Reflect.hasOwnMetadata(metadataKey, target, prop);
+    }
+    hasMetadata(metadataKey, target, prop) {
+        if (isUndefined(prop))
+            return Reflect.hasMetadata(metadataKey, target);
+        return Reflect.hasMetadata(metadataKey, target, prop);
+    }
+    getOwnMetadata(metadataKey, target, prop) {
+        if (isUndefined(prop))
+            return Reflect.getOwnMetadata(metadataKey, target);
+        return Reflect.getOwnMetadata(metadataKey, target, prop);
+    }
+    getMetadata(metadataKey, target, prop) {
+        if (isUndefined(prop))
+            return Reflect.getMetadata(metadataKey, target);
+        return Reflect.getMetadata(metadataKey, target, prop);
+    }
+    getOwnMetadataArray(inherit, metadataKey, target, prop) {
+        let own = this.getOwnMetadata(metadataKey, target, prop);
+        if (!own) {
+            if (!inherit) {
+                own = [];
+            }
+            else {
+                const parent = this.getMetadata(metadataKey, target, prop);
+                if (parent) {
+                    own = parent.slice();
+                }
+                else {
+                    own = [];
+                }
+            }
+            this.defineMetadata(metadataKey, own, target, prop);
+        }
+        return own;
+    }
+    getOwnMetadataMap(inherit, metadataKey, target, prop) {
+        let own = this.getOwnMetadata(metadataKey, target, prop);
+        if (!own) {
+            if (!inherit) {
+                own = {};
+            }
+            else {
+                const parent = this.getMetadata(metadataKey, target, prop);
+                if (parent) {
+                    own = Object.assign({}, parent);
+                }
+                else {
+                    own = {};
+                }
+            }
+            this.defineMetadata(metadataKey, own, target, prop);
+        }
+        return own;
+    }
+    getDesignType(target, prop) {
+        return this.getMetadata('design:type', target, prop);
+    }
+    getDesignParamtypes(target, prop) {
+        return this.getMetadata('design:paramtypes', target, prop);
+    }
+    getDesignReturntype(target, prop) {
+        return this.getMetadata('design:returntype', target, prop);
+    }
+}
+export const appMetadata = new AppMetadata();

package/dist/lib/core/resource.d.ts

@@ -0,0 +1,33 @@
+import type { IBeanRecord } from '../bean/type.ts';
+import type { Constructable, IDecoratorBeanOptionsBase, IDecoratorUseOptionsBase } from '../decorator/index.ts';
+import type { MetadataKey } from './metadata.ts';
+import { BeanSimple } from '../bean/beanSimple.ts';
+export declare const SymbolDecoratorBeanFullName: unique symbol;
+export declare const SymbolDecoratorBeanInfo: unique symbol;
+export declare const SymbolDecoratorProxyDisable: unique symbol;
+export declare const SymbolDecoratorUse: unique symbol;
+export type IAppResourceRecord = Record<string, IDecoratorBeanOptionsBase>;
+export declare class AppResource extends BeanSimple {
+    beans: IAppResourceRecord;
+    scenes: Record<string, Record<string, IAppResourceRecord>>;
+    addUse(target: object, options: IDecoratorUseOptionsBase): void;
+    getUses(target: object): Record<MetadataKey, IDecoratorUseOptionsBase> | undefined;
+    addBean(beanOptions: Partial<IDecoratorBeanOptionsBase>): IDecoratorBeanOptionsBase<unknown, unknown>;
+    getBeanFullName<T>(A: Constructable<T> | undefined): string | undefined;
+    getBeanFullName<K extends keyof IBeanRecord>(beanFullName: K | undefined): K | undefined;
+    getBeanFullName(beanFullName: string | undefined): string | undefined;
+    getBean<T>(A: Constructable<T>): IDecoratorBeanOptionsBase<T> | undefined;
+    getBean<K extends keyof IBeanRecord>(beanFullName: K): IDecoratorBeanOptionsBase<IBeanRecord[K]> | undefined;
+    getBean<T>(beanFullName: string): IDecoratorBeanOptionsBase<T> | undefined;
+    _parseBeanName<T>(beanClass: Constructable<T>, scene?: string, name?: string): string;
+    _parseModuleBelong(module: any, beanClass: any, virtual: any): any;
+    _getModuleBelong<T>(A: Constructable<T>): string;
+    _getModuleBelong<K extends keyof IBeanRecord>(beanFullName: K): string;
+    _getModuleBelong(beanFullName: string): string;
+    _getModuleName<T>(A: Constructable<T>): string | undefined;
+    _getModuleName<K extends keyof IBeanRecord>(beanFullName: K): string | undefined;
+    _getModuleName(beanFullName: string): string | undefined;
+    _fixClassName(className: string): string;
+    _prepareOnionOptions(options: unknown, optionsPrimitive: boolean | undefined, scene: any, name: string): any;
+}
+export declare const appResource: AppResource;

package/dist/lib/core/resource.js

@@ -0,0 +1,146 @@
+import { toLowerCaseFirstChar } from '@cabloy/word-utils';
+import chalk from 'chalk';
+import { cast } from "../../types/utils/cast.js";
+import { BeanSimple } from "../bean/beanSimple.js";
+import { useApp } from "../framework/useApp.js";
+import { registerMappedClassMetadataKey } from "../mappedClass/utils.js";
+import { isClass } from "../utils/isClass.js";
+import { deepExtend } from "../utils/util.js";
+import { appMetadata } from "./metadata.js";
+export const SymbolDecoratorBeanFullName = Symbol('SymbolDecoratorBeanFullName');
+export const SymbolDecoratorBeanInfo = Symbol('SymbolDecoratorBeanInfo');
+export const SymbolDecoratorProxyDisable = Symbol('SymbolDecoratorProxyDisable');
+export const SymbolDecoratorUse = Symbol('SymbolDecoratorUse');
+export class AppResource extends BeanSimple {
+    beans = {};
+    scenes = {};
+    addUse(target, options) {
+        registerMappedClassMetadataKey(target, SymbolDecoratorUse);
+        const uses = appMetadata.getOwnMetadataMap(true, SymbolDecoratorUse, target);
+        uses[options.prop] = options;
+        if (process.env.NODE_ENV === 'development') {
+            if (typeof options.prop === 'string' && !options.prop.startsWith('$$')) {
+                console.error(chalk.red(`inject prop name should start with $$: ${options.prop}`));
+            }
+        }
+    }
+    getUses(target) {
+        return appMetadata.getMetadata(SymbolDecoratorUse, target);
+    }
+    addBean(beanOptions) {
+        let { module, scene, name, beanClass, virtual, options, optionsPrimitive } = beanOptions;
+        // name
+        name = this._parseBeanName(beanClass, scene, name);
+        // module
+        if (!module) {
+            throw new Error(`module name not parsed for bean: ${scene}.${name}`);
+        }
+        // beanFullName
+        const beanFullName = scene && scene !== 'bean' ? `${module}.${scene}.${name}` : name;
+        // moduleBelong
+        const moduleBelong = this._parseModuleBelong(module, beanClass, virtual);
+        // options
+        const options2 = this._prepareOnionOptions(options, optionsPrimitive, scene, `${module}:${name}`);
+        // beanOptions2
+        const beanOptions2 = {
+            ...beanOptions,
+            beanFullName,
+            name,
+            moduleBelong,
+            options: options2,
+        };
+        // record
+        this.beans[beanFullName] = beanOptions2;
+        if (!this.scenes[scene])
+            this.scenes[scene] = {};
+        if (!this.scenes[scene][module])
+            this.scenes[scene][module] = {};
+        this.scenes[scene][module][beanFullName] = beanOptions2;
+        // set metadata
+        appMetadata.defineMetadata(SymbolDecoratorBeanFullName, beanFullName, beanOptions2.beanClass);
+        // ok
+        return beanOptions2;
+    }
+    getBeanFullName(beanFullName) {
+        if (!beanFullName)
+            return beanFullName;
+        if (typeof beanFullName === 'function' && isClass(beanFullName)) {
+            return appMetadata.getOwnMetadata(SymbolDecoratorBeanFullName, beanFullName);
+        }
+        return beanFullName;
+    }
+    getBean(beanFullName) {
+        const fullName = this.getBeanFullName(beanFullName);
+        if (!fullName)
+            return null;
+        return this.beans[fullName];
+    }
+    _parseBeanName(beanClass, scene, name) {
+        // name
+        if (name)
+            return name;
+        // scene
+        if (!scene)
+            scene = 'bean';
+        scene = scene.replace(/\./g, '');
+        // bean class name
+        const beanClassName = this._fixClassName(beanClass.name);
+        if (beanClassName.toLocaleUpperCase().startsWith(scene.toLocaleUpperCase())) {
+            name = beanClassName.substring(scene.length);
+        }
+        else {
+            name = beanClassName;
+        }
+        // lowerCase
+        name = toLowerCaseFirstChar(name);
+        return name;
+    }
+    _parseModuleBelong(module, beanClass, virtual) {
+        // not set when virtual
+        if (virtual)
+            return;
+        // check parent
+        let moduleBelong;
+        let parent = Object.getPrototypeOf(beanClass);
+        while (parent) {
+            const beanOptions = this.getBean(parent);
+            if (beanOptions && beanOptions.moduleBelong) {
+                moduleBelong = beanOptions.moduleBelong;
+                break;
+            }
+            parent = Object.getPrototypeOf(parent);
+        }
+        // set to current when parent not set
+        if (!moduleBelong) {
+            moduleBelong = module;
+        }
+        return moduleBelong;
+    }
+    _getModuleBelong(beanFullName) {
+        const beanOptions = this.getBean(beanFullName);
+        if (!beanOptions || !beanOptions.moduleBelong)
+            throw new Error(`not found module belong: ${beanFullName}`);
+        return beanOptions.moduleBelong;
+    }
+    _getModuleName(beanFullName) {
+        const beanOptions = this.getBean(beanFullName);
+        return beanOptions?.module;
+    }
+    _fixClassName(className) {
+        while (className.endsWith('2')) {
+            className = className.substring(0, className.length - 1);
+        }
+        return className;
+    }
+    _prepareOnionOptions(options, optionsPrimitive, scene, name) {
+        const app = useApp();
+        const optionsConfig = cast(app?.config)?.onions?.[scene]?.[name];
+        if (optionsPrimitive) {
+            return optionsConfig === undefined ? options : optionsConfig;
+        }
+        else {
+            return deepExtend({}, options, optionsConfig);
+        }
+    }
+}
+export const appResource = new AppResource();

package/dist/lib/decorator/class/beanInfo.d.ts

@@ -0,0 +1,2 @@
+import type { IDecoratorBeanInfoOptions } from '../interface/beanOptions.ts';
+export declare function BeanInfo(options: IDecoratorBeanInfoOptions): ClassDecorator;

package/dist/lib/decorator/class/beanInfo.js

@@ -0,0 +1,8 @@
+import { appMetadata } from "../../core/metadata.js";
+import { SymbolDecoratorBeanInfo } from "../../core/resource.js";
+export function BeanInfo(options) {
+    return function (target) {
+        // set metadata
+        appMetadata.defineMetadata(SymbolDecoratorBeanInfo, options, target);
+    };
+}