vona-module-a-startup 5.0.9 → 5.0.11

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/this.d.ts

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

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/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/config/config.d.ts

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

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,190 @@
+import { BeanInfo, BeanSimple, BeanBase, cast, BeanScopeBase, createBeanDecorator } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+import { CacheRedis, BeanCacheRedisBase } from 'vona-module-a-cache';
+import { Meta } from 'vona-module-a-meta';
+import { BeanRedlockBase } from 'vona-module-a-redlock';
+import path from 'node:path';
+import { isNil } from '@cabloy/utils';
+import fse from 'fs-extra';
+import { Service } from 'vona-module-a-web';
+
+var _dec$3, _dec2$3, _class$3;
+let CacheRedisStartupDebounce = (_dec$3 = CacheRedis(), _dec2$3 = BeanInfo({
+  module: "a-startup"
+}), _dec$3(_class$3 = _dec2$3(_class$3 = class CacheRedisStartupDebounce extends BeanCacheRedisBase {}) || _class$3) || _class$3);
+
+var _dec$2, _dec2$2, _class$2;
+let MetaRedlock = (_dec$2 = Meta(), _dec2$2 = BeanInfo({
+  module: "a-startup"
+}), _dec$2(_class$2 = _dec2$2(_class$2 = class MetaRedlock extends BeanRedlockBase {}) || _class$2) || _class$2);
+
+function config(_app) {
+  return {
+    startup: {
+      debounce: 10 * 1000
+    }
+  };
+}
+
+const __ThisModule__ = 'a-startup';
+
+class Monkey extends BeanSimple {
+  async appStart() {
+    await this.bean.scope(__ThisModule__).service.startup.appStart();
+  }
+  async appReady() {
+    await this.bean.scope(__ThisModule__).service.startup.appReady();
+  }
+}
+
+var _dec$1, _dec2$1, _class$1;
+let ServiceStartup = (_dec$1 = Service(), _dec2$1 = BeanInfo({
+  module: "a-startup"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = 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'));
+  }
+}) || _class$1) || _class$1);
+
+var _dec, _dec2, _class;
+let ScopeModuleAStartup = (_dec = Scope(), _dec2 = BeanInfo({
+  module: "a-startup"
+}), _dec(_class = _dec2(_class = class ScopeModuleAStartup extends BeanScopeBase {}) || _class) || _class);
+
+/** scope: end */
+
+function Startup(options) {
+  return createBeanDecorator('startup', options);
+}
+
+export { CacheRedisStartupDebounce, MetaRedlock, Monkey, ScopeModuleAStartup, ServiceStartup, Startup, config };

package/dist/lib/index.d.ts

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

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/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/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/types/index.d.ts

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

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-startup",
   "type": "module",
-  "version": "5.0.9",
+  "version": "5.0.11",
   "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 && vona :bin:buildModule && tsc -p tsconfig.build.json"
   }
 }