@lunora/runtime 1.0.0-alpha.33 → 1.0.0-alpha.35

package/dist/index.mjs

@@ -1,14 +1,17 @@
 export { toAirbyteMessages, toFivetranResponse } from './packem_shared/toAirbyteMessages-DrHdplb4.mjs';
-export { composeWorker, createLunoraHandler, createWorker, defineRpcEnvelope, resolveLunoraOptions, withFrameworkWorker } from './packem_shared/composeWorker-DAwO9LLs.mjs';
+export { composeWorker, createLunoraHandler, createWorker, defineRpcEnvelope, resolveLunoraOptions, withFrameworkWorker } from './packem_shared/composeWorker-UwHY2r8O.mjs';
 export { createCrossShardRelationCapabilities } from './packem_shared/createCrossShardRelationCapabilities-CbcWjkAn.mjs';
 export { DEFAULT_REGISTRY_CACHE_TTL_MS, SHARD_REGISTRY_DO_NAME, createDynamicShardRegistry } from './packem_shared/DEFAULT_REGISTRY_CACHE_TTL_MS-B3pA7aXp.mjs';
 export { LunoraError, toErrorResponse } from './packem_shared/LunoraError-Bpb9EFJ3.mjs';
+export { createKvCursorStore, createMemoryCursorStore, defineExportSink, r2Sink, runExportTap, sanitizeChange, webhookExportSink } from './packem_shared/createKvCursorStore-g8aA6B4L.mjs';
+export { HEALTH_PATH, HEALTH_READY_PATH, buildHealthRoutes, d1Probe, durableObjectProbe, presenceProbe } from './packem_shared/HEALTH_PATH-e5J_NHBx.mjs';
 export { LOG_ARCHIVE_PATH, resolveLogArchiveFromEnv } from './packem_shared/LOG_ARCHIVE_PATH-CNs0bznX.mjs';
-export { emitLogEvent, emitRpcEvent } from './packem_shared/emitLogEvent-pEdtqAK8.mjs';
-export { analyticsEngineSink, combineSinks, consoleSink, otlpSink, pipelineLogSink, sentrySink, webhookSink } from './packem_shared/analyticsEngineSink-Bn7p0URe.mjs';
+export { e as emitLogEvent, a as emitRpcEvent } from './packem_shared/observability--NOFYBFc.mjs';
+export { analyticsEngineSink, combineSinks, consoleSink, otlpSink, pipelineLogSink, sentrySink, webhookSink } from './packem_shared/analyticsEngineSink-DgL64WVC.mjs';
 export { D as DEFAULT_LOG_COLUMNS, a as DEFAULT_LOG_LIMIT, c as createPipelineLogReader } from './packem_shared/pipeline-log-reader-BXULGNC3.mjs';
 export { createQueryCoordinator, createStaticShardRegistry, mergeStrategyForAggregate } from './packem_shared/createQueryCoordinator-DNCJzOZE.mjs';
 export { applyJurisdiction, resolveShard } from './packem_shared/applyJurisdiction-BkZtTkct.mjs';
+export { argsFromQuery, buildRestRoutes, createRestRateLimit, readShardKey, restSurfaceFromRegistry } from './packem_shared/argsFromQuery-BqPiQTPc.mjs';
 export { decorateResponse, enforceOrigin, handleCorsPreflight, resolveSecurity } from './packem_shared/decorateResponse-DRWQFNhF.mjs';
 export { LOG_ARCHIVE_NOT_CONFIGURED } from './packem_shared/LOG_ARCHIVE_NOT_CONFIGURED-acNcguqc.mjs';
 export { NOOP_EXECUTION_CONTEXT } from './packem_shared/NOOP_EXECUTION_CONTEXT-CCTu0Bf1.mjs';

package/dist/packem_shared/HEALTH_PATH-e5J_NHBx.mjs

@@ -0,0 +1,150 @@
+import { LunoraError } from './LunoraError-Bpb9EFJ3.mjs';
+import { m as methodGuard } from './method-guard-Qzw99aCj.mjs';
+
+const HEALTH_PATH = "/_lunora/health";
+const HEALTH_READY_PATH = "/_lunora/health/ready";
+const toCheckerType = (kind) => {
+  if (kind === "liveness") {
+    return ["liveness"];
+  }
+  if (kind === "readiness") {
+    return ["readiness"];
+  }
+  return ["liveness", "readiness"];
+};
+class HealthRegistry {
+  #checkers = /* @__PURE__ */ new Map();
+  addChecker(name, run, options) {
+    this.#checkers.set(name, { run, types: options.type });
+  }
+  async getReport(filter) {
+    const selected = [...this.#checkers].filter(([, checker]) => filter === void 0 || checker.types.includes(filter));
+    const entries = await Promise.all(selected.map(async ([name, checker]) => [name, await checker.run()]));
+    return {
+      healthy: entries.every(([, result]) => result.health.healthy),
+      report: Object.fromEntries(entries)
+    };
+  }
+}
+const buildRegistry = (probes) => {
+  const registry = new HealthRegistry();
+  const criticalNames = /* @__PURE__ */ new Set();
+  for (const probe of probes) {
+    if (probe.critical) {
+      criticalNames.add(probe.name);
+    }
+    registry.addChecker(
+      probe.name,
+      async () => {
+        let result;
+        try {
+          result = await probe.check();
+        } catch (error) {
+          result = { healthy: false, message: error instanceof Error ? error.message : "probe failed" };
+        }
+        return {
+          health: {
+            healthy: result.healthy,
+            ...result.message === void 0 ? {} : { message: result.message }
+          }
+        };
+      },
+      { type: toCheckerType(probe.kind) }
+    );
+  }
+  return { criticalNames, registry };
+};
+const buildBody = (report, criticalNames, posture, appName, appVersion) => {
+  const checks = [];
+  let anyCriticalDown = false;
+  let anyDown = false;
+  for (const [name, entry] of Object.entries(report)) {
+    const critical = criticalNames.has(name);
+    const up = entry.health.healthy;
+    if (!up) {
+      anyDown = true;
+      if (critical) {
+        anyCriticalDown = true;
+      }
+    }
+    checks.push({
+      critical,
+      ...posture === "admin" && entry.health.message !== void 0 ? { message: entry.health.message } : {},
+      name,
+      status: up ? "up" : "down"
+    });
+  }
+  checks.sort((a, b) => a.name.localeCompare(b.name));
+  let status = "healthy";
+  if (anyCriticalDown) {
+    status = "unhealthy";
+  } else if (anyDown) {
+    status = "degraded";
+  }
+  return {
+    anyCriticalDown,
+    body: { appName, appVersion, checks, status, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+  };
+};
+const buildHealthRoutes = (deps) => {
+  const { appName = "lunora", appVersion = "0.0.0", auth = "public", isAdmin, resolveProbes } = deps;
+  const gate = (request) => {
+    if (auth === "admin" && !isAdmin(request)) {
+      throw new LunoraError("health endpoint requires a valid admin bearer", { code: "ADMIN_FORBIDDEN", status: 403 });
+    }
+  };
+  const respond = async (request, env, probeKind) => {
+    const wrongMethod = methodGuard(request, ["GET", "HEAD"]);
+    if (wrongMethod) {
+      return wrongMethod;
+    }
+    gate(request);
+    const { criticalNames, registry } = buildRegistry(resolveProbes(env));
+    const { healthy, report } = await registry.getReport(probeKind === "readiness" ? "readiness" : void 0);
+    const { anyCriticalDown, body } = buildBody(report, criticalNames, auth, appName, appVersion);
+    const down = probeKind === "readiness" ? !healthy : anyCriticalDown;
+    return Response.json(body, { headers: { "cache-control": "no-store" }, status: down ? 503 : 200 });
+  };
+  return {
+    [HEALTH_PATH]: (request, env) => respond(request, env, "aggregate"),
+    [HEALTH_READY_PATH]: (request, env) => respond(request, env, "readiness")
+  };
+};
+const durableObjectProbe = (name, namespace, shardKey) => {
+  return {
+    check: async () => {
+      try {
+        const stub = namespace.get(namespace.idFromName(shardKey));
+        await stub.fetch(new Request("https://shard.internal/_lunora/status", { method: "GET" }));
+        return { healthy: true };
+      } catch {
+        return { healthy: false, message: "durable object unreachable" };
+      }
+    },
+    critical: true,
+    name
+  };
+};
+const d1Probe = (name, database) => {
+  return {
+    check: async () => {
+      try {
+        await database.prepare("SELECT 1").first();
+        return { healthy: true };
+      } catch {
+        return { healthy: false, message: "d1 query failed" };
+      }
+    },
+    critical: true,
+    name
+  };
+};
+const presenceProbe = (name, bound) => {
+  return {
+    check: () => bound ? { healthy: true } : { healthy: false, message: "binding not configured" },
+    critical: false,
+    name
+  };
+};
+
+export { HEALTH_PATH, HEALTH_READY_PATH, buildHealthRoutes, d1Probe, durableObjectProbe, presenceProbe };

package/dist/packem_shared/{analyticsEngineSink-Bn7p0URe.mjs → analyticsEngineSink-DgL64WVC.mjs}

@@ -1,4 +1,4 @@
-import { m as mergeHeaders, w as wrapResourceSpans, o as otlpRandomHex, a as wrapResourceMetrics, c as wrapResourceLogs, e as encodeAttribute, O as OTLP_SEVERITY, d as otlpUnixNano } from './otlp-DOLuy1Aj.mjs';
+import { m as mergeHeaders, w as wrapResourceSpans, o as otlpRandomHex, a as wrapResourceMetrics, c as wrapResourceLogs, e as encodeAttribute, O as OTLP_SEVERITY, d as otlpUnixNano } from './otlp-DKZJCkdD.mjs';
 
 const stringifyFieldValue = (value) => {
   if (typeof value === "string") {
@@ -139,9 +139,15 @@ const otlpLogBody = (event, serviceName) => {
   }
   return wrapResourceLogs(logRecord, "@lunora/runtime", serviceName);
 };
+const OTLP_GZIP_THRESHOLD = 1024;
+const gzipEncode = async (text) => {
+  const stream = new Blob([text]).stream().pipeThrough(new CompressionStream("gzip"));
+  return new Response(stream).arrayBuffer();
+};
 const otlpPost = (url, body, headers, context) => {
   try {
-    const sent = fetch(url, { body: JSON.stringify(body), headers, method: "POST" }).catch(() => {
+    const json = JSON.stringify(body);
+    const sent = (json.length < OTLP_GZIP_THRESHOLD ? fetch(url, { body: json, headers, method: "POST" }) : gzipEncode(json).then((gz) => fetch(url, { body: gz, headers: { ...headers, "content-encoding": "gzip" }, method: "POST" }))).catch(() => {
     });
     if (context?.waitUntil) {
       context.waitUntil(sent);

package/dist/packem_shared/argsFromQuery-BqPiQTPc.mjs

@@ -0,0 +1,114 @@
+import { m as methodGuard } from './method-guard-Qzw99aCj.mjs';
+
+const REST_PATH_PREFIX = "/_lunora/rest";
+const splitFunctionPath = (functionPath) => {
+  const colon = functionPath.indexOf(":");
+  if (colon <= 0 || colon >= functionPath.length - 1 || functionPath.indexOf(":", colon + 1) !== -1) {
+    return void 0;
+  }
+  return { name: functionPath.slice(colon + 1), namespace: functionPath.slice(0, colon) };
+};
+const restPathForFunction = (functionPath) => {
+  const parts = splitFunctionPath(functionPath);
+  if (parts === void 0) {
+    return void 0;
+  }
+  return `${REST_PATH_PREFIX}/${parts.namespace}/${parts.name}`;
+};
+const restMethodForKind = (kind) => kind === "query" ? "GET" : "POST";
+const describeRestSurface = (procedures) => {
+  const entries = [];
+  for (const procedure of procedures) {
+    if (procedure.exposure?.rest !== true || procedure.kind === "stream") {
+      continue;
+    }
+    const parts = splitFunctionPath(procedure.functionPath);
+    const path = restPathForFunction(procedure.functionPath);
+    if (parts === void 0 || path === void 0) {
+      continue;
+    }
+    entries.push({
+      functionPath: procedure.functionPath,
+      kind: procedure.kind,
+      method: restMethodForKind(procedure.kind),
+      name: parts.name,
+      namespace: parts.namespace,
+      path
+    });
+  }
+  entries.sort((a, b) => a.path.localeCompare(b.path));
+  return entries;
+};
+
+const registryToSurfaceInput = (functions) => Object.entries(functions).map(([functionPath, entry]) => {
+  return { exposure: entry.expose, functionPath, kind: entry.kind };
+});
+const restSurfaceFromRegistry = (functions) => describeRestSurface(registryToSurfaceInput(functions));
+const readShardKey = (url, request) => {
+  const fromQuery = url.searchParams.get("shardKey");
+  if (fromQuery !== null && fromQuery !== "") {
+    return fromQuery;
+  }
+  const fromHeader = request.headers.get("x-lunora-shard-key");
+  return fromHeader === null || fromHeader === "" ? void 0 : fromHeader;
+};
+const argsFromQuery = (url) => {
+  const args = {};
+  for (const [key, value] of url.searchParams.entries()) {
+    if (key === "shardKey") {
+      continue;
+    }
+    try {
+      args[key] = JSON.parse(value);
+    } catch {
+      args[key] = value;
+    }
+  }
+  return args;
+};
+const buildRestRoutes = (deps) => {
+  const { functions, invoke, rateLimit, readJsonBody } = deps;
+  const routes = {};
+  for (const entry of restSurfaceFromRegistry(functions)) {
+    const allowed = entry.kind === "query" ? ["GET", "POST"] : ["POST"];
+    routes[entry.path] = async (request, env) => {
+      const wrongMethod = methodGuard(request, allowed);
+      if (wrongMethod) {
+        return wrongMethod;
+      }
+      const url = new URL(request.url);
+      if (rateLimit) {
+        const limited = await rateLimit(request, entry.functionPath);
+        if (limited) {
+          return limited;
+        }
+      }
+      let args;
+      if (request.method === "GET") {
+        args = argsFromQuery(url);
+      } else {
+        args = request.body === null ? {} : await readJsonBody(request);
+      }
+      const shardKey = readShardKey(url, request);
+      return invoke({ args, env, functionPath: entry.functionPath, request, ...shardKey === void 0 ? {} : { shardKey } });
+    };
+  }
+  return routes;
+};
+const createRestRateLimit = (limiter, options) => async (request, functionPath) => {
+  const key = options.key ? options.key(request, functionPath) : request.headers.get("cf-connecting-ip") ?? void 0;
+  const status = await limiter.limit(options.name, key === void 0 ? {} : { key });
+  if (status.ok) {
+    return void 0;
+  }
+  const retryAfterSeconds = Math.max(1, Math.ceil(status.retryAfter / 1e3));
+  return Response.json(
+    { error: { code: "RATE_LIMITED", message: "Rate limit exceeded" } },
+    {
+      headers: { "content-type": "application/json", "retry-after": String(retryAfterSeconds) },
+      status: 429
+    }
+  );
+};
+
+export { argsFromQuery, buildRestRoutes, createRestRateLimit, readShardKey, restSurfaceFromRegistry };