@lunora/runtime 0.0.0 → 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,15 @@
+export { toAirbyteMessages, toFivetranResponse } from './packem_shared/toAirbyteMessages-DrHdplb4.mjs';
+export { composeWorker, createLunoraHandler, createWorker, defineRpcEnvelope, resolveLunoraOptions, withFrameworkWorker } from './packem_shared/composeWorker-BEv9IBWS.mjs';
+export { createCrossShardRelationCapabilities } from './packem_shared/createCrossShardRelationCapabilities-C0KOf7er.mjs';
+export { DEFAULT_REGISTRY_CACHE_TTL_MS, SHARD_REGISTRY_DO_NAME, createDynamicShardRegistry } from './packem_shared/DEFAULT_REGISTRY_CACHE_TTL_MS-ocax8v0n.mjs';
+export { LunoraError, toErrorResponse } from './packem_shared/LunoraError-CL0aOtpo.mjs';
+export { emitLogEvent, emitRpcEvent } from './packem_shared/emitLogEvent-pEdtqAK8.mjs';
+export { analyticsEngineSink, combineSinks, consoleSink, sentrySink, webhookSink } from './packem_shared/analyticsEngineSink-DqEvrQs0.mjs';
+export { createQueryCoordinator, createStaticShardRegistry, mergeStrategyForAggregate } from './packem_shared/createQueryCoordinator-Cbds9cUI.mjs';
+export { applyJurisdiction, resolveShard } from './packem_shared/applyJurisdiction-BkZtTkct.mjs';
+export { decorateResponse, enforceOrigin, handleCorsPreflight, resolveSecurity } from './packem_shared/decorateResponse-DbISh_Wi.mjs';
+export { NOOP_EXECUTION_CONTEXT } from './packem_shared/NOOP_EXECUTION_CONTEXT-CCTu0Bf1.mjs';
+
+const VERSION = "0.0.0";
+
+export { VERSION };

package/dist/packem_shared/DEFAULT_REGISTRY_CACHE_TTL_MS-ocax8v0n.mjs

@@ -0,0 +1,78 @@
+import { applyJurisdiction } from './applyJurisdiction-BkZtTkct.mjs';
+
+const SHARD_REGISTRY_DO_NAME = "__lunora_shard_registry__";
+const DEFAULT_REGISTRY_CACHE_TTL_MS = 3e4;
+const REGISTRY_BASE_URL = "https://shard-registry.internal";
+const decodeJson = async (response) => (
+  // Response.json() throws on non-JSON; the DO always returns JSON so this
+  // only surfaces if the DO route is misbehaving — let it bubble.
+  await response.json()
+);
+const createDynamicShardRegistry = (options) => {
+  const instanceName = options.instanceName ?? SHARD_REGISTRY_DO_NAME;
+  const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_REGISTRY_CACHE_TTL_MS;
+  const cache = /* @__PURE__ */ new Map();
+  const namespace = applyJurisdiction(options.namespace, options.jurisdiction);
+  let cachedStub;
+  const stub = () => {
+    cachedStub ??= namespace.get(namespace.idFromName(instanceName));
+    return cachedStub;
+  };
+  const post = async (path, body) => stub().fetch(
+    new Request(`${REGISTRY_BASE_URL}${path}`, {
+      body: JSON.stringify(body),
+      headers: { "content-type": "application/json" },
+      method: "POST"
+    })
+  );
+  const get = async (path) => stub().fetch(new Request(`${REGISTRY_BASE_URL}${path}`, { method: "GET" }));
+  return {
+    invalidate(table) {
+      if (table === void 0) {
+        cache.clear();
+      } else {
+        cache.delete(table);
+      }
+    },
+    async listShardKeys(table) {
+      const now = Date.now();
+      const cached = cache.get(table);
+      if (cached && cached.expiresAt > now) {
+        return cached.shardKeys;
+      }
+      const response = await get(`/list?table=${encodeURIComponent(table)}`);
+      if (!response.ok) {
+        throw new Error(`shard registry /list returned ${String(response.status)}`);
+      }
+      const { shardKeys } = await decodeJson(response);
+      if (cacheTtlMs > 0) {
+        cache.set(table, { expiresAt: now + cacheTtlMs, shardKeys });
+      }
+      return shardKeys;
+    },
+    async register(table, shardKey) {
+      const response = await post("/register", { shardKey, table });
+      if (!response.ok) {
+        throw new Error(`shard registry /register returned ${String(response.status)}`);
+      }
+      cache.delete(table);
+    },
+    async snapshot() {
+      const response = await get("/snapshot");
+      if (!response.ok) {
+        throw new Error(`shard registry /snapshot returned ${String(response.status)}`);
+      }
+      const { tables } = await decodeJson(response);
+      return tables;
+    },
+    async unregister(table, shardKey) {
+      const response = await post("/unregister", { shardKey, table });
+      if (!response.ok) {
+        throw new Error(`shard registry /unregister returned ${String(response.status)}`);
+      }
+      cache.delete(table);
+    }
+  };
+};
+
+export { DEFAULT_REGISTRY_CACHE_TTL_MS, SHARD_REGISTRY_DO_NAME, createDynamicShardRegistry };

package/dist/packem_shared/LunoraError-CL0aOtpo.mjs

@@ -0,0 +1,46 @@
+class LunoraError extends Error {
+  code;
+  status;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "LunoraError";
+    this.code = options?.code ?? "INTERNAL";
+    this.status = options?.status ?? 500;
+  }
+  toResponse() {
+    const body = { error: { code: this.code, message: this.message } };
+    return Response.json(body, {
+      headers: { "content-type": "application/json" },
+      status: this.status
+    });
+  }
+}
+const hasErrorShape = (error, name) => {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const candidate = error;
+  return candidate.name === name && typeof candidate.code === "string" && typeof candidate.status === "number" && typeof candidate.message === "string";
+};
+const isStructuralConflictError = (error) => hasErrorShape(error, "ConflictError");
+const isStructuralLunoraError = (error) => hasErrorShape(error, "LunoraError");
+const toErrorResponse = (error) => {
+  if (error instanceof LunoraError) {
+    return error.toResponse();
+  }
+  if (isStructuralLunoraError(error) || isStructuralConflictError(error)) {
+    const body2 = { error: { code: error.code, message: error.message } };
+    return Response.json(body2, {
+      headers: { "content-type": "application/json" },
+      status: error.status
+    });
+  }
+  console.error("[lunora] unhandled error:", error);
+  const body = { error: { code: "INTERNAL", message: "Internal error" } };
+  return Response.json(body, {
+    headers: { "content-type": "application/json" },
+    status: 500
+  });
+};
+
+export { LunoraError, isStructuralConflictError, isStructuralLunoraError, toErrorResponse };

package/dist/packem_shared/NOOP_EXECUTION_CONTEXT-CCTu0Bf1.mjs

@@ -0,0 +1,8 @@
+const NOOP_EXECUTION_CONTEXT = {
+  passThroughOnException: () => {
+  },
+  waitUntil: () => {
+  }
+};
+
+export { NOOP_EXECUTION_CONTEXT };

package/dist/packem_shared/analyticsEngineSink-DqEvrQs0.mjs

@@ -0,0 +1,141 @@
+const shouldSkip = (event, onlyErrors) => onlyErrors === true && event.ok;
+const mergeHeaders = (defaults, overrides) => {
+  if (!overrides) {
+    return { ...defaults };
+  }
+  const merged = {};
+  const seen = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(defaults)) {
+    const lower = name.toLowerCase();
+    seen.set(lower, name);
+    merged[name] = value;
+  }
+  for (const [name, value] of Object.entries(overrides)) {
+    const lower = name.toLowerCase();
+    const existing = seen.get(lower);
+    if (existing === void 0) {
+      seen.set(lower, name);
+      merged[name] = value;
+    } else {
+      merged[existing] = value;
+    }
+  }
+  return merged;
+};
+const consoleSink = (options = {}) => {
+  const { onlyErrors } = options;
+  return {
+    onLog: (event) => {
+      if (event.level === "error") {
+        console.error("[lunora:log]", event.functionPath, event.message);
+      } else {
+        console.log("[lunora:log]", event.functionPath, event.message);
+      }
+    },
+    onRpc: (event) => {
+      if (shouldSkip(event, onlyErrors)) {
+        return;
+      }
+      if (event.ok) {
+        console.log("[lunora:rpc]", event);
+      } else {
+        console.error("[lunora:rpc]", event);
+      }
+    }
+  };
+};
+const webhookSink = (options) => {
+  const { headers, onlyErrors, transform, url } = options;
+  const mergedHeaders = mergeHeaders({ "content-type": "application/json" }, headers);
+  return {
+    onRpc: (event, context) => {
+      if (shouldSkip(event, onlyErrors)) {
+        return;
+      }
+      try {
+        let payload = event;
+        if (transform) {
+          try {
+            payload = transform(event);
+          } catch {
+            return;
+          }
+        }
+        if (payload === null || payload === void 0) {
+          return;
+        }
+        const sent = fetch(url, {
+          body: JSON.stringify(payload),
+          headers: mergedHeaders,
+          method: "POST"
+        }).catch(() => {
+        });
+        if (context?.waitUntil) {
+          context.waitUntil(sent);
+        }
+      } catch {
+      }
+    }
+  };
+};
+const sentrySink = (options) => {
+  const { capture } = options;
+  const onlyErrors = options.onlyErrors ?? true;
+  return {
+    onRpc: (event) => {
+      if (shouldSkip(event, onlyErrors)) {
+        return;
+      }
+      try {
+        capture(event);
+      } catch {
+      }
+    }
+  };
+};
+const analyticsEngineSink = (options) => {
+  const { dataset, onlyErrors } = options;
+  return {
+    onRpc: (event) => {
+      if (shouldSkip(event, onlyErrors)) {
+        return;
+      }
+      try {
+        dataset.writeDataPoint({
+          blobs: [event.functionPath, event.ok ? "ok" : "error", event.shardKey ?? "", event.error?.code ?? "", event.fanOut?.table ?? ""],
+          doubles: [event.durationMs, event.ok ? 0 : 1, event.fanOut?.shards ?? 0, event.fanOut?.failed ?? 0],
+          indexes: [event.functionPath]
+        });
+      } catch {
+      }
+    }
+  };
+};
+const combineSinks = (...sinks) => {
+  return {
+    onLog: (event, context) => {
+      for (const sink of sinks) {
+        if (!sink.onLog) {
+          continue;
+        }
+        try {
+          sink.onLog(event, context);
+        } catch {
+        }
+      }
+    },
+    onRpc: (event, context) => {
+      for (const sink of sinks) {
+        if (!sink.onRpc) {
+          continue;
+        }
+        try {
+          sink.onRpc(event, context);
+        } catch {
+        }
+      }
+    }
+  };
+};
+
+export { analyticsEngineSink, combineSinks, consoleSink, sentrySink, webhookSink };

package/dist/packem_shared/applyJurisdiction-BkZtTkct.mjs

@@ -0,0 +1,20 @@
+const applyJurisdiction = (namespace, jurisdiction) => {
+  if (jurisdiction === void 0) {
+    return namespace;
+  }
+  if (typeof namespace.jurisdiction !== "function") {
+    throw new TypeError(
+      `@lunora/runtime: Durable Object namespace does not support jurisdiction("${jurisdiction}") — update @cloudflare/workers-types or remove the jurisdiction option`
+    );
+  }
+  return namespace.jurisdiction(jurisdiction);
+};
+const resolveShard = (namespace, shardKey) => {
+  if (typeof namespace.getByName === "function") {
+    return namespace.getByName(shardKey);
+  }
+  const id = namespace.idFromName(shardKey);
+  return namespace.get(id);
+};
+
+export { applyJurisdiction, resolveShard };