@lunora/runtime 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/index.mjs

@@ -1,13 +1,15 @@
 export { toAirbyteMessages, toFivetranResponse } from './packem_shared/toAirbyteMessages-DrHdplb4.mjs';
-export { composeWorker, createWorker, defineRpcEnvelope, withFrameworkWorker } from './packem_shared/composeWorker-BmfKl1ei.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-BpCwo_mo.mjs';
-export { LunoraError, toErrorResponse } from './packem_shared/LunoraError-CL0aOtpo.mjs';
+export { composeWorker, createLunoraHandler, createWorker, defineRpcEnvelope, resolveLunoraOptions, withFrameworkWorker } from './packem_shared/composeWorker-Dpw9d1s5.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 { 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-DbxC7iUz.mjs';
-export { resolveShard } from './packem_shared/resolveShard-DDkzWtrU.mjs';
-export { decorateResponse, enforceOrigin, handleCorsPreflight, resolveSecurity } from './packem_shared/decorateResponse-DbISh_Wi.mjs';
+export { createQueryCoordinator, createStaticShardRegistry, mergeStrategyForAggregate } from './packem_shared/createQueryCoordinator-DNCJzOZE.mjs';
+export { applyJurisdiction, resolveShard } from './packem_shared/applyJurisdiction-BkZtTkct.mjs';
+export { decorateResponse, enforceOrigin, handleCorsPreflight, resolveSecurity } from './packem_shared/decorateResponse-CsZc49QC.mjs';
+export { NOOP_EXECUTION_CONTEXT } from './packem_shared/NOOP_EXECUTION_CONTEXT-CCTu0Bf1.mjs';
+export { composeIdentityResolvers, routeIdentityResolvers } from './packem_shared/composeIdentityResolvers-XGjO7V1J.mjs';
 
 const VERSION = "0.0.0";
 

package/dist/packem_shared/{DEFAULT_REGISTRY_CACHE_TTL_MS-BpCwo_mo.mjs → DEFAULT_REGISTRY_CACHE_TTL_MS-B3pA7aXp.mjs}

@@ -1,3 +1,6 @@
+import { LunoraError } from './LunoraError-Bpb9EFJ3.mjs';
+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";
@@ -10,9 +13,10 @@ 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 ??= options.namespace.get(options.namespace.idFromName(instanceName));
+    cachedStub ??= namespace.get(namespace.idFromName(instanceName));
     return cachedStub;
   };
   const post = async (path, body) => stub().fetch(
@@ -39,7 +43,7 @@ const createDynamicShardRegistry = (options) => {
       }
       const response = await get(`/list?table=${encodeURIComponent(table)}`);
       if (!response.ok) {
-        throw new Error(`shard registry /list returned ${String(response.status)}`);
+        throw new LunoraError(`shard registry /list returned ${String(response.status)}`);
       }
       const { shardKeys } = await decodeJson(response);
       if (cacheTtlMs > 0) {
@@ -50,14 +54,14 @@ const createDynamicShardRegistry = (options) => {
     async register(table, shardKey) {
       const response = await post("/register", { shardKey, table });
       if (!response.ok) {
-        throw new Error(`shard registry /register returned ${String(response.status)}`);
+        throw new LunoraError(`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)}`);
+        throw new LunoraError(`shard registry /snapshot returned ${String(response.status)}`);
       }
       const { tables } = await decodeJson(response);
       return tables;
@@ -65,7 +69,7 @@ const createDynamicShardRegistry = (options) => {
     async unregister(table, shardKey) {
       const response = await post("/unregister", { shardKey, table });
       if (!response.ok) {
-        throw new Error(`shard registry /unregister returned ${String(response.status)}`);
+        throw new LunoraError(`shard registry /unregister returned ${String(response.status)}`);
       }
       cache.delete(table);
     }

package/dist/packem_shared/LunoraError-Bpb9EFJ3.mjs

@@ -0,0 +1,22 @@
+import { LunoraError as LunoraError$1, toErrorBody } from '@lunora/errors';
+
+const toErrorResponse = (error) => {
+  const { body, redacted, status } = toErrorBody(error, { fallbackCode: "INTERNAL", redactedMessage: "Internal error" });
+  if (redacted) {
+    console.error("[lunora] internal error:", error);
+  }
+  return Response.json({ error: body }, {
+    headers: { "content-type": "application/json" },
+    status
+  });
+};
+class LunoraError extends LunoraError$1 {
+  constructor(message, options) {
+    super(options?.code ?? "INTERNAL", message, { cause: options?.cause, status: options?.status });
+  }
+  toResponse() {
+    return toErrorResponse(this);
+  }
+}
+
+export { LunoraError, 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/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 };

package/dist/packem_shared/composeIdentityResolvers-XGjO7V1J.mjs

@@ -0,0 +1,55 @@
+import { LunoraError } from './LunoraError-Bpb9EFJ3.mjs';
+
+const composeIdentityResolvers = (resolvers, options = {}) => {
+  const onError = options.onError ?? "fail-closed";
+  return async (request, env) => {
+    for (const resolver of resolvers) {
+      let resolved;
+      try {
+        resolved = await resolver(request, env);
+      } catch (error) {
+        if (onError === "skip") {
+          continue;
+        }
+        throw error;
+      }
+      if (resolved) {
+        return resolved;
+      }
+    }
+    return null;
+  };
+};
+const routeIdentityResolvers = (routes) => {
+  const prefixes = Object.keys(routes).filter((key) => key !== "*").toSorted((a, b) => b.length - a.length);
+  return (request, env) => {
+    const { pathname } = new URL(request.url);
+    const matched = prefixes.find((prefix) => pathname === prefix || pathname.startsWith(prefix.endsWith("/") ? prefix : `${prefix}/`));
+    const resolver = matched === void 0 ? routes["*"] : routes[matched];
+    if (resolver === void 0) {
+      return null;
+    }
+    return resolver(request, env);
+  };
+};
+const wrapResolverWithContract = (baseResolveIdentity, contract) => {
+  if (contract === void 0 || baseResolveIdentity === void 0) {
+    return baseResolveIdentity;
+  }
+  return async (request, env) => {
+    const resolved = await baseResolveIdentity(request, env);
+    if (!resolved) {
+      return resolved;
+    }
+    const result = contract.validate(resolved);
+    if (result.ok) {
+      return resolved;
+    }
+    if (contract.onInvalid === "reject") {
+      throw new LunoraError(`identity claims failed the declared contract: ${result.error}`, { code: "UNAUTHENTICATED", status: 401 });
+    }
+    return null;
+  };
+};
+
+export { composeIdentityResolvers, routeIdentityResolvers, wrapResolverWithContract };