@vampgg/utils 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/worker-router.mjs

@@ -1,111 +1,24 @@
 import { Message } from "./bebop.mjs";
-import { createEventIterator } from "./create-event-iterator.mjs";
-import { Deadline, Metadata, MethodType, TempoError, TempoStatusCode, TempoUtil, stringifyCredential } from "@tempojs/common";
-import { EventEmitter } from "tseep";
-import { BaseRouter, ServerContext, TempoRouterConfiguration } from "@tempojs/server";
+import { RouterCore } from "./router-core.mjs";
+import { TempoError, TempoStatusCode } from "@tempojs/common";
+import { BaseRouter, TempoRouterConfiguration } from "@tempojs/server";
 //#region src/worker-router.ts
 var TempoWorkerRouter = class extends BaseRouter {
-	events = new EventEmitter();
-	clientStreams = /* @__PURE__ */ new Map();
+	core;
 	serverStreams = /* @__PURE__ */ new Map();
 	constructor(logger, registry, configuration = new TempoRouterConfiguration(), authInterceptor) {
 		super(logger, registry, configuration, authInterceptor);
-	}
-	async setAuthContext(request, context) {
-		const authHeader = request.authorization;
-		if (authHeader !== void 0 && this.authInterceptor !== void 0) {
-			const authContext = await this.authInterceptor.intercept(context, authHeader);
-			if (authContext !== void 0) context.authContext = authContext;
-		}
-	}
-	async invokeUnaryMethod(request, context, method, contentType) {
-		await this.setAuthContext(request, context);
-		if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
-		const requestData = request.data;
-		const record = this.deserializeRequest(requestData, method, contentType);
-		if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
-		return await method.invoke(record, context);
-	}
-	async invokeClientStreamMethod(request, context, method, contentType) {
-		await this.setAuthContext(request, context);
-		if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
-		const messageId = request.messageId;
-		if (this.clientStreams.has(messageId)) {
-			const invocation = this.clientStreams.get(messageId);
-			this.events.emit(messageId, request);
-			return await invocation;
-		}
-		const generator = () => {
-			return createEventIterator(({ emit, cancel }) => {
-				const eventHandler = async (message) => {
-					if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
-					if (message.status === TempoStatusCode.CANCELLED) {
-						cancel();
-						return;
-					}
-					const requestData = message.data;
-					const record = this.deserializeRequest(requestData, method, contentType);
-					if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
-					emit(record);
-				};
-				this.events.on(messageId, eventHandler);
-				return () => {
-					this.events.off(messageId, eventHandler);
-					this.clientStreams.delete(messageId);
-				};
-			});
-		};
-		const invocation = method.invoke(generator, context);
-		this.clientStreams.set(messageId, invocation);
-		this.events.emit(messageId, request);
-		return await invocation.finally(() => {
-			this.clientStreams.delete(messageId);
+		this.core = new RouterCore({
+			logger,
+			maxRetryAttempts: this.maxRetryAttempts,
+			transmitInternalErrors: this.transmitInternalErrors,
+			authInterceptor,
+			getMethod: (methodId) => this.registry.getMethod(methodId),
+			getHooks: () => this.hooks,
+			deserializeRequest: (data, method, contentType) => this.deserializeRequest(data, method, contentType),
+			serializeResponse: (record, method, contentType) => this.serializeResponse(record, method, contentType)
 		});
 	}
-	async invokeServerStreamMethod(request, context, method, contentType) {
-		await this.setAuthContext(request, context);
-		if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
-		const requestData = request.data;
-		const record = this.deserializeRequest(requestData, method, contentType);
-		if (!TempoUtil.isAsyncGeneratorFunction(method.invoke.bind(method))) throw new TempoError(TempoStatusCode.INTERNAL, "service method incorrect: method must be async generator");
-		if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
-		return method.invoke(record, context);
-	}
-	async invokeDuplexStreamMethod(request, context, method, contentType) {
-		await this.setAuthContext(request, context);
-		if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
-		const messageId = request.messageId;
-		if (this.clientStreams.has(messageId)) {
-			const invocation = this.clientStreams.get(messageId);
-			this.events.emit(messageId, request);
-			return invocation;
-		}
-		if (!TempoUtil.isAsyncGeneratorFunction(method.invoke.bind(method))) throw new TempoError(TempoStatusCode.INTERNAL, "service method incorrect: method must be async generator");
-		const generator = () => {
-			return createEventIterator(({ emit, cancel }) => {
-				const eventHandler = async (message) => {
-					if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
-					if (message.status === TempoStatusCode.CANCELLED) {
-						cancel();
-						return;
-					}
-					const requestData = message.data;
-					const record = this.deserializeRequest(requestData, method, contentType);
-					if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
-					emit(record);
-				};
-				this.events.on(messageId, eventHandler);
-				this.events.emit(messageId, request);
-				return () => {
-					this.events.off(messageId, eventHandler);
-					this.clientStreams.delete(messageId);
-				};
-			});
-		};
-		const invocation = method.invoke(generator, context);
-		this.clientStreams.set(messageId, invocation);
-		return invocation;
-	}
 	/**
 	* Tear down all open streams for this connection (driven by the host
 	* close/error lifecycle). Returns each server-stream generator and emits a
@@ -117,20 +30,11 @@ var TempoWorkerRouter = class extends BaseRouter {
 			await info.generator.return(void 0).catch(() => {});
 			this.serverStreams.delete(id);
 		}
-		for (const id of [...this.clientStreams.keys()]) {
-			this.events.emit(id, Message({
-				messageId: id,
-				status: TempoStatusCode.CANCELLED,
-				data: new Uint8Array()
-			}));
-			this.clientStreams.delete(id);
-		}
-		this.events.removeAllListeners();
+		this.core.cancelClientStreams();
+		this.core.removeAllListeners();
 	}
 	async process(req, response, env) {
-		let request = Message.decode(req);
-		let context;
-		const contentType = "bebop";
+		const request = Message.decode(req);
 		if (request.status === TempoStatusCode.CANCELLED && request.messageId) {
 			const streamInfo = this.serverStreams.get(request.messageId);
 			if (streamInfo) {
@@ -140,111 +44,31 @@ var TempoWorkerRouter = class extends BaseRouter {
 			}
 			return;
 		}
-		try {
-			const methodId = request.methodId;
-			const method = this.registry.getMethod(methodId);
-			if (!method) throw new TempoError(TempoStatusCode.NOT_FOUND, `no service is registered which contains a method of '${methodId}'`);
-			const metadataHeader = request.customMetadata;
-			const metadata = metadataHeader ? Metadata.fromHttpHeader(metadataHeader) : new Metadata();
-			const previousAttempts = request.previousAttempts;
-			if (previousAttempts !== void 0 && previousAttempts > this.maxRetryAttempts) throw new TempoError(TempoStatusCode.RESOURCE_EXHAUSTED, "max retry attempts exceeded");
-			let deadline;
-			const deadlineHeader = request.deadline;
-			if (deadlineHeader !== void 0) deadline = Deadline.fromUnixTimestamp(deadlineHeader.valueOf());
-			if (deadline !== void 0 && deadline.isExpired()) throw new TempoError(TempoStatusCode.DEADLINE_EXCEEDED, "incoming request has already exceeded its deadline");
-			const outgoingMetadata = new Metadata();
-			const incomingContext = {
-				headers: new Headers(),
-				metadata
-			};
-			if (deadline !== void 0) incomingContext.deadline = deadline;
-			context = new ServerContext(incomingContext, { metadata: outgoingMetadata }, env);
-			const handleRequest = async () => {
-				let recordGenerator = void 0;
-				let record;
-				switch (method.type) {
-					case MethodType.Unary:
-						record = await this.invokeUnaryMethod(request, context, method, contentType);
-						break;
-					case MethodType.ClientStream:
-						record = await this.invokeClientStreamMethod(request, context, method, contentType);
-						break;
-					case MethodType.ServerStream:
-						recordGenerator = await this.invokeServerStreamMethod(request, context, method, contentType);
-						break;
-					case MethodType.DuplexStream:
-						recordGenerator = await this.invokeDuplexStreamMethod(request, context, method, contentType);
-						break;
-					default: throw new TempoError(TempoStatusCode.INTERNAL, "service method incorrect: unknown method type");
-				}
-				const outgoingCredential = context.outgoingCredential;
-				if (outgoingCredential) response.credential = stringifyCredential(outgoingCredential);
-				response.methodId = request.methodId;
-				response.messageId = request.messageId;
-				response.status = TempoStatusCode.OK;
-				response.timestamp = /* @__PURE__ */ new Date();
-				if (this.hooks !== void 0) await this.hooks.executeResponseHooks(context);
-				outgoingMetadata.freeze();
-				if (outgoingMetadata.size() > 0) response.customMetadata = outgoingMetadata.data;
-				if (recordGenerator !== void 0) {
-					const messageId = request.messageId;
-					const streamInfo = {
-						generator: recordGenerator,
-						cancelled: false
-					};
-					this.serverStreams.set(messageId, streamInfo);
-					const writeFrames = async () => {
-						try {
-							for await (const value of recordGenerator) {
-								if (streamInfo.cancelled) break;
-								const responseData = this.serializeResponse(value, method, "bebop");
-								response.data = new Uint8Array(responseData);
-								const encoded = Message.encode(response).slice();
-								postMessage(encoded, [encoded.buffer]);
-							}
-						} finally {
-							this.serverStreams.delete(messageId);
-							response.data = new Uint8Array();
-							response.status = TempoStatusCode.CANCELLED;
-							const encoded = Message.encode(response).slice();
-							postMessage(encoded, [encoded.buffer]);
-						}
-					};
-					if (deadline) await deadline.executeWithinDeadline(writeFrames);
-					else await writeFrames();
-				} else {
-					if (record === void 0) throw new TempoError(TempoStatusCode.INTERNAL, "service method did not return a record");
-					const responseData = this.serializeResponse(record, method, contentType);
-					response.data = new Uint8Array(responseData);
-					const encoded = Message.encode(response).slice();
-					postMessage(encoded, [encoded.buffer]);
-				}
-			};
-			if (deadline !== void 0) await deadline.executeWithinDeadline(handleRequest);
-			else await handleRequest();
-		} catch (e) {
-			let status = TempoStatusCode.UNKNOWN;
-			let message = "unknown error";
-			if (e instanceof TempoError) {
-				status = e.status;
-				message = e.message;
-				if (e.status === TempoStatusCode.INTERNAL && this.transmitInternalErrors !== true) message = "internal error";
-				if (e.status === TempoStatusCode.INTERNAL) this.logger.critical(e.message, void 0, e);
-				else this.logger.error(message, void 0, e);
-			} else if (e instanceof Error) {
-				message = e.message;
-				this.logger.error(message, void 0, e);
-			}
-			if (e instanceof Error && this.hooks !== void 0) await this.hooks.executeErrorHooks(context, e);
-			this.clientStreams.delete(request.messageId);
-			response.status = status;
-			response.msg = message;
-			response.messageId = request.messageId;
-			response.timestamp = request.timestamp;
-			response.methodId = request.methodId;
-			const encoded = Message.encode(response).slice();
+		const send = (message) => {
+			const encoded = Message.encode(message).slice();
 			postMessage(encoded, [encoded.buffer]);
-		}
+		};
+		await this.core.processRequest(request, response, env, {
+			send,
+			stampErrorResponse: true,
+			writeStreamFrames: async (generator, resp, method) => {
+				const messageId = request.messageId;
+				const streamInfo = {
+					generator,
+					cancelled: false
+				};
+				this.serverStreams.set(messageId, streamInfo);
+				await this.core.writeStreamFrames({
+					generator,
+					response: resp,
+					method,
+					send,
+					shouldStop: () => streamInfo.cancelled,
+					alwaysTerminate: true,
+					onEnd: () => this.serverStreams.delete(messageId)
+				});
+			}
+		});
 	}
 	handle(_request, _env) {
 		throw new TempoError(TempoStatusCode.UNIMPLEMENTED, "Method not implemented.");

package/dist/ws-channel.d.mts

@@ -1,9 +1,8 @@
 import { Message } from "./bebop.mjs";
-import { BebopRecord } from "bebop";
+import { CoreChannel } from "./channel-core.mjs";
+import { CallCredential, TempoChannelOptions } from "@tempojs/client";
 import * as _tempojs_common0 from "@tempojs/common";
-import { BebopContentType, Credential, Deadline, TempoError } from "@tempojs/common";
-import { BaseChannel, CallCredential, CallOptions, ClientContext, MethodInfo, RetryPolicy, TempoChannelOptions } from "@tempojs/client";
-import { EventEmitter } from "tseep";
+import { BebopContentType, Credential } from "@tempojs/common";
 import { Websocket, WebsocketOptions } from "websocket-ts";
 
 //#region src/ws-channel.d.ts
@@ -13,19 +12,17 @@ type TempoWSChannelOptions = TempoChannelOptions & {
 /**
  * Represents a Tempo channel for communication with a remote server.
  */
-declare class TempoWSChannel extends BaseChannel {
+declare class TempoWSChannel extends CoreChannel {
   static readonly defaultMaxRetryAttempts: number;
   static readonly defaultMaxReceiveMessageSize: number;
   static readonly defaultMaxSendMessageSize: number;
   static readonly defaultCredential: CallCredential;
   static readonly defaultContentType: BebopContentType;
   ws: Websocket;
-  readonly events: EventEmitter<Record<string, (message: Message) => void>>;
-  readonly pending: Map<string, (e: unknown) => void>;
-  private closed;
+  /** Teardown of a duplex consumer must tell the server to stop streaming. */
+  protected readonly cancelDuplexOnCleanup: boolean;
   private readonly isSecure;
   private readonly credential;
-  private readonly userAgent;
   private readonly maxReceiveMessageSize;
   private readonly maxSendMessageSize;
   private readonly _url;
@@ -59,50 +56,22 @@ declare class TempoWSChannel extends BaseChannel {
   private _reconnect;
   removeCredential(): Promise<void>;
   getCredential(): Promise<Credential | undefined>;
+  /** Every RPC waits for the socket to open before sending. */
+  protected beforeCall(): Promise<void>;
+  /** {@inheritDoc CoreChannel.getAuthorizationValue} */
+  protected getAuthorizationValue(): Promise<string | undefined>;
   /**
-   * Executes a function with retries according to the provided retry policy.
-   * The function will be retried if it fails with a TempoError and its status code is included in the retryableStatusCodes of the retry policy.
-   * If a deadline is provided, the deadline for each attempt will be managed by the provided deadline, but the deadline will not be reset upon each retry.
+   * {@inheritDoc CoreChannel.storeResponseCredential}
    *
-   * @template T - The type of the result returned by the function.
-   * @param {((retryAttempt: number) => Promise<T>)} func - A function that returns a Promise with a result. The function will receive a number indicating the current retry attempt.
-   * @param {RetryPolicy} retryPolicy - An object defining the retry policy, including maxAttempts, initialBackoff, maxBackoff, backoffMultiplier, and retryableStatusCodes.
-   * @param {Deadline} [deadline] - An optional deadline object that manages the timeout for each attempt.
-   * @param {AbortController} [abortController] - An optional AbortController instance to cancel the function execution.
-   * @returns {Promise<T>} - A Promise that resolves with the result of the function if it completes within the deadline and retry policy constraints.
-   * @throws {Error} - If the function execution fails and the error does not match the retry policy, or if the maximum number of attempts is reached without a successful result.
+   * @throws {TempoError} If the credential received on the response cannot be parsed.
    */
-  executeWithRetry<T>(func: (retryAttempt: number) => Promise<T>, retryPolicy: RetryPolicy, deadline?: Deadline, abortController?: AbortController): Promise<T>;
-  private fetchUnary;
-  private fetchClientStream;
-  private fetchServerStream;
-  private fetchDuplexStream;
-  private createRequest;
-  private processResponseHeaders;
+  protected storeResponseCredential(responseCredential: string): Promise<void>;
   waitForOpen(): Promise<void>;
   send(message: Message): void;
-  /**
-   * Tear down the channel: reject every in-flight unary/client-stream call,
-   * remove all event listeners, and close the socket. Idempotent and safe to
-   * invoke from the socket `close`/`error` events or by an explicit caller.
-   */
-  close(reason?: TempoError): void;
-  /**
-   * {@inheritDoc BaseChannel.startUnary}
-   */
-  startUnary<TRequest extends BebopRecord, TResponse extends BebopRecord>(request: TRequest, context: ClientContext, method: MethodInfo<TRequest, TResponse>, options?: CallOptions): Promise<TResponse>;
-  /**
-   * {@inheritDoc BaseChannel.startClientStream}
-   */
-  startClientStream<TRequest extends BebopRecord, TResponse extends BebopRecord>(generator: () => AsyncGenerator<TRequest, void, undefined>, context: ClientContext, method: MethodInfo<TRequest, TResponse>, options?: CallOptions): Promise<TResponse>;
-  /**
-   * {@inheritDoc BaseChannel.startServerStream}
-   */
-  startServerStream<TRequest extends BebopRecord, TResponse extends BebopRecord>(request: TRequest, context: ClientContext, method: MethodInfo<TRequest, TResponse>, options?: CallOptions): Promise<AsyncGenerator<TResponse, void, undefined>>;
-  /**
-   * {@inheritDoc BaseChannel.startDuplexStream}
-   */
-  startDuplexStream<TRequest extends BebopRecord, TResponse extends BebopRecord>(generator: () => AsyncGenerator<TRequest, void, undefined>, context: ClientContext, method: MethodInfo<TRequest, TResponse>, options?: CallOptions): Promise<AsyncGenerator<TResponse, void, undefined>>;
+  /** {@inheritDoc CoreChannel.sendFrame} */
+  protected sendFrame(message: Message): void;
+  /** Close the socket on {@link CoreChannel.close}. */
+  protected closeTransport(): void;
 }
 //#endregion
 export { TempoWSChannel, TempoWSChannelOptions };