@deepexi/datasense-cli 2.0.3 → 3.0.1

package/dist/connector-child.cjs

@@ -0,0 +1,350 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+
+// src/runtime/session.ts
+var import_node_vm = __toESM(require("node:vm"), 1);
+
+// src/runtime/protocol.ts
+var HOST_METHODS = Object.freeze([
+  "definition",
+  "declaration",
+  "http",
+  "db.query",
+  "db.next",
+  "db.close",
+  "crypto",
+  "cache.get",
+  "cache.set",
+  "secret.reveal",
+  "emit"
+]);
+var GUEST_FAILURE_CODES = Object.freeze([
+  "CONNECTOR_LOAD_FAILED",
+  "CONFIG_INVALID",
+  "SCHEMA_ERROR",
+  "FATAL_ERROR",
+  "AUTH_ERROR",
+  "TRANSIENT_ERROR",
+  "PUSH_UNKNOWN",
+  "CANCELED"
+]);
+var HTTP_METHODS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
+var BODY_ENCODINGS = new Set(["utf8", "base64"]);
+var DIGEST_ENCODINGS = new Set(["hex", "base64"]);
+var HMAC_ALGORITHMS = new Set(["sha1", "sha256", "sha512"]);
+var HASH_ALGORITHMS = new Set(["md5", "sha1", "sha256", "sha512"]);
+var LOG_LEVELS = new Set(["info", "warn", "error"]);
+var SYNC_MODES = new Set(["full", "incremental"]);
+var SNAPSHOTS = new Set(["complete", "partial"]);
+var HOST_METHOD_SET = new Set(HOST_METHODS);
+var FAILURE_CODE_SET = new Set(GUEST_FAILURE_CODES);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((item) => typeof item === "string");
+}
+function isId(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function parsePushRequest(value) {
+  if (!isRecord(value))
+    return null;
+  const { requestId, push, receivedAt, headers, body } = value;
+  if (typeof requestId !== "string" || typeof push !== "string" || typeof receivedAt !== "string" || !isStringRecord(headers) || typeof body !== "string")
+    return null;
+  return { requestId, push, receivedAt, headers: { ...headers }, body };
+}
+function parseJob(value) {
+  if (!isRecord(value) || !isRecord(value.config) || !isStringArray(value.secretFields))
+    return null;
+  const config = value.config;
+  const secretFields = [...value.secretFields];
+  if (value.kind === "push") {
+    if (!Array.isArray(value.requests))
+      return null;
+    const requests = [];
+    for (const item of value.requests) {
+      const request = parsePushRequest(item);
+      if (!request)
+        return null;
+      requests.push(request);
+    }
+    return { kind: "push", config, secretFields, requests };
+  }
+  if (value.kind === "discover")
+    return { kind: "discover", config, secretFields };
+  if (value.kind === "check")
+    return { kind: "check", config, secretFields };
+  if (value.kind === "pull") {
+    const { stream, mode, streamConfig, tables, discoverFirst } = value;
+    if (typeof stream !== "string" || typeof mode !== "string" || !SYNC_MODES.has(mode) || !isRecord(streamConfig) || !isStringArray(tables))
+      return null;
+    if (discoverFirst !== undefined && typeof discoverFirst !== "boolean")
+      return null;
+    return {
+      kind: "pull",
+      config,
+      secretFields,
+      stream,
+      mode,
+      state: value.state,
+      streamConfig,
+      tables: [...tables],
+      ...discoverFirst === true ? { discoverFirst: true } : {}
+    };
+  }
+  return null;
+}
+function parseHostError(value) {
+  if (!isRecord(value) || typeof value.code !== "string" || typeof value.message !== "string")
+    return null;
+  const error = { code: value.code, message: value.message };
+  if (value.status !== undefined) {
+    if (typeof value.status !== "number" || !Number.isInteger(value.status))
+      return null;
+    error.status = value.status;
+  }
+  if (value.retryAfterMs !== undefined) {
+    if (typeof value.retryAfterMs !== "number" || !Number.isFinite(value.retryAfterMs) || value.retryAfterMs < 0)
+      return null;
+    error.retryAfterMs = value.retryAfterMs;
+  }
+  return error;
+}
+function parseParentMessage(value) {
+  if (!isRecord(value))
+    return null;
+  switch (value.type) {
+    case "execute": {
+      const { guest, code, expect } = value;
+      if (typeof guest !== "string" || typeof code !== "string")
+        return null;
+      if (!isRecord(expect) || typeof expect.name !== "string" || typeof expect.version !== "string")
+        return null;
+      const job = parseJob(value.job);
+      return job ? { type: "execute", guest, code, expect: { name: expect.name, version: expect.version }, job } : null;
+    }
+    case "reply": {
+      if (!isId(value.id))
+        return null;
+      if (value.ok === true)
+        return { type: "reply", id: value.id, ok: true, value: value.value };
+      if (value.ok !== false)
+        return null;
+      const error = parseHostError(value.error);
+      return error ? { type: "reply", id: value.id, ok: false, error } : null;
+    }
+    case "cancel":
+      return { type: "cancel" };
+    default:
+      return null;
+  }
+}
+
+// src/runtime/session.ts
+var GUEST_FILENAME = "ontos-guest.js";
+var CONNECTOR_FILENAME = "connector.js";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function guestErrorMessage(error) {
+  try {
+    if (error !== null && typeof error === "object") {
+      const message = error.message;
+      if (typeof message === "string")
+        return message;
+    }
+  } catch {}
+  return "unknown error";
+}
+function bootGuest(context, guestSource) {
+  const wrapped = `(() => { const module = { exports: {} }; const exports = module.exports; ${guestSource}
+; return module.exports; })()`;
+  const exported = new import_node_vm.default.Script(wrapped, { filename: GUEST_FILENAME }).runInContext(context);
+  const boot = exported.bootGuest;
+  if (typeof boot !== "function")
+    throw new Error("guest runtime does not export bootGuest");
+  const api = boot();
+  const { start, handle, poll } = api;
+  if (typeof start !== "function" || typeof handle !== "function" || typeof poll !== "function")
+    throw new Error("guest runtime returned an incomplete API");
+  return { start, handle, poll };
+}
+function bootInVm(guestSource, code) {
+  const context = import_node_vm.default.createContext(Object.create(null), { codeGeneration: { strings: false, wasm: false } });
+  let guest;
+  try {
+    guest = bootGuest(context, guestSource);
+  } catch (error) {
+    return { ok: false, code: "CONNECTOR_LOAD_FAILED", message: `connector runtime failed to start: ${guestErrorMessage(error)}` };
+  }
+  try {
+    const factory = new import_node_vm.default.Script(`(function (module, exports, require) {${code}
+})`, { filename: CONNECTOR_FILENAME }).runInContext(context);
+    return { ok: true, guest, factory };
+  } catch (error) {
+    return { ok: false, code: "CONNECTOR_LOAD_FAILED", message: `connector code failed to compile: ${guestErrorMessage(error)}` };
+  }
+}
+function createGuestSession(send) {
+  return createSession(send, bootInVm);
+}
+function createSession(send, boot) {
+  let guest = null;
+  let started = false;
+  let done = false;
+  let timer;
+  let timerAt = Number.POSITIVE_INFINITY;
+  const stop = () => {
+    done = true;
+    if (timer !== undefined)
+      clearTimeout(timer);
+    timer = undefined;
+  };
+  const fail = (code, message) => {
+    if (done)
+      return;
+    stop();
+    send(JSON.stringify({ type: "failure", code, message, logs: [] }));
+  };
+  const schedule = (delay) => {
+    if (done)
+      return;
+    const at = Date.now() + delay;
+    if (timer !== undefined && timerAt <= at)
+      return;
+    if (timer !== undefined)
+      clearTimeout(timer);
+    timerAt = at;
+    timer = setTimeout(pump, delay);
+  };
+  function pump() {
+    timer = undefined;
+    timerAt = Number.POSITIVE_INFINITY;
+    if (done || !guest)
+      return;
+    let text;
+    try {
+      text = guest.poll();
+    } catch (error) {
+      fail("FATAL_ERROR", `connector runtime failed: ${guestErrorMessage(error)}`);
+      return;
+    }
+    let parsed;
+    try {
+      parsed = typeof text === "string" ? JSON.parse(text) : null;
+    } catch {
+      parsed = null;
+    }
+    if (!isRecord2(parsed) || !Array.isArray(parsed.out)) {
+      fail("FATAL_ERROR", "connector runtime returned a malformed poll result");
+      return;
+    }
+    for (const message of parsed.out) {
+      if (!isRecord2(message))
+        continue;
+      send(JSON.stringify(message));
+      if (message.type === "result" || message.type === "failure") {
+        stop();
+        return;
+      }
+    }
+    if (parsed.out.length > 0 || parsed.fired === true)
+      schedule(0);
+    else if (typeof parsed.wake === "number" && parsed.wake >= 0)
+      schedule(parsed.wake);
+  }
+  const execute = (guestSource, code, payload) => {
+    const booted = boot(guestSource, code);
+    if (!booted.ok) {
+      fail(booted.code, booted.message);
+      return;
+    }
+    guest = booted.guest;
+    try {
+      guest.start(payload, booted.factory);
+    } catch (error) {
+      fail("FATAL_ERROR", `connector runtime failed: ${guestErrorMessage(error)}`);
+      return;
+    }
+    schedule(0);
+  };
+  return {
+    handle(json) {
+      if (done || typeof json !== "string")
+        return;
+      let raw;
+      try {
+        raw = JSON.parse(json);
+      } catch {
+        return;
+      }
+      const message = parseParentMessage(raw);
+      if (!message)
+        return;
+      if (message.type === "execute") {
+        if (started)
+          return;
+        started = true;
+        execute(message.guest, message.code, JSON.stringify({ expect: message.expect, job: message.job }));
+        return;
+      }
+      if (!guest)
+        return;
+      try {
+        guest.handle(JSON.stringify(message));
+      } catch (error) {
+        fail("FATAL_ERROR", `connector runtime failed: ${guestErrorMessage(error)}`);
+        return;
+      }
+      schedule(0);
+    }
+  };
+}
+
+// src/testing/child.ts
+var session = createGuestSession((json) => {
+  process.send?.(json);
+});
+process.on("message", (raw) => {
+  if (typeof raw === "string")
+    session.handle(raw);
+});
+process.on("disconnect", () => {
+  process.exit(0);
+});
+process.send?.(JSON.stringify({ type: "ready" }));