vona-module-a-broadcast 5.0.9 → 5.0.11

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

@@ -0,0 +1,52 @@
+import type { BeanScopeUtil } from 'vona';
+/** service: end */
+/** service: begin */
+import type { ServiceBroadcast } from '../service/broadcast.ts';
+/** service: end */
+/** service: begin */
+/** main: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+/** monkey: end */
+/** main: begin */
+import 'vona';
+import 'vona';
+import 'vona';
+export * from '../main.ts';
+declare module 'vona-module-a-web' {
+    interface IServiceRecord {
+        'a-broadcast:broadcast': never;
+    }
+}
+declare module 'vona-module-a-broadcast' {
+    interface ServiceBroadcast {
+    }
+}
+export interface IModuleService {
+    broadcast: ServiceBroadcast;
+}
+declare module 'vona' {
+    interface IBeanRecordGeneral {
+        'a-broadcast.service.broadcast': ServiceBroadcast;
+    }
+}
+/** service: end */
+/** monkey: begin */
+export * from '../monkey.ts';
+/** service: begin */
+export * from '../service/broadcast.ts';
+export declare class ScopeModuleABroadcast extends BeanScopeBase {
+}
+export interface ScopeModuleABroadcast {
+    util: BeanScopeUtil;
+    service: IModuleService;
+}
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'a-broadcast': ScopeModuleABroadcast;
+    }
+    interface IBeanScopeContainer {
+        broadcast: ScopeModuleABroadcast;
+    }
+}
+/** scope: end */

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

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

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,110 @@
+import { BeanSimple, BeanInfo, BeanBase, BeanScopeBase, createBeanDecorator } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+import { Service } from 'vona-module-a-web';
+
+class Main extends BeanSimple {
+  async moduleLoading() {}
+  async moduleLoaded() {
+    // force broadcast init
+    this.bean._getBean('a-broadcast.service.broadcast');
+  }
+  async configLoaded(_config) {}
+}
+
+const __ThisModule__ = 'a-broadcast';
+
+class Monkey extends BeanSimple {
+  async appClose() {
+    const scopeSelf = this.bean.scope(__ThisModule__);
+    await scopeSelf.service.broadcast.disposeSub();
+  }
+  async appClosed() {
+    const scopeSelf = this.bean.scope(__ThisModule__);
+    await scopeSelf.service.broadcast.disposePub();
+  }
+}
+
+var _dec$1, _dec2$1, _class$1;
+let ServiceBroadcast = (_dec$1 = Service(), _dec2$1 = BeanInfo({
+  module: "a-broadcast"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = class ServiceBroadcast extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this.__callerId = void 0;
+    this.__channelName = void 0;
+    this.__sub = void 0;
+    this.__pub = void 0;
+  }
+  __init__() {
+    const app = this.app;
+    this.__callerId = app.bean.worker.id;
+    this.__channelName = `broadcast_${this.app.name}:`;
+    this.__pub = app.bean.redis.get('broadcast').duplicate();
+    this.__sub = app.bean.redis.get('broadcast').duplicate();
+    this.__sub.subscribe(this.__channelName, () => {});
+    this.__sub.on('message', (_channel, info) => {
+      this._performTask(JSON.parse(info)).then(() => {
+        // do nothing
+      }).catch(err => {
+        this.$logger.error(err);
+      });
+    });
+  }
+  async disposePub() {
+    await this.__pub?.quit();
+  }
+  async disposeSub() {
+    await this.__sub?.quit();
+  }
+  emit(info) {
+    info.callerId = this.__callerId;
+    this.__pub.publish(this.__channelName, JSON.stringify(info));
+  }
+  async _performTask(info) {
+    // isEmitter
+    const isEmitter = info.callerId === this.__callerId;
+    // broadcast config
+    const broadcastItem = this.bean.onion.broadcast.getOnionSlice(info.broadcastName);
+    const broadcastConfig = this.bean.onion.broadcast.getOnionOptions(info.broadcastName);
+    // execute
+    return await this.bean.executor.newCtx(async () => {
+      const beanFullName = broadcastItem.beanOptions.beanFullName;
+      const beanInstance = this.app.bean._getBean(beanFullName);
+      return await beanInstance.execute(info.data, isEmitter);
+    }, {
+      dbInfo: info.options?.dbInfo,
+      locale: info.options?.locale,
+      instanceName: info.options?.instanceName,
+      extraData: info.options?.extraData,
+      transaction: broadcastConfig?.transaction,
+      instance: broadcastConfig?.instance !== false
+    });
+  }
+}) || _class$1) || _class$1);
+
+var _dec, _dec2, _class;
+let ScopeModuleABroadcast = (_dec = Scope(), _dec2 = BeanInfo({
+  module: "a-broadcast"
+}), _dec(_class = _dec2(_class = class ScopeModuleABroadcast extends BeanScopeBase {}) || _class) || _class);
+
+/** scope: end */
+
+class BeanBroadcastBase extends BeanBase {
+  emit(data, options) {
+    return this.$scope.broadcast.service.broadcast.emit(this._prepareInfo(data, options));
+  }
+  _prepareInfo(data, options) {
+    options = this.$scope.executor.service.executor.prepareGeneralInfo(options);
+    return {
+      broadcastName: this.$onionName,
+      data,
+      options
+    };
+  }
+}
+
+function Broadcast(options) {
+  return createBeanDecorator('broadcast', options);
+}
+
+export { BeanBroadcastBase, Broadcast, Main, Monkey, ScopeModuleABroadcast, ServiceBroadcast };

package/dist/lib/beanBroadcastBase.d.ts

@@ -0,0 +1,6 @@
+import type { IBroadcastEmitOptions } from '../types/broadcast.ts';
+import { BeanBase } from 'vona';
+export declare class BeanBroadcastBase<DATA = unknown> extends BeanBase {
+    emit(data?: DATA, options?: IBroadcastEmitOptions): void;
+    private _prepareInfo;
+}

package/dist/lib/broadcast.d.ts

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

package/dist/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './beanBroadcastBase.ts';
+export * from './broadcast.ts';

package/dist/main.d.ts

@@ -0,0 +1,7 @@
+import type { IModuleMain } from 'vona';
+import { BeanSimple } from 'vona';
+export declare class Main extends BeanSimple implements IModuleMain {
+    moduleLoading(): Promise<void>;
+    moduleLoaded(): Promise<void>;
+    configLoaded(_config: any): Promise<void>;
+}

package/dist/monkey.d.ts

@@ -0,0 +1,6 @@
+import type { IMonkeyAppClose, IMonkeyAppClosed } from 'vona';
+import { BeanSimple } from 'vona';
+export declare class Monkey extends BeanSimple implements IMonkeyAppClose, IMonkeyAppClosed {
+    appClose(): Promise<void>;
+    appClosed(): Promise<void>;
+}

package/dist/service/broadcast.d.ts

@@ -0,0 +1,13 @@
+import type { IBroadcastJobContext } from '../types/broadcast.ts';
+import { BeanBase } from 'vona';
+export declare class ServiceBroadcast extends BeanBase {
+    private __callerId;
+    private __channelName;
+    private __sub;
+    private __pub;
+    protected __init__(): void;
+    disposePub(): Promise<void>;
+    disposeSub(): Promise<void>;
+    emit<DATA>(info: IBroadcastJobContext<DATA>): void;
+    _performTask<DATA>(info: IBroadcastJobContext<DATA>): Promise<void>;
+}

package/dist/types/broadcast.d.ts

@@ -0,0 +1,33 @@
+import type { OmitNever } from 'vona';
+import type { IGeneralInfoOptions } from 'vona-module-a-executor';
+import type { ServiceOnion } from 'vona-module-a-onion';
+export interface IBroadcastEmitOptions extends IGeneralInfoOptions {
+}
+export interface IBroadcastExecute<DATA = unknown> {
+    execute(data?: DATA, isEmitter?: boolean): Promise<void>;
+}
+export interface IBroadcastJobContext<DATA> {
+    broadcastName: keyof IBroadcastRecord;
+    data?: DATA;
+    options?: IBroadcastEmitOptions;
+    callerId?: string;
+}
+export interface IBroadcastRecord {
+}
+export interface IDecoratorBroadcastOptions {
+    transaction?: boolean;
+    instance?: boolean;
+}
+declare module 'vona-module-a-onion' {
+    interface BeanOnion {
+        broadcast: ServiceOnion<IDecoratorBroadcastOptions, keyof IBroadcastRecord>;
+    }
+}
+declare module 'vona' {
+    interface ConfigOnions {
+        broadcast: OmitNever<IBroadcastRecord>;
+    }
+    interface IBeanSceneRecord {
+        broadcast: never;
+    }
+}

package/dist/types/index.d.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-broadcast",
   "type": "module",
-  "version": "5.0.9",
+  "version": "5.0.11",
   "title": "a-broadcast",
   "vonaModule": {
     "dependencies": {
@@ -39,8 +39,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"
   }
 }