@procedures/client 0.14.0 → 0.14.1

package/src/procedures/collection/procedures.ts

@@ -56,10 +56,12 @@ import {
   type SetBatchInput,
   type DeleteBatchInput,
 } from "./schemas.js";
-import { DEFAULT_FIND_LIMIT, applyPatch, queryEntries, type StoragePatch, type StorageQueryOptions, type StorageQueryPolicy } from "./query.js";
+import { DEFAULT_FIND_LIMIT, queryEntries, type StorageQueryOptions, type StorageQueryPolicy } from "./query.js";
 import type { CollectionStorage, StorageWriteOptions } from "./storage.js";
 import { collectionChangeTopic, startChangeChain, writeWithChangeEvent } from "./changes.js";
 import { partitionOfCall, storageOfCall, withPartition, type PartitionInput } from "./partition.js";
+import { admitsRow, admittedStorage, type CollectionAdmission } from "./admission.js";
+import { patchItem } from "./patch-in-parts.js";
 
 // =============================================================================
 // Handler Factory
@@ -122,6 +124,13 @@ export interface CollectionProceduresOptions {
    * @default true, with the topic `collections.<name>` and no values
    */
   changeEvents?: boolean | CollectionChangeEventsOptions | undefined;
+  /**
+   * The rules of the rows (roadmap CLI-41). `admit` examines each row of each read and of each
+   * change event with values. `guard` examines each write before the storage changes, and a
+   * refused write gets `FORBIDDEN` (reason `write-not-allowed`). Without it, the procedures check
+   * only the partition.
+   */
+  admission?: CollectionAdmission | undefined;
 }
 
 /** The write options of an input with an origin. */
@@ -129,40 +138,6 @@ function writeOptionsOf(input: { origin?: string }): StorageWriteOptions | undef
   return input.origin === undefined ? undefined : { origin: input.origin };
 }
 
-/**
- * The patches of a storage without `patch()` that run, for each id. A patch of an id waits for the
- * patch before it, so two patches of one process keep each field. A write of another writer
- * between the read and the write of a patch is lost: give the storage a `patch()` for one step.
- */
-const PATCHES = new WeakMap<object, Map<string, Promise<unknown>>>();
-
-/** This function patches an item of a storage without `patch()`: a read, a merge and a write. */
-function patchInParts(storage: CollectionStorage<unknown>, id: string, fields: StoragePatch, options?: StorageWriteOptions): Promise<unknown> {
-  let running = PATCHES.get(storage);
-  if (!running) {
-    running = new Map();
-    PATCHES.set(storage, running);
-  }
-  const queue = running;
-  const before = queue.get(id) ?? Promise.resolve();
-  const patch = before.then(async () => {
-    const current = await storage.get(id);
-    if (current === undefined) return undefined;
-    const next = applyPatch(current, fields);
-    await storage.set(id, next, options);
-    return next;
-  });
-  const settled = patch.then(
-    () => undefined,
-    () => undefined,
-  );
-  queue.set(id, settled);
-  void settled.then(() => {
-    if (queue.get(id) === settled) queue.delete(id);
-  });
-  return patch;
-}
-
 // =============================================================================
 // Collection Procedure Definitions
 // =============================================================================
@@ -192,17 +167,20 @@ export function createCollectionProcedures(collectionName: string, options: Coll
     events === false ? undefined : (events !== true && events.topic) || ((name: string, _ctx: ProcedureContext, partition: string | undefined) => collectionChangeTopic(name, partition));
   const topicOf = (ctx: ProcedureContext, partition: string | undefined): string | undefined => topicRule?.(collectionName, ctx, partition);
   const withValues = events !== false && events !== true && events.values === true;
-  /** A write, and then its change event on the bus of the context. */
+  const admission = options.admission;
+  /** A write, and then its change event on the bus of the context. The chain of the events belongs to the storage, not to its view. */
   const changing = <R>(ctx: ProcedureContext, partition: string | undefined, storage: CollectionStorage<unknown>, ids: readonly string[] | "*", origin: string | undefined, write: () => Promise<R>): Promise<R> =>
-    writeWithChangeEvent(ctx.bus, storage, topicRule ? topicOf(ctx, partition) : undefined, ids, origin, write, withValues);
+    writeWithChangeEvent(ctx.bus, storage, topicRule ? topicOf(ctx, partition) : undefined, ids, origin, write, withValues, admission?.admit);
   /**
    * The partition and the storage of a call (roadmap CLI-17). The repository of the call has the
-   * partitions of the collection and their resolver: the tenant comes from the principal.
+   * partitions of the collection and their resolver: the tenant comes from the principal. Each read
+   * and each write goes through the view, with the rules of the rows (roadmap CLI-41).
    */
-  const storageOf = async (input: PartitionInput, ctx: ProcedureContext): Promise<{ storage: CollectionStorage<unknown>; partition: string | undefined }> => {
+  const storageOf = async (input: PartitionInput, ctx: ProcedureContext): Promise<{ storage: CollectionStorage<unknown>; view: CollectionStorage<unknown>; partition: string | undefined }> => {
     const collection = getCollectionFromPath(ctx.path);
     const partition = await partitionOfCall(ctx, collection, input.partition);
-    return { storage: storageOfCall<unknown>(ctx, collection, partition), partition };
+    const storage = storageOfCall<unknown>(ctx, collection, partition);
+    return { storage, view: admittedStorage(storage, admission, ctx), partition };
   };
 
   return [
@@ -217,8 +195,8 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "read"],
       },
       handler: async (input: GetInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage } = await storageOf(input, ctx);
-        const value = await storage.get(input.id);
+        const { view } = await storageOf(input, ctx);
+        const value = await view.get(input.id);
         if (input.found !== true) return value;
         // The output with `found` keeps a stored null apart from a missing id, in one call
         const output: GetFoundOutput = value === undefined ? { found: false } : { found: true, value };
@@ -237,8 +215,8 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "write"],
       },
       handler: async (input: SetInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage, partition } = await storageOf(input, ctx);
-        await changing(ctx, partition, storage, [input.id], input.origin, () => storage.set(input.id, input.value, writeOptionsOf(input)));
+        const { storage, view, partition } = await storageOf(input, ctx);
+        await changing(ctx, partition, storage, [input.id], input.origin, () => view.set(input.id, input.value, writeOptionsOf(input)));
       },
     }),
 
@@ -253,8 +231,8 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "write"],
       },
       handler: async (input: DeleteInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage, partition } = await storageOf(input, ctx);
-        return changing(ctx, partition, storage, [input.id], input.origin, () => storage.delete(input.id, writeOptionsOf(input)));
+        const { storage, view, partition } = await storageOf(input, ctx);
+        return changing(ctx, partition, storage, [input.id], input.origin, () => view.delete(input.id, writeOptionsOf(input)));
       },
     }),
 
@@ -269,8 +247,8 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "read"],
       },
       handler: async (input: HasInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage } = await storageOf(input, ctx);
-        return storage.has(input.id);
+        const { view } = await storageOf(input, ctx);
+        return view.has(input.id);
       },
     }),
 
@@ -285,8 +263,8 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "read"],
       },
       handler: async (input: GetAllInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage } = await storageOf(input, ctx);
-        return storage.getAll();
+        const { view } = await storageOf(input, ctx);
+        return view.getAll();
       },
     }),
 
@@ -301,11 +279,11 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "read"],
       },
       handler: async (input: EntriesInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage } = await storageOf(input, ctx);
-        if (!storage.getEntries) {
+        const { view } = await storageOf(input, ctx);
+        if (!view.getEntries) {
           throw new Error(`The storage of ${collectionName} cannot give the ids of its items`);
         }
-        return (await storage.getEntries()).map(([id, value]) => ({ id, value }));
+        return (await view.getEntries()).map(([id, value]) => ({ id, value }));
       },
     }),
 
@@ -320,10 +298,10 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "read"],
       },
       handler: async (input: IdsInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage } = await storageOf(input, ctx);
-        if (storage.getIds) return storage.getIds();
+        const { view } = await storageOf(input, ctx);
+        if (view.getIds) return view.getIds();
         // A storage without getIds() gives its entries: the values stay on the server
-        if (storage.getEntries) return (await storage.getEntries()).map(([id]) => id);
+        if (view.getEntries) return (await view.getEntries()).map(([id]) => id);
         throw new Error(`The storage of ${collectionName} cannot give the ids of its items`);
       },
     }),
@@ -339,9 +317,9 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "read"],
       },
       handler: async (input: ChangesInput & PartitionInput, ctx: ProcedureContext): Promise<ChangesOutput> => {
-        const { storage, partition } = await storageOf(input, ctx);
-        if (storage.getChangesSince) {
-          const changes = await storage.getChangesSince(input.since);
+        const { storage, view, partition } = await storageOf(input, ctx);
+        if (view.getChangesSince) {
+          const changes = await view.getChangesSince(input.since);
           // The chain of the change events starts at this version: the caller then applies the
           // next event without a read (roadmap CLI-15)
           if (topicRule) startChangeChain(ctx.bus, storage, topicOf(ctx, partition), changes.version);
@@ -354,8 +332,8 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         }
         // A storage without a change log gives all its items. The empty version asks for all
         // items again at the next call.
-        if (storage.getEntries) {
-          const entries = await storage.getEntries();
+        if (view.getEntries) {
+          const entries = await view.getEntries();
           return { version: "", full: true, changed: entries.map(([id, value]) => ({ id, value })), deleted: [] };
         }
         throw new Error(`The storage of ${collectionName} cannot give its changes or the ids of its items`);
@@ -373,16 +351,16 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "read", "query"],
       },
       handler: async (input: FindInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage } = await storageOf(input, ctx);
+        const { view } = await storageOf(input, ctx);
         const selector = input.selector ?? {};
         const query = queryOptionsOf(input, queryPolicy);
         // The storage runs the selector itself when it can: a database does not read each item. It
         // gets the policy of the host, so it permits what the procedure permits.
-        if (storage.query) return (await storage.query(selector, query, queryPolicy)).map(([id, value]) => ({ id, value }));
-        if (!storage.getEntries) {
+        if (view.query) return (await view.query(selector, query, queryPolicy)).map(([id, value]) => ({ id, value }));
+        if (!view.getEntries) {
           throw new Error(`The storage of ${collectionName} cannot run a selector or give the ids of its items`);
         }
-        return queryEntries(await storage.getEntries(), selector, query, queryPolicy).map(([id, value]) => ({ id, value }));
+        return queryEntries(await view.getEntries(), selector, query, queryPolicy).map(([id, value]) => ({ id, value }));
       },
     }),
 
@@ -397,12 +375,12 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "write"],
       },
       handler: async (input: PatchInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage, partition } = await storageOf(input, ctx);
+        const { storage, view, partition } = await storageOf(input, ctx);
         const write = writeOptionsOf(input);
-        const value = await changing(ctx, partition, storage, [input.id], input.origin, () =>
-          storage.patch ? storage.patch(input.id, input.fields, write) : patchInParts(storage, input.id, input.fields, write),
-        );
-        const output: GetFoundOutput = value === undefined ? { found: false } : { found: true, value };
+        const value = await changing(ctx, partition, storage, [input.id], input.origin, () => patchItem(view, input.id, input.fields, write));
+        if (value === undefined) return { found: false } satisfies GetFoundOutput;
+        // The new item is a row too: a caller gets it only when the rule of the rows admits it (roadmap CLI-41)
+        const output: GetFoundOutput = (await admitsRow(admission, ctx, input.id, value)) ? { found: true, value } : { found: true };
         return output;
       },
     }),
@@ -418,8 +396,8 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "read"],
       },
       handler: async (input: SizeInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage } = await storageOf(input, ctx);
-        return storage.size();
+        const { view } = await storageOf(input, ctx);
+        return view.size();
       },
     }),
 
@@ -434,8 +412,8 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "write"],
       },
       handler: async (input: ClearInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage, partition } = await storageOf(input, ctx);
-        await changing(ctx, partition, storage, "*", input.origin, () => storage.clear(writeOptionsOf(input)));
+        const { storage, view, partition } = await storageOf(input, ctx);
+        await changing(ctx, partition, storage, "*", input.origin, () => view.clear(writeOptionsOf(input)));
       },
     }),
 
@@ -450,8 +428,8 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "read", "batch"],
       },
       handler: async (input: GetBatchInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage } = await storageOf(input, ctx);
-        const result = await storage.getBatch(input.ids);
+        const { view } = await storageOf(input, ctx);
+        const result = await view.getBatch(input.ids);
         // Convert Map to plain object
         return Object.fromEntries(result);
       },
@@ -468,12 +446,12 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "write", "batch"],
       },
       handler: async (input: SetBatchInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage, partition } = await storageOf(input, ctx);
+        const { storage, view, partition } = await storageOf(input, ctx);
         const items: Array<[string, unknown]> = input.items.map((item) => [
           item.id,
           item.value,
         ]);
-        await changing(ctx, partition, storage, items.map(([id]) => id), input.origin, () => storage.setBatch(items, writeOptionsOf(input)));
+        await changing(ctx, partition, storage, items.map(([id]) => id), input.origin, () => view.setBatch(items, writeOptionsOf(input)));
       },
     }),
 
@@ -488,8 +466,8 @@ export function createCollectionProcedures(collectionName: string, options: Coll
         tags: ["collections", collectionName, "write", "batch"],
       },
       handler: async (input: DeleteBatchInput & PartitionInput, ctx: ProcedureContext) => {
-        const { storage, partition } = await storageOf(input, ctx);
-        return changing(ctx, partition, storage, input.ids, input.origin, () => storage.deleteBatch(input.ids, writeOptionsOf(input)));
+        const { storage, view, partition } = await storageOf(input, ctx);
+        return changing(ctx, partition, storage, input.ids, input.origin, () => view.deleteBatch(input.ids, writeOptionsOf(input)));
       },
     }),
   ];

package/src/procedures/index.ts

@@ -133,6 +133,9 @@ export {
   PARTITION_PATTERN,
   collectionTopicPartition,
   collectionTopicTarget,
+  // The rules of the rows of a collection (roadmap CLI-41)
+  admittedStorage,
+  admitsRow,
   DEFAULT_FIND_LIMIT,
   DEFAULT_QUERY_OPERATORS,
   DEFAULT_QUERY_POLICY,
@@ -152,6 +155,10 @@ export type {
   CollectionProceduresOptions,
   CollectionChangeEventsOptions,
   CollectionChangeEvent,
+  CollectionAdmission,
+  CollectionRow,
+  CollectionWrite,
+  CollectionWriteGuard,
   CollectionPartitions,
   PartitionInput,
   PartitionResolver,

package/src/procedures/invoke.ts

@@ -76,8 +76,10 @@ export type InvocationErrorCode =
  *   subscription (`documentation/EVENTS.md`).
  * - `partition-not-allowed`: the partition resolver of the collection procedures refuses the
  *   partition of a call (roadmap CLI-17).
+ * - `write-not-allowed`: the guard of a collection (`admission.guard`) refuses a write (roadmap
+ *   CLI-41).
  */
-export type ForbiddenReason = CapabilityRefusalReason | "outside-root" | "host-not-allowed" | "topic-not-allowed" | "partition-not-allowed";
+export type ForbiddenReason = CapabilityRefusalReason | "outside-root" | "host-not-allowed" | "topic-not-allowed" | "partition-not-allowed" | "write-not-allowed";
 
 /** An error of the invocation itself. An error that the handler throws passes through unchanged. */
 export class InvocationError extends Error {
@@ -87,7 +89,8 @@ export class InvocationError extends Error {
   readonly retryable: boolean = false;
   /**
    * The reason of a `FORBIDDEN` error: `effects-undeclared`, `effects-exceeded`, `clearance`,
-   * `deadline`, `outside-root`, `host-not-allowed`, `topic-not-allowed` or `partition-not-allowed`.
+   * `deadline`, `outside-root`, `host-not-allowed`, `topic-not-allowed`, `partition-not-allowed` or
+   * `write-not-allowed`.
    */
   readonly reason: ForbiddenReason | undefined;
 
@@ -550,6 +553,8 @@ export function createProcedureContext(
   if (options.principal !== undefined) context.principal = options.principal;
   // The procedure of the parent invocation made this call (roadmap R33: the root of the files)
   if (invocation?.parent) context.caller = invocation.parent.procedure;
+  // The rules of the rows of a collection get the invocation of the call (roadmap CLI-41)
+  if (invocation) context.invocation = invocation;
   // The output filter of the host, for the data that a handler sends later (roadmap CLI-15)
   const admitItem = options.admitItem;
   if (invocation && invocation.depth === 0 && admitItem) context.admit = async (item) => admitItem(item, invocation);

package/src/procedures/types.ts

@@ -14,6 +14,7 @@ import type { CollectionStorage } from "./collection/storage.js";
 import type { EventBus } from "../events/types.js";
 import type { HydrationEvent } from "./ref.js";
 import type { Principal } from "../server/types.js";
+import type { Invocation } from "./invoke.js";
 
 // =============================================================================
 // Procedure Path
@@ -419,6 +420,13 @@ export interface ProcedureContext {
    * examines each row with it. Absent for a nested call, or when the host has no filter.
    */
   admit?: ((item: unknown) => Promise<boolean>) | undefined;
+
+  /**
+   * The invocation of this call: the procedure, the path, the principal and the capability
+   * (roadmap CLI-41). A rule with the shape of `AdmitItem` gets it, for example the rules of the
+   * rows of a collection. Absent for a context without an invocation.
+   */
+  invocation?: Invocation | undefined;
 }
 
 /**

package/src/server/index.ts

@@ -11,9 +11,13 @@
  * - Handler registry with pattern matching
  * - Graceful shutdown
  *
+ * The server transports have the entry `@procedures/client/node` (CLI-6). This entry still
+ * exports them as deprecated aliases. The next MINOR removes the aliases.
+ *
  * @example
  * ```typescript
- * import { Server, HttpServerTransport } from "@common/server";
+ * import { Server } from "@procedures/client/server";
+ * import { HttpServerTransport } from "@procedures/client/node";
  *
  * const server = new Server();
  *
@@ -34,6 +38,19 @@
  * ```
  */
 
+import { HttpServerTransport as NodeHttpServerTransport } from "../adapters/http/server/transport.js";
+import type {
+  HttpServerTransportOptions as NodeHttpServerTransportOptions,
+  HttpUrlStrategy as NodeHttpUrlStrategy,
+} from "../adapters/http/server/types.js";
+import { WebSocketServerTransport as NodeWebSocketServerTransport } from "../adapters/websocket/server/transport.js";
+import type {
+  WebSocketServerTransportOptions as NodeWebSocketServerTransportOptions,
+  WebSocketAuthHandler as NodeWebSocketAuthHandler,
+  WebSocketConnectionHandler as NodeWebSocketConnectionHandler,
+  WebSocketMessage as NodeWebSocketMessage,
+} from "../adapters/websocket/server/types.js";
+
 export { Server } from "./server.js";
 export type { ServerOptions } from "./server.js";
 
@@ -59,19 +76,79 @@ export {
   type ServerTransport,
 } from "./types.js";
 
-export {
-  HttpServerTransport,
-  defaultServerUrlStrategy,
-  rpcServerUrlStrategy,
-} from "../adapters/http/server/index.js";
-export type {
-  HttpServerTransportOptions,
-  HttpUrlStrategy,
-} from "../adapters/http/server/index.js";
-export { WebSocketServerTransport } from "../adapters/websocket/server/index.js";
-export type {
-  WebSocketServerTransportOptions,
-  WebSocketAuthHandler,
-  WebSocketConnectionHandler,
-  WebSocketMessage,
-} from "../adapters/websocket/server/index.js";
+export { defaultServerUrlStrategy, rpcServerUrlStrategy } from "../adapters/http/server/strategies.js";
+
+// ============================================================================
+// The server transports: deprecated here (CLI-6 step 1)
+// ============================================================================
+// Their entry is `@procedures/client/node`. This entry and the root (which re-exports these
+// names from this module) give them through deprecated aliases until the next MINOR, so an
+// editor marks each old import. Each alias is the same class or type as the export of ./node.
+
+/**
+ * The HTTP server transport of Express, a shim over `procedureHandler`.
+ *
+ * @deprecated Import it from `@procedures/client/node`. The root and `@procedures/client/server` stop exporting it in the next MINOR (CLI-6).
+ */
+export const HttpServerTransport: typeof NodeHttpServerTransport = NodeHttpServerTransport;
+/**
+ * The HTTP server transport of Express, a shim over `procedureHandler`.
+ *
+ * @deprecated Import it from `@procedures/client/node`. The root and `@procedures/client/server` stop exporting it in the next MINOR (CLI-6).
+ */
+export type HttpServerTransport = NodeHttpServerTransport;
+
+/**
+ * The options of `HttpServerTransport`.
+ *
+ * @deprecated Import it from `@procedures/client/node`. The root and `@procedures/client/server` stop exporting it in the next MINOR (CLI-6).
+ */
+export type HttpServerTransportOptions = NodeHttpServerTransportOptions;
+
+/**
+ * The URL strategy of `HttpServerTransport`: it gives the method of an Express request.
+ *
+ * @deprecated Import it from `@procedures/client/node`. The root and `@procedures/client/server` stop exporting it in the next MINOR (CLI-6).
+ */
+export type HttpUrlStrategy = NodeHttpUrlStrategy;
+
+/**
+ * The WebSocket server transport, on the `ws` package.
+ *
+ * @deprecated Import it from `@procedures/client/node`. The root and `@procedures/client/server` stop exporting it in the next MINOR (CLI-6).
+ */
+export const WebSocketServerTransport: typeof NodeWebSocketServerTransport = NodeWebSocketServerTransport;
+/**
+ * The WebSocket server transport, on the `ws` package.
+ *
+ * @deprecated Import it from `@procedures/client/node`. The root and `@procedures/client/server` stop exporting it in the next MINOR (CLI-6).
+ */
+export type WebSocketServerTransport = NodeWebSocketServerTransport;
+
+/**
+ * The options of `WebSocketServerTransport`.
+ *
+ * @deprecated Import it from `@procedures/client/node`. The root and `@procedures/client/server` stop exporting it in the next MINOR (CLI-6).
+ */
+export type WebSocketServerTransportOptions = NodeWebSocketServerTransportOptions;
+
+/**
+ * The authentication handler of `WebSocketServerTransport`, for each upgrade request.
+ *
+ * @deprecated Import it from `@procedures/client/node`. The root and `@procedures/client/server` stop exporting it in the next MINOR (CLI-6).
+ */
+export type WebSocketAuthHandler = NodeWebSocketAuthHandler;
+
+/**
+ * The connection handler of `WebSocketServerTransport`, for each new connection.
+ *
+ * @deprecated Import it from `@procedures/client/node`. The root and `@procedures/client/server` stop exporting it in the next MINOR (CLI-6).
+ */
+export type WebSocketConnectionHandler = NodeWebSocketConnectionHandler;
+
+/**
+ * The RPC message of `WebSocketServerTransport`.
+ *
+ * @deprecated Import it from `@procedures/client/node`. The root and `@procedures/client/server` stop exporting it in the next MINOR (CLI-6).
+ */
+export type WebSocketMessage<TReq = unknown> = NodeWebSocketMessage<TReq>;