iii-sdk 0.0.2-alpha

package/dist/index.mjs

@@ -0,0 +1,610 @@
+import { D as EngineFunctions, E as DEFAULT_INVOCATION_TIMEOUT_MS, O as EngineTriggers, S as injectTraceparent, T as DEFAULT_BRIDGE_RECONNECTION_CONFIG, _ as extractContext, a as SeverityNumber$1, c as getLogger, d as initOtel, f as shutdownOtel, h as currentTraceId, i as safeStringify, l as getMeter, m as currentSpanId, n as stopWorkerGauges, o as SpanKind, p as withSpan, t as registerWorkerGauges, u as getTracer, x as injectBaggage } from "./otel-worker-gauges-ELciXZRg.mjs";
+import { context } from "@opentelemetry/api";
+import { createRequire } from "module";
+import * as os from "os";
+import { WebSocket } from "ws";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+
+//#region src/iii-types.ts
+let MessageType = /* @__PURE__ */ function(MessageType$1) {
+	MessageType$1["RegisterFunction"] = "registerfunction";
+	MessageType$1["UnregisterFunction"] = "unregisterfunction";
+	MessageType$1["RegisterService"] = "registerservice";
+	MessageType$1["InvokeFunction"] = "invokefunction";
+	MessageType$1["InvocationResult"] = "invocationresult";
+	MessageType$1["RegisterTriggerType"] = "registertriggertype";
+	MessageType$1["RegisterTrigger"] = "registertrigger";
+	MessageType$1["UnregisterTrigger"] = "unregistertrigger";
+	MessageType$1["UnregisterTriggerType"] = "unregistertriggertype";
+	MessageType$1["TriggerRegistrationResult"] = "triggerregistrationresult";
+	MessageType$1["WorkerRegistered"] = "workerregistered";
+	return MessageType$1;
+}({});
+
+//#endregion
+//#region src/logger.ts
+var Logger = class {
+	get otelLogger() {
+		if (!this._otelLogger) this._otelLogger = getLogger();
+		return this._otelLogger;
+	}
+	constructor(invoker, traceId, serviceName, spanId) {
+		this.invoker = invoker;
+		this.traceId = traceId;
+		this.serviceName = serviceName;
+		this.spanId = spanId;
+		this._otelLogger = null;
+	}
+	emit(message, severity, data) {
+		const attributes = {};
+		if (this.traceId) attributes.trace_id = this.traceId;
+		if (this.spanId) attributes.span_id = this.spanId;
+		if (this.serviceName) attributes["service.name"] = this.serviceName;
+		if (data !== void 0) attributes["log.data"] = typeof data === "string" ? data : safeStringify(data);
+		if (this.otelLogger) this.otelLogger.emit({
+			severityNumber: severity,
+			body: message,
+			attributes: Object.keys(attributes).length > 0 ? attributes : void 0
+		});
+		else switch (severity) {
+			case SeverityNumber.DEBUG:
+				console.debug(message, data);
+				break;
+			case SeverityNumber.INFO:
+				console.info(message, data);
+				break;
+			case SeverityNumber.WARN:
+				console.warn(message, data);
+				break;
+			case SeverityNumber.ERROR:
+				console.error(message, data);
+				break;
+			default: console.log(message, data);
+		}
+	}
+	info(message, data) {
+		this.emit(message, SeverityNumber.INFO, data);
+	}
+	warn(message, data) {
+		this.emit(message, SeverityNumber.WARN, data);
+	}
+	error(message, data) {
+		this.emit(message, SeverityNumber.ERROR, data);
+	}
+	debug(message, data) {
+		this.emit(message, SeverityNumber.DEBUG, data);
+	}
+};
+
+//#endregion
+//#region src/context.ts
+const globalStorage = new AsyncLocalStorage();
+const withContext = async (fn, ctx) => {
+	const currentOtelContext = context.active();
+	return globalStorage.run(ctx, async () => {
+		return context.with(currentOtelContext, async () => await fn(ctx));
+	});
+};
+const getContext = () => {
+	const store = globalStorage.getStore();
+	if (store) return store;
+	return { logger: new Logger() };
+};
+
+//#endregion
+//#region src/iii.ts
+const { version: SDK_VERSION } = createRequire(import.meta.url)("../package.json");
+function getOsInfo() {
+	return `${os.platform()} ${os.release()} (${os.arch()})`;
+}
+function getDefaultWorkerName() {
+	return `${os.hostname()}:${process.pid}`;
+}
+var Sdk = class {
+	constructor(address, options) {
+		this.address = address;
+		this.functions = /* @__PURE__ */ new Map();
+		this.services = /* @__PURE__ */ new Map();
+		this.invocations = /* @__PURE__ */ new Map();
+		this.triggers = /* @__PURE__ */ new Map();
+		this.triggerTypes = /* @__PURE__ */ new Map();
+		this.functionsAvailableCallbacks = /* @__PURE__ */ new Set();
+		this.logCallbacks = /* @__PURE__ */ new Map();
+		this.messagesToSend = [];
+		this.reconnectAttempt = 0;
+		this.connectionState = "disconnected";
+		this.stateCallbacks = /* @__PURE__ */ new Set();
+		this.isShuttingDown = false;
+		this.registerTriggerType = (triggerType, handler) => {
+			this.sendMessage(MessageType.RegisterTriggerType, triggerType, true);
+			this.triggerTypes.set(triggerType.id, {
+				message: {
+					...triggerType,
+					type: MessageType.RegisterTriggerType
+				},
+				handler
+			});
+		};
+		this.on = (event, callback) => {
+			this.ws?.on(event, callback);
+		};
+		this.unregisterTriggerType = (triggerType) => {
+			this.sendMessage(MessageType.UnregisterTriggerType, triggerType, true);
+			this.triggerTypes.delete(triggerType.id);
+		};
+		this.registerTrigger = (trigger) => {
+			const id = crypto.randomUUID();
+			this.sendMessage(MessageType.RegisterTrigger, {
+				...trigger,
+				id
+			}, true);
+			this.triggers.set(id, {
+				...trigger,
+				id,
+				type: MessageType.RegisterTrigger
+			});
+			return { unregister: () => {
+				this.sendMessage(MessageType.UnregisterTrigger, {
+					id,
+					trigger_type: MessageType.UnregisterTrigger
+				});
+				this.triggers.delete(id);
+			} };
+		};
+		this.registerFunction = (message, handler) => {
+			if (!message.id || message.id.trim() === "") throw new Error("id is required");
+			this.sendMessage(MessageType.RegisterFunction, message, true);
+			this.functions.set(message.id, {
+				message: {
+					...message,
+					type: MessageType.RegisterFunction
+				},
+				handler: async (input, traceparent, baggage) => {
+					if (getTracer()) {
+						const parentContext = extractContext(traceparent, baggage);
+						return context.with(parentContext, () => withSpan(`invoke ${message.id}`, { kind: SpanKind.SERVER }, async (span) => {
+							const traceId = currentTraceId() ?? crypto.randomUUID();
+							const spanId = currentSpanId();
+							return withContext(async () => await handler(input), {
+								logger: new Logger(void 0, traceId, message.id, spanId),
+								trace: span
+							});
+						}));
+					}
+					return withContext(async () => await handler(input), { logger: new Logger(void 0, crypto.randomUUID(), message.id) });
+				}
+			});
+			return {
+				id: message.id,
+				unregister: () => {
+					this.sendMessage(MessageType.UnregisterFunction, { id: message.id }, true);
+					this.functions.delete(message.id);
+				}
+			};
+		};
+		this.registerService = (message) => {
+			this.sendMessage(MessageType.RegisterService, message, true);
+			this.services.set(message.id, {
+				...message,
+				type: MessageType.RegisterService
+			});
+		};
+		this.call = async (function_id, data, timeoutMs) => {
+			const invocation_id = crypto.randomUUID();
+			const traceparent = injectTraceparent();
+			const baggage = injectBaggage();
+			const effectiveTimeout = timeoutMs ?? this.invocationTimeoutMs;
+			return new Promise((resolve, reject) => {
+				const timeout = setTimeout(() => {
+					if (this.invocations.get(invocation_id)) {
+						this.invocations.delete(invocation_id);
+						reject(/* @__PURE__ */ new Error(`Invocation timeout after ${effectiveTimeout}ms: ${function_id}`));
+					}
+				}, effectiveTimeout);
+				this.invocations.set(invocation_id, {
+					resolve: (result) => {
+						clearTimeout(timeout);
+						resolve(result);
+					},
+					reject: (error) => {
+						clearTimeout(timeout);
+						reject(error);
+					},
+					timeout
+				});
+				this.sendMessage(MessageType.InvokeFunction, {
+					invocation_id,
+					function_id,
+					data,
+					traceparent,
+					baggage
+				});
+			});
+		};
+		this.callVoid = (function_id, data) => {
+			const traceparent = injectTraceparent();
+			const baggage = injectBaggage();
+			this.sendMessage(MessageType.InvokeFunction, {
+				function_id,
+				data,
+				traceparent,
+				baggage
+			});
+		};
+		this.listFunctions = async () => {
+			return (await this.call(EngineFunctions.LIST_FUNCTIONS, {})).functions;
+		};
+		this.listWorkers = async () => {
+			return (await this.call(EngineFunctions.LIST_WORKERS, {})).workers;
+		};
+		this.createStream = (streamName, stream) => {
+			this.registerFunction({ id: `stream.get(${streamName})` }, stream.get.bind(stream));
+			this.registerFunction({ id: `stream.set(${streamName})` }, stream.set.bind(stream));
+			this.registerFunction({ id: `stream.delete(${streamName})` }, stream.delete.bind(stream));
+			this.registerFunction({ id: `stream.list(${streamName})` }, stream.list.bind(stream));
+			this.registerFunction({ id: `stream.list_groups(${streamName})` }, stream.listGroups.bind(stream));
+		};
+		this.onFunctionsAvailable = (callback) => {
+			this.functionsAvailableCallbacks.add(callback);
+			if (!this.functionsAvailableTrigger) {
+				if (!this.functionsAvailableFunctionPath) this.functionsAvailableFunctionPath = `engine.on_functions_available.${crypto.randomUUID()}`;
+				const function_id = this.functionsAvailableFunctionPath;
+				if (!this.functions.has(function_id)) this.registerFunction({ id: function_id }, async ({ functions }) => {
+					this.functionsAvailableCallbacks.forEach((handler) => {
+						handler(functions);
+					});
+					return null;
+				});
+				this.functionsAvailableTrigger = this.registerTrigger({
+					trigger_type: EngineTriggers.FUNCTIONS_AVAILABLE,
+					function_id,
+					config: {}
+				});
+			}
+			return () => {
+				this.functionsAvailableCallbacks.delete(callback);
+				if (this.functionsAvailableCallbacks.size === 0 && this.functionsAvailableTrigger) {
+					this.functionsAvailableTrigger.unregister();
+					this.functionsAvailableTrigger = void 0;
+				}
+			};
+		};
+		this.onLog = (callback, config) => {
+			const effectiveConfig = config ?? { level: "all" };
+			this.logCallbacks.set(callback, effectiveConfig);
+			if (!this.logTrigger) {
+				if (!this.logFunctionPath) this.logFunctionPath = `engine.on_log.${crypto.randomUUID()}`;
+				const function_id = this.logFunctionPath;
+				if (!this.functions.has(function_id)) this.registerFunction({ id: function_id }, async (log) => {
+					this.logCallbacks.forEach((cfg, handler) => {
+						try {
+							const minSeverity = this.severityTextToNumber(cfg.level ?? "all");
+							if (cfg.level === "all" || log.severity_number >= minSeverity) handler(log);
+						} catch (error) {
+							this.logError("Log callback handler threw an exception", error);
+						}
+					});
+					return null;
+				});
+				this.logTrigger = this.registerTrigger({
+					trigger_type: EngineTriggers.LOG,
+					function_id,
+					config: {
+						level: "all",
+						severity_min: 0
+					}
+				});
+			}
+			return () => {
+				this.logCallbacks.delete(callback);
+				if (this.logCallbacks.size === 0 && this.logTrigger) {
+					this.logTrigger.unregister();
+					this.logTrigger = void 0;
+				}
+			};
+		};
+		this.getConnectionState = () => {
+			return this.connectionState;
+		};
+		this.onConnectionStateChange = (callback) => {
+			this.stateCallbacks.add(callback);
+			callback(this.connectionState);
+			return () => this.stateCallbacks.delete(callback);
+		};
+		this.shutdown = async () => {
+			this.isShuttingDown = true;
+			this.stopMetricsReporting();
+			await shutdownOtel();
+			this.clearReconnectTimeout();
+			for (const [_id, invocation] of this.invocations) {
+				if (invocation.timeout) clearTimeout(invocation.timeout);
+				invocation.reject(/* @__PURE__ */ new Error("iii is shutting down"));
+			}
+			this.invocations.clear();
+			if (this.ws) {
+				this.ws.removeAllListeners();
+				this.ws.close();
+				this.ws = void 0;
+			}
+			this.stateCallbacks.clear();
+			this.setConnectionState("disconnected");
+		};
+		this.workerName = options?.workerName ?? getDefaultWorkerName();
+		this.metricsReportingEnabled = options?.enableMetricsReporting ?? true;
+		this.invocationTimeoutMs = options?.invocationTimeoutMs ?? DEFAULT_INVOCATION_TIMEOUT_MS;
+		this.reconnectionConfig = {
+			...DEFAULT_BRIDGE_RECONNECTION_CONFIG,
+			...options?.reconnectionConfig
+		};
+		if (options?.otel) initOtel({
+			...options.otel,
+			engineWsUrl: this.address
+		});
+		this.connect();
+	}
+	registerWorkerMetadata() {
+		this.callVoid(EngineFunctions.REGISTER_WORKER, {
+			runtime: "node",
+			version: SDK_VERSION,
+			name: this.workerName,
+			os: getOsInfo()
+		});
+	}
+	setConnectionState(state) {
+		if (this.connectionState !== state) {
+			this.connectionState = state;
+			for (const callback of this.stateCallbacks) try {
+				callback(state);
+			} catch (error) {
+				this.logError("Error in connection state callback", error);
+			}
+		}
+	}
+	connect() {
+		if (this.isShuttingDown) return;
+		this.setConnectionState("connecting");
+		this.ws = new WebSocket(this.address);
+		this.ws.on("open", this.onSocketOpen.bind(this));
+		this.ws.on("close", this.onSocketClose.bind(this));
+		this.ws.on("error", this.onSocketError.bind(this));
+	}
+	clearReconnectTimeout() {
+		if (this.reconnectTimeout) {
+			clearTimeout(this.reconnectTimeout);
+			this.reconnectTimeout = void 0;
+		}
+	}
+	scheduleReconnect() {
+		if (this.isShuttingDown) return;
+		const { maxRetries, initialDelayMs, backoffMultiplier, maxDelayMs, jitterFactor } = this.reconnectionConfig;
+		if (maxRetries !== -1 && this.reconnectAttempt >= maxRetries) {
+			this.setConnectionState("failed");
+			this.logError(`Max reconnection retries (${maxRetries}) reached, giving up`);
+			return;
+		}
+		if (this.reconnectTimeout) return;
+		const exponentialDelay = initialDelayMs * backoffMultiplier ** this.reconnectAttempt;
+		const cappedDelay = Math.min(exponentialDelay, maxDelayMs);
+		const jitter = cappedDelay * jitterFactor * (2 * Math.random() - 1);
+		const delay = Math.floor(cappedDelay + jitter);
+		this.setConnectionState("reconnecting");
+		console.debug(`[iii] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt + 1})...`);
+		this.reconnectTimeout = setTimeout(() => {
+			this.reconnectTimeout = void 0;
+			this.reconnectAttempt++;
+			this.connect();
+		}, delay);
+	}
+	onSocketError(error) {
+		this.logError("WebSocket error", error);
+	}
+	startMetricsReporting() {
+		if (!this.metricsReportingEnabled || !this.workerId) return;
+		const meter = getMeter();
+		if (!meter) {
+			console.warn("[iii] Worker metrics disabled: OpenTelemetry not initialized. Call initOtel() with metricsEnabled: true before creating the iii.");
+			return;
+		}
+		registerWorkerGauges(meter, {
+			workerId: this.workerId,
+			workerName: this.workerName
+		});
+	}
+	stopMetricsReporting() {
+		stopWorkerGauges();
+	}
+	onSocketClose() {
+		this.ws?.removeAllListeners();
+		this.ws?.terminate();
+		this.ws = void 0;
+		this.setConnectionState("disconnected");
+		this.stopMetricsReporting();
+		this.scheduleReconnect();
+	}
+	onSocketOpen() {
+		this.clearReconnectTimeout();
+		this.reconnectAttempt = 0;
+		this.setConnectionState("connected");
+		this.ws?.on("message", this.onMessage.bind(this));
+		this.triggerTypes.forEach(({ message }) => {
+			this.sendMessage(MessageType.RegisterTriggerType, message, true);
+		});
+		this.services.forEach((service) => {
+			this.sendMessage(MessageType.RegisterService, service, true);
+		});
+		this.functions.forEach(({ message }) => {
+			this.sendMessage(MessageType.RegisterFunction, message, true);
+		});
+		this.triggers.forEach((trigger) => {
+			this.sendMessage(MessageType.RegisterTrigger, trigger, true);
+		});
+		const pending = this.messagesToSend;
+		this.messagesToSend = [];
+		for (const message of pending) {
+			if (message.type === MessageType.InvokeFunction && message.invocation_id && !this.invocations.has(message.invocation_id)) continue;
+			this.sendMessageRaw(JSON.stringify(message));
+		}
+		this.registerWorkerMetadata();
+	}
+	isOpen() {
+		return this.ws?.readyState === WebSocket.OPEN;
+	}
+	sendMessageRaw(data) {
+		if (this.ws && this.isOpen()) try {
+			this.ws.send(data, (err) => {
+				if (err) this.logError("Failed to send message", err);
+			});
+		} catch (error) {
+			this.logError("Exception while sending message", error);
+		}
+	}
+	sendMessage(type, message, skipIfClosed = false) {
+		const fullMessage = {
+			...message,
+			type
+		};
+		if (this.isOpen()) this.sendMessageRaw(JSON.stringify(fullMessage));
+		else if (!skipIfClosed) this.messagesToSend.push(fullMessage);
+	}
+	logError(message, error) {
+		const otelLogger = getLogger();
+		const errorMessage = error instanceof Error ? error.message : String(error ?? "");
+		if (otelLogger) otelLogger.emit({
+			severityNumber: SeverityNumber$1.ERROR,
+			body: `[iii] ${message}${errorMessage ? `: ${errorMessage}` : ""}`
+		});
+		else console.error(`[iii] ${message}`, error ?? "");
+	}
+	severityTextToNumber(level) {
+		switch (level) {
+			case "trace": return 1;
+			case "debug": return 5;
+			case "info": return 9;
+			case "warn": return 13;
+			case "error": return 17;
+			case "fatal": return 21;
+			case "all": return 0;
+			default: return 0;
+		}
+	}
+	onInvocationResult(invocation_id, result, error) {
+		const invocation = this.invocations.get(invocation_id);
+		if (invocation) {
+			if (invocation.timeout) clearTimeout(invocation.timeout);
+			error ? invocation.reject(error) : invocation.resolve(result);
+		}
+		this.invocations.delete(invocation_id);
+	}
+	async onInvokeFunction(invocation_id, function_id, input, traceparent, baggage) {
+		const fn = this.functions.get(function_id);
+		const getResponseTraceparent = () => injectTraceparent() ?? traceparent;
+		const getResponseBaggage = () => injectBaggage() ?? baggage;
+		if (fn) {
+			if (!invocation_id) {
+				try {
+					await fn.handler(input, traceparent, baggage);
+				} catch (error) {
+					this.logError(`Error invoking function ${function_id}`, error);
+				}
+				return;
+			}
+			try {
+				const result = await fn.handler(input, traceparent, baggage);
+				this.sendMessage(MessageType.InvocationResult, {
+					invocation_id,
+					function_id,
+					result,
+					traceparent: getResponseTraceparent(),
+					baggage: getResponseBaggage()
+				});
+			} catch (error) {
+				this.sendMessage(MessageType.InvocationResult, {
+					invocation_id,
+					function_id,
+					error: {
+						code: "invocation_failed",
+						message: error.message
+					},
+					traceparent: getResponseTraceparent(),
+					baggage: getResponseBaggage()
+				});
+			}
+		} else this.sendMessage(MessageType.InvocationResult, {
+			invocation_id,
+			function_id,
+			error: {
+				code: "function_not_found",
+				message: "Function not found"
+			},
+			traceparent,
+			baggage
+		});
+	}
+	async onRegisterTrigger(message) {
+		const triggerTypeData = this.triggerTypes.get(message.trigger_type);
+		const { id, trigger_type, function_id, config } = message;
+		if (triggerTypeData) try {
+			await triggerTypeData.handler.registerTrigger({
+				id,
+				function_id,
+				config
+			});
+			this.sendMessage(MessageType.TriggerRegistrationResult, {
+				id,
+				trigger_type,
+				function_id
+			});
+		} catch (error) {
+			this.sendMessage(MessageType.TriggerRegistrationResult, {
+				id,
+				trigger_type,
+				function_id,
+				error: {
+					code: "trigger_registration_failed",
+					message: error.message
+				}
+			});
+		}
+		else this.sendMessage(MessageType.TriggerRegistrationResult, {
+			id,
+			trigger_type,
+			function_id,
+			error: {
+				code: "trigger_type_not_found",
+				message: "Trigger type not found"
+			}
+		});
+	}
+	onMessage(socketMessage) {
+		let type;
+		let message;
+		try {
+			const parsed = JSON.parse(socketMessage.toString());
+			type = parsed.type;
+			const { type: _, ...rest } = parsed;
+			message = rest;
+		} catch (error) {
+			this.logError("Failed to parse incoming message", error);
+			return;
+		}
+		if (type === MessageType.InvocationResult) {
+			const { invocation_id, result, error } = message;
+			this.onInvocationResult(invocation_id, result, error);
+		} else if (type === MessageType.InvokeFunction) {
+			const { invocation_id, function_id, data, traceparent, baggage } = message;
+			this.onInvokeFunction(invocation_id, function_id, data, traceparent, baggage);
+		} else if (type === MessageType.RegisterTrigger) this.onRegisterTrigger(message);
+		else if (type === MessageType.WorkerRegistered) {
+			const { worker_id } = message;
+			this.workerId = worker_id;
+			console.debug("[iii] Worker registered with ID:", worker_id);
+			this.startMetricsReporting();
+		}
+	}
+};
+const init = (address, options) => new Sdk(address, options);
+
+//#endregion
+export { Logger, getContext, init, withContext };
+//# sourceMappingURL=index.mjs.map