@lunora/runtime 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/consoleSink-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/createCrossShardRelationCapabilities-C0KOf7er.mjs

@@ -0,0 +1,61 @@
+const RPC_ENDPOINT = "/_lunora/rpc";
+const buildIdentityHeaders = (options) => {
+  const headers = { "content-type": "application/json" };
+  if (options.userId !== void 0 && options.userId.length > 0) {
+    headers["x-lunora-userid"] = options.userId;
+  }
+  if (options.identity !== void 0) {
+    headers["x-lunora-identity"] = JSON.stringify(options.identity);
+  }
+  return headers;
+};
+const fanOutRelation = async (options, body, label) => {
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const response = await doFetch(
+    new Request(`${options.origin}${RPC_ENDPOINT}`, {
+      body: JSON.stringify(body),
+      headers: buildIdentityHeaders(options),
+      method: "POST"
+    })
+  );
+  if (!response.ok) {
+    throw new Error(`cross-shard relation ${label} failed: worker returned ${String(response.status)}`);
+  }
+  const result = await response.json();
+  if (typeof result.failed === "number" && result.failed > 0) {
+    const reached = (typeof result.ok === "number" ? result.ok : 0) + result.failed;
+    throw new Error(
+      `cross-shard relation ${label} failed on ${String(result.failed)} of ${String(reached)} shard(s) — refusing to return a partial result`
+    );
+  }
+  return result.data;
+};
+const createCrossShardRelationCapabilities = (options) => {
+  const crossShardReader = async (table, args) => {
+    const data = await fanOutRelation(
+      options,
+      {
+        args: { orderBy: args?.orderBy, table, where: args?.where, with: args?.with },
+        fanOut: { merge: { kind: "concat" }, table },
+        functionPath: "__lunora_relation__:read"
+      },
+      "read"
+    );
+    return { continueCursor: null, isDone: true, page: Array.isArray(data) ? data : [] };
+  };
+  const crossShardCounter = async (table, where) => {
+    const data = await fanOutRelation(
+      options,
+      {
+        args: { table, where },
+        fanOut: { merge: { kind: "sum" }, table },
+        functionPath: "__lunora_relation__:count"
+      },
+      "count"
+    );
+    return typeof data === "number" ? data : 0;
+  };
+  return { crossShardCounter, crossShardReader };
+};
+
+export { createCrossShardRelationCapabilities };

package/dist/packem_shared/createDynamicShardRegistry-BpCwo_mo.mjs

@@ -0,0 +1,75 @@
+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();
+  let cachedStub;
+  const stub = () => {
+    cachedStub ??= options.namespace.get(options.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 };