@geekmidas/constructs 10.0.0-alpha.125 → 10.0.0-alpha.127

package/dist/websocket-api.d.mts

@@ -0,0 +1,449 @@
+import { n as StandardSchemaV1 } from "./index-DdRjYhiJ.mjs";
+import { c as ServicesOf, i as Declarable, r as Consumable, t as Authenticator } from "./construct-interface-ZvYQbivO.mjs";
+import { n as Telemetry } from "./telemetry-BEoBn6GO.mjs";
+import { ConstructName, Declaration, Dependency } from "@geekmidas/manifest";
+import { Service, ServiceRecord, ServiceRegisterOptions } from "@geekmidas/services";
+import { EnvironmentParser } from "@geekmidas/envkit";
+import { Hono } from "hono";
+import { Logger } from "@geekmidas/logger";
+import { InferStandardSchema } from "@geekmidas/schema";
+import { IncomingMessage, Server } from "node:http";
+import { Duplex } from "node:stream";
+//#region src/websocket/transport.d.ts
+/**
+ * How a send reaches the process holding the socket.
+ *
+ * A connection id names the process it lives on — `<instance>.<n>` — so a send
+ * needs no registry: it is published to that instance's channel and nowhere
+ * else. A broadcast goes to every instance. On a stack the channels are Redis
+ * pub/sub, so an endpoint in another container reaches a socket the same way a
+ * route beside it does; in one process (a test, a single dev server) they are
+ * a map.
+ */
+/** What one process is asked to do with the sockets it holds. */
+type Delivery = {
+  kind: 'send';
+  ids: readonly string[];
+  payload: string;
+} | {
+  kind: 'broadcast';
+  payload: string;
+  except?: readonly string[];
+} | {
+  kind: 'close';
+  ids: readonly string[];
+  code: number;
+  reason: string;
+};
+interface WebSocketTransport {
+  /** Deliver to one instance, or to every instance when it is `'*'`. */
+  publish(instance: string, delivery: Delivery): Promise<void>;
+  /** Receive what is published to `instance`, and every broadcast. */
+  subscribe(instance: string, receive: (delivery: Delivery) => void): Promise<void>;
+  close(): Promise<void>;
+}
+/** A connection string names no transport this package knows. */
+export declare class UnsupportedWebSocketTransport extends Error {
+  readonly connectionString: string;
+  constructor(connectionString: string);
+}
+/**
+ * In one process: the server and whoever sends meet in a map, keyed by the
+ * channel the connection string names.
+ */
+export declare class MemoryTransport implements WebSocketTransport {
+  private readonly channel;
+  private readonly subscribed;
+  constructor(channel: string);
+  publish(instance: string, delivery: Delivery): Promise<void>;
+  subscribe(instance: string, receive: (delivery: Delivery) => void): Promise<void>;
+  close(): Promise<void>;
+}
+/** The subset of an ioredis client the transport uses. */
+interface RedisClient {
+  publish(channel: string, message: string): Promise<number>;
+  subscribe(...channels: string[]): Promise<unknown>;
+  on(event: 'message', listener: (channel: string, message: string) => void): unknown;
+  duplicate(): RedisClient;
+  quit(): Promise<unknown>;
+}
+/**
+ * Over Redis pub/sub: one channel per instance and one for broadcasts, under
+ * a prefix that keeps two surfaces — or two projects on one Redis — apart.
+ * Channels are not scoped by database index, so the prefix is what does it.
+ *
+ * Publishing and subscribing take separate connections, because a connection
+ * that has subscribed can do nothing else.
+ */
+export declare class RedisTransport implements WebSocketTransport {
+  private readonly client;
+  private readonly prefix;
+  private subscriber?;
+  private closed?;
+  constructor(client: RedisClient, prefix: string);
+  private channel;
+  publish(instance: string, delivery: Delivery): Promise<void>;
+  subscribe(instance: string, receive: (delivery: Delivery) => void): Promise<void>;
+  /** Idempotent: the server and a shutdown hook may both close it. */
+  close(): Promise<void>;
+}
+/**
+ * The transport a connection string names.
+ *
+ * `redis://` and `rediss://` take an optional `channel` query parameter, the
+ * prefix every channel is named under; `memory://<channel>` is in-process.
+ * Absent, the channel is `fallback` — the surface's own.
+ */
+export declare function transportFromConnectionString(connectionString: string, fallback: string): Promise<WebSocketTransport>;
+//#endregion
+//#region src/websocket/publisher.d.ts
+/**
+ * What a surface sends its sockets, by action — `WebSocketApiConfig.messages`.
+ */
+type WebSocketMessages = Record<string, StandardSchemaV1>;
+/** A surface that declares no messages: any action, any data. */
+type NoMessages = Record<never, never>;
+/** The actions a publisher sends: the declared ones, or any. */
+type MessageAction<TMessages extends WebSocketMessages> = [keyof TMessages] extends [never] ? string : keyof TMessages & string;
+/** What `action`'s data is, as its schema takes it. */
+type MessageData<TMessages extends WebSocketMessages, TAction extends string> = TAction extends keyof TMessages ? StandardSchemaV1.InferInput<TMessages[TAction]> : unknown;
+/** A message sent on an action the surface does not declare. */
+export declare class UnknownWebSocketMessage extends Error {
+  readonly surface: string;
+  readonly action: string;
+  readonly declared: readonly string[];
+  constructor(surface: string, action: string, declared: readonly string[]);
+}
+/** A message whose data its action's schema refused. */
+export declare class InvalidWebSocketMessage extends Error {
+  readonly surface: string;
+  readonly action: string;
+  readonly issues: readonly StandardSchemaV1.Issue[];
+  constructor(surface: string, action: string, issues: readonly StandardSchemaV1.Issue[]);
+}
+/**
+ * How anything reaches a socket — `services.realtime` in an endpoint, and
+ * `sockets` in a route of the surface itself.
+ *
+ * A message is `{ action, data }`, the shape a client's frames arrive in.
+ * Where the surface declares its messages, `action` is one of them and
+ * `data` is typed and checked by its schema before anything is sent; where it
+ * declares none, any action and any JSON value go. A message is serialised
+ * once, whatever the number of sockets it goes to. An id whose process has
+ * gone is dropped silently, as API Gateway's `postToConnection` to a closed
+ * connection is a no-op the sender rarely wants to handle.
+ */
+export declare class WebSocketPublisher<TMessages extends WebSocketMessages = NoMessages> {
+  private readonly transport;
+  /**
+   * Delivers to this process's own sockets without a round trip through
+   * the transport — set on the server's own publisher.
+   */
+  private readonly local?;
+  /** The surface's declared messages, which every send is checked by. */
+  private readonly declared?;
+  constructor(transport: WebSocketTransport,
+  /**
+   * Delivers to this process's own sockets without a round trip through
+   * the transport — set on the server's own publisher.
+   */
+  local?: {
+    instance: string;
+    deliver(delivery: Delivery): void;
+  } | undefined,
+  /** The surface's declared messages, which every send is checked by. */
+  declared?: {
+    surface: string;
+    messages: TMessages;
+  } | undefined);
+  /** Send `action`'s message to each connection. */
+  send<TAction extends MessageAction<TMessages>>(ids: string | readonly string[], action: TAction, data: MessageData<TMessages, TAction>): Promise<void>;
+  /** Send `action`'s message to every open connection, on every process. */
+  broadcast<TAction extends MessageAction<TMessages>>(action: TAction, data: MessageData<TMessages, TAction>, options?: {
+    except?: readonly string[];
+  }): Promise<void>;
+  /** Close each connection, with a close code and reason its client sees. */
+  close(ids: string | readonly string[], code?: number, reason?: string): Promise<void>;
+  /**
+   * The frame, checked by the action's schema where the surface declares
+   * its messages.
+   *
+   * @throws {UnknownWebSocketMessage}, {InvalidWebSocketMessage}
+   */
+  private payload;
+  /** One delivery per process that holds any of `ids`. */
+  private each;
+}
+//#endregion
+//#region src/websocket/route.d.ts
+/** One open connection, as a handler sees it. */
+interface Connection {
+  readonly id: string;
+  /**
+   * What the connect handler returned — who the connection is for, the room
+   * it joined. `{}` when it returned nothing.
+   */
+  readonly data: Record<string, unknown>;
+}
+interface BaseContext<TServices extends Service[], TMessages extends WebSocketMessages> {
+  services: ServiceRecord<TServices>;
+  logger: Logger;
+  /** Every socket this surface holds, on whichever process holds it. */
+  sockets: WebSocketPublisher<TMessages>;
+}
+interface ConnectContext<TServices extends Service[], TMessages extends WebSocketMessages = NoMessages> extends BaseContext<TServices, TMessages> {
+  connectionId: string;
+  headers: Headers;
+  query: URLSearchParams;
+  /**
+   * Whose connection it is, from the surface's `.auth()` — `null` when the
+   * upgrade carried no session, and when the surface names no authenticator.
+   * Throw an `UnauthorizedError` to refuse it.
+   */
+  session: unknown;
+}
+interface MessageContext<TBody, TServices extends Service[], TMessages extends WebSocketMessages = NoMessages> extends BaseContext<TServices, TMessages> {
+  connection: Connection;
+  body: TBody;
+  /** Send to this connection alone. */
+  reply(message: unknown): void;
+}
+interface DisconnectContext<TServices extends Service[], TMessages extends WebSocketMessages = NoMessages> extends BaseContext<TServices, TMessages> {
+  connection: Connection;
+  code: number;
+  reason: string;
+}
+/** What a frame is dispatched on: an action, or the connection's lifecycle. */
+type RouteKind = 'connect' | 'disconnect' | 'message';
+/**
+ * A handler bound to a WebSocket surface — what `realtime.route('chat.send')
+ * …handle()` returns, and what a file exports.
+ *
+ * Carries `surface` and `constructs` the way an endpoint does, so discovery
+ * records what its process reaches without knowing what a route is.
+ */
+export declare class WebSocketRoute {
+  readonly kind: RouteKind;
+  /** The `action` it answers; `$connect` and `$disconnect` for the lifecycle. */
+  readonly action: string;
+  readonly surface: {
+    id: string;
+  };
+  readonly services: readonly Service[];
+  /** Construct ids it depends on — its edges in the manifest. */
+  readonly constructs: readonly string[];
+  readonly handler: (context: never) => unknown;
+  readonly schema?: StandardSchemaV1 | undefined;
+  readonly __IS_WEBSOCKET_ROUTE__ = true;
+  static isRoute(value: unknown): value is WebSocketRoute;
+  constructor(kind: RouteKind,
+  /** The `action` it answers; `$connect` and `$disconnect` for the lifecycle. */
+  action: string, surface: {
+    id: string;
+  }, services: readonly Service[],
+  /** Construct ids it depends on — its edges in the manifest. */
+  constructs: readonly string[], handler: (context: never) => unknown, schema?: StandardSchemaV1 | undefined);
+}
+/** The builder `connect()`, `disconnect()` and `route()` start. */
+export declare class WebSocketRouteBuilder<TKind extends RouteKind, TSchema extends StandardSchemaV1 | undefined = undefined, TServices extends Service[] = [],
+/** The surface's declared messages, which `sockets` sends. */
+TMessages extends WebSocketMessages = NoMessages> {
+  private readonly kind;
+  private readonly action;
+  private readonly surface;
+  private readonly _services;
+  private readonly _constructs;
+  private readonly schema?;
+  constructor(kind: TKind, action: string, surface: {
+    id: string;
+  }, _services?: readonly Service[], _constructs?: readonly string[], schema?: TSchema | undefined);
+  /** The schema a frame's `data` must satisfy before the handler runs. */
+  body<S extends StandardSchemaV1>(schema: S): WebSocketRouteBuilder<TKind, S, TServices, TMessages>;
+  /** What the handler reaches, as `services.<id>` — per route, as an endpoint's. */
+  dependsOn<const T extends readonly Consumable[]>(constructs: T): WebSocketRouteBuilder<TKind, TSchema, [...TServices, ...(ServicesOf<T> extends Service[] ? ServicesOf<T> : [])], TMessages>;
+  /**
+   * The handler. A message handler's return value, when there is one, is
+   * sent back to the connection as the reply to that frame; a connect
+   * handler's is kept as the connection's `data`.
+   */
+  handle(handler: TKind extends 'connect' ? (context: ConnectContext<TServices, TMessages>) => Record<string, unknown> | undefined | Promise<Record<string, unknown> | undefined> : TKind extends 'disconnect' ? (context: DisconnectContext<TServices, TMessages>) => unknown : (context: MessageContext<TSchema extends StandardSchemaV1 ? InferStandardSchema<TSchema> : unknown, TServices, TMessages>) => unknown): WebSocketRoute;
+}
+//#endregion
+//#region src/websocket/server.d.ts
+/** Close codes a client sees. */
+export declare const CLOSE: {
+  readonly normal: 1000;
+  /** The process is stopping; reconnect and land on another. */
+  readonly serviceRestart: 1012;
+  /** It stopped reading, and what was queued for it passed the limit. */
+  readonly tooSlow: 1013;
+};
+/** Two routes answer one action. */
+export declare class DuplicateWebSocketRoute extends Error {
+  readonly surface: string;
+  readonly action: string;
+  constructor(surface: string, action: string);
+}
+interface WebSocketServerOptions<TMessages extends WebSocketMessages = NoMessages> {
+  surface: string;
+  /** What the surface sends its sockets — see `WebSocketApiConfig.messages`. */
+  messages?: TMessages;
+  routes: readonly WebSocketRoute[];
+  transport: WebSocketTransport;
+  envParser: EnvironmentParser<{}>;
+  logger: Logger;
+  authenticator?: Authenticator;
+  /**
+   * Origins a browser may open a socket from. A request with an `Origin`
+   * not in the list is refused with 403; one with none — a server, a load
+   * generator — is not a browser, and is let through.
+   */
+  trustedOrigins: readonly string[];
+  /** How often each socket is pinged; one that missed the last is dropped. */
+  heartbeatMs?: number;
+  /** The largest frame accepted, in bytes. */
+  maxPayload?: number;
+  /** Queued bytes a socket may hold before it is closed as too slow. */
+  maxBufferedBytes?: number;
+}
+export declare class WebSocketSurfaceServer<TMessages extends WebSocketMessages = NoMessages> {
+  private readonly wss;
+  private readonly options;
+  /** This process, as connection ids name it. */
+  readonly instance: string;
+  /** `sockets` in a route: local sends skip the transport. */
+  readonly publisher: WebSocketPublisher<TMessages>;
+  private readonly held;
+  private readonly routes;
+  private readonly lifecycle;
+  private readonly heartbeat;
+  private next;
+  private closing;
+  private constructor();
+  static start<TMessages extends WebSocketMessages = NoMessages>(options: WebSocketServerOptions<TMessages>): Promise<WebSocketSurfaceServer<TMessages>>;
+  /** How many sockets this process holds. */
+  get size(): number;
+  /** Take over `server`'s upgrades. */
+  attach(server: Server): void;
+  /** Upgrade one request, or refuse it with a status line. */
+  upgrade(request: IncomingMessage, socket: Duplex, head: Buffer): Promise<void>;
+  private open;
+  /** Parse, validate and run one frame. Errors go back as frames, not closes. */
+  private dispatch;
+  /** Run a handler with its services, inside a request context of its own. */
+  private run;
+  private error;
+  /** Write, unless the socket has stopped reading and its queue is full. */
+  private write;
+  /** What the transport, or a local publisher, asked of this process. */
+  private deliver;
+  /** Drop every socket that missed the last ping, and ping the rest. */
+  private beat;
+  /**
+   * Stop: refuse new upgrades, close every socket with `code` — 1012 tells
+   * a client to reconnect, and it lands on a process that is still up — and
+   * leave the transport.
+   */
+  close(code?: number, reason?: string): Promise<void>;
+}
+//#endregion
+//#region src/websocket-api.d.ts
+export interface WebSocketApiConfig<TMessages extends WebSocketMessages = NoMessages> {
+  /** The app that serves it, relative to the workspace root. */
+  path: string;
+  /**
+   * What it sends its sockets, by action — each with the schema its `data`
+   * is checked by before it is sent.
+   *
+   * ```ts
+   * messages: {
+   *   announcement: z.object({ text: z.string() }),
+   *   'chat.said': z.object({ from: z.string(), text: z.string() }),
+   * }
+   * ```
+   *
+   * The publisher is typed by it — `services.realtime.broadcast(
+   * 'announcement', { text })` — in an endpoint and in a route's `sockets`
+   * alike. Absent, any action and any data go, unchecked.
+   */
+  messages?: TMessages;
+  /** The label it answers on. Absent, its id kebab-cased. */
+  subdomain?: string;
+  /** How many processes serve it on one machine. Default 1. */
+  replicas?: number;
+  logger?: Logger;
+  envParser?: EnvironmentParser<{}>;
+  telemetry?: Telemetry;
+  /** Seconds between pings; a socket that misses one is dropped. Default 30. */
+  heartbeat?: number;
+  /** The largest frame accepted, in bytes. Default 1 MiB. */
+  maxPayload?: number;
+}
+/** A replica count that is not a whole number of at least one. */
+export declare class InvalidReplicaCount extends Error {
+  readonly id: string;
+  readonly replicas: number;
+  constructor(id: string, replicas: number);
+}
+export declare class WebSocketApi<TName extends string = string, TMessages extends WebSocketMessages = NoMessages> implements Declarable<TName> {
+  private readonly config;
+  /** Internal: how `.calls()` carries edges into the copy it returns. */
+  private readonly dependencies;
+  /** Internal: how `.auth()` carries the authenticator into its copy. */
+  readonly authenticator?: Authenticator | undefined;
+  readonly id: TName;
+  readonly keys: {
+    url: string;
+    trustedOrigins: string;
+    publisherConnectionString: string;
+  };
+  readonly logger: Logger;
+  readonly envParser: EnvironmentParser<{}>;
+  readonly telemetry?: Telemetry;
+  /**
+   * The surface as a dependency: `services.<id>` is its publisher, so an
+   * endpoint sends to a socket the way a route beside it does.
+   */
+  readonly service: Service<Uncapitalize<TName>, WebSocketPublisher<TMessages>>;
+  constructor(id: ConstructName<TName>, config: WebSocketApiConfig<TMessages>,
+  /** Internal: how `.calls()` carries edges into the copy it returns. */
+  dependencies?: readonly Dependency[],
+  /** Internal: how `.auth()` carries the authenticator into its copy. */
+  authenticator?: Authenticator | undefined);
+  /** The handler a connection's upgrade runs: refuse it, or say who it is. */
+  connect(): WebSocketRouteBuilder<'connect', undefined, [], TMessages>;
+  /** The handler a closed connection runs. */
+  disconnect(): WebSocketRouteBuilder<'disconnect', undefined, [], TMessages>;
+  /**
+   * The handler for frames whose `action` is `action`. `$default` answers
+   * any action nothing else does.
+   */
+  route(action: string): WebSocketRouteBuilder<'message', undefined, [], TMessages>;
+  /** What authenticates a connection — its session reaches `connect()`. */
+  auth(construct: Authenticator): WebSocketApi<TName, TMessages>;
+  /** Other surfaces this one calls. See `RestApi.calls`. */
+  calls(constructs: readonly Declarable[]): WebSocketApi<TName, TMessages>;
+  /**
+   * Serve it: the routes exported by `modules` that were built from this
+   * surface, on whatever HTTP server `attach` is handed.
+   *
+   * `app` answers plain HTTP — the generated entry puts `/health` in front
+   * of it — and `attach` takes over the server's upgrades. The sockets are
+   * closed with 1012 when the server shuts down.
+   */
+  server(options: ServiceRegisterOptions & {
+    modules?: readonly object[];
+  }): Promise<{
+    app: Hono;
+    attach(server: Server): void;
+    /** Close every socket with 1012, so the HTTP server can close. */
+    release(): Promise<void>;
+    server: WebSocketSurfaceServer<TMessages>;
+  }>;
+  /** The declared messages, with the surface they are checked for. */
+  private get declared();
+  declare(): Declaration[];
+}
+//#endregion
+export type { ConnectContext, Connection, Delivery, DisconnectContext, MessageAction, MessageContext, MessageData, NoMessages, RouteKind, WebSocketMessages, WebSocketServerOptions, WebSocketTransport };
+//# sourceMappingURL=websocket-api.d.mts.map

package/dist/websocket-api.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-api.d.mts","names":[],"sources":["../src/websocket/transport.ts","../src/websocket/publisher.ts","../src/websocket/route.ts","../src/websocket/server.ts","../src/websocket-api.ts"],"mappings":"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"}