@lunora/runtime 1.0.0-alpha.37 → 1.0.0-alpha.39

package/dist/packem_shared/argsFromQuery-c-U1WRy-.mjs

@@ -1,121 +0,0 @@
-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, _url, context) => {
-      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 },
-        ...context?.waitUntil === void 0 ? {} : { waitUntil: (promise) => context.waitUntil?.(promise) }
-      });
-    };
-  }
-  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 };

package/dist/packem_shared/composeIdentityResolvers-XGjO7V1J.mjs

@@ -1,55 +0,0 @@
-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 };