vona-module-a-startup 5.0.8 → 5.0.10

package/dist/.metadata/index.d.ts

@@ -0,0 +1,92 @@
+import type { BeanScopeUtil, TypeModuleConfig } from 'vona';
+/** cacheRedis: begin */
+import type { IDecoratorCacheRedisOptions } from 'vona-module-a-cache';
+/** cacheRedis: end */
+/** cacheRedis: begin */
+import type { CacheRedisStartupDebounce } from '../bean/cacheRedis.startupDebounce.ts';
+/** meta: end */
+/** meta redlock: begin */
+import type { MetaRedlock } from '../bean/meta.redlock.ts';
+import type { config } from '../config/config.ts';
+/** service: end */
+/** service: begin */
+import type { ServiceStartup } from '../service/startup.ts';
+/** monkey: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from '../bean/cacheRedis.startupDebounce.ts';
+declare module 'vona-module-a-cache' {
+    interface ICacheRedisRecord {
+        'a-startup:startupDebounce': IDecoratorCacheRedisOptions;
+    }
+}
+declare module 'vona-module-a-startup' {
+    interface CacheRedisStartupDebounce {
+    }
+}
+export interface IModuleCacheRedis {
+    startupDebounce: CacheRedisStartupDebounce;
+}
+/** cacheRedis: end */
+/** meta: begin */
+export * from '../bean/meta.redlock.ts';
+declare module 'vona' {
+    interface IMetaRecord {
+        'a-startup:redlock': never;
+    }
+}
+declare module 'vona-module-a-startup' {
+    interface MetaRedlock {
+    }
+}
+/** service: end */
+/** config: begin */
+export * from '../config/config.ts';
+declare module 'vona-module-a-web' {
+    interface IServiceRecord {
+        'a-startup:startup': never;
+    }
+}
+declare module 'vona-module-a-startup' {
+    interface ServiceStartup {
+    }
+}
+export interface IModuleService {
+    startup: ServiceStartup;
+}
+declare module 'vona' {
+    interface IBeanRecordGeneral {
+        'a-startup.service.startup': ServiceStartup;
+    }
+}
+/** config: end */
+/** monkey: begin */
+export * from '../monkey.ts';
+/** meta redlock: end */
+/** service: begin */
+export * from '../service/startup.ts';
+export declare class ScopeModuleAStartup extends BeanScopeBase {
+}
+export interface ScopeModuleAStartup {
+    util: BeanScopeUtil;
+    config: TypeModuleConfig<typeof config>;
+    cacheRedis: IModuleCacheRedis;
+    redlock: MetaRedlock;
+    service: IModuleService;
+}
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'a-startup': ScopeModuleAStartup;
+    }
+    interface IBeanScopeContainer {
+        startup: ScopeModuleAStartup;
+    }
+    interface IBeanScopeConfig {
+        'a-startup': ReturnType<typeof config>;
+    }
+}
+/** scope: end */

package/dist/.metadata/index.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/** monkey: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+/** service: end */
+/** service: begin */
+import { Scope } from 'vona-module-a-bean';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from "../bean/cacheRedis.startupDebounce.js";
+/** cacheRedis: end */
+/** meta: begin */
+export * from "../bean/meta.redlock.js";
+/** service: end */
+/** config: begin */
+export * from "../config/config.js";
+/** config: end */
+/** monkey: begin */
+export * from "../monkey.js";
+/** meta redlock: end */
+/** service: begin */
+export * from "../service/startup.js";
+let ScopeModuleAStartup = class ScopeModuleAStartup extends BeanScopeBase {
+};
+ScopeModuleAStartup = __decorate([
+    Scope()
+], ScopeModuleAStartup);
+export { ScopeModuleAStartup };
+/** scope: end */

package/dist/.metadata/this.d.ts

@@ -0,0 +1,2 @@
+export declare const __ThisModule__ = "a-startup";
+export { ScopeModuleAStartup as ScopeModule } from './index.ts';

package/dist/.metadata/this.js

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'a-startup';
+export { ScopeModuleAStartup as ScopeModule } from "./index.js";

package/dist/bean/cacheRedis.startupDebounce.d.ts

@@ -0,0 +1,5 @@
+import { BeanCacheRedisBase } from 'vona-module-a-cache';
+export type TCacheRedisStartupDebounceKey = `startupDebounce:${string}`;
+export type TCacheRedisStartupDebounceData = boolean;
+export declare class CacheRedisStartupDebounce extends BeanCacheRedisBase<TCacheRedisStartupDebounceKey, TCacheRedisStartupDebounceData> {
+}

package/dist/bean/cacheRedis.startupDebounce.js

@@ -0,0 +1,13 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BeanCacheRedisBase, CacheRedis } from 'vona-module-a-cache';
+let CacheRedisStartupDebounce = class CacheRedisStartupDebounce extends BeanCacheRedisBase {
+};
+CacheRedisStartupDebounce = __decorate([
+    CacheRedis()
+], CacheRedisStartupDebounce);
+export { CacheRedisStartupDebounce };

package/dist/bean/meta.redlock.d.ts

@@ -0,0 +1,8 @@
+import type { FunctionAsync } from 'vona';
+import type { IRedlockLockIsolateOptions } from 'vona-module-a-redlock';
+import { BeanRedlockBase } from 'vona-module-a-redlock';
+export interface MetaRedlock {
+    lockIsolate<RESULT, KEY extends string>(resource: `startup.${KEY}`, fn: FunctionAsync<RESULT>, options?: IRedlockLockIsolateOptions): Promise<RESULT>;
+}
+export declare class MetaRedlock extends BeanRedlockBase {
+}

package/dist/bean/meta.redlock.js

@@ -0,0 +1,14 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Meta } from 'vona-module-a-meta';
+import { BeanRedlockBase } from 'vona-module-a-redlock';
+let MetaRedlock = class MetaRedlock extends BeanRedlockBase {
+};
+MetaRedlock = __decorate([
+    Meta()
+], MetaRedlock);
+export { MetaRedlock };

package/dist/config/config.d.ts

@@ -0,0 +1,6 @@
+import type { VonaApplication } from 'vona';
+export declare function config(_app: VonaApplication): {
+    startup: {
+        debounce: number;
+    };
+};

package/dist/config/config.js

@@ -0,0 +1,7 @@
+export function config(_app) {
+    return {
+        startup: {
+            debounce: 10 * 1000,
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './.metadata/index.ts';
+export * from './lib/index.ts';
+export * from './types/index.ts';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./.metadata/index.js";
+export * from "./lib/index.js";
+export * from "./types/index.js";

package/dist/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './startup.ts';

package/dist/lib/index.js

@@ -0,0 +1 @@
+export * from "./startup.js";

package/dist/lib/startup.d.ts

@@ -0,0 +1,2 @@
+import type { IDecoratorStartupOptions } from '../types/startup.ts';
+export declare function Startup(options?: IDecoratorStartupOptions): ClassDecorator;

package/dist/lib/startup.js

@@ -0,0 +1,4 @@
+import { createBeanDecorator } from 'vona';
+export function Startup(options) {
+    return createBeanDecorator('startup', options);
+}

package/dist/monkey.d.ts

@@ -0,0 +1,6 @@
+import type { IMonkeyAppReady, IMonkeyAppStart } from 'vona';
+import { BeanSimple } from 'vona';
+export declare class Monkey extends BeanSimple implements IMonkeyAppStart, IMonkeyAppReady {
+    appStart(): Promise<void>;
+    appReady(): Promise<void>;
+}

package/dist/monkey.js

@@ -0,0 +1,10 @@
+import { BeanSimple } from 'vona';
+import { __ThisModule__ } from "./.metadata/this.js";
+export class Monkey extends BeanSimple {
+    async appStart() {
+        await this.bean.scope(__ThisModule__).service.startup.appStart();
+    }
+    async appReady() {
+        await this.bean.scope(__ThisModule__).service.startup.appReady();
+    }
+}

package/dist/service/startup.d.ts

@@ -0,0 +1,13 @@
+import type { IOnionSlice } from 'vona-module-a-onion';
+import type { IDecoratorStartupOptions, IInstanceStartupOptions } from '../types/startup.ts';
+import { BeanBase } from 'vona';
+export declare class ServiceStartup extends BeanBase {
+    appStart(): Promise<void>;
+    appReady(): Promise<void>;
+    runStartup(startupName: string, instanceName?: string | null, options?: IInstanceStartupOptions): Promise<void>;
+    _runStartupLock(startup: IOnionSlice<IDecoratorStartupOptions>, instanceName?: string | null, options?: IInstanceStartupOptions): Promise<void>;
+    _runStartupInner(startup: IOnionSlice<IDecoratorStartupOptions>, instanceName?: string | null, options?: IInstanceStartupOptions): Promise<void>;
+    runStartupInstance(instanceName: string, options?: IInstanceStartupOptions): Promise<void>;
+    private get _startups();
+    private _clearResources;
+}

package/dist/service/startup.js

@@ -0,0 +1,142 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import path from 'node:path';
+import { isNil } from '@cabloy/utils';
+import fse from 'fs-extra';
+import { BeanBase, cast } from 'vona';
+import { Service } from 'vona-module-a-web';
+let ServiceStartup = class ServiceStartup extends BeanBase {
+    async appStart() {
+        // clear keys
+        await this._clearResources();
+        // run startups: not after
+        for (const startup of this._startups) {
+            const startupOptions = startup.beanOptions.options;
+            if (!startupOptions?.instance && startupOptions?.after !== true) {
+                await this.runStartup(startup.name, null);
+            }
+        }
+    }
+    async appReady() {
+        // run startups: after
+        for (const startup of this._startups) {
+            const startupOptions = startup.beanOptions.options;
+            if (!startupOptions?.instance && startupOptions?.after === true) {
+                await this.runStartup(startup.name, null);
+            }
+        }
+        // version init : force: should be false
+        if (this.app.meta.isTest || this.app.meta.isLocal) {
+            const instanceName = '';
+            await this.bean.executor.newCtx(async () => {
+                await this.$scope.instance.service.instance.instanceStartup(instanceName, { force: false });
+            }, {
+                dbInfo: true,
+                instanceName,
+            });
+        }
+        else {
+            // all instances
+            const instances = await this.bean.executor.newCtx(async () => {
+                return await this.bean.instance.list();
+            }, { dbInfo: true });
+            for (const instance of instances) {
+                const instanceName = instance.name;
+                // need not await
+                this.bean.executor.newCtx(async () => {
+                    await this.$scope.instance.service.instance.instanceStartup(instanceName, { force: false });
+                }, {
+                    dbInfo: true,
+                    instanceName,
+                });
+            }
+        }
+        // version test
+        if (this.app.meta.isTest) {
+            const instanceName = '';
+            await this.bean.executor.newCtx(async () => {
+                await this.$scope.version.service.version.__instanceTest(instanceName);
+            }, {
+                dbInfo: true,
+                instanceName,
+            });
+        }
+    }
+    async runStartup(startupName, instanceName, options) {
+        const startup = this.bean.onion.startup.onionsNormal[startupName];
+        const startupOptions = startup.beanOptions.options;
+        // normal
+        if (!startupOptions.debounce) {
+            return await this._runStartupInner(startup, instanceName, options);
+        }
+        // debounce: lock
+        return await this.scope.redlock.lockIsolate(`startup.${startupName}`, async () => {
+            return await this._runStartupLock(startup, instanceName, options);
+        }, {
+            instanceName,
+        });
+    }
+    async _runStartupLock(startup, instanceName, options) {
+        // ignore debounce for test
+        if (!options?.force && !this.app.meta.isTest) {
+            const startupOptions = startup.beanOptions.options;
+            const cacheKey = `startupDebounce:${startup.name}${!isNil(instanceName) ? `:${this.ctx.instance.id}` : ''}`;
+            const debounce = typeof startupOptions.debounce === 'number' ? startupOptions.debounce : this.scope.config.startup.debounce;
+            const flag = await this.scope.cacheRedis.startupDebounce.getset(true, cacheKey, { ttl: debounce });
+            if (flag)
+                return;
+        }
+        // perform
+        await this._runStartupInner(startup, instanceName, options);
+    }
+    async _runStartupInner(startup, instanceName, options) {
+        this.$logger.silly(`startup${startup.beanOptions?.options?.instance ? ' instance' : ''}: ${startup.name}, pid: ${process.pid}`);
+        const startupOptions = startup.beanOptions.options;
+        // execute
+        return await this.bean.executor.newCtx(async () => {
+            const bean = cast(this.bean._getBean(startup.beanOptions.beanFullName));
+            await bean.execute(options);
+        }, {
+            dbInfo: true,
+            instanceName,
+            transaction: startupOptions.transaction,
+        });
+    }
+    async runStartupInstance(instanceName, options) {
+        // run startups: not after
+        for (const startup of this._startups) {
+            const startupOptions = startup.beanOptions.options;
+            if (startupOptions?.instance && startupOptions?.after !== true) {
+                await this.runStartup(startup.name, instanceName, options);
+            }
+        }
+        // set flag
+        this.app.meta.appReadyInstances[instanceName] = true;
+        // run startups: after
+        for (const startup of this._startups) {
+            const startupOptions = startup.beanOptions.options;
+            if (startupOptions?.instance && startupOptions?.after === true) {
+                await this.runStartup(startup.name, instanceName, options);
+            }
+        }
+    }
+    get _startups() {
+        return this.bean.onion.startup.getOnionsEnabled();
+    }
+    async _clearResources() {
+        if (!this.app.meta.isTest)
+            return;
+        // redis
+        await this.$scope.redis.service.redisClient.clearAllData();
+        // .app/public
+        await fse.remove(path.join(this.app.config.server.publicDir, '1'));
+    }
+};
+ServiceStartup = __decorate([
+    Service()
+], ServiceStartup);
+export { ServiceStartup };

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './startup.ts';

package/dist/types/index.js

@@ -0,0 +1 @@
+export * from "./startup.js";

package/dist/types/startup.d.ts

@@ -0,0 +1,30 @@
+import type { ConfigInstanceBase, OmitNever } from 'vona';
+import type { IOnionOptionsDeps, IOnionOptionsEnable, ServiceOnion } from 'vona-module-a-onion';
+export interface IStartupRecord {
+}
+export interface IStartupExecute {
+    execute: (options?: IInstanceStartupOptions) => Promise<void>;
+}
+export interface IDecoratorStartupOptions extends IOnionOptionsEnable, IOnionOptionsDeps<keyof IStartupRecord> {
+    instance?: boolean;
+    debounce?: boolean | number;
+    transaction?: boolean;
+    after?: boolean;
+}
+export interface IInstanceStartupOptions {
+    force?: boolean;
+    configInstanceBase?: ConfigInstanceBase;
+}
+declare module 'vona-module-a-onion' {
+    interface BeanOnion {
+        startup: ServiceOnion<IDecoratorStartupOptions, keyof IStartupRecord>;
+    }
+}
+declare module 'vona' {
+    interface ConfigOnions {
+        startup: OmitNever<IStartupRecord>;
+    }
+    interface IBeanSceneRecord {
+        startup: never;
+    }
+}

package/dist/types/startup.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-startup",
   "type": "module",
-  "version": "5.0.8",
+  "version": "5.0.10",
   "title": "a-startup",
   "vonaModule": {
     "dependencies": {},
@@ -36,8 +36,12 @@
     "dist",
     "static"
   ],
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.0.1"
+  },
   "scripts": {
-    "clean": "rimraf dist tsconfig.tsbuildinfo",
-    "tsc:publish": "npm run clean && tsc"
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && tsc -p tsconfig.build.json"
   }
 }