@vampgg/utils 1.0.0-beta.1

package/dist/extension-router.mjs

@@ -0,0 +1,375 @@
+import { Message } from "./bebop.mjs";
+import { createEventIterator } from "./create-event-iterator.mjs";
+import { Deadline, Metadata, MethodType, TempoError, TempoStatusCode, TempoUtil, TempoVersion, stringifyCredential } from "@tempojs/common";
+import { EventEmitter } from "tseep";
+import { tabs } from "webextension-polyfill";
+import { ServerContext, TempoRouterConfiguration } from "@tempojs/server";
+//#region src/extension-router.ts
+/**
+* Interface defining the configuration options for a TempoRouter instance.
+*/
+var TempoExtensionRouterConfiguration = class {
+	static defaultMaxRetryAttempts = 5;
+	static defaultMaxReceiveMessageSize = 1024 * 1024 * 4;
+	static defaultMaxSendMessageSize = 1024 * 1024 * 4;
+	/**
+	* Optional flag to enable CORS (Cross-Origin Resource Sharing) support.
+	*/
+	enableCors;
+	/**
+	* Optional list of allowed origins for CORS. Ignored if enableCors is false.
+	*/
+	allowedOrigins;
+	/**
+	* Optional flag to indicate whether internal errors should be transmitted
+	* in the API response. Defaults to false, meaning internal errors are
+	* masked and not exposed to clients.
+	*/
+	transmitInternalErrors;
+	/**
+	* The maximum size of the message that can be received. Defaults to the value in `TempoRouterConfiguration.defaultMaxReceiveMessageSize`.
+	*/
+	maxReceiveMessageSize;
+	/**
+	* The maximum size of the message that can be sent.
+	*/
+	maxSendMessageSize;
+	/**
+	* The maximum number of retry attempts for failed requests. Defaults to the value in `TempoRouterConfiguration.defaultMaxRetryAttempts`.
+	*/
+	maxRetryAttempts;
+	/**
+	* Constructs a new instance of TempoRouterConfiguration with default values.
+	*/
+	constructor() {
+		this.maxReceiveMessageSize = TempoRouterConfiguration.defaultMaxReceiveMessageSize;
+		this.maxSendMessageSize = TempoRouterConfiguration.defaultMaxSendMessageSize;
+		this.maxRetryAttempts = TempoRouterConfiguration.defaultMaxRetryAttempts;
+	}
+};
+/**
+* Represents an abstract base class for a router that handles incoming requests, performs validation, and routes
+* them to the appropriate services and methods in a Tempo application.
+*
+* @template TRequest - The type of the request object.
+* @template TEnvironment - The type of the environment/context object.
+* @template TResponse - The type of the response object.
+*/
+var ExtensionBaseRouter = class {
+	logger;
+	registry;
+	configuration;
+	authInterceptor;
+	corsEnabled;
+	allowedCorsOrigins;
+	transmitInternalErrors;
+	maxReceiveMessageSize;
+	maxSendMessageSize;
+	maxRetryAttempts;
+	exposeTempo;
+	hooks;
+	poweredByHeader = "x-powered-by";
+	poweredByHeaderValue;
+	/**
+	* Constructs a new BaseRouter instance.
+	* @param logger - The logger to use for logging router-related information.
+	* @param registry - The service registry instance that manages services and methods for this router.
+	* @param authInterceptor - The interceptor (if any) that will be used for authenticating the peer of an incoming requests.
+	*/
+	constructor(logger, registry, configuration, authInterceptor) {
+		this.logger = logger;
+		this.registry = registry;
+		this.configuration = configuration;
+		this.authInterceptor = authInterceptor;
+		this.corsEnabled = configuration.enableCors ?? false;
+		this.allowedCorsOrigins = configuration.allowedOrigins;
+		this.transmitInternalErrors = configuration.transmitInternalErrors ?? false;
+		this.maxReceiveMessageSize = configuration.maxReceiveMessageSize ?? TempoRouterConfiguration.defaultMaxReceiveMessageSize;
+		if (configuration.maxSendMessageSize !== void 0) this.maxSendMessageSize = configuration.maxSendMessageSize;
+		this.maxRetryAttempts = configuration.maxRetryAttempts ?? TempoRouterConfiguration.defaultMaxRetryAttempts;
+		this.exposeTempo = configuration.exposeTempo ?? false;
+		this.registry.init();
+	}
+	/**
+	* Private function that retrieves custom metadata from the header.
+	*
+	* @private
+	* @function
+	* @param {string | null} value The custom metadata value from the request.
+	* @returns {Metadata} The metadata object.
+	*/
+	getCustomMetaData(value) {
+		if (!value) return new Metadata();
+		return Metadata.fromHttpHeader(value);
+	}
+	/**
+	* Defines a hook registry for the router.
+	* @param hooks - The hook registry to be used.
+	*/
+	useHooks(hooks) {
+		this.hooks = hooks;
+	}
+	definePoweredByHeader(variant) {
+		this.poweredByHeaderValue = TempoUtil.buildUserAgent("javascript", TempoVersion, variant, { runtime: TempoUtil.getEnvironmentName() });
+	}
+	/**
+	* Deserializes an incoming request based on its content type.
+	*
+	* @param requestData - The incoming request data as a Uint8Array.
+	* @param method - The Bebop method to use for deserialization.
+	* @param contentType - The content type of the incoming request.
+	* @returns The deserialized request record.
+	* @throws {TempoError} When the content type is not valid.
+	* @throws {BebopRuntimeError} When the request data cannot be deserialized.
+	*/
+	deserializeRequest(requestData, method, contentType) {
+		switch (contentType) {
+			case "bebop": return method.deserialize(requestData);
+			default: throw new TempoError(TempoStatusCode.UNKNOWN_CONTENT_TYPE, `invalid request content type: ${contentType}`);
+		}
+	}
+	/**
+	* Serializes a response record based on its content type.
+	*
+	* @param response - The response record to be serialized.
+	* @param method - The Bebop method to use for serialization.
+	* @param contentType - The content type of the response.
+	* @returns The serialized response as a Uint8Array.
+	* @throws {TempoError} When the content type is not valid.
+	* @throws {BebopRuntimeError} When the response record cannot be serialized.
+	*/
+	serializeResponse(response, method, contentType) {
+		switch (contentType) {
+			case "bebop": return method.serialize(response);
+			default: throw new TempoError(TempoStatusCode.UNKNOWN_CONTENT_TYPE, `invalid response content type: ${contentType}`);
+		}
+	}
+};
+var TempoExtensionRouter = class extends ExtensionBaseRouter {
+	events = new EventEmitter();
+	clientStreams = /* @__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) {
+		await this.setAuthContext(request, context);
+		if (this.hooks !== void 0) await this.hooks.executeRequestHooks(context);
+		const record = this.deserializeRequest(request.data, method, "bebop");
+		if (this.hooks !== void 0) await this.hooks.executeDecodeHooks(context, record);
+		return await method.invoke(record, context);
+	}
+	async invokeClientStreamMethod(request, context, method) {
+		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, "bebop");
+					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) {
+		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, "bebop");
+		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) {
+		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, "bebop");
+					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. Emits a synthetic CANCELLED
+	* to each in-flight client/duplex stream so its generator ends, then clears
+	* all listeners.
+	*/
+	async closeConnection() {
+		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, ctx) {
+		let request = Message(req);
+		let context;
+		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 }, ctx);
+			const handleRequest = async () => {
+				let recordGenerator = void 0;
+				let record;
+				switch (method.type) {
+					case MethodType.Unary:
+						record = await this.invokeUnaryMethod(request, context, method);
+						break;
+					case MethodType.ClientStream:
+						record = await this.invokeClientStreamMethod(request, context, method);
+						break;
+					case MethodType.ServerStream:
+						recordGenerator = await this.invokeServerStreamMethod(request, context, method);
+						break;
+					case MethodType.DuplexStream:
+						recordGenerator = await this.invokeDuplexStreamMethod(request, context, method);
+						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();
+				response.msg = "";
+				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 writeFrames = async () => {
+						for await (const value of recordGenerator) {
+							const responseData = this.serializeResponse(value, method, "bebop");
+							response.data = new Uint8Array(responseData);
+							await this.send(ctx.sender, response);
+						}
+						response.data = new Uint8Array();
+						response.status = TempoStatusCode.CANCELLED;
+						await this.send(ctx.sender, response);
+					};
+					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, "bebop");
+					response.data = new Uint8Array(responseData);
+					await this.send(ctx.sender, response);
+				}
+			};
+			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;
+			await this.send(ctx.sender, response);
+		}
+	}
+	async send(sender, message) {
+		if (!sender.tab?.id || sender.tab?.discarded === true) {
+			this.logger.warn(`ignoring message to discarded tab`, { tab: sender.tab });
+			return;
+		}
+		try {
+			await tabs.sendMessage(sender.tab.id, Array.apply(null, Message.encode(message)));
+		} catch (e) {
+			this.logger.error("failed to send message, tab is likely inactive", {}, e);
+		}
+	}
+	async handle(_req, _ctx) {
+		return Message({});
+	}
+};
+//#endregion
+export { ExtensionBaseRouter, TempoExtensionRouter, TempoExtensionRouterConfiguration };

package/dist/memory-storage.d.mts

@@ -0,0 +1,12 @@
+import { Credential } from "@tempojs/common";
+import { CredentialStorage } from "@tempojs/client";
+
+//#region src/memory-storage.d.ts
+declare class MemoryStorageStrategy implements CredentialStorage {
+  storage: Map<string, string>;
+  getCredential(key: string): Promise<Credential | undefined>;
+  storeCredential(key: string, _credential: Credential): Promise<void>;
+  removeCredential(key: string): Promise<void>;
+}
+//#endregion
+export { MemoryStorageStrategy };

package/dist/memory-storage.mjs

@@ -0,0 +1,18 @@
+import { parseCredential, stringifyCredential } from "@tempojs/common";
+//#region src/memory-storage.ts
+var MemoryStorageStrategy = class {
+	storage = /* @__PURE__ */ new Map();
+	async getCredential(key) {
+		let credentials = this.storage.get(key);
+		if (!credentials) return void 0;
+		return parseCredential(credentials);
+	}
+	async storeCredential(key, _credential) {
+		this.storage.set(key, stringifyCredential(_credential));
+	}
+	async removeCredential(key) {
+		this.storage.delete(key);
+	}
+};
+//#endregion
+export { MemoryStorageStrategy };

package/dist/pino-logger.d.mts

@@ -0,0 +1,44 @@
+import { ContextLogger } from "./context-logger.mjs";
+import { ConsoleLogger, TempoLogLevel, TempoLogger } from "@tempojs/common";
+import pino from "pino";
+
+//#region src/pino-logger.d.ts
+declare class PinoLogger extends ContextLogger implements ConsoleLogger {
+  logger: pino.Logger;
+  sourceName: string;
+  logLevel: TempoLogLevel;
+  children: Set<TempoLogger>;
+  constructor(sourceName: string, logLevel?: TempoLogLevel, parent?: pino.Logger, bindings?: Record<string, unknown>);
+  static getPinoLevel(level: string): string;
+  clone<TLogger extends TempoLogger>(sourceName: string, asOrphan?: boolean, bindings?: Record<string, unknown>): TLogger;
+  write(level: TempoLogLevel, message: string, data?: Record<string, unknown>, error?: Error): void;
+  /**
+   * @inheritDoc
+   */
+  trace(message: string, data?: Record<string, unknown>, error?: Error): void;
+  /**
+   * @inheritDoc
+   */
+  debug(message: string, data?: Record<string, unknown>, error?: Error): void;
+  /**
+   * @inheritDoc
+   */
+  info(message: string, data?: Record<string, unknown>, error?: Error): void;
+  /**
+   * @inheritDoc
+   */
+  warn(message: string, data?: Record<string, unknown>, error?: Error): void;
+  /**
+   * @inheritDoc
+   */
+  error(message: string, data?: Record<string, unknown>, error?: Error): void;
+  /**
+   * @inheritDoc
+   */
+  critical(message: string, data?: Record<string, unknown>, error?: Error): void;
+  setLogLevel(level: TempoLogLevel): void;
+  private tempoPinoLevelMap;
+  formatErrorMessage(error: Error, indentLevel?: number): string;
+}
+//#endregion
+export { PinoLogger };

package/dist/pino-logger.mjs

@@ -0,0 +1,127 @@
+import { ContextLogger } from "./context-logger.mjs";
+import { TempoLogLevel } from "@tempojs/common";
+import pino from "pino";
+//#region src/pino-logger.ts
+var PinoLogger = class PinoLogger extends ContextLogger {
+	logger;
+	sourceName;
+	logLevel;
+	children = /* @__PURE__ */ new Set();
+	constructor(sourceName, logLevel = TempoLogLevel.Info, parent = pino(), bindings) {
+		super(sourceName, logLevel, void 0, bindings);
+		this.sourceName = sourceName;
+		this.logLevel = logLevel;
+		this.logger = parent.child({
+			source: sourceName,
+			...bindings
+		});
+		this.logger.level = PinoLogger.getPinoLevel(String(logLevel));
+	}
+	static getPinoLevel(level) {
+		switch (level) {
+			case "0": return "trace";
+			case "1": return "debug";
+			case "2": return "info";
+			case "3": return "warn";
+			case "4":
+			case "5": return "error";
+			default: return "info";
+		}
+	}
+	clone(sourceName, asOrphan, bindings) {
+		return new PinoLogger(sourceName, this.logLevel, asOrphan ? void 0 : this.logger, bindings);
+	}
+	write(level, message, data = {}, error) {
+		if (level < this.logLevel) return;
+		let logError = "";
+		if (error) {
+			logError = `\n${this.formatErrorMessage(error)}`;
+			data.error = logError;
+		}
+		switch (level) {
+			case TempoLogLevel.Trace:
+				this.logger.trace(data, message);
+				break;
+			case TempoLogLevel.Debug:
+				this.logger.debug(data, message);
+				break;
+			case TempoLogLevel.Info:
+				this.logger.info(data, message);
+				break;
+			case TempoLogLevel.Warn:
+				this.logger.warn(data, message);
+				break;
+			case TempoLogLevel.Error:
+				this.logger.error(data, message);
+				break;
+			case TempoLogLevel.Critical:
+				this.logger.error(data, message);
+				break;
+		}
+	}
+	/**
+	* @inheritDoc
+	*/
+	trace(message, data, error) {
+		this.write(0, message, data, error);
+	}
+	/**
+	* @inheritDoc
+	*/
+	debug(message, data, error) {
+		this.write(1, message, data, error);
+	}
+	/**
+	* @inheritDoc
+	*/
+	info(message, data, error) {
+		this.write(2, message, data, error);
+	}
+	/**
+	* @inheritDoc
+	*/
+	warn(message, data, error) {
+		this.write(3, message, data, error);
+	}
+	/**
+	* @inheritDoc
+	*/
+	error(message, data, error) {
+		this.write(4, message, data, error);
+	}
+	/**
+	* @inheritDoc
+	*/
+	critical(message, data, error) {
+		this.write(5, message, data, error);
+	}
+	setLogLevel(level) {
+		this.logLevel = level;
+		const pinoLevel = this.tempoPinoLevelMap(level);
+		this.logger.level = pinoLevel;
+	}
+	tempoPinoLevelMap(level) {
+		switch (level) {
+			case TempoLogLevel.Trace: return "trace";
+			case TempoLogLevel.Debug: return "debug";
+			case TempoLogLevel.Info: return "info";
+			case TempoLogLevel.Warn: return "warn";
+			case TempoLogLevel.Error: return "error";
+			case TempoLogLevel.Critical: return "fatal";
+			default: return "info";
+		}
+	}
+	formatErrorMessage(error, indentLevel = 0) {
+		const indent = "  ".repeat(indentLevel);
+		const message = error.message || "Unknown error";
+		const indentedStack = (error.stack || "Stack unavailable").split("\n").map((line) => `${indent}${line}`).join("\n");
+		let cause = "";
+		if ("cause" in error) cause = error?.cause instanceof Error ? this.formatErrorMessage(error.cause, indentLevel + 1) : "";
+		return `
+${indent}Error message: ${message}
+${indentedStack}
+${indent}${cause ? `Cause: ${cause}` : ""}`.trimEnd();
+	}
+};
+//#endregion
+export { PinoLogger };

package/dist/sync-storage.d.mts

@@ -0,0 +1,11 @@
+import { Credential } from "@tempojs/common";
+import { CredentialStorage } from "@tempojs/client";
+
+//#region src/sync-storage.d.ts
+declare class SyncStorageStrategy implements CredentialStorage {
+  getCredential(key: string): Promise<Credential | undefined>;
+  storeCredential(key: string, _credential: Credential): Promise<void>;
+  removeCredential(key: string): Promise<void>;
+}
+//#endregion
+export { SyncStorageStrategy };

package/dist/sync-storage.mjs

@@ -0,0 +1,18 @@
+import { parseCredential, stringifyCredential } from "@tempojs/common";
+import { storage } from "webextension-polyfill";
+//#region src/sync-storage.ts
+var SyncStorageStrategy = class {
+	async getCredential(key) {
+		let credentials = await storage.sync.get(key);
+		if (!credentials[key]) return void 0;
+		return parseCredential(credentials[key]);
+	}
+	async storeCredential(key, _credential) {
+		await storage.sync.set({ [key]: stringifyCredential(_credential) });
+	}
+	async removeCredential(key) {
+		await storage.sync.remove(key);
+	}
+};
+//#endregion
+export { SyncStorageStrategy };