vona-module-a-socket 5.0.0 → 5.1.1

package/src/.metadata/index.ts

@@ -0,0 +1,359 @@
+// eslint-disable
+/** bean: begin */
+export * from '../bean/bean.socket.ts';
+
+import 'vona';
+declare module 'vona' {
+  
+  
+}
+declare module 'vona-module-a-socket' {
+  
+        export interface BeanSocket {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        } 
+}
+/** bean: end */
+/** bean: begin */
+import type { BeanSocket } from '../bean/bean.socket.ts';
+import 'vona';  
+declare module 'vona' {
+  export interface IBeanRecordGlobal {
+    'socket': BeanSocket;
+  }
+}
+/** bean: end */
+/** service: begin */
+export * from '../service/socket.ts';
+export * from '../service/socketEvent.ts';
+
+import 'vona-module-a-bean';
+declare module 'vona-module-a-bean' {
+  
+    export interface IServiceRecord {
+      'a-socket:socket': never;
+'a-socket:socketEvent': never;
+    }
+
+  
+}
+declare module 'vona-module-a-socket' {
+  
+        export interface ServiceSocket {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface ServiceSocket {
+            get $beanFullName(): 'a-socket.service.socket';
+            get $onionName(): 'a-socket:socket';
+            
+          }
+
+        export interface ServiceSocketEvent {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface ServiceSocketEvent {
+            get $beanFullName(): 'a-socket.service.socketEvent';
+            get $onionName(): 'a-socket:socketEvent';
+            
+          } 
+}
+/** service: end */
+/** service: begin */
+import type { ServiceSocket } from '../service/socket.ts';
+import type { ServiceSocketEvent } from '../service/socketEvent.ts';
+export interface IModuleService {
+  'socket': ServiceSocket;
+'socketEvent': ServiceSocketEvent;
+}
+/** service: end */
+/** service: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'a-socket.service.socket': ServiceSocket;
+'a-socket.service.socketEvent': ServiceSocketEvent;
+  }
+}
+/** service: end */
+/** broadcast: begin */
+export * from '../bean/broadcast.broadcast.ts';
+export * from '../bean/broadcast.send.ts';
+
+import { type IDecoratorBroadcastOptions } from 'vona-module-a-broadcast';
+declare module 'vona-module-a-broadcast' {
+  
+    export interface IBroadcastRecord {
+      'a-socket:broadcast': IDecoratorBroadcastOptions;
+'a-socket:send': IDecoratorBroadcastOptions;
+    }
+
+  
+}
+declare module 'vona-module-a-socket' {
+  
+        export interface BroadcastBroadcast {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface BroadcastBroadcast {
+            get $beanFullName(): 'a-socket.broadcast.broadcast';
+            get $onionName(): 'a-socket:broadcast';
+            get $onionOptions(): IDecoratorBroadcastOptions;
+          }
+
+        export interface BroadcastSend {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface BroadcastSend {
+            get $beanFullName(): 'a-socket.broadcast.send';
+            get $onionName(): 'a-socket:send';
+            get $onionOptions(): IDecoratorBroadcastOptions;
+          } 
+}
+/** broadcast: end */
+/** broadcast: begin */
+import type { BroadcastBroadcast } from '../bean/broadcast.broadcast.ts';
+import type { BroadcastSend } from '../bean/broadcast.send.ts';
+export interface IModuleBroadcast {
+  'broadcast': BroadcastBroadcast;
+'send': BroadcastSend;
+}
+/** broadcast: end */
+/** socketConnection: begin */
+export * from '../bean/socketConnection.alive.ts';
+export * from '../bean/socketConnection.app.ts';
+export * from '../bean/socketConnection.cors.ts';
+export * from '../bean/socketConnection.event.ts';
+export * from '../bean/socketConnection.instance.ts';
+export * from '../bean/socketConnection.passport.ts';
+export * from '../bean/socketConnection.ready.ts';
+import type { ISocketConnectionOptionsAlive } from '../bean/socketConnection.alive.ts';
+import type { ISocketConnectionOptionsApp } from '../bean/socketConnection.app.ts';
+import type { ISocketConnectionOptionsCors } from '../bean/socketConnection.cors.ts';
+import type { ISocketConnectionOptionsEvent } from '../bean/socketConnection.event.ts';
+import type { ISocketConnectionOptionsInstance } from '../bean/socketConnection.instance.ts';
+import type { ISocketConnectionOptionsPassport } from '../bean/socketConnection.passport.ts';
+import type { ISocketConnectionOptionsReady } from '../bean/socketConnection.ready.ts';
+import 'vona-module-a-socket';
+declare module 'vona-module-a-socket' {
+  
+    export interface ISocketConnectionRecord {
+      'a-socket:alive': ISocketConnectionOptionsAlive;
+'a-socket:app': ISocketConnectionOptionsApp;
+'a-socket:cors': ISocketConnectionOptionsCors;
+'a-socket:event': ISocketConnectionOptionsEvent;
+'a-socket:instance': ISocketConnectionOptionsInstance;
+'a-socket:passport': ISocketConnectionOptionsPassport;
+'a-socket:ready': ISocketConnectionOptionsReady;
+    }
+
+  
+}
+declare module 'vona-module-a-socket' {
+  
+        export interface SocketConnectionAlive {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface SocketConnectionAlive {
+            get $beanFullName(): 'a-socket.socketConnection.alive';
+            get $onionName(): 'a-socket:alive';
+            get $onionOptions(): ISocketConnectionOptionsAlive;
+          }
+
+        export interface SocketConnectionApp {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface SocketConnectionApp {
+            get $beanFullName(): 'a-socket.socketConnection.app';
+            get $onionName(): 'a-socket:app';
+            get $onionOptions(): ISocketConnectionOptionsApp;
+          }
+
+        export interface SocketConnectionCors {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface SocketConnectionCors {
+            get $beanFullName(): 'a-socket.socketConnection.cors';
+            get $onionName(): 'a-socket:cors';
+            get $onionOptions(): ISocketConnectionOptionsCors;
+          }
+
+        export interface SocketConnectionEvent {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface SocketConnectionEvent {
+            get $beanFullName(): 'a-socket.socketConnection.event';
+            get $onionName(): 'a-socket:event';
+            get $onionOptions(): ISocketConnectionOptionsEvent;
+          }
+
+        export interface SocketConnectionInstance {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface SocketConnectionInstance {
+            get $beanFullName(): 'a-socket.socketConnection.instance';
+            get $onionName(): 'a-socket:instance';
+            get $onionOptions(): ISocketConnectionOptionsInstance;
+          }
+
+        export interface SocketConnectionPassport {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface SocketConnectionPassport {
+            get $beanFullName(): 'a-socket.socketConnection.passport';
+            get $onionName(): 'a-socket:passport';
+            get $onionOptions(): ISocketConnectionOptionsPassport;
+          }
+
+        export interface SocketConnectionReady {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface SocketConnectionReady {
+            get $beanFullName(): 'a-socket.socketConnection.ready';
+            get $onionName(): 'a-socket:ready';
+            get $onionOptions(): ISocketConnectionOptionsReady;
+          } 
+}
+/** socketConnection: end */
+/** socketPacket: begin */
+export * from '../bean/socketPacket.event.ts';
+export * from '../bean/socketPacket.performAction.ts';
+import type { ISocketPacketOptionsEvent } from '../bean/socketPacket.event.ts';
+import type { ISocketPacketOptionsPerformAction } from '../bean/socketPacket.performAction.ts';
+import 'vona-module-a-socket';
+declare module 'vona-module-a-socket' {
+  
+    export interface ISocketPacketRecord {
+      'a-socket:event': ISocketPacketOptionsEvent;
+'a-socket:performAction': ISocketPacketOptionsPerformAction;
+    }
+
+  
+}
+declare module 'vona-module-a-socket' {
+  
+        export interface SocketPacketEvent {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface SocketPacketEvent {
+            get $beanFullName(): 'a-socket.socketPacket.event';
+            get $onionName(): 'a-socket:event';
+            get $onionOptions(): ISocketPacketOptionsEvent;
+          }
+
+        export interface SocketPacketPerformAction {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface SocketPacketPerformAction {
+            get $beanFullName(): 'a-socket.socketPacket.performAction';
+            get $onionName(): 'a-socket:performAction';
+            get $onionOptions(): ISocketPacketOptionsPerformAction;
+          } 
+}
+/** socketPacket: end */
+/** hmr: begin */
+export * from '../bean/hmr.socketConnection.ts';
+export * from '../bean/hmr.socketPacket.ts';
+
+import 'vona';
+declare module 'vona' {
+  
+    export interface IHmrRecord {
+      'a-socket:socketConnection': never;
+'a-socket:socketPacket': never;
+    }
+
+  
+}
+declare module 'vona-module-a-socket' {
+  
+        export interface HmrSocketConnection {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface HmrSocketConnection {
+            get $beanFullName(): 'a-socket.hmr.socketConnection';
+            get $onionName(): 'a-socket:socketConnection';
+            
+          }
+
+        export interface HmrSocketPacket {
+          /** @internal */
+          get scope(): ScopeModuleASocket;
+        }
+
+          export interface HmrSocketPacket {
+            get $beanFullName(): 'a-socket.hmr.socketPacket';
+            get $onionName(): 'a-socket:socketPacket';
+            
+          } 
+}
+/** hmr: end */
+/** config: begin */
+export * from '../config/config.ts';
+import type { config } from '../config/config.ts';
+/** config: end */
+/** monkey: begin */
+export * from '../monkey.ts';
+/** monkey: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export class ScopeModuleASocket extends BeanScopeBase {}
+
+export interface ScopeModuleASocket {
+  util: BeanScopeUtil;
+config: TypeModuleConfig<typeof config>;
+service: IModuleService;
+broadcast: IModuleBroadcast;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'a-socket': ScopeModuleASocket;
+  }
+
+  export interface IBeanScopeContainer {
+    socket: ScopeModuleASocket;
+  }
+  
+  export interface IBeanScopeConfig {
+    'a-socket': ReturnType<typeof config>;
+  }
+
+  
+
+  
+}
+/** scope: end */

package/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'a-socket';
+export { ScopeModuleASocket as ScopeModule } from './index.ts';

package/src/bean/bean.socket.ts

@@ -0,0 +1,60 @@
+import type { WebSocket } from 'ws';
+
+import { BeanBase } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+
+import type { ISocketNamespaceRecord } from '../types/socketNamespace.ts';
+
+@Bean()
+export class BeanSocket extends BeanBase {
+  private _clients: Record<string, WebSocket | undefined> = {};
+  private _clientsNamespace: Record<keyof ISocketNamespaceRecord, string[] | undefined> = {} as any;
+
+  protected async __dispose__() {
+    this.close();
+  }
+
+  public close() {
+    const clients = this._clients;
+    this._clients = {};
+    for (const id in clients) {
+      clients[id]?.terminate();
+    }
+  }
+
+  public get clients() {
+    return this._clients;
+  }
+
+  public get clientsNamespace() {
+    return this._clientsNamespace;
+  }
+
+  getClient(id: string) {
+    return this._clients[id];
+  }
+
+  addClient(ws: WebSocket) {
+    const id = ws.id;
+    const namespace = ws.namespace;
+    this._clients[id] = ws;
+    if (!this._clientsNamespace[namespace]) this._clientsNamespace[namespace] = [];
+    this._clientsNamespace[namespace].push(id);
+  }
+
+  removeClient(ws: WebSocket): void;
+  removeClient(id: string): void;
+  removeClient(ws: WebSocket | string): void {
+    const id = typeof ws === 'string' ? ws : ws.id;
+    const ws2 = this.getClient(id);
+    if (!ws2) return;
+    const namespace = ws2.namespace;
+    delete this._clients[id];
+    if (this._clientsNamespace[namespace]) {
+      const index = this._clientsNamespace[namespace].indexOf(id);
+      if (index !== -1) {
+        this._clientsNamespace[namespace].splice(index, 1);
+      }
+    }
+  }
+}

package/src/bean/broadcast.broadcast.ts

@@ -0,0 +1,23 @@
+import type { IBroadcastExecute } from 'vona-module-a-broadcast';
+
+import { BeanBroadcastBase, Broadcast } from 'vona-module-a-broadcast';
+
+import type { ISendEventOptions } from '../types/socketEvent.ts';
+import type { ISocketNamespaceRecord } from '../types/socketNamespace.ts';
+
+export interface TypeBroadcastBroadcastJobData {
+  namespace: keyof ISocketNamespaceRecord;
+  eventName: PropertyKey;
+  data?: unknown;
+  options?: ISendEventOptions;
+}
+
+@Broadcast()
+export class BroadcastBroadcast extends BeanBroadcastBase<TypeBroadcastBroadcastJobData> implements IBroadcastExecute<TypeBroadcastBroadcastJobData> {
+  async execute(data: TypeBroadcastBroadcastJobData, isEmitter?: boolean) {
+    const { namespace, eventName, data: eventData, options } = data;
+    if (!isEmitter) {
+      this.scope.service.socketEvent.broadcastWorker(namespace, eventName, eventData, options);
+    }
+  }
+}

package/src/bean/broadcast.send.ts

@@ -0,0 +1,22 @@
+import type { IBroadcastExecute } from 'vona-module-a-broadcast';
+
+import { BeanBroadcastBase, Broadcast } from 'vona-module-a-broadcast';
+
+import type { ISendEventOptions } from '../types/socketEvent.ts';
+
+export interface TypeBroadcastSendJobData {
+  id: string;
+  eventName: PropertyKey;
+  data?: unknown;
+  options?: ISendEventOptions;
+}
+
+@Broadcast()
+export class BroadcastSend extends BeanBroadcastBase<TypeBroadcastSendJobData> implements IBroadcastExecute<TypeBroadcastSendJobData> {
+  async execute(data: TypeBroadcastSendJobData, isEmitter?: boolean) {
+    const { id, eventName, data: eventData, options } = data;
+    if (!isEmitter) {
+      this.scope.service.socketEvent.sendWorker(id, eventName, eventData, options);
+    }
+  }
+}

package/src/bean/hmr.socketConnection.ts

@@ -0,0 +1,14 @@
+import type { IDecoratorBeanOptionsBase } from 'vona';
+import type { IHmrReload } from 'vona-module-a-hmr';
+
+import { BeanBase } from 'vona';
+import { Hmr } from 'vona-module-a-hmrbase';
+
+import { clearAllCacheSocketConnections } from '../lib/const.ts';
+
+@Hmr()
+export class HmrSocketConnection extends BeanBase implements IHmrReload {
+  async reload(_beanOptions: IDecoratorBeanOptionsBase) {
+    clearAllCacheSocketConnections(this.app);
+  }
+}

package/src/bean/hmr.socketPacket.ts

@@ -0,0 +1,14 @@
+import type { IDecoratorBeanOptionsBase } from 'vona';
+import type { IHmrReload } from 'vona-module-a-hmr';
+
+import { BeanBase } from 'vona';
+import { Hmr } from 'vona-module-a-hmrbase';
+
+import { clearAllCacheSocketPackets } from '../lib/const.ts';
+
+@Hmr()
+export class HmrSocketPacket extends BeanBase implements IHmrReload {
+  async reload(_beanOptions: IDecoratorBeanOptionsBase) {
+    clearAllCacheSocketPackets(this.app);
+  }
+}

package/src/bean/socketConnection.alive.ts

@@ -0,0 +1,48 @@
+import type { Next } from 'vona';
+import type { IDecoratorSocketConnectionOptions, ISocketConnectionExecute } from 'vona-module-a-socket';
+import type { WebSocket } from 'ws';
+
+import { BeanBase } from 'vona';
+import { SocketConnection } from 'vona-module-a-socket';
+
+export interface ISocketConnectionOptionsAlive extends IDecoratorSocketConnectionOptions {}
+
+@SocketConnection<ISocketConnectionOptionsAlive>()
+export class SocketConnectionAlive extends BeanBase implements ISocketConnectionExecute {
+  private _interval: any;
+
+  protected async __dispose__() {
+    if (this._interval) {
+      clearInterval(this._interval);
+      this._interval = null;
+    }
+  }
+
+  async enter(ws: WebSocket, _options: ISocketConnectionOptionsAlive, next: Next): Promise<void> {
+    // isAlive
+    ws.isAlive = true;
+    ws.on('pong', () => {
+      ws.isAlive = true;
+    });
+    // start interval
+    this._startInterval();
+    // next
+    return next();
+  }
+
+  async exit(_ws: WebSocket, _options: ISocketConnectionOptionsAlive, next: Next): Promise<void> {
+    // next
+    await next();
+  }
+
+  private _startInterval() {
+    if (this._interval) return;
+    this._interval = setInterval(() => {
+      this.app.wss.clients.forEach(ws => {
+        if (ws.isAlive === false) return ws.terminate();
+        ws.isAlive = false;
+        ws.ping();
+      });
+    }, this.scope.config.timeout.ping);
+  }
+}

package/src/bean/socketConnection.app.ts

@@ -0,0 +1,26 @@
+import type { Next } from 'vona';
+import type { IDecoratorSocketConnectionOptions, ISocketConnectionExecute } from 'vona-module-a-socket';
+import type { WebSocket } from 'ws';
+
+import { BeanBase } from 'vona';
+import { SocketConnection } from 'vona-module-a-socket';
+
+export interface ISocketConnectionOptionsApp extends IDecoratorSocketConnectionOptions {}
+
+@SocketConnection<ISocketConnectionOptionsApp>({ dependencies: 'a-socket:alive' })
+export class SocketConnectionApp extends BeanBase implements ISocketConnectionExecute {
+  async enter(_ws: WebSocket, _options: ISocketConnectionOptionsApp, next: Next): Promise<void> {
+    // check appReady
+    if (!this.ctx.innerAccess) {
+      if (this.app.meta.appClose) this.app.throw(423);
+      await this.$scope.instance.service.instance.checkAppReady();
+    }
+    // next
+    return next();
+  }
+
+  async exit(_ws: WebSocket, _options: ISocketConnectionOptionsApp, next: Next): Promise<void> {
+    // next
+    return next();
+  }
+}

package/src/bean/socketConnection.cors.ts

@@ -0,0 +1,27 @@
+import type { Next } from 'vona';
+import type { IDecoratorSocketConnectionOptions, ISocketConnectionExecute } from 'vona-module-a-socket';
+import type { WebSocket } from 'ws';
+
+import { BeanBase } from 'vona';
+import { SocketConnection } from 'vona-module-a-socket';
+
+export interface ISocketConnectionOptionsCors extends IDecoratorSocketConnectionOptions {}
+
+@SocketConnection<ISocketConnectionOptionsCors>({ dependencies: 'a-socket:instance' })
+export class SocketConnectionCors extends BeanBase implements ISocketConnectionExecute {
+  async enter(ws: WebSocket, _options: ISocketConnectionOptionsCors, next: Next): Promise<void> {
+    // cors
+    const origin = this.bean.security.checkOrigin(this.ctx.get('origin'), this.ctx.host);
+    if (!origin) {
+      ws.terminate();
+      return;
+    }
+    // next
+    return next();
+  }
+
+  async exit(_ws: WebSocket, _options: ISocketConnectionOptionsCors, next: Next): Promise<void> {
+    // next
+    return next();
+  }
+}

package/src/bean/socketConnection.event.ts

@@ -0,0 +1,34 @@
+import type { Next } from 'vona';
+import type { WebSocket } from 'ws';
+
+import { BeanBase, cast } from 'vona';
+
+import type { IDecoratorSocketConnectionOptions, ISocketConnectionExecute } from '../types/socketConnection.ts';
+import type { ISocketEventRecord } from '../types/socketEvent.ts';
+
+import { SocketConnection } from '../lib/socketConnection.ts';
+import { socketEventRecord } from '../types/socketEvent.ts';
+
+export interface ISocketConnectionOptionsEvent extends IDecoratorSocketConnectionOptions {}
+
+@SocketConnection<ISocketConnectionOptionsEvent>({ dependencies: 'a-socket:cors' })
+export class SocketConnectionEvent extends BeanBase implements ISocketConnectionExecute {
+  async enter(ws: WebSocket, _options: ISocketConnectionOptionsEvent, next: Next): Promise<void> {
+    // sendEvent
+    cast(ws).sendEvent = (eventName: keyof ISocketEventRecord, data, options, cb) => {
+      if (typeof options === 'function') {
+        cb = options;
+        options = {};
+      }
+      const eventNameInner = socketEventRecord[eventName] ?? eventName;
+      ws.send(`${this.scope.config.eventPrefix}${JSON.stringify([eventNameInner, data])}`, options, cb);
+    };
+    // next
+    return next();
+  }
+
+  async exit(_ws: WebSocket, _options: ISocketConnectionOptionsEvent, next: Next): Promise<void> {
+    // next
+    return next();
+  }
+}

package/src/bean/socketConnection.instance.ts

@@ -0,0 +1,23 @@
+import type { Next } from 'vona';
+import type { IDecoratorSocketConnectionOptions, ISocketConnectionExecute } from 'vona-module-a-socket';
+import type { WebSocket } from 'ws';
+
+import { BeanBase } from 'vona';
+import { SocketConnection } from 'vona-module-a-socket';
+
+export interface ISocketConnectionOptionsInstance extends IDecoratorSocketConnectionOptions {}
+
+@SocketConnection<ISocketConnectionOptionsInstance>({ dependencies: 'a-socket:app' })
+export class SocketConnectionInstance extends BeanBase implements ISocketConnectionExecute {
+  async enter(_ws: WebSocket, _options: ISocketConnectionOptionsInstance, next: Next): Promise<void> {
+    // init instance
+    await this.$scope.instance.service.instance.initInstance();
+    // next
+    return next();
+  }
+
+  async exit(_ws: WebSocket, _options: ISocketConnectionOptionsInstance, next: Next): Promise<void> {
+    // next
+    return next();
+  }
+}