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

package/dist/ws-channel.mjs

@@ -1,9 +1,7 @@
 import { Message } from "./bebop.mjs";
-import { createEventIterator } from "./create-event-iterator.mjs";
-import { createDuplexIterator } from "./create-duplex-iterator.mjs";
-import { ConsoleLogger, Deadline, TempoError, TempoStatusCode, TempoUtil, TempoVersion, parseCredential } from "@tempojs/common";
-import { BaseChannel, InsecureChannelCredential } from "@tempojs/client";
-import { EventEmitter } from "tseep";
+import { CoreChannel } from "./channel-core.mjs";
+import { InsecureChannelCredential } from "@tempojs/client";
+import { ConsoleLogger, Deadline, TempoError, TempoStatusCode, parseCredential } from "@tempojs/common";
 import { Websocket, WebsocketEvent } from "websocket-ts";
 //#region src/ws-channel.ts
 var ExistingWebSocket = class extends Websocket {
@@ -22,19 +20,17 @@ var ExistingWebSocket = class extends Websocket {
 /**
 * Represents a Tempo channel for communication with a remote server.
 */
-var TempoWSChannel = class TempoWSChannel extends BaseChannel {
+var TempoWSChannel = class TempoWSChannel extends CoreChannel {
 	static defaultMaxRetryAttempts = 5;
 	static defaultMaxReceiveMessageSize = 1024 * 1024 * 4;
 	static defaultMaxSendMessageSize = 1024 * 1024 * 4;
 	static defaultCredential = InsecureChannelCredential.create();
 	static defaultContentType = "bebop";
 	ws;
-	events = new EventEmitter();
-	pending = /* @__PURE__ */ new Map();
-	closed = false;
+	/** Teardown of a duplex consumer must tell the server to stop streaming. */
+	cancelDuplexOnCleanup = true;
 	isSecure;
 	credential;
-	userAgent;
 	maxReceiveMessageSize;
 	maxSendMessageSize;
 	_url;
@@ -60,7 +56,6 @@ var TempoWSChannel = class TempoWSChannel extends BaseChannel {
 		if (!this.isSecure && !(this.credential instanceof InsecureChannelCredential) && options.unsafeUseInsecureChannelCallCredential !== true) throw new Error("Cannot use secure credential with insecure channel");
 		this.maxReceiveMessageSize = options.maxReceiveMessageSize ?? TempoWSChannel.defaultMaxReceiveMessageSize;
 		this.maxSendMessageSize = options.maxSendMessageSize ?? TempoWSChannel.defaultMaxSendMessageSize;
-		this.userAgent = TempoUtil.buildUserAgent("javascript", TempoVersion, void 0, { runtime: TempoUtil.getEnvironmentName() });
 		this._setupWebSocket(target);
 		this.logger.trace(`created new TempoWSChannel for ${url.href} / ${this.userAgent}`);
 	}
@@ -130,219 +125,24 @@ var TempoWSChannel = class TempoWSChannel extends BaseChannel {
 	async getCredential() {
 		return await this.credential.getCredential();
 	}
-	/**
-	* 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.
-	*
-	* @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.
-	*/
-	async executeWithRetry(func, retryPolicy, deadline, abortController) {
-		let attempt = 0;
-		let lastError;
-		const execute = deadline ? (retryAttempt) => deadline.executeWithinDeadline(async () => await func(retryAttempt), abortController) : (retryAttempt) => func(retryAttempt);
-		while (attempt < retryPolicy.maxAttempts) try {
-			return await execute(attempt);
-		} catch (error) {
-			if (!(error instanceof Error)) throw new TempoError(TempoStatusCode.UNKNOWN, `unexpected error`, { data: error });
-			lastError = error;
-			if (!(error instanceof TempoError) || !retryPolicy.retryableStatusCodes.includes(error.status)) throw error;
-			const backoffWithJitter = Math.min(retryPolicy.initialBackoff.multiply(Math.pow(retryPolicy.backoffMultiplier, attempt)).totalMilliseconds, retryPolicy.maxBackoff.totalMilliseconds) * (Math.random() * .5 + .75);
-			await new Promise((resolve) => setTimeout(resolve, backoffWithJitter));
-			attempt++;
-		}
-		if (abortController && lastError !== void 0 && !(lastError instanceof Error && lastError.name === "AbortError") && !(lastError instanceof TempoError && lastError.status === TempoStatusCode.ABORTED)) abortController.abort();
-		return Promise.reject(lastError || new TempoError(TempoStatusCode.DEADLINE_EXCEEDED, "Failed to execute function with retry policy"));
-	}
-	async fetchUnary(init, options) {
-		const messageId = init.messageId;
-		let listener;
-		let onAbort;
-		const cleanup = () => {
-			this.events.off(messageId, listener);
-			if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
-			this.pending.delete(messageId);
-		};
-		return await new Promise((resolve, reject) => {
-			listener = (message) => resolve(message);
-			this.pending.set(messageId, reject);
-			if (options?.controller) {
-				onAbort = () => reject(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
-				options.controller.signal.addEventListener("abort", onAbort, { once: true });
-			}
-			this.events.on(messageId, listener);
-			this.send(init);
-		}).finally(cleanup);
-	}
-	async fetchClientStream(init, method, generator, options) {
-		const messageId = init.messageId;
-		let listener;
-		let onAbort;
-		const cleanup = () => {
-			this.events.off(messageId, listener);
-			if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
-			this.pending.delete(messageId);
-		};
-		return await new Promise((resolve, reject) => {
-			listener = (message) => resolve(message);
-			this.pending.set(messageId, reject);
-			if (options?.controller) {
-				onAbort = () => reject(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
-				options.controller.signal.addEventListener("abort", onAbort, { once: true });
-			}
-			this.events.on(messageId, listener);
-			runGenerator.call(this).catch(reject);
-			async function runGenerator() {
-				for await (const value of generator()) this.send(Message({
-					...init,
-					data: new Uint8Array(method.serialize(value))
-				}));
-				this.send(Message({
-					...init,
-					status: TempoStatusCode.CANCELLED,
-					data: new Uint8Array()
-				}));
-			}
-		}).finally(cleanup);
+	/** Every RPC waits for the socket to open before sending. */
+	async beforeCall() {
+		await this.waitForOpen();
 	}
-	fetchServerStream(init, context, method, options) {
-		const messageId = init.messageId;
-		return createEventIterator(({ emit, cancel, error }) => {
-			let terminated = false;
-			let onAbort;
-			const eventHandler = async (message) => {
-				try {
-					if (message.status === TempoStatusCode.CANCELLED) {
-						terminated = true;
-						cancel();
-						return;
-					}
-					await this.processResponseHeaders(message, context, method.type);
-					const requestData = message.data;
-					const record = method.deserialize(requestData);
-					if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
-					emit(record);
-				} catch (e) {
-					error(e);
-				}
-			};
-			if (options?.controller) {
-				onAbort = () => error(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
-				options.controller.signal.addEventListener("abort", onAbort, { once: true });
-			}
-			this.events.on(messageId, eventHandler);
-			this.send(init);
-			return () => {
-				this.events.off(messageId, eventHandler);
-				if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
-				if (!terminated && !this.closed) this.send(Message({
-					messageId,
-					methodId: init.methodId,
-					status: TempoStatusCode.CANCELLED,
-					data: new Uint8Array(),
-					timestamp: /* @__PURE__ */ new Date()
-				}));
-			};
-		});
-	}
-	fetchDuplexStream(init, context, method, generator, options) {
-		const messageId = init.messageId;
-		return createDuplexIterator(generator(), (value) => {
-			this.send(Message({
-				...init,
-				data: new Uint8Array(method.serialize(value))
-			}));
-		}, ({ emit, cancel, error }) => {
-			let terminated = false;
-			let onAbort;
-			const eventHandler = async (message) => {
-				try {
-					if (message.status === TempoStatusCode.CANCELLED) {
-						terminated = true;
-						cancel();
-						return;
-					}
-					await this.processResponseHeaders(message, context, method.type);
-					const requestData = message.data;
-					const record = method.deserialize(requestData);
-					if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
-					emit(record);
-				} catch (e) {
-					error(e);
-				}
-			};
-			if (options?.controller) {
-				onAbort = () => error(new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", {}));
-				options.controller.signal.addEventListener("abort", onAbort, { once: true });
-			}
-			this.events.on(messageId, eventHandler);
-			return () => {
-				this.events.off(messageId, eventHandler);
-				if (onAbort) options?.controller?.signal.removeEventListener("abort", onAbort);
-				if (!terminated && !this.closed) this.send(Message({
-					messageId,
-					methodId: init.methodId,
-					status: TempoStatusCode.CANCELLED,
-					data: new Uint8Array(),
-					timestamp: /* @__PURE__ */ new Date()
-				}));
-			};
-		});
-	}
-	/**
-	* Creates a `RequestInit` object for a given payload, context, method and optional call options.
-	* This object can be used to make an HTTP request using the Fetch API.
-	*
-	* @private
-	* @param {Uint8Array} payload - The payload to be sent in the request.
-	* @param {ClientContext} context - The context of the client making the request.
-	* @param {MethodInfo<BebopRecord, BebopRecord>} method - Information about the method being called.
-	* @param {CallOptions | undefined} options - Optional configuration for the call.
-	* @returns {Promise<RequestInit>} A Promise resolving to the created `RequestInit` object.
-	* @throws {TempoError} Throws an error if there's a problem while getting the credential header.
-	*/
-	async createRequest(payload, _context, method, options) {
-		const requestInit = {
-			messageId: crypto.randomUUID(),
-			methodId: method.id,
-			data: new Uint8Array(payload),
-			timestamp: /* @__PURE__ */ new Date()
-		};
-		if (options?.deadline) requestInit.deadline = new Date(options.deadline.toUnixTimestamp());
+	/** {@inheritDoc CoreChannel.getAuthorizationValue} */
+	async getAuthorizationValue() {
 		const credentialHeader = await this.credential.getHeader();
-		if (credentialHeader) requestInit.authorization = credentialHeader.value;
-		return Message(requestInit);
+		return credentialHeader ? credentialHeader.value : void 0;
 	}
 	/**
-	* Processes the headers of the response from the server, validating their integrity and correctness.
-	* Also sets the incoming metadata from the response headers to the provided context.
+	* {@inheritDoc CoreChannel.storeResponseCredential}
 	*
-	* @private
-	* @param {Response} response - The response received from the server.
-	* @param {ClientContext} context - The context of the client making the request.
-	* @param {MethodType} methodType - The type of method being called.
-	* @throws {TempoError} Throws an error if any validation checks fail or if there's a problem parsing or storing credentials.
+	* @throws {TempoError} If the credential received on the response cannot be parsed.
 	*/
-	async processResponseHeaders(response, _context, _methodType) {
-		const statusCode = response.status;
-		if (statusCode === void 0) throw new TempoError(TempoStatusCode.UNKNOWN, "tempo-status missing from response.");
-		if (statusCode !== TempoStatusCode.OK && statusCode !== TempoStatusCode.CANCELLED) {
-			let tempoMessage = response.msg;
-			if (!tempoMessage) tempoMessage = "unknown error";
-			throw new TempoError(statusCode, tempoMessage);
-		}
-		const responseCredential = response.credential;
-		if (responseCredential) {
-			const credential = parseCredential(responseCredential);
-			if (!credential) throw new TempoError(TempoStatusCode.INVALID_ARGUMENT, "unable to parse credentials received on 'tempo-credential' header");
-			await this.credential.storeCredential(credential);
-		}
+	async storeResponseCredential(responseCredential) {
+		const credential = parseCredential(responseCredential);
+		if (!credential) throw new TempoError(TempoStatusCode.INVALID_ARGUMENT, "unable to parse credentials received on 'tempo-credential' header");
+		await this.credential.storeCredential(credential);
 	}
 	async waitForOpen() {
 		const maxAttempts = 2;
@@ -394,127 +194,16 @@ var TempoWSChannel = class TempoWSChannel extends BaseChannel {
 		if (frame.length > this.maxSendMessageSize) throw new TempoError(TempoStatusCode.INVALID_ARGUMENT, `outbound frame ${frame.length}B exceeds maxSendMessageSize ${this.maxSendMessageSize}B`);
 		this.ws.send(frame);
 	}
-	/**
-	* 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) {
-		if (this.closed) return;
-		this.closed = true;
-		const err = reason ?? new TempoError(TempoStatusCode.CANCELLED, "channel disposed");
-		for (const reject of this.pending.values()) reject(err);
-		this.pending.clear();
-		this.events.removeAllListeners();
+	/** {@inheritDoc CoreChannel.sendFrame} */
+	sendFrame(message) {
+		this.send(message);
+	}
+	/** Close the socket on {@link CoreChannel.close}. */
+	closeTransport() {
 		try {
 			this.ws.close();
 		} catch {}
 	}
-	/**
-	* {@inheritDoc BaseChannel.startUnary}
-	*/
-	async startUnary(request, context, method, options) {
-		try {
-			await this.waitForOpen();
-			const requestData = method.serialize(request);
-			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
-			const requestInit = await this.createRequest(requestData, context, method, options);
-			let response;
-			if (options?.retryPolicy) response = await this.executeWithRetry(async (retryAttempt) => {
-				if (retryAttempt > 0) requestInit.previousAttempts = retryAttempt;
-				return await this.fetchUnary(requestInit);
-			}, options.retryPolicy, options.deadline, options.controller);
-			else if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
-				return await this.fetchUnary(requestInit, options);
-			}, options.controller);
-			else response = await this.fetchUnary(requestInit, options);
-			await this.processResponseHeaders(response, context, method.type);
-			if (this.hooks !== void 0) await this.hooks.executeResponseHooks(context);
-			const record = method.deserialize(response.data);
-			if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
-			return record;
-		} catch (e) {
-			if (this.hooks !== void 0 && e instanceof Error) this.hooks.executeErrorHooks(context, e);
-			if (e instanceof TempoError) throw e;
-			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
-			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
-			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
-		}
-	}
-	/**
-	* {@inheritDoc BaseChannel.startClientStream}
-	*/
-	async startClientStream(generator, context, method, options) {
-		try {
-			await this.waitForOpen();
-			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
-			const requestInit = await this.createRequest(new Uint8Array(), context, method, options);
-			let response;
-			if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
-				return await this.fetchClientStream(requestInit, method, generator, options);
-			}, options.controller);
-			else response = await this.fetchClientStream(requestInit, method, generator, options);
-			await this.processResponseHeaders(response, context, method.type);
-			const record = this.deserializeResponse(response.data, method);
-			if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
-			return record;
-		} catch (e) {
-			if (this.hooks !== void 0 && e instanceof Error) this.hooks.executeErrorHooks(context, e);
-			if (e instanceof TempoError) throw e;
-			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
-			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
-			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
-		}
-	}
-	/**
-	* {@inheritDoc BaseChannel.startServerStream}
-	*/
-	async startServerStream(request, context, method, options) {
-		try {
-			await this.waitForOpen();
-			const requestData = method.serialize(request);
-			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
-			const requestInit = await this.createRequest(requestData, context, method, options);
-			let response;
-			if (options?.retryPolicy) response = await this.executeWithRetry(async (retryAttempt) => {
-				if (retryAttempt > 0) requestInit.previousAttempts = retryAttempt;
-				return this.fetchServerStream(requestInit, context, method, options);
-			}, options.retryPolicy, options.deadline, options.controller);
-			else if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
-				return this.fetchServerStream(requestInit, context, method, options);
-			}, options.controller);
-			else response = this.fetchServerStream(requestInit, context, method, options);
-			return response;
-		} catch (e) {
-			if (this.hooks !== void 0 && e instanceof Error) this.hooks.executeErrorHooks(context, e);
-			if (e instanceof TempoError) throw e;
-			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
-			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
-			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
-		}
-	}
-	/**
-	* {@inheritDoc BaseChannel.startDuplexStream}
-	*/
-	async startDuplexStream(generator, context, method, options) {
-		try {
-			await this.waitForOpen();
-			if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
-			const requestInit = await this.createRequest(new Uint8Array(), context, method, options);
-			let response;
-			if (options?.deadline) response = await options.deadline.executeWithinDeadline(async () => {
-				return this.fetchDuplexStream(requestInit, context, method, generator, options);
-			}, options.controller);
-			else response = this.fetchDuplexStream(requestInit, context, method, generator, options);
-			return response;
-		} catch (e) {
-			if (this.hooks !== void 0 && e instanceof Error) await this.hooks.executeErrorHooks(context, e);
-			if (e instanceof TempoError) throw e;
-			if (e instanceof Error) if (e.name === "AbortError") throw new TempoError(TempoStatusCode.ABORTED, "RPC fetch aborted", e);
-			else throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", e);
-			throw new TempoError(TempoStatusCode.UNKNOWN, "an unknown error occurred", { data: e });
-		}
-	}
 };
 //#endregion
 export { TempoWSChannel };

package/dist/ws-router.d.mts

@@ -29,16 +29,11 @@ declare function encodeServerStreamFrame(opts: {
   data: Uint8Array;
 }): Uint8Array;
 declare class TempoWsRouter<Context, Ws extends GenericWs = WebSocket, Env extends [Context, Ws] = [Context, Ws]> extends BaseRouter<ArrayBuffer, Env, Message> {
-  private readonly events;
-  private readonly clientStreams;
+  private readonly core;
   private readonly serverStreams;
   private readonly _streamEncodeCache;
   constructor(logger: TempoLogger, registry: ServiceRegistry, configuration?: TempoRouterConfiguration, authInterceptor?: AuthInterceptor);
-  private setAuthContext;
-  private invokeUnaryMethod;
-  private invokeClientStreamMethod;
   private invokeServerStreamMethod;
-  private invokeDuplexStreamMethod;
   /**
    * Tear down all open streams for this connection (driven by the DO socket
    * close/error lifecycle). Emits a synthetic CANCELLED to each in-flight