@lunora/runtime 1.0.0-alpha.10 → 1.0.0-alpha.12

package/dist/index.mjs

@@ -1,11 +1,11 @@
 export { toAirbyteMessages, toFivetranResponse } from './packem_shared/toAirbyteMessages-DrHdplb4.mjs';
-export { composeWorker, createLunoraHandler, createWorker, defineRpcEnvelope, resolveLunoraOptions, withFrameworkWorker } from './packem_shared/composeWorker-BEv9IBWS.mjs';
+export { composeWorker, createLunoraHandler, createWorker, defineRpcEnvelope, resolveLunoraOptions, withFrameworkWorker } from './packem_shared/composeWorker-BNYeYQqL.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 { createQueryCoordinator, createStaticShardRegistry, mergeStrategyForAggregate } from './packem_shared/createQueryCoordinator-ZeZYUPNu.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';

package/dist/packem_shared/{composeWorker-BEv9IBWS.mjs → composeWorker-BNYeYQqL.mjs}

@@ -282,6 +282,45 @@ const buildAuthAdminRoutes = (deps) => {
   return routes;
 };
 
+const MAX_BATCH_ENTRIES = 500;
+
+const normalizeBatchCall = (raw, index, defaultShard) => {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new LunoraError("each batch call must be an object", { code: "BAD_REQUEST", status: 400 });
+  }
+  const call = raw;
+  if (typeof call.functionPath !== "string") {
+    throw new LunoraError("each batch call needs a string `functionPath`", { code: "BAD_REQUEST", status: 400 });
+  }
+  if (call.functionPath.startsWith("__lunora_relation__:") || call.functionPath.startsWith("__lunora_admin__")) {
+    throw new LunoraError("reserved function path cannot be batched", { code: "FORBIDDEN", status: 403 });
+  }
+  return {
+    entry: {
+      args: call.args === void 0 ? {} : call.args,
+      clientId: typeof call.clientId === "string" ? call.clientId : void 0,
+      clientSeq: typeof call.clientSeq === "number" ? call.clientSeq : void 0,
+      functionPath: call.functionPath,
+      id: typeof call.id === "number" ? call.id : index,
+      mutationId: typeof call.mutationId === "string" ? call.mutationId : void 0
+    },
+    shardKey: typeof call.shardKey === "string" ? call.shardKey : defaultShard
+  };
+};
+const groupBatchCallsByShard = (calls, defaultShard) => {
+  if (calls.length > MAX_BATCH_ENTRIES) {
+    throw new LunoraError(`RPC batch exceeds the ${String(MAX_BATCH_ENTRIES)}-call limit`, { code: "BAD_REQUEST", status: 400 });
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const [index, raw] of calls.entries()) {
+    const { entry, shardKey } = normalizeBatchCall(raw, index, defaultShard);
+    const group = groups.get(shardKey) ?? [];
+    group.push(entry);
+    groups.set(shardKey, group);
+  }
+  return groups;
+};
+
 const MAX_BODY_BYTES = 1048576;
 const readBodyTextWithLimit = async (request, limit = MAX_BODY_BYTES) => {
   if (!request.body) {
@@ -1558,6 +1597,7 @@ const buildWorkflowsAdminRoutes = (deps) => {
 
 const NDJSON_ENCODER = new TextEncoder();
 const RPC_PATH = "/_lunora/rpc";
+const RPC_BATCH_PATH = "/_lunora/rpc-batch";
 const WS_PATH = "/_lunora/ws";
 const SCHEDULER_DISPATCH_PATH = "/_lunora/scheduler/dispatch";
 const CRON_JOBS_RUN_PATH = "/_lunora/admin/cron-jobs/run";
@@ -2298,6 +2338,119 @@ const createWorker = (options) => {
       return dispatchSingleShard(envelope.functionPath, envelope.args ?? {}, shardKey, forwardedHeaders, sinkContext);
     }
   };
+  const handleBatchRpc = async (request, env, context) => {
+    if (request.method !== "POST") {
+      throw new LunoraError("RPC batch endpoint requires POST", { code: "METHOD_NOT_ALLOWED", status: 405 });
+    }
+    const text = await readBodyTextWithLimit(request);
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      throw new LunoraError("RPC batch body must be valid JSON", { code: "BAD_REQUEST", status: 400 });
+    }
+    if (typeof body !== "object" || body === null || Array.isArray(body)) {
+      throw new LunoraError("RPC batch body must be an object", { code: "BAD_REQUEST", status: 400 });
+    }
+    const { calls } = body;
+    if (!Array.isArray(calls)) {
+      throw new LunoraError("RPC batch `calls` must be an array", { code: "BAD_REQUEST", status: 400 });
+    }
+    const { headers: forwardedHeaders, identity } = await resolveForwardContext(request, env, options.resolveIdentity);
+    const groups = groupBatchCallsByShard(calls, defaultShard);
+    await Promise.all(
+      [...groups.entries()].flatMap(
+        ([shardKey, entries]) => entries.map((entry) => authorizeRpcEnvelope({ functionPath: entry.functionPath, shardKey }, identity))
+      )
+    );
+    const { observability } = options;
+    const sinkContext = context ? {
+      waitUntil: (promise) => {
+        context.waitUntil?.(promise);
+      }
+    } : void 0;
+    const results = [];
+    let latestBookmark;
+    const slotError = (entry, status, code, message) => {
+      return { body: { error: { code, message } }, id: entry.id, status };
+    };
+    const failSubBatch = (entries, status, code, message, eventFor) => {
+      for (const entry of entries) {
+        emitRpcEvent(observability, eventFor(entry), sinkContext);
+        results.push(slotError(entry, status, code, message));
+      }
+    };
+    const emitEntryEvents = (entries, shardKey, durationMs, statusById, fallbackStatus) => {
+      for (const entry of entries) {
+        const status = statusById.get(entry.id) ?? fallbackStatus;
+        const ok = status < 400;
+        emitRpcEvent(
+          observability,
+          {
+            durationMs,
+            functionPath: entry.functionPath,
+            ok,
+            shardKey,
+            ...ok ? {} : { error: { code: "SHARD_ERROR", message: `batched call returned ${String(status)}`, status } }
+          },
+          sinkContext
+        );
+      }
+    };
+    await Promise.all(
+      [...groups.entries()].map(async ([shardKey, entries]) => {
+        const headers = new Headers(forwardedHeaders);
+        headers.set("content-type", "application/json");
+        const subRequest = new Request("https://shard.internal/rpc-batch", { body: JSON.stringify({ calls: entries }), headers, method: "POST" });
+        const subStartedAt = Date.now();
+        let response;
+        try {
+          response = await forwardToShard(shardDO, shardKey, subRequest);
+        } catch (error) {
+          const durationMs2 = Date.now() - subStartedAt;
+          const message = error instanceof Error ? error.message : String(error);
+          failSubBatch(entries, 502, "SHARD_UNAVAILABLE", message, (entry) => buildErrorEvent(entry.functionPath, durationMs2, error, { shardKey }));
+          return;
+        }
+        const durationMs = Date.now() - subStartedAt;
+        const bookmark = response.headers.get("x-d1-bookmark");
+        if (bookmark) {
+          latestBookmark = bookmark;
+        }
+        let parsed;
+        try {
+          parsed = await response.json();
+        } catch {
+          const message = `shard batch returned a non-JSON response (${String(response.status)})`;
+          failSubBatch(entries, response.status, "SHARD_ERROR", message, (entry) => {
+            return {
+              durationMs,
+              error: { code: "SHARD_ERROR", message, status: response.status },
+              functionPath: entry.functionPath,
+              ok: false,
+              shardKey
+            };
+          });
+          return;
+        }
+        const entryResults = Array.isArray(parsed.results) ? parsed.results : [];
+        const statusById = new Map(entryResults.map((entry) => [entry.id, entry.status ?? response.status]));
+        const seenIds = new Set(entryResults.map((entry) => entry.id));
+        emitEntryEvents(entries, shardKey, durationMs, statusById, response.status);
+        results.push(...entryResults);
+        for (const entry of entries) {
+          if (!seenIds.has(entry.id)) {
+            results.push(slotError(entry, response.status, "SHARD_ERROR", `shard batch omitted result for call ${String(entry.id)}`));
+          }
+        }
+      })
+    );
+    const responseHeaders = { "content-type": "application/json" };
+    if (latestBookmark !== void 0) {
+      responseHeaders["x-d1-bookmark"] = latestBookmark;
+    }
+    return Response.json({ results }, { headers: responseHeaders, status: 200 });
+  };
   const serverQuery = async (request, env, reference, args = {}, callOptions = {}) => {
     try {
       const functionPath = reference.__lunoraRef;
@@ -2461,6 +2614,7 @@ const createWorker = (options) => {
   const internalRoutes = {
     [WS_PATH]: (request, env, url) => handleWebSocketUpgrade(request, env, url),
     [RPC_PATH]: (request, env, _url, context) => handleRpc(request, env, context),
+    [RPC_BATCH_PATH]: (request, env, _url, context) => handleBatchRpc(request, env, context),
     [SCHEDULER_DISPATCH_PATH]: (request, env) => handleSchedulerDispatch(request, env),
     [CRON_JOBS_RUN_PATH]: (request, env) => handleRunCronJob(request, env),
     // Extracted handler clusters built above, merged in (mirroring the auth

package/dist/packem_shared/{createQueryCoordinator-Cbds9cUI.mjs → createQueryCoordinator-ZeZYUPNu.mjs}

@@ -547,7 +547,16 @@ const mergeTopK = (values, strategy) => {
     }
   }
   const direction = strategy.direction ?? "desc";
-  collected.sort((a, b) => direction === "asc" ? a.score - b.score : b.score - a.score);
+  const ascending = (x, y) => {
+    if (x < y) {
+      return -1;
+    }
+    if (x > y) {
+      return 1;
+    }
+    return 0;
+  };
+  collected.sort((a, b) => direction === "asc" ? ascending(a.score, b.score) : ascending(b.score, a.score));
   return collected.slice(0, strategy.k).map((entry) => entry.row);
 };
 const mergeShardResults = (values, strategy) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/runtime",
-  "version": "1.0.0-alpha.10",
+  "version": "1.0.0-alpha.12",
   "description": "Lunora Worker runtime: the RPC router, shard resolver, and query coordinator",
   "keywords": [
     "cloudflare",