vona-module-a-socket 5.0.0 → 5.1.1

package/src/bean/socketConnection.passport.ts

@@ -0,0 +1,37 @@
+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 ISocketConnectionOptionsPassport extends IDecoratorSocketConnectionOptions {}
+
+@SocketConnection<ISocketConnectionOptionsPassport>({ dependencies: 'a-socket:event' })
+export class SocketConnectionPassport extends BeanBase implements ISocketConnectionExecute {
+  async enter(ws: WebSocket, _options: ISocketConnectionOptionsPassport, next: Next): Promise<void> {
+    // checkOauthCode
+    await this._checkOauthCode(ws);
+    // next
+    return next();
+  }
+
+  async exit(_ws: WebSocket, _options: ISocketConnectionOptionsPassport, next: Next): Promise<void> {
+    // next
+    return next();
+  }
+
+  private async _checkOauthCode(_ws: WebSocket) {
+    // auth token
+    if (!this.bean.passport.current) {
+      const code = this.ctx.query[this.scope.config.queryKey.passportCode] as string | undefined;
+      if (code) {
+        await this.bean.passport.checkAuthToken(code, 'access', { path: this.ctx.path });
+      }
+    }
+    // check current
+    if (!this.bean.passport.current) {
+      await this.bean.passport.signinWithAnonymous();
+    }
+  }
+}

package/src/bean/socketConnection.ready.ts

@@ -0,0 +1,21 @@
+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 ISocketConnectionOptionsReady extends IDecoratorSocketConnectionOptions {}
+
+@SocketConnection<ISocketConnectionOptionsReady>({ dependencies: 'a-socket:passport' })
+export class SocketConnectionReady extends BeanBase implements ISocketConnectionExecute {
+  async enter(_ws: WebSocket, _options: ISocketConnectionOptionsReady, next: Next): Promise<void> {
+    // next
+    return next();
+  }
+
+  async exit(_ws: WebSocket, _options: ISocketConnectionOptionsReady, next: Next): Promise<void> {
+    // next
+    return next();
+  }
+}

package/src/bean/socketPacket.event.ts

@@ -0,0 +1,29 @@
+import type { Next } from 'vona';
+import type { WebSocket } from 'ws';
+
+import { BeanBase } from 'vona';
+
+import type { TypeSocketPacketEvent } from '../types/socketEvent.ts';
+import type { IDecoratorSocketPacketOptions, ISocketPacketExecute } from '../types/socketPacket.ts';
+
+import { SocketPacket } from '../lib/socketPacket.ts';
+import { socketEventRecordReverse } from '../types/socketEvent.ts';
+
+export interface ISocketPacketOptionsEvent extends IDecoratorSocketPacketOptions {}
+
+@SocketPacket<ISocketPacketOptionsEvent>()
+export class SocketPacketEvent extends BeanBase implements ISocketPacketExecute {
+  async execute(data: any, _ws: WebSocket, _options: ISocketPacketOptionsEvent, next: Next): Promise<void> {
+    let packet: TypeSocketPacketEvent;
+    const eventPrefix = this.scope.config.eventPrefix;
+    if (typeof data === 'string' && data.startsWith(eventPrefix)) {
+      const packetInner = JSON.parse(data.substring(eventPrefix.length));
+      const eventName = socketEventRecordReverse[packetInner[0]] ?? packetInner[0];
+      packet = [eventName, packetInner[1]];
+    } else {
+      packet = [undefined, data];
+    }
+    // next
+    return next(packet);
+  }
+}

package/src/bean/socketPacket.performAction.ts

@@ -0,0 +1,37 @@
+import type { Next } from 'vona';
+import type { WebSocket } from 'ws';
+
+import { BeanBase } from 'vona';
+
+import type {
+  ISocketEventPerformActionOptionsInner,
+  ISocketEventRecord,
+  ISocketEventRecordSystem,
+  TypeSocketPacketEvent,
+} from '../types/socketEvent.ts';
+import type { IDecoratorSocketPacketOptions, ISocketPacketExecute } from '../types/socketPacket.ts';
+
+import { SocketPacket } from '../lib/socketPacket.ts';
+
+export interface ISocketPacketOptionsPerformAction extends IDecoratorSocketPacketOptions {}
+
+@SocketPacket<ISocketPacketOptionsPerformAction>({ dependencies: 'a-socket:event' })
+export class SocketPacketPerformAction extends BeanBase implements ISocketPacketExecute {
+  async execute(packet: TypeSocketPacketEvent, ws: WebSocket, _options: ISocketPacketOptionsPerformAction, next: Next): Promise<void> {
+    const eventName: keyof ISocketEventRecord | undefined = packet[0];
+    const data: ISocketEventPerformActionOptionsInner = packet[1];
+    if (eventName !== ('sysPerformAction' satisfies keyof ISocketEventRecordSystem)) return next();
+    try {
+      // performAction
+      const res = await this.$scope.executor.service.executor.performActionInner(data.m, data.p as never, {
+        innerAccess: false,
+        query: data.q,
+        body: data.b,
+        headers: data.h,
+      });
+      ws.sendEvent('sysPerformActionBack' satisfies keyof ISocketEventRecordSystem as never, { i: data.i, c: 0, d: res } as never);
+    } catch (err: any) {
+      ws.sendEvent('sysPerformActionBack' satisfies keyof ISocketEventRecordSystem as never, { i: data.i, c: err.code, m: err.message } as never);
+    }
+  }
+}

package/src/config/config.ts

@@ -0,0 +1,19 @@
+import type { VonaApplication } from 'vona';
+
+import { $customKey } from 'vona';
+
+export function config(_app: VonaApplication) {
+  return {
+    eventPrefix: '_:',
+    globalPrefix: '/ws',
+    queryKey: {
+      passportCode: $customKey('x-vona-passport-code'),
+      instanceName: $customKey('x-vona-instance-name'),
+      locale: $customKey('x-vona-locale'),
+      tz: $customKey('x-vona-tz'),
+    },
+    timeout: {
+      ping: 20000,
+    },
+  };
+}

package/src/index.ts

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

package/src/lib/beanSocketNamespaceBase.ts

@@ -0,0 +1,15 @@
+import { BeanBase, cast } from 'vona';
+
+import type { ISendEventOptions } from '../types/socketEvent.ts';
+import type { IDecoratorSocketNamespaceOptions } from '../types/socketNamespace.ts';
+
+export class BeanSocketNamespaceBase<EVENTS extends {}> extends BeanBase {
+  send<K extends keyof EVENTS>(id: string, eventName: K, data?: EVENTS[K], options?: ISendEventOptions) {
+    this.$scope.socket.service.socketEvent.send(id, eventName, data, options);
+  }
+
+  broadcast<K extends keyof EVENTS>(eventName: K, data?: EVENTS[K], options?: ISendEventOptions) {
+    const namespace = cast<IDecoratorSocketNamespaceOptions>(this.$onionOptions).namespace;
+    this.$scope.socket.service.socketEvent.broadcast(namespace, eventName, data, options);
+  }
+}

package/src/lib/const.ts

@@ -0,0 +1,22 @@
+import type { VonaApplication } from 'vona';
+
+export const SymbolCacheSocketConnections = Symbol('SymbolCacheSocketConnections');
+export const SymbolCacheSocketPackets = Symbol('SymbolCacheSocketPackets');
+
+export function getCacheSocketConnections(app: VonaApplication) {
+  if (!app.meta[SymbolCacheSocketConnections]) app.meta[SymbolCacheSocketConnections] = {};
+  return app.meta[SymbolCacheSocketConnections];
+}
+
+export function clearAllCacheSocketConnections(app: VonaApplication) {
+  delete app.meta[SymbolCacheSocketConnections];
+}
+
+export function getCacheSocketPackets(app: VonaApplication) {
+  if (!app.meta[SymbolCacheSocketPackets]) app.meta[SymbolCacheSocketPackets] = {};
+  return app.meta[SymbolCacheSocketPackets];
+}
+
+export function clearAllCacheSocketPackets(app: VonaApplication) {
+  delete app.meta[SymbolCacheSocketPackets];
+}

package/src/lib/index.ts

@@ -0,0 +1,5 @@
+export * from './beanSocketNamespaceBase.ts';
+export * from './const.ts';
+export * from './socketConnection.ts';
+export * from './socketNamespace.ts';
+export * from './socketPacket.ts';

package/src/lib/socketConnection.ts

@@ -0,0 +1,7 @@
+import { createBeanDecorator } from 'vona';
+
+import type { IDecoratorSocketConnectionOptions } from '../types/socketConnection.ts';
+
+export function SocketConnection<T extends IDecoratorSocketConnectionOptions>(options?: T): ClassDecorator {
+  return createBeanDecorator('socketConnection', options);
+}

package/src/lib/socketNamespace.ts

@@ -0,0 +1,9 @@
+import type { PowerPartial } from 'vona';
+
+import { createBeanDecorator } from 'vona';
+
+import type { IDecoratorSocketNamespaceOptions } from '../types/socketNamespace.ts';
+
+export function SocketNamespace<T extends IDecoratorSocketNamespaceOptions>(options?: PowerPartial<T>): ClassDecorator {
+  return createBeanDecorator('socketNamespace', options);
+}

package/src/lib/socketPacket.ts

@@ -0,0 +1,7 @@
+import { createBeanDecorator } from 'vona';
+
+import type { IDecoratorSocketPacketOptions } from '../types/socketPacket.ts';
+
+export function SocketPacket<T extends IDecoratorSocketPacketOptions>(options?: T): ClassDecorator {
+  return createBeanDecorator('socketPacket', options);
+}

package/src/monkey.ts

@@ -0,0 +1,15 @@
+import type { IMonkeyAppClose, IMonkeyAppReady } from 'vona';
+
+import { BeanSimple } from 'vona';
+
+import { __ThisModule__ } from './.metadata/this.ts';
+
+export class Monkey extends BeanSimple implements IMonkeyAppReady, IMonkeyAppClose {
+  async appReady() {
+    await this.app.scope(__ThisModule__).service.socket.appReady();
+  }
+
+  async appClose() {
+    await this.app.scope(__ThisModule__).service.socket.appClose();
+  }
+}

package/src/service/socket.ts

@@ -0,0 +1,180 @@
+import type { IncomingMessage } from 'node:http';
+import type { IInstanceRecord, ILocaleRecord, Next } from 'vona';
+import type { IOnionSlice } from 'vona-module-a-onion';
+
+import { compose } from '@cabloy/compose';
+import { AsyncResource } from 'node:async_hooks';
+import { URL } from 'node:url';
+import { BeanBase, uuidv4 } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { WebSocket, WebSocketServer } from 'ws';
+
+import type {
+  ISocketConnectionComposeData,
+  ISocketConnectionExecute,
+  ISocketConnectionRecord,
+  ISocketPacketComposeData,
+} from '../types/socketConnection.ts';
+import type { ISocketEventRecordSystem } from '../types/socketEvent.ts';
+import type { ISocketNamespaceRecord } from '../types/socketNamespace.ts';
+import type { ISocketPacketExecute, ISocketPacketRecord } from '../types/socketPacket.ts';
+
+import { getCacheSocketConnections, getCacheSocketPackets } from '../lib/const.ts';
+
+@Service()
+export class ServiceSocket extends BeanBase {
+  async appReady() {
+    // maybe running in play
+    if (!this.app.server) return;
+    // wss
+    this.app.wss = new WebSocketServer({ server: this.app.server });
+    this.app.wss.on('connection', (ws, req) => {
+      this._onConnection(ws, req);
+    });
+  }
+
+  async appClose() {
+    this.app.wss.close();
+    this.bean.socket.close();
+  }
+
+  private async _onConnection(ws: WebSocket, req: IncomingMessage) {
+    if (this.app.meta.appClose) {
+      // terminate
+      ws.terminate();
+      return;
+    }
+    const url = URL.parse(req.url ?? '', `https://${req.headers.host}`); // req.headers.host 'http://localhost'
+    const instanceName = (url?.searchParams.get(this.scope.config.queryKey.instanceName) || undefined) as keyof IInstanceRecord | undefined;
+    const locale = (url?.searchParams.get(this.scope.config.queryKey.locale) || undefined) as keyof ILocaleRecord | undefined;
+    const tz = (url?.searchParams.get(this.scope.config.queryKey.tz) || undefined) as string | undefined;
+    // enter
+    return await this.app.bean.executor.newCtx(
+      async () => {
+        const ctx = this.app.ctx;
+        // ws
+        Object.defineProperty(ctx, 'ws', {
+          get() {
+            return ws;
+          },
+        });
+        // enter
+        try {
+          // namespace
+          ws.namespace = this.getNamespace();
+          // id
+          ws.id = uuidv4();
+          // add
+          this.bean.socket.addClient(ws);
+          // compose
+          await this._getComposeSocketConnections(ws.namespace)({ method: 'enter', ws });
+        } catch (err: any) {
+          this.app.handleError(err);
+          // terminate
+          ws.terminate();
+          return;
+        }
+        // promise
+        return new Promise(resolve => {
+          // exit
+          ws.onclose = AsyncResource.bind(async () => {
+            try {
+              // compose
+              await this._getComposeSocketConnections(ws.namespace)({ method: 'exit', ws });
+            } catch (err: any) {
+              this.app.handleError(err);
+            } finally {
+              // remove
+              this.bean.socket.removeClient(ws);
+              resolve(undefined);
+            }
+          });
+          // message
+          ws.onmessage = AsyncResource.bind(async event => {
+            try {
+              await this._getComposeSocketPackets(ws.namespace)({ data: event.data, ws });
+            } catch (err: any) {
+              this.app.handleError(err);
+            }
+          });
+          // error
+          ws.onerror = AsyncResource.bind(event => {
+            this.$logger.error(event.error);
+          });
+          // onReady
+          ws.sendEvent('sysReady' satisfies keyof ISocketEventRecordSystem as never);
+        });
+      },
+      { dbInfo: { level: 0 }, innerAccess: false, req, instanceName, locale, tz },
+    ); // not set instance: true
+  }
+
+  public getNamespace(): keyof ISocketNamespaceRecord {
+    const globalPrefix = this.scope.config.globalPrefix;
+    let path = this.ctx.path;
+    if (path.startsWith(globalPrefix)) {
+      path = path.substring(globalPrefix.length);
+    }
+    if (!path) path = '/';
+    return path as keyof ISocketNamespaceRecord;
+  }
+
+  private _getComposeSocketConnections(namespace: keyof ISocketNamespaceRecord) {
+    const cacheSocketConnections = getCacheSocketConnections(this.app);
+    if (!cacheSocketConnections[namespace]) {
+      const connections = this.bean.onion.socketConnection.getOnionsEnabledWrapped(item => {
+        return this._wrapOnionConnection(item);
+      });
+      cacheSocketConnections[namespace] = compose(connections);
+    }
+    return cacheSocketConnections[namespace];
+  }
+
+  private _getComposeSocketPackets(namespace: keyof ISocketNamespaceRecord) {
+    const cacheSocketPackets = getCacheSocketPackets(this.app);
+    if (!cacheSocketPackets[namespace]) {
+      const packets = this.bean.onion.socketPacket.getOnionsEnabledWrapped(item => {
+        return this._wrapOnionPacket(item);
+      });
+      cacheSocketPackets[namespace] = compose(packets);
+    }
+    return cacheSocketPackets[namespace];
+  }
+
+  private _wrapOnionConnection<T extends keyof ISocketConnectionRecord>(item: IOnionSlice<ISocketConnectionRecord, T>) {
+    const fn = (data: ISocketConnectionComposeData, next: Next) => {
+      const options = item.beanOptions.options!;
+      // execute
+      const beanFullName = item.beanOptions.beanFullName;
+      const beanInstance = this.app.bean._getBean<ISocketConnectionExecute>(beanFullName as any);
+      if (!beanInstance) {
+        throw new Error(`socketConnection bean not found: ${beanFullName}`);
+      }
+      return beanInstance[data.method](data.ws, options, next);
+    };
+    fn._name = item.name;
+    return fn;
+  }
+
+  private _wrapOnionPacket<T extends keyof ISocketPacketRecord>(item: IOnionSlice<ISocketPacketRecord, T>) {
+    const fn = (data: ISocketPacketComposeData, next: Next) => {
+      const options = item.beanOptions.options!;
+      // execute
+      const beanFullName = item.beanOptions.beanFullName;
+      const beanInstance = this.app.bean._getBean<ISocketPacketExecute>(beanFullName as any);
+      if (!beanInstance) {
+        throw new Error(`socketPacket bean not found: ${beanFullName}`);
+      }
+      return beanInstance.execute(data.data, data.ws, options, _patchPacketNext(data, next));
+    };
+    fn._name = item.name;
+    return fn;
+  }
+}
+
+function _patchPacketNext(data: ISocketPacketComposeData, next) {
+  return (...args) => {
+    const context = args.length === 0 ? data.data : args[0];
+    return next({ data: context, ws: data.ws });
+  };
+}

package/src/service/socketEvent.ts

@@ -0,0 +1,30 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { ISendEventOptions } from '../types/socketEvent.ts';
+import type { ISocketNamespaceRecord } from '../types/socketNamespace.ts';
+
+@Service()
+export class ServiceSocketEvent extends BeanBase {
+  send(id: string, eventName: PropertyKey, data?: unknown, options?: ISendEventOptions) {
+    this.sendWorker(id, eventName, data, options);
+    this.scope.broadcast.send.emit({ id, eventName, data, options });
+  }
+
+  sendWorker(id: string, eventName: PropertyKey, data?: unknown, options?: ISendEventOptions) {
+    this.bean.socket.clients[id]?.sendEvent(eventName, data, options);
+  }
+
+  broadcast(namespace: keyof ISocketNamespaceRecord, eventName: PropertyKey, data?: unknown, options?: ISendEventOptions) {
+    this.broadcastWorker(namespace, eventName, data, options);
+    this.scope.broadcast.broadcast.emit({ namespace, eventName, data, options });
+  }
+
+  broadcastWorker(namespace: keyof ISocketNamespaceRecord, eventName: PropertyKey, data?: unknown, options?: ISendEventOptions) {
+    const ids = this.bean.socket.clientsNamespace[namespace];
+    if (!ids) return;
+    for (const id of ids) {
+      this.bean.socket.clients[id]?.sendEvent(eventName, data, options);
+    }
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,5 @@
+export * from './socket.ts';
+export * from './socketConnection.ts';
+export * from './socketEvent.ts';
+export * from './socketNamespace.ts';
+export * from './socketPacket.ts';

package/src/types/socket.ts

@@ -0,0 +1,21 @@
+import type { WebSocket, WebSocketServer } from 'ws';
+
+import type { ISocketNamespaceRecord } from './socketNamespace.ts';
+
+declare module 'vona' {
+  export interface VonaApplication {
+    wss: WebSocketServer;
+  }
+
+  export interface VonaContext {
+    get ws(): WebSocket;
+  }
+}
+
+declare module 'ws' {
+  export interface WebSocket {
+    namespace: keyof ISocketNamespaceRecord;
+    id: string;
+    isAlive: boolean;
+  }
+}

package/src/types/socketConnection.ts

@@ -0,0 +1,41 @@
+import type { Next, OmitNever } from 'vona';
+import type { IOnionOptionsDeps, ServiceOnion, TypeOnionOptionsBaseSimple } from 'vona-module-a-onion';
+import type { WebSocket } from 'ws';
+
+import type { ISocketNamespaceRecord } from './socketNamespace.ts';
+
+export interface ISocketConnectionRecord {}
+
+export interface ISocketConnectionExecute {
+  enter: (ws: WebSocket, options: IDecoratorSocketConnectionOptions, next: Next) => Promise<void>;
+  exit: (ws: WebSocket, options: IDecoratorSocketConnectionOptions, next: Next) => Promise<void>;
+}
+
+export interface IDecoratorSocketConnectionOptions
+  extends TypeOnionOptionsBaseSimple<keyof ISocketNamespaceRecord>, IOnionOptionsDeps<keyof ISocketConnectionRecord> {}
+
+export interface ISocketConnectionComposeData {
+  method: 'enter' | 'exit';
+  ws: WebSocket;
+}
+
+export interface ISocketPacketComposeData {
+  data: any;
+  ws: WebSocket;
+}
+
+declare module 'vona-module-a-onion' {
+  export interface BeanOnion {
+    socketConnection: ServiceOnion<ISocketConnectionRecord>;
+  }
+}
+
+declare module 'vona' {
+  export interface ConfigOnions {
+    socketConnection: OmitNever<ISocketConnectionRecord>;
+  }
+
+  export interface IBeanSceneRecord {
+    socketConnection: never;
+  }
+}

package/src/types/socketEvent.ts

@@ -0,0 +1,55 @@
+export interface ISocketEventRecordSystem {
+  sysReady: never;
+  sysPerformAction: never;
+  sysPerformActionBack: never;
+}
+
+export interface ISocketEventRecord {}
+
+export const socketEventRecord = {
+  sysReady: '_a',
+  sysPerformAction: '_b',
+  sysPerformActionBack: '_c',
+};
+export const socketEventRecordReverse = {
+  _a: 'sysReady',
+  _b: 'sysPerformAction',
+  _c: 'sysPerformActionBack',
+};
+
+export type TypeSocketEventPerformActionMethod = 'get' | 'post' | 'delete' | 'put' | 'patch';
+export interface ISocketEventPerformActionOptions {
+  method: TypeSocketEventPerformActionMethod;
+  path: string;
+  body?: any;
+  headers?: object;
+}
+export interface ISocketEventPerformActionOptionsInner {
+  i: number;
+  m: TypeSocketEventPerformActionMethod;
+  q?: object;
+  p: string;
+  b?: any;
+  h?: object;
+}
+
+export type TypeSocketPacketEvent<K extends keyof ISocketEventRecord = never> = [K | undefined, ISocketEventRecord[K] | any];
+
+export interface ISendEventOptions {
+  mask?: boolean | undefined;
+  binary?: boolean | undefined;
+  compress?: boolean | undefined;
+  fin?: boolean | undefined;
+}
+
+declare module 'ws' {
+  export interface WebSocket {
+    sendEvent<K extends keyof ISocketEventRecord>(
+      eventName: K | PropertyKey,
+      data?: ISocketEventRecord[K] | any,
+      options?: ISendEventOptions,
+      cb?: (err?: Error) => void,
+    ): void;
+    sendEvent<K extends keyof ISocketEventRecord>(eventName: K | PropertyKey, data?: ISocketEventRecord[K] | any, cb?: (err?: Error) => void): void;
+  }
+}

package/src/types/socketNamespace.ts

@@ -0,0 +1,27 @@
+import type { OmitNever } from 'vona';
+import type { ServiceOnion } from 'vona-module-a-onion';
+
+export interface ISocketNamespaceRecord {
+  '/': never;
+}
+
+export interface IDecoratorSocketNamespaceOptions<Events extends {} = {}> {
+  namespace: keyof ISocketNamespaceRecord;
+  events: Events;
+}
+
+declare module 'vona-module-a-onion' {
+  export interface BeanOnion {
+    socketNamespace: ServiceOnion<ISocketNamespaceRecord>;
+  }
+}
+
+declare module 'vona' {
+  export interface ConfigOnions {
+    socketNamespace: OmitNever<ISocketNamespaceRecord>;
+  }
+
+  export interface IBeanSceneRecord {
+    socketNamespace: never;
+  }
+}

package/src/types/socketPacket.ts

@@ -0,0 +1,30 @@
+import type { Next, OmitNever } from 'vona';
+import type { IOnionOptionsDeps, ServiceOnion, TypeOnionOptionsBaseSimple } from 'vona-module-a-onion';
+import type { WebSocket } from 'ws';
+
+import type { ISocketNamespaceRecord } from './socketNamespace.ts';
+
+export interface ISocketPacketRecord {}
+
+export interface ISocketPacketExecute {
+  execute: (data: any, ws: WebSocket, options: IDecoratorSocketPacketOptions, next: Next) => Promise<void>;
+}
+
+export interface IDecoratorSocketPacketOptions
+  extends TypeOnionOptionsBaseSimple<keyof ISocketNamespaceRecord>, IOnionOptionsDeps<keyof ISocketPacketRecord> {}
+
+declare module 'vona-module-a-onion' {
+  export interface BeanOnion {
+    socketPacket: ServiceOnion<ISocketPacketRecord>;
+  }
+}
+
+declare module 'vona' {
+  export interface ConfigOnions {
+    socketPacket: OmitNever<ISocketPacketRecord>;
+  }
+
+  export interface IBeanSceneRecord {
+    socketPacket: never;
+  }
+}

package/README.md

@@ -1 +0,0 @@
-# @cabloy/set