coakka-v2-connector-node 1.3.1

package/dist/orchestrator.js

@@ -0,0 +1,260 @@
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DeliveryHint, toConnectorConfig, } from "./models.js";
+import { NodeRuntimeClient } from "./runtime-client.js";
+import { COAKKA_V2_NATIVE_PACKAGE_VERSION } from "./packaging.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_LIBRARY_CANDIDATES = [
+    `libcoakka_runtime_v2-${COAKKA_V2_NATIVE_PACKAGE_VERSION}.dll`,
+    `libcoakka_runtime_v2-${COAKKA_V2_NATIVE_PACKAGE_VERSION}.dylib`,
+    `libcoakka_runtime_v2-${COAKKA_V2_NATIVE_PACKAGE_VERSION}.so`,
+    "libcoakka_runtime_v2.dll",
+    "libcoakka_runtime_v2.dylib",
+    "libcoakka_runtime_v2.so",
+];
+export class RuntimeLibraryResolver {
+    static envVar = "COAKKA_RUNTIME_LIB";
+    static resolve(explicitPath, candidateNames = DEFAULT_LIBRARY_CANDIDATES) {
+        if (explicitPath != null && String(explicitPath).trim() !== "") {
+            return this.requireExisting(resolve(String(explicitPath)), "explicit runtimeLibPath");
+        }
+        const configuredPath = process.env[this.envVar]?.trim();
+        if (configuredPath != null && configuredPath !== "") {
+            return this.requireExisting(resolve(configuredPath), `$${this.envVar}`);
+        }
+        const embedded = this.resolveEmbedded();
+        if (embedded != null) {
+            return embedded;
+        }
+        for (const candidate of this.searchCandidates(candidateNames)) {
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        throw new Error("native runtime library was not found. " +
+            `Set ${this.envVar}, pass runtimeLibPath explicitly, or place one of ` +
+            `${candidateNames.join(", ")} under a repo-local lib/ directory or packaged native resource.`);
+    }
+    static platformId(osName = process.platform, archName = process.arch) {
+        return `${this.normalizeOs(osName)}-${this.normalizeArch(archName)}`;
+    }
+    static normalizeOs(osName) {
+        const normalized = osName.toLowerCase();
+        if (normalized === "darwin" || normalized.includes("mac")) {
+            return "macos";
+        }
+        if (normalized === "linux" || normalized.includes("linux")) {
+            return "linux";
+        }
+        if (normalized === "win32" || normalized.includes("windows")) {
+            return "windows";
+        }
+        throw new Error(`unsupported os.name=${osName}; supported platforms are macOS, Linux, and Windows`);
+    }
+    static normalizeArch(archName) {
+        const normalized = archName.toLowerCase();
+        if (normalized === "arm64" || normalized === "aarch64") {
+            return "aarch64";
+        }
+        if (normalized === "x64" || normalized === "x86_64" || normalized === "amd64") {
+            return "x86_64";
+        }
+        throw new Error(`unsupported os.arch=${archName}; supported architectures are aarch64 and x86_64`);
+    }
+    static runtimeResourceFileNamesForCurrentPlatform(osName = process.platform) {
+        const versionedBase = `libcoakka_runtime_v2-${COAKKA_V2_NATIVE_PACKAGE_VERSION}`;
+        switch (this.normalizeOs(osName)) {
+            case "macos":
+                return [`${versionedBase}.dylib`, "libcoakka_runtime_v2.dylib", "libcoakka_runtime_v2.so"];
+            case "linux":
+                return [`${versionedBase}.so`, "libcoakka_runtime_v2.so"];
+            case "windows":
+                return [`${versionedBase}.dll`, "libcoakka_runtime_v2.dll"];
+            default:
+                throw new Error("unsupported platform");
+        }
+    }
+    static resolveEmbedded() {
+        const platformId = this.platformId();
+        for (const fileName of this.runtimeResourceFileNamesForCurrentPlatform()) {
+            const resourcePath = resolve(__dirname, "..", "native", platformId, fileName);
+            if (existsSync(resourcePath)) {
+                const tempDir = mkdtempSync(resolve(tmpdir(), "coakka-runtime-node-"));
+                process.once("exit", () => rmSync(tempDir, { recursive: true, force: true }));
+                const targetPath = resolve(tempDir, fileName);
+                writeFileSync(targetPath, readFileSync(resourcePath));
+                return targetPath;
+            }
+        }
+        return null;
+    }
+    static searchCandidates(candidateNames) {
+        const cwd = process.cwd();
+        const roots = [cwd, resolve(cwd, "lib"), resolve(cwd, "node", "lib")];
+        const candidates = [];
+        const seen = new Set();
+        for (const root of roots) {
+            for (const name of candidateNames) {
+                const candidate = root.endsWith("/lib") ? resolve(root, name) : resolve(root, "lib", name);
+                if (!seen.has(candidate)) {
+                    candidates.push(candidate);
+                    seen.add(candidate);
+                }
+            }
+        }
+        return candidates;
+    }
+    static requireExisting(path, source) {
+        if (!existsSync(path)) {
+            throw new Error(`${source} does not exist: ${path}`);
+        }
+        return path;
+    }
+}
+class ControlApi {
+    orchestrator;
+    constructor(orchestrator) {
+        this.orchestrator = orchestrator;
+    }
+    applySnapshot(generation, routes, sourceConnector, seq = 1, overloadPolicy) {
+        this.orchestrator.applySnapshot(generation, routes, sourceConnector, seq, overloadPolicy);
+    }
+}
+class MonitorApi {
+    orchestrator;
+    constructor(orchestrator) {
+        this.orchestrator = orchestrator;
+    }
+    isEnabled() {
+        return this.orchestrator.monitorIsEnabled();
+    }
+    snapshot(signalCount = 0) {
+        return this.orchestrator.monitorSnapshot(signalCount);
+    }
+    async awaitNext(timeoutMs = 1_000) {
+        return await this.orchestrator.awaitNextMonitor(timeoutMs);
+    }
+    async awaitAppliedGenerationAtLeast(generation, timeoutMs = 1_000) {
+        return await this.orchestrator.awaitAppliedGenerationAtLeast(generation, timeoutMs);
+    }
+}
+export class ConnectorOrchestrator {
+    runtimeLibPath;
+    startSpec;
+    client;
+    static active = null;
+    static start(startSpec, runtimeLibPath) {
+        if (this.active != null) {
+            throw new Error("ConnectorOrchestrator already started for this Node.js process");
+        }
+        const resolvedRuntimeLibPath = RuntimeLibraryResolver.resolve(runtimeLibPath);
+        const orchestrator = new ConnectorOrchestrator(resolvedRuntimeLibPath, startSpec, new NodeRuntimeClient(resolvedRuntimeLibPath, toConnectorConfig(startSpec)));
+        this.active = orchestrator;
+        return orchestrator;
+    }
+    control;
+    monitor;
+    closed = false;
+    constructor(runtimeLibPath, startSpec, client) {
+        this.runtimeLibPath = runtimeLibPath;
+        this.startSpec = startSpec;
+        this.client = client;
+        this.control = new ControlApi(this);
+        this.monitor = new MonitorApi(this);
+    }
+    async askTyped(source, target, payload, payloadIdentity, timeoutMs = 5_000, operation = "ask", deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        return await this.client.askTyped(source, target, payload, payloadIdentity, timeoutMs, operation, deliveryHint, headers);
+    }
+    async askJson(source, target, payload, payloadIdentity, timeoutMs = 5_000, operation = "ask", deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        return await this.client.askJson(source, target, payload, payloadIdentity, timeoutMs, operation, deliveryHint, headers);
+    }
+    async askRaw(request, timeoutMs) {
+        return await this.client.askRaw(request, timeoutMs);
+    }
+    submitRequestTyped(source, target, payload, payloadIdentity, timeoutMs = 5_000, operation = "ask", deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        return this.client.submitRequestTyped(source, target, payload, payloadIdentity, timeoutMs, operation, deliveryHint, headers);
+    }
+    submitRequestJson(source, target, payload, payloadIdentity, timeoutMs = 5_000, operation = "ask", deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        return this.client.submitRequestJson(source, target, payload, payloadIdentity, timeoutMs, operation, deliveryHint, headers);
+    }
+    submitRequestRaw(request) {
+        return this.client.submitRequestRaw(request);
+    }
+    terminalEvents(options = {}) {
+        return this.client.terminalEvents(options);
+    }
+    deadletters(options = {}) {
+        return this.client.deadletters(options);
+    }
+    sendOneWayTyped(source, target, payload, payloadIdentity, deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        this.client.sendOneWayTyped(source, target, payload, payloadIdentity, deliveryHint, headers);
+    }
+    sendOneWayJson(source, target, payload, payloadIdentity, deliveryHint = DeliveryHint.ROUTER_DEFAULT, headers = {}) {
+        this.client.sendOneWayJson(source, target, payload, payloadIdentity, deliveryHint, headers);
+    }
+    submitEnvelope(envelope) {
+        this.client.submitEnvelope(envelope);
+    }
+    submitTypedEnvelope(envelope) {
+        this.client.submitTypedEnvelope(envelope);
+    }
+    submitRawEnvelope(envelope) {
+        this.client.submitRawEnvelope(envelope);
+    }
+    registerHandler(target, handler, typedReplies = true) {
+        this.client.registerHandler(target, handler, typedReplies);
+    }
+    registerRawHandler(target, handler) {
+        this.client.registerRawHandler(target, handler);
+    }
+    clientStats() {
+        return this.client.snapshotStats();
+    }
+    runtimeInfo() {
+        return this.client.runtimeInfoSnapshot();
+    }
+    runtimeConfig() {
+        return this.client.runtimeConfigSnapshot();
+    }
+    health() {
+        return this.client.healthSnapshot();
+    }
+    stats() {
+        return this.client.statsSnapshot();
+    }
+    runtimeSnapshot() {
+        return this.client.runtimeSnapshot();
+    }
+    applySnapshot(generation, routes, sourceConnector = this.startSpec.systemName, seq = 1, overloadPolicy = this.startSpec.overloadPolicy) {
+        this.client.applySnapshot(generation, routes, sourceConnector, seq, overloadPolicy);
+    }
+    monitorIsEnabled() {
+        return this.client.monitorIsEnabled();
+    }
+    monitorSnapshot(signalCount = 0) {
+        return this.client.monitorSnapshot(signalCount);
+    }
+    async awaitNextMonitor(timeoutMs = 1_000) {
+        return await this.client.awaitNextMonitor(timeoutMs);
+    }
+    async awaitAppliedGenerationAtLeast(generation, timeoutMs = 1_000) {
+        return await this.client.awaitAppliedGenerationAtLeast(generation, timeoutMs);
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        try {
+            this.client.close();
+        }
+        finally {
+            if (ConnectorOrchestrator.active === this) {
+                ConnectorOrchestrator.active = null;
+            }
+        }
+    }
+}
+export const RuntimeHost = ConnectorOrchestrator;

package/dist/packaging.d.ts

@@ -0,0 +1,4 @@
+export declare const COAKKA_V2_NODE_VERSION = "1.3.1";
+export declare const COAKKA_V2_NATIVE_CORE_VERSION = "1.3.1";
+export declare const COAKKA_V2_NATIVE_GIT_COMMIT = "bda2ef5";
+export declare const COAKKA_V2_NATIVE_PACKAGE_VERSION = "1.3.1+bda2ef5";

package/dist/packaging.js

@@ -0,0 +1,4 @@
+export const COAKKA_V2_NODE_VERSION = "1.3.1";
+export const COAKKA_V2_NATIVE_CORE_VERSION = "1.3.1";
+export const COAKKA_V2_NATIVE_GIT_COMMIT = "bda2ef5";
+export const COAKKA_V2_NATIVE_PACKAGE_VERSION = "1.3.1+bda2ef5";

package/dist/protobuf.d.ts

@@ -0,0 +1,63 @@
+export interface TransportEnvelope {
+    message_id: string;
+    correlation_id: string;
+    source: string;
+    target: string;
+    reply_to: string;
+    kind: number;
+    one_way: boolean;
+    timeout_ms: number;
+    payload: Uint8Array;
+    headers: Record<string, string>;
+    status: number;
+    error_code: string;
+    error_message: string;
+    delivery_hint: number;
+    message_type: string;
+    payload_schema_version: number;
+    payload_format: number;
+}
+export interface TransportDeadletter {
+    original_envelope: TransportEnvelope;
+    reason: number;
+    detail: string;
+    active_generation: number;
+    resolved_host: string;
+    resolved_port: number;
+}
+export interface ControlEnvelope {
+    seq: number;
+    generation: number;
+    kind: number;
+    payload_format: number;
+    payload_type: number;
+    schema_version: number;
+    payload: Uint8Array;
+    metadata: Record<string, string>;
+}
+export interface RouteSnapshotPayload {
+    generation: number;
+    overload_policy?: {
+        ingress_mode: number;
+        local_delivery_mode: number;
+        remote_outbound_mode: number;
+        remote_outbound_reply_reserve_slots: number;
+    };
+    routes: Array<{
+        target: string;
+        strategy: number;
+        route_key_hint: string;
+        flags: number;
+        endpoints: Array<{
+            host: string;
+            port: number;
+            weight: number;
+            flags: number;
+        }>;
+    }>;
+}
+export declare function encodeEnvelope(envelope: TransportEnvelope): Buffer;
+export declare function encodeControlEnvelope(envelope: ControlEnvelope): Buffer;
+export declare function encodeRouteSnapshotPayload(snapshot: RouteSnapshotPayload): Buffer;
+export declare function decodeEnvelope(bytes: Uint8Array): TransportEnvelope;
+export declare function decodeDeadletter(bytes: Uint8Array): TransportDeadletter;

package/dist/protobuf.js

@@ -0,0 +1,323 @@
+const WIRE_VARINT = 0;
+const WIRE_LENGTH_DELIMITED = 2;
+function defaultEnvelope() {
+    return {
+        message_id: "",
+        correlation_id: "",
+        source: "",
+        target: "",
+        reply_to: "",
+        kind: 0,
+        one_way: false,
+        timeout_ms: 0,
+        payload: Buffer.alloc(0),
+        headers: {},
+        status: 0,
+        error_code: "",
+        error_message: "",
+        delivery_hint: 0,
+        message_type: "",
+        payload_schema_version: 0,
+        payload_format: 0,
+    };
+}
+function defaultDeadletter() {
+    return {
+        original_envelope: defaultEnvelope(),
+        reason: 0,
+        detail: "",
+        active_generation: 0,
+        resolved_host: "",
+        resolved_port: 0,
+    };
+}
+function encodeKey(fieldNumber, wireType) {
+    return encodeVarint((fieldNumber << 3) | wireType);
+}
+function encodeVarint(value) {
+    let remaining = typeof value === "bigint" ? value : BigInt(Math.max(0, Math.trunc(value)));
+    const bytes = [];
+    do {
+        let byte = Number(remaining & 0x7fn);
+        remaining >>= 7n;
+        if (remaining !== 0n) {
+            byte |= 0x80;
+        }
+        bytes.push(byte);
+    } while (remaining !== 0n);
+    return Buffer.from(bytes);
+}
+function encodeString(fieldNumber, value) {
+    if (value === "") {
+        return Buffer.alloc(0);
+    }
+    return encodeBytes(fieldNumber, Buffer.from(value, "utf8"));
+}
+function encodeBytes(fieldNumber, value) {
+    if (value.length === 0) {
+        return Buffer.alloc(0);
+    }
+    return Buffer.concat([encodeKey(fieldNumber, WIRE_LENGTH_DELIMITED), encodeVarint(value.length), Buffer.from(value)]);
+}
+function encodeNumber(fieldNumber, value) {
+    if (value === 0) {
+        return Buffer.alloc(0);
+    }
+    return Buffer.concat([encodeKey(fieldNumber, WIRE_VARINT), encodeVarint(value)]);
+}
+function encodeBool(fieldNumber, value) {
+    return value ? Buffer.concat([encodeKey(fieldNumber, WIRE_VARINT), encodeVarint(1)]) : Buffer.alloc(0);
+}
+function encodeMapStringString(fieldNumber, value) {
+    const entries = [];
+    for (const [key, entryValue] of Object.entries(value)) {
+        const entry = Buffer.concat([
+            encodeString(1, key),
+            encodeString(2, entryValue),
+        ]);
+        entries.push(encodeBytes(fieldNumber, entry));
+    }
+    return Buffer.concat(entries);
+}
+function encodeEnvelopeMessage(envelope) {
+    return Buffer.concat([
+        encodeString(1, envelope.message_id),
+        encodeString(2, envelope.correlation_id),
+        encodeString(3, envelope.source),
+        encodeString(4, envelope.target),
+        encodeString(5, envelope.reply_to),
+        encodeNumber(6, envelope.kind),
+        encodeBool(7, envelope.one_way),
+        encodeNumber(8, envelope.timeout_ms),
+        encodeBytes(9, envelope.payload),
+        encodeMapStringString(10, envelope.headers),
+        encodeNumber(11, envelope.status),
+        encodeString(12, envelope.error_code),
+        encodeString(13, envelope.error_message),
+        encodeNumber(14, envelope.delivery_hint),
+        encodeString(15, envelope.message_type),
+        encodeNumber(16, envelope.payload_schema_version),
+        encodeNumber(17, envelope.payload_format),
+    ]);
+}
+export function encodeEnvelope(envelope) {
+    return encodeEnvelopeMessage(envelope);
+}
+export function encodeControlEnvelope(envelope) {
+    return Buffer.concat([
+        encodeNumber(1, envelope.seq),
+        encodeNumber(2, envelope.generation),
+        encodeNumber(3, envelope.kind),
+        encodeNumber(4, envelope.payload_format),
+        encodeNumber(5, envelope.payload_type),
+        encodeNumber(6, envelope.schema_version),
+        encodeBytes(7, envelope.payload),
+        encodeMapStringString(8, envelope.metadata),
+    ]);
+}
+export function encodeRouteSnapshotPayload(snapshot) {
+    const parts = [encodeNumber(1, snapshot.generation)];
+    for (const route of snapshot.routes) {
+        parts.push(encodeBytes(2, encodeRoute(route)));
+    }
+    if (snapshot.overload_policy != null) {
+        parts.push(encodeBytes(3, encodeOverloadPolicy(snapshot.overload_policy)));
+    }
+    return Buffer.concat(parts);
+}
+function encodeRoute(route) {
+    const parts = [
+        encodeString(1, route.target),
+        encodeNumber(2, route.strategy),
+        encodeString(3, route.route_key_hint),
+        encodeNumber(4, route.flags),
+    ];
+    for (const endpoint of route.endpoints) {
+        parts.push(encodeBytes(5, encodeEndpoint(endpoint)));
+    }
+    return Buffer.concat(parts);
+}
+function encodeEndpoint(endpoint) {
+    return Buffer.concat([
+        encodeString(1, endpoint.host),
+        encodeNumber(2, endpoint.port),
+        encodeNumber(3, endpoint.weight),
+        encodeNumber(4, endpoint.flags),
+    ]);
+}
+function encodeOverloadPolicy(policy) {
+    return Buffer.concat([
+        encodeNumber(1, policy.ingress_mode),
+        encodeNumber(2, policy.local_delivery_mode),
+        encodeNumber(3, policy.remote_outbound_mode),
+        encodeNumber(4, policy.remote_outbound_reply_reserve_slots),
+    ]);
+}
+class Reader {
+    bytes;
+    offset = 0;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    done() {
+        return this.offset >= this.bytes.length;
+    }
+    readTag() {
+        const tag = this.readVarint();
+        return { fieldNumber: tag >> 3, wireType: tag & 0x7 };
+    }
+    readVarint() {
+        let shift = 0n;
+        let result = 0n;
+        while (this.offset < this.bytes.length) {
+            const byte = this.bytes[this.offset++];
+            result |= BigInt(byte & 0x7f) << shift;
+            if ((byte & 0x80) === 0) {
+                return Number(result);
+            }
+            shift += 7n;
+        }
+        throw new Error("truncated varint");
+    }
+    readBytes() {
+        const length = this.readVarint();
+        const end = this.offset + length;
+        if (length < 0 || end > this.bytes.length) {
+            throw new Error("truncated bytes");
+        }
+        const value = this.bytes.subarray(this.offset, end);
+        this.offset = end;
+        return Buffer.from(value);
+    }
+    readString() {
+        return Buffer.from(this.readBytes()).toString("utf8");
+    }
+    skip(wireType) {
+        switch (wireType) {
+            case WIRE_VARINT:
+                this.readVarint();
+                return;
+            case WIRE_LENGTH_DELIMITED:
+                this.readBytes();
+                return;
+            default:
+                throw new Error(`unsupported wire type=${wireType}`);
+        }
+    }
+}
+export function decodeEnvelope(bytes) {
+    return decodeEnvelopeMessage(new Reader(bytes));
+}
+function decodeEnvelopeMessage(reader) {
+    const envelope = defaultEnvelope();
+    while (!reader.done()) {
+        const { fieldNumber, wireType } = reader.readTag();
+        switch (fieldNumber) {
+            case 1:
+                envelope.message_id = reader.readString();
+                break;
+            case 2:
+                envelope.correlation_id = reader.readString();
+                break;
+            case 3:
+                envelope.source = reader.readString();
+                break;
+            case 4:
+                envelope.target = reader.readString();
+                break;
+            case 5:
+                envelope.reply_to = reader.readString();
+                break;
+            case 6:
+                envelope.kind = reader.readVarint();
+                break;
+            case 7:
+                envelope.one_way = reader.readVarint() !== 0;
+                break;
+            case 8:
+                envelope.timeout_ms = reader.readVarint();
+                break;
+            case 9:
+                envelope.payload = reader.readBytes();
+                break;
+            case 10:
+                Object.assign(envelope.headers, decodeStringMapEntry(new Reader(reader.readBytes())));
+                break;
+            case 11:
+                envelope.status = reader.readVarint();
+                break;
+            case 12:
+                envelope.error_code = reader.readString();
+                break;
+            case 13:
+                envelope.error_message = reader.readString();
+                break;
+            case 14:
+                envelope.delivery_hint = reader.readVarint();
+                break;
+            case 15:
+                envelope.message_type = reader.readString();
+                break;
+            case 16:
+                envelope.payload_schema_version = reader.readVarint();
+                break;
+            case 17:
+                envelope.payload_format = reader.readVarint();
+                break;
+            default:
+                reader.skip(wireType);
+                break;
+        }
+    }
+    return envelope;
+}
+export function decodeDeadletter(bytes) {
+    const reader = new Reader(bytes);
+    const deadletter = defaultDeadletter();
+    while (!reader.done()) {
+        const { fieldNumber, wireType } = reader.readTag();
+        switch (fieldNumber) {
+            case 1:
+                deadletter.original_envelope = decodeEnvelopeMessage(new Reader(reader.readBytes()));
+                break;
+            case 2:
+                deadletter.reason = reader.readVarint();
+                break;
+            case 3:
+                deadletter.detail = reader.readString();
+                break;
+            case 4:
+                deadletter.active_generation = reader.readVarint();
+                break;
+            case 5:
+                deadletter.resolved_host = reader.readString();
+                break;
+            case 6:
+                deadletter.resolved_port = reader.readVarint();
+                break;
+            default:
+                reader.skip(wireType);
+                break;
+        }
+    }
+    return deadletter;
+}
+function decodeStringMapEntry(reader) {
+    let key = "";
+    let value = "";
+    while (!reader.done()) {
+        const { fieldNumber, wireType } = reader.readTag();
+        switch (fieldNumber) {
+            case 1:
+                key = reader.readString();
+                break;
+            case 2:
+                value = reader.readString();
+                break;
+            default:
+                reader.skip(wireType);
+                break;
+        }
+    }
+    return key === "" ? {} : { [key]: value };
+}