@procedures/client 0.0.0-stage → 0.1.0

package/src/adapters/http/shared/status-codes.ts

@@ -0,0 +1,212 @@
+/**
+ * HTTP Status Code Utilities
+ *
+ * Utilities for working with HTTP status codes, including mappings
+ * and classification helpers.
+ */
+
+import { HTTPStatus, HTTP } from "./constants.js";
+
+/**
+ * HTTP Status Code to String Code Mapping
+ *
+ * Maps numeric status codes to semantic string codes.
+ */
+export const HTTPStatusToCode: Record<HTTPStatus, string> = {
+  [HTTPStatus.UNKNOWN]: "UNKNOWN",
+  [HTTPStatus.CONTINUE]: "CONTINUE",
+  [HTTPStatus.SWITCHING_PROTOCOLS]: "SWITCHING_PROTOCOLS",
+  [HTTPStatus.PROCESSING]: "PROCESSING",
+  [HTTPStatus.EARLY_HINTS]: "EARLY_HINTS",
+  [HTTPStatus.RESPONSE_IS_TOO_LARGE]: "RESPONSE_IS_TOO_LARGE",
+  [HTTPStatus.OK]: "OK",
+  [HTTPStatus.CREATED]: "CREATED",
+  [HTTPStatus.ACCEPTED]: "ACCEPTED",
+  [HTTPStatus.NON_AUTHORITATIVE_INFORMATION]: "NON_AUTHORITATIVE_INFORMATION",
+  [HTTPStatus.NO_CONTENT]: "NO_CONTENT",
+  [HTTPStatus.RESET_CONTENT]: "RESET_CONTENT",
+  [HTTPStatus.PARTIAL_CONTENT]: "PARTIAL_CONTENT",
+  [HTTPStatus.MULTI_STATUS]: "MULTI_STATUS",
+  [HTTPStatus.ALREADY_REPORTED]: "ALREADY_REPORTED",
+  [HTTPStatus.IM_USED]: "IM_USED",
+  [HTTPStatus.MULTIPLE_CHOICES]: "MULTIPLE_CHOICES",
+  [HTTPStatus.MOVED_PERMANENTLY]: "MOVED_PERMANENTLY",
+  [HTTPStatus.FOUND]: "FOUND",
+  [HTTPStatus.SEE_OTHER]: "SEE_OTHER",
+  [HTTPStatus.NOT_MODIFIED]: "NOT_MODIFIED",
+  [HTTPStatus.USE_PROXY]: "USE_PROXY",
+  [HTTPStatus.TEMPORARY_REDIRECT]: "TEMPORARY_REDIRECT",
+  [HTTPStatus.PERMANENT_REDIRECT]: "PERMANENT_REDIRECT",
+  [HTTPStatus.BAD_REQUEST]: "BAD_REQUEST",
+  [HTTPStatus.UNAUTHORIZED]: "UNAUTHORIZED",
+  [HTTPStatus.FORBIDDEN]: "FORBIDDEN",
+  [HTTPStatus.NOT_FOUND]: "NOT_FOUND",
+  [HTTPStatus.METHOD_NOT_ALLOWED]: "METHOD_NOT_ALLOWED",
+  [HTTPStatus.NOT_ACCEPTABLE]: "NOT_ACCEPTABLE",
+  [HTTPStatus.PROXY_AUTHENTICATION_REQUIRED]: "PROXY_AUTHENTICATION_REQUIRED",
+  [HTTPStatus.REQUEST_TIMEOUT]: "REQUEST_TIMEOUT",
+  [HTTPStatus.CONFLICT]: "CONFLICT",
+  [HTTPStatus.GONE]: "GONE",
+  [HTTPStatus.LENGTH_REQUIRED]: "LENGTH_REQUIRED",
+  [HTTPStatus.PRECONDITION_FAILED]: "PRECONDITION_FAILED",
+  [HTTPStatus.PAYLOAD_TOO_LARGE]: "PAYLOAD_TOO_LARGE",
+  [HTTPStatus.URI_TOO_LONG]: "URI_TOO_LONG",
+  [HTTPStatus.UNSUPPORTED_MEDIA_TYPE]: "UNSUPPORTED_MEDIA_TYPE",
+  [HTTPStatus.RANGE_NOT_SATISFIABLE]: "RANGE_NOT_SATISFIABLE",
+  [HTTPStatus.EXPECTATION_FAILED]: "EXPECTATION_FAILED",
+  [HTTPStatus.IM_A_TEAPOT]: "IM_A_TEAPOT",
+  [HTTPStatus.MISDIRECTED_REQUEST]: "MISDIRECTED_REQUEST",
+  [HTTPStatus.UNPROCESSABLE_ENTITY]: "UNPROCESSABLE_ENTITY",
+  [HTTPStatus.LOCKED]: "LOCKED",
+  [HTTPStatus.FAILED_DEPENDENCY]: "FAILED_DEPENDENCY",
+  [HTTPStatus.TOO_EARLY]: "TOO_EARLY",
+  [HTTPStatus.UPGRADE_REQUIRED]: "UPGRADE_REQUIRED",
+  [HTTPStatus.PRECONDITION_REQUIRED]: "PRECONDITION_REQUIRED",
+  [HTTPStatus.TOO_MANY_REQUESTS]: "TOO_MANY_REQUESTS",
+  [HTTPStatus.REQUEST_HEADER_FIELDS_TOO_LARGE]:
+    "REQUEST_HEADER_FIELDS_TOO_LARGE",
+  [HTTPStatus.UNAVAILABLE_FOR_LEGAL_REASONS]: "UNAVAILABLE_FOR_LEGAL_REASONS",
+  [HTTPStatus.CLIENT_CLOSED_REQUEST]: "CLIENT_CLOSED_REQUEST",
+  [HTTPStatus.INTERNAL_SERVER_ERROR]: "INTERNAL_SERVER_ERROR",
+  [HTTPStatus.NOT_IMPLEMENTED]: "NOT_IMPLEMENTED",
+  [HTTPStatus.BAD_GATEWAY]: "BAD_GATEWAY",
+  [HTTPStatus.SERVICE_UNAVAILABLE]: "SERVICE_UNAVAILABLE",
+  [HTTPStatus.GATEWAY_TIMEOUT]: "GATEWAY_TIMEOUT",
+  [HTTPStatus.HTTP_VERSION_NOT_SUPPORTED]: "HTTP_VERSION_NOT_SUPPORTED",
+  [HTTPStatus.VARIANT_ALSO_NEGOTIATES]: "VARIANT_ALSO_NEGOTIATES",
+  [HTTPStatus.INSUFFICIENT_STORAGE]: "INSUFFICIENT_STORAGE",
+  [HTTPStatus.LOOP_DETECTED]: "LOOP_DETECTED",
+  [HTTPStatus.NOT_EXTENDED]: "NOT_EXTENDED",
+  [HTTPStatus.NETWORK_AUTHENTICATION_REQUIRED]:
+    "NETWORK_AUTHENTICATION_REQUIRED",
+  [HTTPStatus.HTTP_NETWORK_CONNECT_TIMEOUT_ERROR]:
+    "HTTP_NETWORK_CONNECT_TIMEOUT_ERROR",
+} as const satisfies Record<HTTPStatus, string>;
+
+/**
+ * Legacy alias for backwards compatibility
+ * @deprecated Use HTTPStatusToCode instead
+ */
+export const HTTPCodeMap: typeof HTTPStatusToCode = HTTPStatusToCode;
+
+/**
+ * String Code to HTTP Status Mapping (Reverse of HTTPStatusToCode)
+ *
+ * Maps semantic string codes back to numeric status codes.
+ */
+export const CodeToHTTPStatus: Record<string, HTTPStatus> = Object.fromEntries(
+  Object.entries(HTTPStatusToCode).map(([status, code]) => [code, Number(status) as HTTPStatus])
+) as Record<string, HTTPStatus>;
+
+/**
+ * Check if status code represents success (2xx)
+ */
+export function isSuccessStatus(status: HTTPStatus): boolean {
+  return status >= HTTPStatus.OK && status < HTTPStatus.MULTIPLE_CHOICES;
+}
+
+/**
+ * Check if status code represents informational response (1xx)
+ */
+export function isInformationalStatus(status: HTTPStatus): boolean {
+  return status >= HTTPStatus.CONTINUE && status < HTTPStatus.OK;
+}
+
+/**
+ * Check if status code represents redirection (3xx)
+ */
+export function isRedirectStatus(status: HTTPStatus): boolean {
+  return status >= HTTPStatus.MULTIPLE_CHOICES && status < HTTPStatus.BAD_REQUEST;
+}
+
+/**
+ * Check if status code represents client error (4xx)
+ */
+export function isClientErrorStatus(status: HTTPStatus): boolean {
+  return status >= HTTPStatus.BAD_REQUEST && status < HTTPStatus.INTERNAL_SERVER_ERROR;
+}
+
+/**
+ * Check if status code represents server error (5xx)
+ */
+export function isServerErrorStatus(status: HTTPStatus): boolean {
+  return status >= HTTPStatus.INTERNAL_SERVER_ERROR && status < 600;
+}
+
+/**
+ * Check if status code represents any error (4xx or 5xx)
+ */
+export function isErrorStatus(status: HTTPStatus): boolean {
+  return isClientErrorStatus(status) || isServerErrorStatus(status);
+}
+
+/**
+ * Check if status code is typically retryable
+ *
+ * Default policy: server errors and specific client errors (timeout, rate limit) are retryable.
+ * Can be overridden via retry middleware configuration.
+ */
+export function isRetryableStatus(status: HTTPStatus): boolean {
+  // Server errors are generally retryable
+  if (isServerErrorStatus(status)) {
+    return true;
+  }
+
+  // Specific client errors that are retryable
+  if (
+    status === HTTPStatus.REQUEST_TIMEOUT ||
+    status === HTTPStatus.TOO_MANY_REQUESTS
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get semantic code string for a status
+ *
+ * @example
+ * ```typescript
+ * getStatusCode(HTTPStatus.OK) // "OK"
+ * getStatusCode(404) // "NOT_FOUND"
+ * getStatusCode(999) // "UNKNOWN"
+ * ```
+ */
+export function getStatusCode(status: HTTPStatus): string {
+  return HTTPStatusToCode[status] ?? HTTPStatusToCode[HTTPStatus.UNKNOWN];
+}
+
+/**
+ * Get HTTP status from semantic code string
+ *
+ * @example
+ * ```typescript
+ * getStatusFromCode("OK") // HTTPStatus.OK (200)
+ * getStatusFromCode("NOT_FOUND") // HTTPStatus.NOT_FOUND (404)
+ * getStatusFromCode("INVALID") // HTTPStatus.UNKNOWN (0)
+ * ```
+ */
+export function getStatusFromCode(code: string): HTTPStatus {
+  return CodeToHTTPStatus[code] ?? HTTPStatus.UNKNOWN;
+}
+
+/**
+ * Format HTTP error message
+ *
+ * @example
+ * ```typescript
+ * formatHTTPError(HTTPStatus.NOT_FOUND) // "HTTP 404"
+ * formatHTTPError(500) // "HTTP 500"
+ * ```
+ */
+export function formatHTTPError(status: HTTPStatus): string {
+  return `${HTTP} ${status}`;
+}
+
+/**
+ * Validate if a number is a valid HTTP status code
+ */
+export function isValidHTTPStatus(status: number): status is HTTPStatus {
+  return status in HTTPStatusToCode;
+}

package/src/adapters/http/shared/strategies.ts

@@ -0,0 +1,255 @@
+/**
+ * HTTP Strategy Interfaces
+ *
+ * Defines extensible, bidirectional strategies for URL mapping
+ * and HTTP method selection. These strategies ensure client
+ * and server use consistent, inverse operations.
+ */
+
+import type { Method } from "../../../client/types.js";
+import { HTTPMethod } from "./constants.js";
+
+/**
+ * URL Strategy (Client-side)
+ *
+ * Converts Method → URL
+ */
+export type UrlStrategy = (method: Method, baseUrl: string) => string;
+
+/**
+ * URL Parser Strategy (Server-side)
+ *
+ * Converts URL → Method (inverse of UrlStrategy)
+ */
+export type UrlParserStrategy = (url: string, httpMethod: HTTPMethod) => Method | null;
+
+/**
+ * HTTP Method Strategy (Client-side)
+ *
+ * Converts Method → HTTP method verb
+ */
+export type HttpMethodStrategy = (method: Method) => HTTPMethod;
+
+/**
+ * HTTP Method Parser Strategy (Server-side)
+ *
+ * Converts HTTP method verb → operation hints (inverse of HttpMethodStrategy)
+ */
+export type HttpMethodParserStrategy = (httpMethod: HTTPMethod) => Partial<Method>;
+
+/**
+ * Bidirectional URL Pattern
+ *
+ * Encapsulates both URL generation (client) and parsing (server)
+ * to ensure they remain algorithmic inverses.
+ */
+export interface UrlPattern {
+  /** Template pattern (e.g., "/{version?}/{service}/{operation}") */
+  readonly template: string;
+
+  /** Generate URL from Method (client-side) */
+  format(method: Method, baseUrl: string): string;
+
+  /** Parse URL back to Method (server-side) */
+  parse(url: string, httpMethod: HTTPMethod): Method | null;
+}
+
+/**
+ * Default URL Pattern: /{version?}/{service}/{operation}
+ *
+ * Examples:
+ * - { service: "users", operation: "get" } → "/users/get"
+ * - { service: "users", operation: "get", version: "v2" } → "/v2/users/get"
+ */
+export const defaultUrlPattern: UrlPattern = {
+  template: "/{version?}/{service}/{operation}",
+
+  format(method: Method, baseUrl: string): string {
+    const parts = [baseUrl.replace(/\/$/, "")];
+
+    if (method.version) {
+      parts.push(method.version);
+    }
+
+    parts.push(method.service, method.operation);
+
+    return parts.join("/");
+  },
+
+  parse(url: string, _httpMethod: HTTPMethod): Method | null {
+    // Remove base URL and query params
+    const path = url.split("?")[0];
+    const segments = path?.split("/").filter(Boolean) ?? [];
+
+    // Minimum: /service/operation (2 segments)
+    if (segments.length < 2) {
+      return null;
+    }
+
+    // Pattern: [version?]/service/operation
+    if (segments.length === 2) {
+      return {
+        service: segments[0]!,
+        operation: segments[1]!,
+      };
+    }
+
+    if (segments.length === 3) {
+      return {
+        version: segments[0]!,
+        service: segments[1]!,
+        operation: segments[2]!,
+      };
+    }
+
+    return null;
+  },
+};
+
+/**
+ * RESTful URL Pattern: /{version?}/{service}/{id?}
+ *
+ * Infers operation from HTTP method and presence of ID:
+ * - GET /users → list
+ * - GET /users/123 → get
+ * - POST /users → create
+ * - PUT /users/123 → update
+ * - PATCH /users/123 → patch
+ * - DELETE /users/123 → delete
+ */
+export const restfulUrlPattern: UrlPattern = {
+  template: "/{version?}/{service}/{id?}",
+
+  format(method: Method, baseUrl: string): string {
+    const parts = [baseUrl.replace(/\/$/, "")];
+
+    if (method.version) {
+      parts.push(method.version);
+    }
+
+    parts.push(method.service);
+
+    // For RESTful, operation might encode the ID
+    // This is simplified - real implementation would need ID extraction
+    if (method.operation !== "list" && method.operation !== "create") {
+      // Assume operation is actually the ID for get/update/delete
+      parts.push(method.operation);
+    }
+
+    return parts.join("/");
+  },
+
+  parse(url: string, httpMethod: HTTPMethod): Method | null {
+    const path = url.split("?")[0];
+    const segments = path?.split("/").filter(Boolean) ?? [];
+
+    if (segments.length < 1) {
+      return null;
+    }
+
+    let version: string | undefined;
+    let service: string;
+    let id: string | undefined;
+
+    // Pattern: [version?]/service/[id?]
+    if (segments.length === 1) {
+      service = segments[0]!;
+    } else if (segments.length === 2) {
+      // Could be version/service or service/id
+      // Heuristic: if starts with 'v', treat as version
+      if (segments[0]!.startsWith("v")) {
+        version = segments[0]!;
+        service = segments[1]!;
+      } else {
+        service = segments[0]!;
+        id = segments[1]!;
+      }
+    } else {
+      version = segments[0]!;
+      service = segments[1]!;
+      id = segments[2]!;
+    }
+
+    // Infer operation from HTTP method and ID presence
+    const operation = inferRESTOperation(httpMethod, !!id);
+
+    return {
+      ...(version && { version }),
+      service,
+      operation,
+      // Store ID in metadata or custom field if needed
+    };
+  },
+};
+
+/**
+ * RESTful HTTP Method Strategy
+ *
+ * Maps operation names to HTTP methods:
+ * - get/list/find/watch → GET
+ * - create → POST
+ * - update → PUT
+ * - patch → PATCH
+ * - delete/remove → DELETE
+ * - default → POST
+ */
+export const restfulHttpMethodStrategy: HttpMethodStrategy = (method) => {
+  const op = method.operation.toLowerCase();
+
+  if (op === "get" || op === "list" || op === "find" || op === "watch") {
+    return HTTPMethod.GET;
+  }
+
+  if (op === "create") {
+    return HTTPMethod.POST;
+  }
+
+  if (op === "update") {
+    return HTTPMethod.PUT;
+  }
+
+  if (op === "patch") {
+    return HTTPMethod.PATCH;
+  }
+
+  if (op === "delete" || op === "remove") {
+    return HTTPMethod.DELETE;
+  }
+
+  // Default to POST for RPC-style operations
+  return HTTPMethod.POST;
+};
+
+/**
+ * POST-only HTTP Method Strategy
+ *
+ * All operations use POST (simple RPC style).
+ */
+export const postOnlyStrategy: HttpMethodStrategy = () => HTTPMethod.POST;
+
+/**
+ * Infer REST operation from HTTP method and ID presence
+ */
+function inferRESTOperation(httpMethod: HTTPMethod, hasId: boolean): string {
+  switch (httpMethod) {
+    case HTTPMethod.GET:
+      return hasId ? "get" : "list";
+    case HTTPMethod.POST:
+      return "create";
+    case HTTPMethod.PUT:
+      return "update";
+    case HTTPMethod.PATCH:
+      return "patch";
+    case HTTPMethod.DELETE:
+      return "delete";
+    default:
+      return "unknown";
+  }
+}
+
+/**
+ * Validate payload can be JSON stringified
+ */
+export function isValidJSONPayload(payload: unknown): boolean {
+  return typeof payload === "object" && payload !== null;
+}

package/src/adapters/local/client/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Local Client Transport Adapter
+ *
+ * Public API for Local client adapter.
+ */
+
+// Types
+export type { LocalTransportOptions, Handler } from "./types.js";
+
+// Transport
+export { LocalTransport } from "./transport.js";

package/src/adapters/local/client/transport.ts

@@ -0,0 +1,188 @@
+/**
+ * Local Transport Implementation
+ *
+ * In-process RPC with handler registry - no network calls!
+ */
+
+import type { Transport, Message, ResponseItem, Method } from "../../../client/types.js";
+import type { Handler, LocalTransportOptions } from "./types.js";
+import { methodKey } from "./types.js";
+import type { ProcedureRegistry } from "../../../procedures/registry.js";
+import type { AnyProcedure } from "../../../procedures/types.js";
+import { InvocationError, invokeProcedure, isAsyncIterable } from "../../../procedures/invoke.js";
+import { methodToPath } from "../../../server/method.js";
+
+function successItem<TRes>(id: string, payload: unknown): ResponseItem<TRes> {
+  return { id, status: { type: "success", code: 200 }, payload: payload as TRes, metadata: {} };
+}
+
+function errorItem<TRes>(id: string, code: string, message: string): ResponseItem<TRes> {
+  // Local handlers do not benefit from retries
+  return { id, status: { type: "error", code, message, retryable: false }, payload: null as TRes, metadata: {} };
+}
+
+/**
+ * Local Transport - executes handlers in-process without network calls.
+ *
+ * Features:
+ * - No network - instant execution
+ * - Sync and async handler support
+ * - Handler registry (register/unregister)
+ * - Same Transport interface as HTTP/gRPC
+ * - Perfect for testing!
+ *
+ * @example
+ * ```typescript
+ * const transport = new LocalTransport();
+ *
+ * transport.register(
+ *   { service: "users", operation: "get" },
+ *   async ({ id }) => database.users.findById(id)
+ * );
+ *
+ * const client = new Client({ transport });
+ * const user = await client.call(
+ *   { service: "users", operation: "get" },
+ *   { id: 123 }
+ * );
+ * ```
+ */
+export class LocalTransport implements Transport {
+  readonly name = "local";
+
+  private readonly handlers = new Map<string, Handler>();
+  private readonly throwOnMissing: boolean;
+  private readonly registry: ProcedureRegistry | undefined;
+
+  constructor(options: LocalTransportOptions = {}) {
+    this.throwOnMissing = options.throwOnMissing !== false;
+    this.registry = options.registry;
+
+    // Register pre-configured handlers. A key without a version ("users.get") gets the
+    // empty version, as methodKey() makes it: before, such a key was never found.
+    if (options.handlers) {
+      for (const [key, handler] of Object.entries(options.handlers)) {
+        this.handlers.set(key.includes(":") ? key : `:${key}`, handler);
+      }
+    }
+  }
+
+  /**
+   * Register a handler for a method.
+   *
+   * @param method - Method to handle
+   * @param handler - Handler function (sync, async, or an async generator for a stream)
+   */
+  register<TReq, TRes>(method: Method, handler: Handler<TReq, TRes>): void {
+    this.handlers.set(methodKey(method), handler as Handler);
+  }
+
+  /**
+   * Unregister a handler.
+   *
+   * @param method - Method to unregister
+   */
+  unregister(method: Method): void {
+    this.handlers.delete(methodKey(method));
+  }
+
+  /**
+   * Check if handler is registered.
+   *
+   * @param method - Method to check
+   */
+  has(method: Method): boolean {
+    return this.handlers.has(methodKey(method)) || this.procedureFor(method) !== undefined;
+  }
+
+  /** The procedure of the registry at the path of a method. */
+  private procedureFor(method: Method): AnyProcedure | undefined {
+    if (!this.registry) return undefined;
+    return this.registry.get(methodToPath(method));
+  }
+
+  /**
+   * Send message to local handler.
+   *
+   * A handler (or a procedure) that gives an async iterable gives a stream: one response item
+   * for each value. An error ends the stream with an error item.
+   *
+   * @param message - Message to send
+   * @returns Async iterable of response items
+   */
+  async *send<TReq, TRes>(message: Message<TReq>): AsyncIterable<ResponseItem<TRes>> {
+    const key = methodKey(message.method);
+    const handler = this.handlers.get(key);
+    const procedure = handler ? undefined : this.procedureFor(message.method);
+
+    // Handler not found
+    if (!handler && !procedure) {
+      if (this.throwOnMissing) {
+        yield errorItem<TRes>(message.id, "NOT_FOUND", `No handler registered for ${key}`);
+        return;
+      }
+
+      // Silently return empty response
+      return;
+    }
+
+    // Check if cancelled
+    if (message.signal?.aborted) {
+      yield errorItem<TRes>(message.id, "ABORTED", "Request was aborted");
+      return;
+    }
+
+    try {
+      let values: AsyncIterable<unknown> | undefined;
+      let value: unknown;
+      if (procedure) {
+        const output = await invokeProcedure(procedure, message.payload, {
+          registry: this.registry,
+          metadata: message.metadata,
+          signal: message.signal,
+        });
+        if (output.kind === "stream") values = output.items;
+        else value = output.value;
+      } else {
+        // Execute handler (may be sync, async or an async generator)
+        const result = await handler!(message.payload, message);
+        if (isAsyncIterable(result)) values = result;
+        else value = result;
+      }
+
+      if (values === undefined) {
+        yield successItem<TRes>(message.id, value);
+        return;
+      }
+      for await (const item of values) {
+        if (message.signal?.aborted) {
+          yield errorItem<TRes>(message.id, "ABORTED", "Request was aborted");
+          return;
+        }
+        yield successItem<TRes>(message.id, item);
+      }
+    } catch (error) {
+      // The handler threw, or the invocation failed (its code: VALIDATION_ERROR, ABORTED and so on)
+      const code = error instanceof InvocationError ? error.code : "HANDLER_ERROR";
+      yield errorItem<TRes>(message.id, code, error instanceof Error ? error.message : "Unknown error");
+    }
+  }
+
+  async close(): Promise<void> {
+    // No resources to clean up
+  }
+
+  /**
+   * Clear all handlers.
+   */
+  clear(): void {
+    this.handlers.clear();
+  }
+
+  /**
+   * Get all registered method keys.
+   */
+  getMethods(): string[] {
+    return Array.from(this.handlers.keys());
+  }
+}