vona-core 1.0.0 → 5.0.9

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

@@ -0,0 +1,3 @@
+import type { IBeanSceneRecord } from '../interface/beanOptions.ts';
+import type { Constructable } from '../type/constructable.ts';
+export declare function createBeanDecorator<T>(scene: keyof IBeanSceneRecord, options?: T, optionsPrimitive?: boolean, virtual?: boolean, fn?: (target: Constructable) => void): ClassDecorator;

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

@@ -0,0 +1,23 @@
+import { appResource } from "../../core/resource.js";
+import { parseModuleName } from "./util.js";
+export function createBeanDecorator(scene, options, optionsPrimitive, virtual, fn) {
+    return function (target) {
+        const beanClass = target;
+        // module
+        const module = parseModuleName(beanClass);
+        // name
+        const name = scene === 'scope' ? 'module' : undefined;
+        // add
+        appResource.addBean({
+            module,
+            scene,
+            name,
+            beanClass,
+            options,
+            optionsPrimitive,
+            virtual,
+        });
+        // fn
+        fn?.(beanClass);
+    };
+}

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

@@ -0,0 +1,4 @@
+export * from './beanInfo.ts';
+export * from './createBeanDecorator.ts';
+export * from './proxyDisable.ts';
+export * from './use.ts';

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

@@ -0,0 +1,4 @@
+export * from "./beanInfo.js";
+export * from "./createBeanDecorator.js";
+export * from "./proxyDisable.js";
+export * from "./use.js";

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

@@ -0,0 +1 @@
+export declare function ProxyDisable(): ClassDecorator;

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

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

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

@@ -0,0 +1,7 @@
+import type { IBeanRecord } from '../../bean/type.ts';
+import type { IDecoratorUseOptions, IDecoratorUseOptionsBase, IInjectSelectorInfo } from '../index.ts';
+export declare function Use(options?: IDecoratorUseOptions): PropertyDecorator & MethodDecorator;
+export declare function Use<T extends keyof IBeanRecord>(beanFullName?: T): PropertyDecorator & MethodDecorator;
+export declare function usePrepareArg(arg: () => any, withSelector?: boolean): any;
+export declare function usePrepareArgs(args: Array<(() => any) | any>, withSelector?: boolean): any;
+export declare function __prepareInjectSelectorInfo(beanInstance: any, useOptions: IDecoratorUseOptionsBase): IInjectSelectorInfo;

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

@@ -0,0 +1,69 @@
+import { evaluateExpressions } from '@cabloy/utils';
+import { appMetadata } from "../../core/metadata.js";
+import { appResource } from "../../core/resource.js";
+export function Use(options) {
+    return function (target, prop, descriptor) {
+        if (!options)
+            options = {};
+        if (typeof options === 'string') {
+            options = { beanFullName: options };
+        }
+        // beanClass maybe has no specific class type
+        const beanClass = appMetadata.getDesignType(target, prop);
+        // beanFullName
+        let beanFullName = options.beanFullName;
+        if (!beanFullName) {
+            beanFullName = appResource.getBeanFullName(beanClass);
+            if (!beanFullName)
+                throw new Error(`beanFullName not found for: ${beanClass.name}`);
+        }
+        // record
+        appResource.addUse(target, {
+            ...options,
+            prop,
+            beanFullName,
+            descriptor,
+        });
+    };
+}
+export function usePrepareArg(arg, withSelector) {
+    return {
+        withSelector,
+        args: [arg],
+    };
+}
+export function usePrepareArgs(args, withSelector) {
+    return {
+        withSelector,
+        args,
+    };
+}
+export function __prepareInjectSelectorInfo(beanInstance, useOptions) {
+    let selectorInfo = __prepareInjectSelectorInfo_descriptor(beanInstance, useOptions);
+    if (!selectorInfo) {
+        selectorInfo = __prepareInjectSelectorInfo_init(beanInstance, useOptions);
+    }
+    return selectorInfo ?? { withSelector: false, args: [] };
+}
+function __prepareInjectSelectorInfo_descriptor(beanInstance, useOptions) {
+    const fnGet = useOptions.descriptor?.get;
+    if (!fnGet)
+        return;
+    const res = fnGet.call(beanInstance);
+    if (!res)
+        return;
+    const withSelector = res.withSelector ?? false;
+    const args = res.args.map(arg => arg());
+    return { withSelector, args };
+}
+function __prepareInjectSelectorInfo_init(beanInstance, useOptions) {
+    const init = useOptions.init;
+    if (!init)
+        return;
+    const withSelector = init.withSelector ?? false;
+    const _args = init.args ?? [init.arg];
+    if (!_args)
+        return;
+    const args = _args.map(arg => evaluateExpressions(arg, beanInstance));
+    return { withSelector, args };
+}

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

@@ -0,0 +1,3 @@
+import type { Constructable } from '../type/constructable.ts';
+export declare const ParseModuleNameLevel: number;
+export declare function parseModuleName(beanClass: Constructable): string | undefined;

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

@@ -0,0 +1,9 @@
+import { parseModuleName as _parseModuleName, ParseModuleNameLevelInit } from '@cabloy/module-info-pro';
+import { appMetadata } from "../../core/metadata.js";
+import { SymbolDecoratorBeanInfo } from "../../core/resource.js";
+export const ParseModuleNameLevel = ParseModuleNameLevelInit + 5;
+export function parseModuleName(beanClass) {
+    // beanInfo
+    const beanInfo = appMetadata.getMetadata(SymbolDecoratorBeanInfo, beanClass);
+    return beanInfo?.module || _parseModuleName(ParseModuleNameLevel);
+}

package/dist/lib/decorator/index.d.ts

@@ -0,0 +1,3 @@
+export * from './class/index.ts';
+export * from './interface/index.ts';
+export * from './type/index.ts';

package/dist/lib/decorator/index.js

@@ -0,0 +1,3 @@
+export * from "./class/index.js";
+export * from "./interface/index.js";
+export * from "./type/index.js";

package/dist/lib/decorator/interface/beanOptions.d.ts

@@ -0,0 +1,21 @@
+import type { Constructable } from '../index.ts';
+export interface IBeanSceneRecord {
+}
+export interface IDecoratorBeanOptionsBase<T = unknown, OPTIONS = unknown> {
+    /**
+     * global: equal to name
+     * others: module.scene.name
+     */
+    beanFullName: string;
+    module: string;
+    scene: keyof IBeanSceneRecord;
+    name: string;
+    beanClass: Constructable<T>;
+    virtual?: boolean;
+    moduleBelong?: string;
+    options?: OPTIONS;
+    optionsPrimitive?: boolean;
+}
+export interface IDecoratorBeanInfoOptions {
+    module: string;
+}

package/dist/lib/decorator/interface/beanOptions.js

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

package/dist/lib/decorator/interface/index.d.ts

@@ -0,0 +1,2 @@
+export * from './beanOptions.ts';
+export * from './useOptions.ts';

package/dist/lib/decorator/interface/index.js

@@ -0,0 +1,2 @@
+export * from "./beanOptions.js";
+export * from "./useOptions.js";

package/dist/lib/decorator/interface/useOptions.d.ts

@@ -0,0 +1,29 @@
+import type { IBeanRecord, InjectionScope, MetadataKey } from '../../../index.ts';
+export interface IDecoratorUseOptionsBase {
+    prop: MetadataKey;
+    beanFullName: string;
+    /** such as: moduleScope */
+    selector?: string;
+    injectionScope?: InjectionScope;
+    init?: IDecoratorUseOptionsInit;
+    descriptor?: PropertyDescriptor;
+}
+export interface IDecoratorUseOptions {
+    beanFullName?: keyof IBeanRecord;
+    selector?: string;
+    init?: IDecoratorUseOptionsInit;
+}
+export type TypeDecoratorUseOptionsInitArg = any | any[] | Record<string, any>;
+export interface IDecoratorUseOptionsInit {
+    withSelector?: boolean;
+    arg?: TypeDecoratorUseOptionsInitArg;
+    args?: TypeDecoratorUseOptionsInitArg[];
+}
+export interface IUsePrepareArgResult {
+    withSelector?: boolean;
+    args: (Function | any)[];
+}
+export interface IInjectSelectorInfo {
+    withSelector: boolean;
+    args: any[];
+}

package/dist/lib/decorator/interface/useOptions.js

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

package/dist/lib/decorator/type/constructable.d.ts

@@ -0,0 +1 @@
+export type Constructable<T = unknown> = new (...args: any[]) => T;

package/dist/lib/decorator/type/constructable.js

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

package/dist/lib/decorator/type/containerScope.d.ts

@@ -0,0 +1 @@
+export type ContainerScope = 'app' | 'ctx' | 'new';

package/dist/lib/decorator/type/containerScope.js

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

package/dist/lib/decorator/type/function.d.ts

@@ -0,0 +1,6 @@
+export type FunctionAsync<RESULT> = () => Promise<RESULT>;
+export type Next = (data?: any) => Promise<any>;
+export type NextSync = (data?: any) => any;
+export type NextGeneral = (data?: any) => Promise<any> | any;
+export declare const functionNoop: () => void;
+export type FunctionAny = (...args: any[]) => any;

package/dist/lib/decorator/type/function.js

@@ -0,0 +1 @@
+export const functionNoop = () => { };

package/dist/lib/decorator/type/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constructable.ts';
+export * from './containerScope.ts';
+export * from './function.ts';
+export * from './injectionScope.ts';

package/dist/lib/decorator/type/index.js

@@ -0,0 +1,4 @@
+export * from "./constructable.js";
+export * from "./containerScope.js";
+export * from "./function.js";
+export * from "./injectionScope.js";

package/dist/lib/decorator/type/injectionScope.d.ts

@@ -0,0 +1 @@
+export type InjectionScope = 'app' | 'ctx' | 'new';

package/dist/lib/decorator/type/injectionScope.js

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

package/dist/lib/framework/bootstrap.d.ts

@@ -0,0 +1,3 @@
+import type { BootstrapOptions } from '../../types/interface/bootstrap.ts';
+import type { VonaApplication } from '../core/application.ts';
+export declare function bootstrap(bootstrapOptions: BootstrapOptions): Promise<VonaApplication | undefined>;

package/dist/lib/framework/bootstrap.js

@@ -0,0 +1,13 @@
+import { prepareEnv } from "../utils/util.js";
+import { startCluster } from "./cluster.js";
+import { createApp } from "./createApp.js";
+import { handleProcessWork } from "./process.js";
+export async function bootstrap(bootstrapOptions) {
+    const env = prepareEnv(bootstrapOptions.env);
+    const workers = Number.parseInt(env.SERVER_WORKERS);
+    if (workers === 1) {
+        handleProcessWork();
+        return await createApp(bootstrapOptions);
+    }
+    await startCluster(workers, bootstrapOptions);
+}

package/dist/lib/framework/cluster.d.ts

@@ -0,0 +1,2 @@
+import type { BootstrapOptions } from '../../types/interface/bootstrap.ts';
+export declare function startCluster(workers: number, bootstrapOptions: BootstrapOptions): Promise<void>;

package/dist/lib/framework/cluster.js

@@ -0,0 +1,32 @@
+import cluster from 'node:cluster';
+import { createApp } from "./createApp.js";
+import { handleProcessMaster, handleProcessWork } from "./process.js";
+export async function startCluster(workers, bootstrapOptions) {
+    if (cluster.isPrimary) {
+        handleProcessMaster();
+        // console.log(`Primary ${process.pid} is running`);
+        // Fork workers.
+        for (let i = 0; i < workers; i++) {
+            cluster.fork();
+        }
+        cluster.on('message', (worker, message) => {
+            if (message === 'reload-worker') {
+                worker.process.kill('SIGTERM');
+                cluster.fork();
+            }
+        });
+        cluster.on('exit', (_worker, _code, _signal) => {
+            // console.log(`worker ${worker.process.pid} died`, code, signal);
+            // should not kill master self by manual
+            // master -> worker, rather than worker -> master
+            // if (cluster.workers && Object.keys(cluster.workers).length === 0) {
+            //   process.kill(process.pid, 'SIGTERM');
+            // }
+        });
+    }
+    else {
+        handleProcessWork();
+        await createApp(bootstrapOptions);
+        // console.log(`Worker ${process.pid} started`);
+    }
+}

package/dist/lib/framework/createApp.d.ts

@@ -0,0 +1,2 @@
+import type { BootstrapOptions } from '../../types/interface/bootstrap.ts';
+export declare function createApp(bootstrapOptions: BootstrapOptions): Promise<any>;

package/dist/lib/framework/createApp.js

@@ -0,0 +1,71 @@
+import { sleep } from '@cabloy/utils';
+import { cast } from "../../types/utils/cast.js";
+import { VonaApplication } from "../core/application.js";
+import { combineAppConfigDefault } from "../core/config.js";
+import { deepExtend, prepareEnv } from "../utils/util.js";
+import { Start } from "./start.js";
+export async function createApp(bootstrapOptions) {
+    while (globalThis.__creating__) {
+        await sleep(100);
+    }
+    try {
+        globalThis.__creating__ = true;
+        globalThis.__bootstrapOptions__ = bootstrapOptions;
+        const { modulesMeta, locales, config, env, AppMonkey } = bootstrapOptions;
+        if (!globalThis.__app__) {
+            globalThis.__app__ = __createApp({
+                modulesMeta,
+                locales,
+                config,
+                env,
+                AppMonkey,
+            });
+            const start = new Start(globalThis.__app__);
+            await start.start();
+        }
+        await globalThis.__app__.meta.waitAppStarted();
+        return globalThis.__app__;
+    }
+    finally {
+        globalThis.__creating__ = false;
+    }
+}
+function __createApp({ modulesMeta, locales, config, env, AppMonkey }) {
+    // env
+    const env2 = prepareEnv(env);
+    // appInfo
+    const appInfo = prepareAppInfo(env2);
+    // config
+    const appConfig = prepareConfig(appInfo, config, env2);
+    // options
+    const options = {
+        name: appInfo.name,
+        projectPath: appInfo.projectPath,
+        modulesMeta,
+        locales,
+        config: appConfig,
+        env: env2,
+        AppMonkey,
+    };
+    return new VonaApplication(options);
+}
+function prepareAppInfo(env) {
+    return {
+        name: env.APP_NAME,
+        projectPath: process.cwd(),
+        configMeta: {
+            flavor: cast(env).META_FLAVOR,
+            mode: cast(env).META_MODE,
+        },
+    };
+}
+function prepareConfig(appInfo, configs, env) {
+    const config = combineAppConfigDefault(appInfo, env);
+    for (const configItem of configs) {
+        const res = configItem(appInfo, env);
+        if (res) {
+            deepExtend(config, res);
+        }
+    }
+    return config;
+}

package/dist/lib/framework/index.d.ts

@@ -0,0 +1,4 @@
+export * from './bootstrap.ts';
+export * from './createApp.ts';
+export * from './process.ts';
+export * from './useApp.ts';

package/dist/lib/framework/index.js

@@ -0,0 +1,4 @@
+export * from "./bootstrap.js";
+export * from "./createApp.js";
+export * from "./process.js";
+export * from "./useApp.js";

package/dist/lib/framework/process.d.ts

@@ -0,0 +1,2 @@
+export declare function handleProcessWork(): void;
+export declare function handleProcessMaster(): void;

package/dist/lib/framework/process.js

@@ -0,0 +1,36 @@
+import { closeApp, useApp } from "./useApp.js";
+export function handleProcessWork() {
+    process.once('SIGUSR2', async () => {
+        // console.log('------------SIGUSR2');
+        await closeApp(true);
+    });
+    process.once('SIGINT', async () => {
+        // console.log('------------SIGINT');
+        await closeApp(true);
+    });
+    process.on('uncaughtException', async (err) => {
+        const app = useApp();
+        if (!app) {
+            console.error(err);
+            process.kill(process.pid, 'SIGTERM');
+        }
+        else {
+            const logger = app.meta.logger.get();
+            logger.error(err);
+            if (!app.meta.appStarted) {
+                await app.meta.logger.dispose();
+                process.kill(process.pid, 'SIGTERM');
+            }
+        }
+    });
+}
+export function handleProcessMaster() {
+    process.once('SIGUSR2', () => {
+        // should not kill master self by manual
+        // process.kill(process.pid, 'SIGTERM');
+    });
+    // should not kill master self by manual
+    // process.once('SIGINT', () => {
+    //   process.kill(process.pid, 'SIGTERM');
+    // });
+}

package/dist/lib/framework/start.d.ts

@@ -0,0 +1,10 @@
+import type { VonaApplication } from '../core/application.ts';
+export declare class Start {
+    app: VonaApplication;
+    constructor(app: VonaApplication);
+    start(): Promise<void>;
+    _start_appLoad(): Promise<void>;
+    _start_appStart(): Promise<void>;
+    _start_appReady(): Promise<void>;
+    _start_appStarted(): Promise<void>;
+}

package/dist/lib/framework/start.js

@@ -0,0 +1,51 @@
+import { EnumAppEvent } from "../../types/index.js";
+import { ModuleLoader } from "../module/loader.js";
+export class Start {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async start() {
+        const app = this.app;
+        try {
+            await this._start_appLoad();
+            await this._start_appStart();
+            await this._start_appReady();
+            await this._start_appStarted();
+        }
+        catch (err) {
+            // record
+            app.meta.appStartError = err;
+            // event: appReadyError
+            app.emit(EnumAppEvent.AppStartError, err);
+            // throw exception
+            throw err;
+        }
+    }
+    async _start_appLoad() {
+        const app = this.app;
+        // module loader
+        const moduleLoader = app.bean._newBean(ModuleLoader);
+        await moduleLoader.execute();
+    }
+    async _start_appStart() {
+        const app = this.app;
+        // hook: appStart
+        await app.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, 'appStart');
+    }
+    async _start_appReady() {
+        const app = this.app;
+        app.meta.appReady = true;
+        app.meta.appReadyInstances = {};
+        // hook: appReady
+        await app.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, 'appReady');
+    }
+    async _start_appStarted() {
+        const app = this.app;
+        app.meta.appStarted = true;
+        // event: appStarted
+        app.emit(EnumAppEvent.AppStarted);
+        // hook: appStarted
+        await app.util.monkeyModule(app.meta.appMonkey, app.meta.modulesMonkey, 'appStarted');
+    }
+}

package/dist/lib/framework/useApp.d.ts

@@ -0,0 +1,4 @@
+import type { VonaApplication } from '../core/application.ts';
+export declare function useApp(): VonaApplication;
+export declare function closeApp(terminate?: boolean): Promise<void>;
+export declare function createGeneralApp(projectPath: string, envRuntime?: Partial<NodeJS.ProcessEnv>): Promise<any>;

package/dist/lib/framework/useApp.js

@@ -0,0 +1,49 @@
+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 { sleep } from '@cabloy/utils';
+import { pathToHref } from "../utils/util.js";
+export function useApp() {
+    return globalThis.__app__;
+}
+export async function closeApp(terminate) {
+    while (globalThis.__closing__) {
+        await sleep(50);
+    }
+    try {
+        globalThis.__closing__ = true;
+        if (globalThis.__app__) {
+            await globalThis.__app__.meta.close();
+            delete globalThis.__app__;
+        }
+    }
+    finally {
+        globalThis.__closing__ = false;
+    }
+    if (terminate) {
+        process.kill(process.pid, 'SIGTERM');
+    }
+}
+export async function createGeneralApp(projectPath, envRuntime) {
+    const testFile = path.join(projectPath, '.vona/app.ts');
+    const testInstance = await import(__rewriteRelativeImportExtension(pathToHref(testFile)));
+    return await testInstance.createSingleApp(envRuntime);
+}
+// export async function reloadApp() {
+//   while (globalThis.__reloading__) {
+//     await sleep(100);
+//   }
+//   try {
+//     globalThis.__reloading__ = true;
+//     await closeApp();
+//     await createApp(globalThis.__bootstrapOptions__);
+//   } finally {
+//     globalThis.__reloading__ = false;
+//   }
+// }

package/dist/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './bean/index.ts';
+export * from './core/index.ts';
+export * from './decorator/index.ts';
+export * from './framework/index.ts';
+export * from './mappedClass/index.ts';
+export * from './utils/index.ts';

package/dist/lib/index.js

@@ -0,0 +1,6 @@
+export * from "./bean/index.js";
+export * from "./core/index.js";
+export * from "./decorator/index.js";
+export * from "./framework/index.js";
+export * from "./mappedClass/index.js";
+export * from "./utils/index.js";