akanjs 0.0.1 → 2.0.0-beta.0

package/signal/endpointInfo.ts

@@ -0,0 +1,374 @@
+import {
+  arraiedModel,
+  type Cls,
+  type Dayjs,
+  type EnumInstance,
+  getNonArrayModel,
+  isEnum,
+  type PromiseOrObject,
+} from "akanjs/base";
+import type {
+  ConstantFieldType,
+  ConstantFieldTypeInput,
+  DocumentModel,
+  FieldToValue,
+  ParamFieldType,
+  PlainTypeToFieldType,
+  PurifiedModel,
+} from "akanjs/constant";
+import type { ServiceModel } from "akanjs/service";
+import type { InternalArgCls } from "./internalArg";
+import type { ArgType, SignalOption } from "./types";
+
+export type EndpointType = "query" | "mutation" | "pubsub" | "message";
+
+export interface EndpointArgProps<Optional extends boolean = false> {
+  nullable?: Optional;
+  example?: string | number | boolean | Dayjs;
+}
+export interface InternalArgProps<Optional extends boolean = false> {
+  nullable?: Optional;
+}
+
+export interface ReturnInfo<Returns extends ConstantFieldTypeInput = any, Nullable extends boolean = false> {
+  returnRef: Returns;
+  arrDepth: number;
+  enum?: EnumInstance;
+  nullable?: Nullable;
+}
+
+export interface ArgInfo<ArgProps = any> {
+  type: ArgType;
+  name: string;
+  argRef: ConstantFieldType;
+  arrDepth: number;
+  enum?: EnumInstance;
+  option?: ArgProps;
+}
+export interface InternalArgInfo<Optional extends boolean = false> {
+  argRef: InternalArgCls;
+  option?: InternalArgProps<Optional>;
+}
+export class EndpointInfo<
+  ReqType extends EndpointType = EndpointType,
+  Srvs extends { [key: string]: any } = { [key: string]: any },
+  ArgNames extends string[] = any,
+  Args extends any[] = any,
+  InternalArgs extends any[] = any,
+  ServerArgs extends any[] = any,
+  Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput,
+  ClientReturns = never,
+  ServerReturns = never,
+  Nullable extends boolean = boolean,
+> {
+  readonly type: ReqType;
+  readonly argNames: ArgNames = [] as unknown as ArgNames;
+  readonly args: ArgInfo<EndpointArgProps<boolean>>[] = [];
+  readonly internalArgs: InternalArgInfo<boolean>[] = [];
+  readonly returns: ReturnInfo<Returns, Nullable>;
+  readonly signalOption: SignalOption<Returns, Nullable, any>;
+  execFn: ((...args: [...ServerArgs, ...InternalArgs]) => PromiseOrObject<any>) | null = null;
+  static getArgInfo(
+    type: ArgType,
+    name: string,
+    arg: ConstantFieldTypeInput,
+    option?: EndpointArgProps<boolean>,
+  ): ArgInfo {
+    const [singleArg, arrDepth] = getNonArrayModel(arg as Cls);
+    const isArgEnum = isEnum(singleArg);
+    const argRef = isArgEnum ? (singleArg as EnumInstance).type : singleArg;
+    return {
+      type,
+      name,
+      argRef: argRef as ConstantFieldType,
+      arrDepth,
+      enum: isArgEnum ? (singleArg as EnumInstance) : undefined,
+      option,
+    };
+  }
+  static getReturnInfo<
+    Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput,
+    Nullable extends boolean = false,
+  >(modelRef: Returns, signalOption: SignalOption<Returns, Nullable> = {}): ReturnInfo<Returns, Nullable> {
+    const [singleReturn, arrDepth] = getNonArrayModel(modelRef as Cls);
+    const isReturnEnum = isEnum(singleReturn);
+    const returnRef = isReturnEnum ? (singleReturn as EnumInstance).type : singleReturn;
+    return {
+      returnRef: returnRef as Returns,
+      arrDepth,
+      enum: isReturnEnum ? (singleReturn as EnumInstance) : undefined,
+      nullable: (signalOption.nullable ?? false) as Nullable,
+    };
+  }
+
+  constructor(type: ReqType, returnRef: Returns, signalOption: SignalOption<Returns, Nullable> = {}) {
+    this.type = type;
+    this.returns = EndpointInfo.getReturnInfo(returnRef, signalOption);
+    this.signalOption = signalOption;
+  }
+  param<
+    ArgName extends string,
+    Arg extends ParamFieldType,
+    _ClientArg = FieldToValue<Arg>,
+    _ServerArg = DocumentModel<_ClientArg>,
+  >(name: string, arg: Arg, option?: Omit<EndpointArgProps, "nullable">) {
+    if (this.execFn) throw new Error("Query function is already set");
+    else if (this.args.at(-1)?.option?.nullable) throw new Error("Last argument is nullable");
+    this.argNames.push(name);
+    this.args.push(EndpointInfo.getArgInfo("param", name, arg, option));
+    return this as unknown as EndpointInfo<
+      ReqType,
+      Srvs,
+      [...ArgNames, ArgName],
+      [...Args, arg: _ClientArg],
+      InternalArgs,
+      [...ServerArgs, arg: _ServerArg],
+      Returns,
+      ClientReturns,
+      ServerReturns,
+      Nullable
+    >;
+  }
+  body<
+    ArgName extends string,
+    ExplicitType = unknown,
+    Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>,
+    Optional extends boolean = false,
+    _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType,
+    _ClientArg = PurifiedModel<_ArgType>,
+    _ServerArg = DocumentModel<_ArgType>,
+  >(name: ArgName, arg: Arg, option?: EndpointArgProps<Optional>) {
+    if (this.execFn) throw new Error("Query function is already set");
+    this.argNames.push(name);
+    this.args.push(EndpointInfo.getArgInfo("body", name, arg, option));
+    return this as unknown as EndpointInfo<
+      ReqType,
+      Srvs,
+      [...ArgNames, ArgName],
+      Optional extends true ? [...Args, arg?: _ClientArg | null] : [...Args, arg: _ClientArg],
+      InternalArgs,
+      [...ServerArgs, arg: _ServerArg | (Optional extends true ? undefined : never)],
+      Returns,
+      ClientReturns,
+      ServerReturns,
+      Nullable
+    >;
+  }
+  room<
+    ArgName extends string,
+    ExplicitType = unknown,
+    Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>,
+    _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType,
+    _ClientArg = PurifiedModel<_ArgType>,
+    _ServerArg = DocumentModel<_ArgType>,
+  >(name: string, arg: Arg, option?: Omit<EndpointArgProps, "nullable">) {
+    if (this.execFn) throw new Error("Query function is already set");
+    else if (this.args.at(-1)?.option?.nullable) throw new Error("Last argument is nullable");
+    this.argNames.push(name);
+    this.args.push(EndpointInfo.getArgInfo("room", name, arg, option));
+    return this as unknown as EndpointInfo<
+      ReqType,
+      Srvs,
+      [...ArgNames, ArgName],
+      [...Args, arg: _ClientArg],
+      InternalArgs,
+      [...ServerArgs, arg: _ServerArg],
+      Returns,
+      ClientReturns,
+      ServerReturns,
+      Nullable
+    >;
+  }
+  msg<
+    ArgName extends string,
+    ExplicitType = unknown,
+    Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>,
+    Optional extends boolean = false,
+    _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType,
+    _ClientArg = PurifiedModel<_ArgType>,
+    _ServerArg = DocumentModel<_ArgType>,
+  >(name: string, arg: Arg, option?: EndpointArgProps<Optional>) {
+    if (this.execFn) throw new Error("Query function is already set");
+    else if (this.args.at(-1)?.option?.nullable) throw new Error("Last argument is nullable");
+    this.argNames.push(name);
+    this.args.push(EndpointInfo.getArgInfo("msg", name, arg, option));
+    return this as unknown as EndpointInfo<
+      ReqType,
+      Srvs,
+      [...ArgNames, ArgName],
+      Optional extends true ? [...Args, arg?: _ClientArg | null] : [...Args, arg: _ClientArg],
+      InternalArgs,
+      [...ServerArgs, arg: _ServerArg | (Optional extends true ? undefined : never)],
+      Returns,
+      ClientReturns,
+      ServerReturns,
+      Nullable
+    >;
+  }
+  search<
+    ArgName extends string,
+    ExplicitType = unknown,
+    Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>,
+    _ArgType = unknown extends ExplicitType ? FieldToValue<Arg> : ExplicitType,
+    _ClientArg = PurifiedModel<_ArgType>,
+    _ServerArg = DocumentModel<_ArgType>,
+  >(name: string, arg: Arg, option?: Omit<EndpointArgProps, "nullable">) {
+    if (this.execFn) throw new Error("Query function is already set");
+    this.argNames.push(name);
+    this.args.push(EndpointInfo.getArgInfo("search", name, arg, { ...option, nullable: true }));
+    return this as unknown as EndpointInfo<
+      ReqType,
+      Srvs,
+      [...ArgNames, ArgName],
+      [...Args, arg?: _ClientArg | null],
+      InternalArgs,
+      [...ServerArgs, arg: _ServerArg | undefined],
+      Returns,
+      ClientReturns,
+      ServerReturns,
+      Nullable
+    >;
+  }
+  _addArgs(args: ArgInfo<EndpointArgProps<boolean>>[]) {
+    for (const arg of args) {
+      const argRef = arraiedModel(arg.enum ?? arg.argRef, arg.arrDepth);
+      switch (arg.type) {
+        case "param":
+          this.param(arg.name, argRef as ParamFieldType, arg.option);
+          break;
+        case "body":
+          this.body(arg.name, argRef, arg.option);
+          break;
+        case "search":
+          this.search(arg.name, argRef, arg.option);
+          break;
+        case "room":
+          this.room(arg.name, argRef, arg.option);
+          break;
+        case "msg":
+          this.msg(arg.name, argRef, arg.option);
+          break;
+        default:
+          throw new Error(`Invalid argument type: ${arg.type}`);
+      }
+    }
+    return this;
+  }
+  with<ArgType, Optional extends boolean = false>(
+    argRef: InternalArgCls<ArgType>,
+    option?: InternalArgProps<Optional>,
+  ) {
+    if (this.execFn) throw new Error("Query function is already set");
+    this.internalArgs.push({ argRef, option });
+    return this as unknown as EndpointInfo<
+      ReqType,
+      Srvs,
+      ArgNames,
+      Args,
+      [...InternalArgs, arg: NonNullable<ArgType> | (Optional extends true ? null : never)],
+      ServerArgs,
+      Returns,
+      ClientReturns,
+      ServerReturns,
+      Nullable
+    >;
+  }
+  _addInternalArgs(args: InternalArgInfo<boolean>[]) {
+    for (const arg of args) this.with(arg.argRef, arg.option);
+    return this;
+  }
+  exec<
+    ExecFn extends (
+      this: Srvs,
+      ...args: [...ServerArgs, ...InternalArgs]
+    ) => ReqType extends "pubsub"
+      ? Promise<void> | void
+      : PromiseOrObject<DocumentModel<FieldToValue<Returns>> | (Nullable extends true ? null | undefined : never)>,
+  >(
+    execFn: ExecFn,
+  ): EndpointInfo<
+    ReqType,
+    Srvs,
+    ArgNames,
+    Args,
+    InternalArgs,
+    ServerArgs,
+    Returns,
+    FieldToValue<Returns>,
+    ReturnType<ExecFn>,
+    Nullable
+  > {
+    if (this.execFn) throw new Error("Query function is already set");
+    this.execFn = execFn;
+    return this as unknown as EndpointInfo<
+      ReqType,
+      Srvs,
+      ArgNames,
+      Args,
+      InternalArgs,
+      ServerArgs,
+      Returns,
+      FieldToValue<Returns>,
+      ReturnType<ExecFn>,
+      Nullable
+    >;
+  }
+
+  getPath(key: string) {
+    if (this.signalOption.path) return `${this.signalOption.path.startsWith("/") ? "" : "/"}${this.signalOption.path}`;
+    else
+      return `/${[
+        this.signalOption.name ?? key,
+        ...this.args.filter((arg) => arg.type === "param").map((arg) => `:${arg.name}`),
+      ].join("/")}`;
+  }
+}
+
+export type BuildEndpoint<SrvModule extends ServiceModel = ServiceModel> = {
+  query: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(
+    returnRef: Returns,
+    signalOption?: SignalOption<Returns, Nullable>,
+  ) => EndpointInfo<"query", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+  mutation: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(
+    returnRef: Returns,
+    signalOption?: SignalOption<Returns, Nullable>,
+  ) => EndpointInfo<"mutation", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+  pubsub: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(
+    returnRef: Returns,
+    signalOption?: SignalOption<Returns, Nullable>,
+  ) => EndpointInfo<"pubsub", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+  message: <Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput, Nullable extends boolean = false>(
+    returnRef: Returns,
+    signalOption?: SignalOption<Returns, Nullable>,
+  ) => EndpointInfo<"message", SrvModule["srvMap"], [], [], [], [], Returns, never, never, Nullable>;
+};
+
+export const buildEndpoint = {
+  query: (returnRef: Cls, signalOption?: SignalOption<Cls>) => new EndpointInfo("query", returnRef, signalOption),
+  mutation: (returnRef: Cls, signalOption?: SignalOption<Cls>) => new EndpointInfo("mutation", returnRef, signalOption),
+  pubsub: (returnRef: Cls, signalOption?: SignalOption<Cls>) => new EndpointInfo("pubsub", returnRef, signalOption),
+  message: (returnRef: Cls, signalOption?: SignalOption<Cls>) => new EndpointInfo("message", returnRef, signalOption),
+} as unknown as BuildEndpoint<any>;
+
+export type EndpointBuilder<SrvModule extends ServiceModel = ServiceModel> = (builder: BuildEndpoint<SrvModule>) => {
+  [key: string]: EndpointInfo;
+};
+
+export type EndpInfoReqType<E> =
+  E extends EndpointInfo<infer T, any, any, any, any, any, any, any, any, any> ? T : never;
+export type EndpInfoSrvs<E> = E extends EndpointInfo<any, infer S, any, any, any, any, any, any, any, any> ? S : never;
+export type EndpInfoArgNames<E> =
+  E extends EndpointInfo<any, any, infer N, any, any, any, any, any, any, any> ? N : never;
+export type EndpInfoArgs<E> = E extends EndpointInfo<any, any, any, infer A, any, any, any, any, any, any> ? A : never;
+export type EndpInfoInternalArgs<E> =
+  E extends EndpointInfo<any, any, any, any, infer I, any, any, any, any, any> ? I : never;
+export type EndpInfoServerArgs<E> =
+  E extends EndpointInfo<any, any, any, any, any, infer S, any, any, any, any> ? S : never;
+export type EndpInfoReturnRef<E> =
+  E extends EndpointInfo<any, any, any, any, any, any, infer R, any, any, any> ? R : never;
+export type EndpInfoClientReturns<E> =
+  E extends EndpointInfo<any, any, any, any, any, any, any, infer R, any, any> ? R : never;
+export type EndpInfoServerReturns<E> =
+  E extends EndpointInfo<any, any, any, any, any, any, any, any, infer R, any> ? R : never;
+export type EndpInfoNullable<E> =
+  E extends EndpointInfo<any, any, any, any, any, any, any, any, any, infer N> ? N : never;

package/signal/exception.ts

@@ -0,0 +1,50 @@
+export class Exception extends Error {
+  constructor(
+    public readonly statusCode: number,
+    message: string,
+    public readonly details?: unknown,
+    public readonly data?: unknown,
+  ) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+
+  toJSON() {
+    return {
+      error: this.message,
+      statusCode: this.statusCode,
+      ...(this.details !== undefined ? { details: this.details } : {}),
+      ...(this.data !== undefined ? { data: this.data } : {}),
+    };
+  }
+  static BadRequest = class BadRequestException extends Exception {
+    constructor(message = "Bad Request", details?: unknown) {
+      super(400, message, details);
+    }
+  };
+  static Unauthorized = class UnauthorizedException extends Exception {
+    constructor(message = "Unauthorized", details?: unknown) {
+      super(401, message, details);
+    }
+  };
+  static Forbidden = class ForbiddenException extends Exception {
+    constructor(message = "Forbidden", details?: unknown) {
+      super(403, message, details);
+    }
+  };
+  static NotFound = class NotFoundException extends Exception {
+    constructor(message = "Not Found", details?: unknown) {
+      super(404, message, details);
+    }
+  };
+  static Conflict = class ConflictException extends Exception {
+    constructor(message = "Conflict", details?: unknown) {
+      super(409, message, details);
+    }
+  };
+  static Error = class InternalServerErrorException extends Exception {
+    constructor(message = "Internal Server Error", details?: unknown) {
+      super(500, message, details);
+    }
+  };
+}

package/signal/guard.ts

@@ -0,0 +1,18 @@
+import type { Cls } from "akanjs/base";
+import type { SignalContext } from "./signalContext";
+
+export interface Guard {
+  canPass(context: SignalContext): boolean;
+}
+
+export type GuardCls<Name extends string = string> = Cls<Guard, { readonly name: Name }>;
+
+/** Creates a named guard base class for signal access checks. */
+export const guard = <T extends string>(name: T): GuardCls<T> => {
+  return class Guard {
+    static name = name;
+    canPass(context: SignalContext): boolean {
+      return true;
+    }
+  };
+};

package/signal/guards.ts

@@ -0,0 +1,16 @@
+import type { Guard } from "./guard";
+import type { SignalContext } from "./signalContext";
+
+export class Public implements Guard {
+  static name = "Public";
+  canPass(context: SignalContext): boolean {
+    return true;
+  }
+}
+
+export class None implements Guard {
+  static name = "None";
+  canPass(context: SignalContext): boolean {
+    return false;
+  }
+}

package/signal/index.ts

@@ -0,0 +1,18 @@
+export * from "./base.signal";
+export * from "./endpoint";
+export * from "./endpointInfo";
+export * from "./exception";
+export * from "./guard";
+export * from "./guards";
+export * from "./intercept";
+export * from "./internal";
+export * from "./internalArg";
+export * from "./internalInfo";
+export * from "./middleware";
+export * from "./serializer";
+export * from "./serverSignal";
+export * from "./signalContext";
+export * from "./signalRegistry";
+export * from "./slice";
+export * from "./sliceInfo";
+export * from "./types";

package/signal/intercept.ts

@@ -0,0 +1,39 @@
+import { type Cls, INJECT_META } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import { type ExtractInjectInfoObject, type InjectBuilder, type InjectInfo, injectionBuilder } from "akanjs/service";
+import type { SignalContext } from "./signalContext";
+
+export type InterceptorCls<Methods = {}, InjectMap extends { [key: string]: InjectInfo } = {}> = Cls<
+  Methods &
+    ExtractInjectInfoObject<InjectMap> & {
+      readonly logger: Logger;
+      onInit(): Promise<void>;
+      onDestroy(): Promise<void>;
+      intercept(context: SignalContext): AsyncGenerator<unknown> | Promise<unknown>;
+    },
+  { readonly [INJECT_META]: InjectMap; readonly refName: string }
+>;
+
+export function intercept<Name extends string>(name: Name): InterceptorCls;
+
+export function intercept<Name extends string, Injection extends InjectBuilder<"use" | "env" | "memory">>(
+  refName: Name,
+  injectBuilder: Injection,
+): InterceptorCls<{}, ReturnType<Injection>>;
+
+export function intercept(refName: string, injectBuilder?: InjectBuilder) {
+  const injectInfoMap = injectBuilder?.(injectionBuilder(refName)) ?? {};
+  return class Interceptor {
+    static readonly refName = refName;
+    static readonly [INJECT_META] = injectInfoMap;
+
+    readonly logger = new Logger(refName);
+    intercept(context: SignalContext): AsyncGenerator | Promise<(res: Response) => Promise<Response>> {
+      return Promise.resolve((res: Response) => Promise.resolve(res));
+    }
+    async onInit() {
+    }
+    async onDestroy() {
+    }
+  };
+}

package/signal/internal.ts

@@ -0,0 +1,56 @@
+import { INTERNAL_META, type MergeAllKeyOfObjects } from "akanjs/base";
+import { applyMixins } from "akanjs/common";
+import {
+  type Adaptor,
+  type AdaptorCls,
+  dangerouslyAdapt,
+  type QueueAdaptor,
+  QueueAdaptorRole,
+  type ScheduleAdaptor,
+  Scheduler,
+  type ServiceModel,
+} from "akanjs/service";
+import { type BuildInternal, buildInternal, type InternalBuilder, type InternalInfo } from "./internalInfo";
+
+export interface Internal extends Adaptor {
+  schedule: ScheduleAdaptor;
+  queue: QueueAdaptor;
+}
+
+export type InternalCls<
+  SrvModule extends ServiceModel = ServiceModel,
+  InternalInfoMap extends { [key: string]: InternalInfo } = { [key: string]: InternalInfo },
+> = AdaptorCls & { refName: SrvModule["srv"]["refName"]; srv: SrvModule; [INTERNAL_META]: InternalInfoMap };
+
+/** Builds an internal adaptor for schedules, queues, processes, and server-only jobs. */
+export function internal<
+  SrvModule extends ServiceModel,
+  InternalInfoMap extends ReturnType<InternalBuilder<SrvModule>>,
+  LibInternals extends InternalCls[],
+>(
+  srv: SrvModule,
+  internalBuilder: (builder: BuildInternal<SrvModule>) => InternalInfoMap,
+  ...libInternals: LibInternals
+): InternalCls<SrvModule, MergeAllKeyOfObjects<LibInternals, typeof INTERNAL_META> & InternalInfoMap> {
+  const refName = srv.srv.refName;
+  const srvKeys = [
+    ...new Set([
+      ...Object.keys(srv.srvMap),
+      ...libInternals.flatMap((libInternal) => Object.keys(libInternal.srv.srvMap)),
+    ]),
+  ];
+  const internalCls = class Internal extends dangerouslyAdapt(`${refName}Internal`, ({ plug, service }) => ({
+    schedule: plug(Scheduler),
+    queue: plug(QueueAdaptorRole),
+    ...Object.fromEntries(srvKeys.map((srvRefName) => [srvRefName, service()])),
+  })) {
+    static srv = srv;
+    static [INTERNAL_META] = internalBuilder(buildInternal as any);
+  };
+  libInternals.forEach((libInternal) => {
+    Object.assign(internalCls[INTERNAL_META], libInternal[INTERNAL_META]);
+    Object.assign(internalCls.srv.srvMap, libInternal.srv.srvMap);
+  });
+  applyMixins(internalCls, libInternals);
+  return internalCls as any;
+}

package/signal/internalArg.ts

@@ -0,0 +1,38 @@
+import type { Cls, PromiseOrObject } from "akanjs/base";
+import type { SignalContext } from "./signalContext";
+
+export interface InternalArg<ArgType = unknown> {
+  getArg: (context: SignalContext) => PromiseOrObject<ArgType | null>;
+}
+export type InternalArgCls<ArgType = unknown> = Cls<InternalArg<ArgType>>;
+
+/** Injects the current Bun request into an endpoint/internal handler. */
+export class Req implements InternalArg {
+  getArg(context: SignalContext): Bun.BunRequest {
+    const httpContext = context.getHttpContext();
+    return httpContext.req;
+  }
+}
+/** Injects the current mutable response context into an endpoint/internal handler. */
+export class Res implements InternalArg {
+  getArg(context: SignalContext) {
+    const httpContext = context.getHttpContext();
+    return httpContext.res;
+  }
+}
+
+/** Injects websocket state and subscription hooks into message/pubsub handlers. */
+export class Ws implements InternalArg {
+  onDisconnect?: () => void;
+  onUnsubscribe?: () => void;
+  getArg(context: SignalContext) {
+    const webSocketContext = context.getWebSocketContext();
+    const ws = webSocketContext.ws;
+    return {
+      ws,
+      subscribe: webSocketContext.eventType === "subscribe",
+      on: webSocketContext.on,
+      off: webSocketContext.off,
+    };
+  }
+}