vona-module-a-worker 5.0.8 → 5.0.10

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

@@ -0,0 +1,94 @@
+import type { BeanScopeUtil, TypeModuleConfig } from 'vona';
+import type { IDecoratorBroadcastOptions } from 'vona-module-a-broadcast';
+import type { IDecoratorCacheRedisOptions } from 'vona-module-a-cache';
+/** bean: end */
+/** bean: begin */
+import type { BeanWorker } from '../bean/bean.worker.ts';
+/** broadcast: end */
+/** broadcast: begin */
+import type { BroadcastExitAll } from '../bean/broadcast.exitAll.ts';
+import type { BroadcastReloadAll } from '../bean/broadcast.reloadAll.ts';
+/** cacheRedis: end */
+/** cacheRedis: begin */
+import type { CacheRedisWorkerAlive } from '../bean/cacheRedis.workerAlive.ts';
+import type { config } from '../config/config.ts';
+/** monkey: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+/** bean: begin */
+import 'vona';
+import 'vona';
+import 'vona';
+export * from '../bean/bean.worker.ts';
+declare module 'vona' {
+}
+declare module 'vona-module-a-worker' {
+    interface BeanWorker {
+    }
+}
+declare module 'vona' {
+    interface IBeanRecordGlobal {
+        worker: BeanWorker;
+    }
+}
+/** bean: end */
+/** broadcast: begin */
+export * from '../bean/broadcast.exitAll.ts';
+export * from '../bean/broadcast.reloadAll.ts';
+declare module 'vona-module-a-broadcast' {
+    interface IBroadcastRecord {
+        'a-worker:exitAll': IDecoratorBroadcastOptions;
+        'a-worker:reloadAll': IDecoratorBroadcastOptions;
+    }
+}
+declare module 'vona-module-a-worker' {
+    interface BroadcastExitAll {
+    }
+    interface BroadcastReloadAll {
+    }
+}
+export interface IModuleBroadcast {
+    exitAll: BroadcastExitAll;
+    reloadAll: BroadcastReloadAll;
+}
+/** broadcast: end */
+/** cacheRedis: begin */
+export * from '../bean/cacheRedis.workerAlive.ts';
+declare module 'vona-module-a-cache' {
+    interface ICacheRedisRecord {
+        'a-worker:workerAlive': IDecoratorCacheRedisOptions;
+    }
+}
+declare module 'vona-module-a-worker' {
+    interface CacheRedisWorkerAlive {
+    }
+}
+export interface IModuleCacheRedis {
+    workerAlive: CacheRedisWorkerAlive;
+}
+/** cacheRedis: end */
+/** config: begin */
+export * from '../config/config.ts';
+/** config: end */
+/** monkey: begin */
+export * from '../monkey.ts';
+export declare class ScopeModuleAWorker extends BeanScopeBase {
+}
+export interface ScopeModuleAWorker {
+    util: BeanScopeUtil;
+    config: TypeModuleConfig<typeof config>;
+    broadcast: IModuleBroadcast;
+    cacheRedis: IModuleCacheRedis;
+}
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'a-worker': ScopeModuleAWorker;
+    }
+    interface IBeanScopeContainer {
+        worker: ScopeModuleAWorker;
+    }
+    interface IBeanScopeConfig {
+        'a-worker': ReturnType<typeof config>;
+    }
+}
+/** scope: end */

package/dist/.metadata/index.js

@@ -0,0 +1,35 @@
+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';
+import { Scope } from 'vona-module-a-bean';
+/** bean: begin */
+import 'vona';
+import 'vona';
+import 'vona';
+export * from "../bean/bean.worker.js";
+/** bean: end */
+/** broadcast: begin */
+export * from "../bean/broadcast.exitAll.js";
+export * from "../bean/broadcast.reloadAll.js";
+/** broadcast: end */
+/** cacheRedis: begin */
+export * from "../bean/cacheRedis.workerAlive.js";
+/** cacheRedis: end */
+/** config: begin */
+export * from "../config/config.js";
+/** config: end */
+/** monkey: begin */
+export * from "../monkey.js";
+let ScopeModuleAWorker = class ScopeModuleAWorker extends BeanScopeBase {
+};
+ScopeModuleAWorker = __decorate([
+    Scope()
+], ScopeModuleAWorker);
+export { ScopeModuleAWorker };
+/** scope: end */

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

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

package/dist/.metadata/this.js

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

package/dist/bean/bean.worker.d.ts

@@ -0,0 +1,11 @@
+import { BeanBase } from 'vona';
+export declare class BeanWorker extends BeanBase {
+    get id(): string;
+    setAlive(id?: string): Promise<void>;
+    delAlive(id?: string): Promise<void>;
+    getAlive(id?: string): Promise<boolean | null | undefined>;
+    exit(code?: number | string | null | undefined): Promise<void>;
+    exitAll(code?: number | string | null | undefined): Promise<void>;
+    reload(): Promise<void>;
+    reloadAll(): Promise<void>;
+}

package/dist/bean/bean.worker.js

@@ -0,0 +1,60 @@
+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 cluster from 'node:cluster';
+import { isNil } from '@cabloy/utils';
+import { BeanBase, closeApp, uuidv4 } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+const SymbolWorkerId = Symbol('SymbolWorkerId');
+let BeanWorker = class BeanWorker extends BeanBase {
+    get id() {
+        if (this.app[SymbolWorkerId] === undefined) {
+            this.app[SymbolWorkerId] = uuidv4();
+        }
+        return this.app[SymbolWorkerId];
+    }
+    async setAlive(id) {
+        const aliveTimeout = this.scope.config.worker.alive.timeout;
+        const aliveTimeoutMore = this.scope.config.worker.alive.timeoutMore;
+        await this.scope.cacheRedis.workerAlive.set(true, id ?? this.id, { ttl: aliveTimeout + aliveTimeoutMore });
+    }
+    async delAlive(id) {
+        await this.scope.cacheRedis.workerAlive.del(id ?? this.id);
+    }
+    async getAlive(id) {
+        if (isNil(id) || id === this.id)
+            return true;
+        return await this.scope.cacheRedis.workerAlive.get(id ?? this.id);
+    }
+    async exit(code) {
+        await this.app.meta.close();
+        process.exit(code);
+    }
+    async exitAll(code) {
+        this.scope.broadcast.exitAll.emit({ code });
+    }
+    async reload() {
+        if (!cluster.worker) {
+            return;
+            // maybe throw uncaughtException
+            // throw new Error('Only take affect in cluster');
+        }
+        await closeApp(false);
+        cluster.worker.send('reload-worker');
+    }
+    async reloadAll() {
+        if (!cluster.worker) {
+            return;
+            // maybe throw uncaughtException
+            // throw new Error('Only take affect in cluster');
+        }
+        this.scope.broadcast.reloadAll.emit();
+    }
+};
+BeanWorker = __decorate([
+    Bean()
+], BeanWorker);
+export { BeanWorker };

package/dist/bean/broadcast.exitAll.d.ts

@@ -0,0 +1,8 @@
+import type { IBroadcastExecute } from 'vona-module-a-broadcast';
+import { BeanBroadcastBase } from 'vona-module-a-broadcast';
+export interface TypeBroadcastExitAllJobData {
+    code?: number | string | null | undefined;
+}
+export declare class BroadcastExitAll extends BeanBroadcastBase<TypeBroadcastExitAllJobData> implements IBroadcastExecute<TypeBroadcastExitAllJobData> {
+    execute(data: TypeBroadcastExitAllJobData, _isEmitter?: boolean): Promise<void>;
+}

package/dist/bean/broadcast.exitAll.js

@@ -0,0 +1,16 @@
+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 { BeanBroadcastBase, Broadcast } from 'vona-module-a-broadcast';
+let BroadcastExitAll = class BroadcastExitAll extends BeanBroadcastBase {
+    async execute(data, _isEmitter) {
+        await this.bean.worker.exit(data.code);
+    }
+};
+BroadcastExitAll = __decorate([
+    Broadcast()
+], BroadcastExitAll);
+export { BroadcastExitAll };

package/dist/bean/broadcast.reloadAll.d.ts

@@ -0,0 +1,6 @@
+import type { IBroadcastExecute } from 'vona-module-a-broadcast';
+import { BeanBroadcastBase } from 'vona-module-a-broadcast';
+export type TypeBroadcastReloadAllJobData = unknown;
+export declare class BroadcastReloadAll extends BeanBroadcastBase<TypeBroadcastReloadAllJobData> implements IBroadcastExecute<TypeBroadcastReloadAllJobData> {
+    execute(_data: TypeBroadcastReloadAllJobData, _isEmitter?: boolean): Promise<void>;
+}

package/dist/bean/broadcast.reloadAll.js

@@ -0,0 +1,16 @@
+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 { BeanBroadcastBase, Broadcast } from 'vona-module-a-broadcast';
+let BroadcastReloadAll = class BroadcastReloadAll extends BeanBroadcastBase {
+    async execute(_data, _isEmitter) {
+        await this.bean.worker.reload();
+    }
+};
+BroadcastReloadAll = __decorate([
+    Broadcast()
+], BroadcastReloadAll);
+export { BroadcastReloadAll };

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

@@ -0,0 +1,5 @@
+import { BeanCacheRedisBase } from 'vona-module-a-cache';
+export type TCacheRedisWorkerAliveKey = string;
+export type TCacheRedisWorkerAliveData = boolean;
+export declare class CacheRedisWorkerAlive extends BeanCacheRedisBase<TCacheRedisWorkerAliveKey, TCacheRedisWorkerAliveData> {
+}

package/dist/bean/cacheRedis.workerAlive.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 CacheRedisWorkerAlive = class CacheRedisWorkerAlive extends BeanCacheRedisBase {
+};
+CacheRedisWorkerAlive = __decorate([
+    CacheRedis()
+], CacheRedisWorkerAlive);
+export { CacheRedisWorkerAlive };

package/dist/config/config.d.ts

@@ -0,0 +1,9 @@
+import type { VonaApplication } from 'vona';
+export declare function config(app: VonaApplication): {
+    worker: {
+        alive: {
+            timeout: number;
+            timeoutMore: number;
+        };
+    };
+};

package/dist/config/config.js

@@ -0,0 +1,10 @@
+export function config(app) {
+    return {
+        worker: {
+            alive: {
+                timeout: app.meta.isProd ? 3000 : 1000,
+                timeoutMore: app.meta.isProd ? 3000 : 1000,
+            },
+        },
+    };
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/monkey.d.ts

@@ -0,0 +1,10 @@
+import type { IModule } from '@cabloy/module-info';
+import type { IMonkeyAppClosed, IMonkeyModule } from 'vona';
+import { BeanSimple } from 'vona';
+export declare class Monkey extends BeanSimple implements IMonkeyModule, IMonkeyAppClosed {
+    _intervalAlive: any;
+    moduleLoading(_module: IModule): Promise<void>;
+    moduleLoaded(module: IModule): Promise<void>;
+    configLoaded(_module: IModule, _config: any): Promise<void>;
+    appClosed(): Promise<void>;
+}

package/dist/monkey.js

@@ -0,0 +1,26 @@
+import { BeanSimple } from 'vona';
+import { __ThisModule__ } from "./.metadata/this.js";
+export class Monkey extends BeanSimple {
+    _intervalAlive = null;
+    async moduleLoading(_module) { }
+    async moduleLoaded(module) {
+        if (module.info.relativeName !== __ThisModule__)
+            return;
+        const scope = this.bean.scope(__ThisModule__);
+        const aliveTimeout = scope.config.worker.alive.timeout;
+        // interval
+        this._intervalAlive = setInterval(async () => {
+            await this.app.bean.worker.setAlive();
+        }, aliveTimeout);
+        // alive
+        await this.app.bean.worker.setAlive();
+    }
+    async configLoaded(_module, _config) { }
+    async appClosed() {
+        await this.bean.worker.delAlive();
+        if (this._intervalAlive) {
+            clearInterval(this._intervalAlive);
+        }
+        this._intervalAlive = null;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-worker",
   "type": "module",
-  "version": "5.0.8",
+  "version": "5.0.10",
   "title": "a-worker",
   "vonaModule": {
     "dependencies": {},
@@ -28,8 +28,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"
   }
 }