@vampgg/utils 1.0.0-beta.1

package/dist/worker-router.mjs

@@ -0,0 +1,254 @@
+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";
+//#region src/worker-router.ts
+var TempoWorkerRouter = class extends BaseRouter {
+	events = new EventEmitter();
+	clientStreams = /* @__PURE__ */ new Map();
+	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);
+		});
+	}
+	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
+	* synthetic CANCELLED to each client/duplex stream, then clears listeners.
+	*/
+	async closeConnection() {
+		for (const [id, info] of [...this.serverStreams]) {
+			info.cancelled = true;
+			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();
+	}
+	async process(req, response, env) {
+		let request = Message.decode(req);
+		let context;
+		const contentType = "bebop";
+		if (request.status === TempoStatusCode.CANCELLED && request.messageId) {
+			const streamInfo = this.serverStreams.get(request.messageId);
+			if (streamInfo) {
+				streamInfo.cancelled = true;
+				await streamInfo.generator.return(void 0);
+				this.serverStreams.delete(request.messageId);
+			}
+			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();
+			postMessage(encoded, [encoded.buffer]);
+		}
+	}
+	handle(_request, _env) {
+		throw new TempoError(TempoStatusCode.UNIMPLEMENTED, "Method not implemented.");
+	}
+};
+//#endregion
+export { TempoWorkerRouter };

package/dist/ws-channel.d.mts

@@ -0,0 +1,108 @@
+import { Message } from "./bebop.mjs";
+import { BebopRecord } from "bebop";
+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 { Websocket, WebsocketOptions } from "websocket-ts";
+
+//#region src/ws-channel.d.ts
+type TempoWSChannelOptions = TempoChannelOptions & {
+  binaryType?: BinaryType;
+} & WebsocketOptions;
+/**
+ * Represents a Tempo channel for communication with a remote server.
+ */
+declare class TempoWSChannel extends BaseChannel {
+  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;
+  private readonly isSecure;
+  private readonly credential;
+  private readonly userAgent;
+  private readonly maxReceiveMessageSize;
+  private readonly maxSendMessageSize;
+  private readonly _url;
+  private readonly _wsOptions;
+  get log(): _tempojs_common0.TempoLogger;
+  /**
+   * Constructs a new TempoChannel instance.
+   *
+   * @param {URL} target - The target URL for the channel.
+   * @param {TempoWSChannelOptions} options - The configuration options for the channel.
+   * @protected
+   */
+  protected constructor(target: URL | WebSocket, options: TempoWSChannelOptions);
+  /**
+   * Creates a new TempoChannel instance for the specified address.
+   *
+   * @param {string | URL} address - The target address as a string or URL object.
+   * @param {TempoChannelOptions} [options] - Optional configuration options for the channel.
+   * @returns {TempoChannel} - A new TempoChannel instance.
+   */
+  static forWebSocket(target: WebSocket, options?: TempoWSChannelOptions): TempoWSChannel;
+  /**
+   * Creates a new TempoChannel instance for the specified address.
+   *
+   * @param {string | URL} address - The target address as a string or URL object.
+   * @param {TempoChannelOptions} [options] - Optional configuration options for the channel.
+   * @returns {TempoChannel} - A new TempoChannel instance.
+   */
+  static forAddress(address: string | URL, options?: TempoWSChannelOptions): TempoWSChannel;
+  private _setupWebSocket;
+  private _reconnect;
+  removeCredential(): Promise<void>;
+  getCredential(): Promise<Credential | 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.
+   *
+   * @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.
+   */
+  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;
+  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>>;
+}
+//#endregion
+export { TempoWSChannel, TempoWSChannelOptions };