@lunora/server 1.0.0-alpha.31 → 1.0.0-alpha.32

package/dist/packem_shared/httpAction-DCXoYPIk.mjs

@@ -1,355 +0,0 @@
-import { toErrorBody } from '@lunora/errors';
-import { parseValidatorMap, ValidationError } from '@lunora/values';
-import { Hono } from 'hono';
-import { LunoraError } from './LunoraError-WbxmrpxR.mjs';
-
-const httpAction = (handler) => async (c) => handler(c.get("lunora"), c.req.raw);
-const httpRouter = () => {
-  const app = new Hono();
-  app.use("*", async (c, next) => {
-    const injected = c.env.__lunoraCtx;
-    if (!injected) {
-      throw new LunoraError(
-        "INTERNAL_SERVER_ERROR",
-        "HttpActionCtx was not injected — mount httpRouter() on createWorker(), which supplies it per request."
-      );
-    }
-    c.set("lunora", injected);
-    await next();
-  });
-  return app;
-};
-const unwrapOptional = (validator) => validator.kind === "optional" ? validator._meta?.inner ?? validator : validator;
-const coerceScalar = (kind, raw) => {
-  switch (kind) {
-    case "bigint": {
-      try {
-        return BigInt(raw);
-      } catch {
-        return raw;
-      }
-    }
-    case "boolean": {
-      if (raw === "true" || raw === "1") {
-        return true;
-      }
-      if (raw === "false" || raw === "0") {
-        return false;
-      }
-      return raw;
-    }
-    case "number": {
-      return raw === "" ? Number.NaN : Number(raw);
-    }
-    default: {
-      return raw;
-    }
-  }
-};
-const coerceSearchParameter = (validator, c, key) => {
-  const effective = unwrapOptional(validator);
-  if (effective.kind === "array") {
-    const values = c.req.queries(key);
-    if (values === void 0) {
-      return void 0;
-    }
-    const element = effective._meta?.inner;
-    return values.map((raw2) => coerceScalar(element?.kind ?? "string", raw2));
-  }
-  const raw = c.req.query(key);
-  return raw === void 0 ? void 0 : coerceScalar(effective.kind, raw);
-};
-const parseSearchParams = (validators, c) => {
-  const raw = {};
-  for (const key of Object.keys(validators)) {
-    const validator = validators[key];
-    if (!validator) {
-      continue;
-    }
-    raw[key] = coerceSearchParameter(validator, c, key);
-  }
-  return parseValidatorMap(validators, raw, "searchParams");
-};
-const parseParams = (validators, c) => {
-  const provided = c.req.param();
-  const raw = {};
-  for (const key of Object.keys(validators)) {
-    const validator = validators[key];
-    if (!validator) {
-      continue;
-    }
-    const value = provided[key];
-    raw[key] = value === void 0 ? void 0 : coerceScalar(unwrapOptional(validator).kind, value);
-  }
-  return parseValidatorMap(validators, raw, "params");
-};
-const parseBody = async (validators, c) => {
-  let json;
-  try {
-    json = await c.req.json();
-  } catch {
-    throw new LunoraError("BAD_REQUEST", "Invalid JSON body");
-  }
-  if (typeof json !== "object" || json === null || Array.isArray(json)) {
-    throw new LunoraError("BAD_REQUEST", "Expected a JSON object body");
-  }
-  return parseValidatorMap(validators, json, "body");
-};
-const applyOutput = (output, result) => {
-  try {
-    return output.parse(result);
-  } catch (error) {
-    if (error instanceof ValidationError) {
-      throw new LunoraError("INTERNAL_SERVER_ERROR", `Response did not match the declared output schema: ${error.message}`);
-    }
-    throw error;
-  }
-};
-const errorResponse = (error) => {
-  if (error instanceof ValidationError) {
-    return Response.json({ code: "BAD_REQUEST", error: error.message }, { status: 400 });
-  }
-  if (error instanceof LunoraError) {
-    const { body, redacted, status } = toErrorBody(error, { fallbackCode: "INTERNAL_SERVER_ERROR", redactedMessage: "Internal error" });
-    if (redacted) {
-      console.error("[lunora] http action error (redacted on the wire):", error);
-    }
-    return Response.json({ code: body.code, error: body.message }, { status });
-  }
-  throw error;
-};
-const buildRouteHandler = (state, userHandler) => async (c) => {
-  try {
-    const context = c.get("lunora");
-    const searchParams = Object.keys(state.searchParams).length > 0 ? parseSearchParams(state.searchParams, c) : {};
-    const params = Object.keys(state.params).length > 0 ? parseParams(state.params, c) : {};
-    const body = Object.keys(state.body).length > 0 ? await parseBody(state.body, c) : {};
-    const result = await userHandler({ body, ctx: context, params, searchParams });
-    const payload = state.output ? applyOutput(state.output, result) : result;
-    const headers = {};
-    if (state.cacheControl) {
-      headers["cache-control"] = state.cacheControl;
-    }
-    if (state.cacheTag) {
-      headers["cache-tag"] = state.cacheTag;
-    }
-    if (state.vary) {
-      headers.vary = state.vary;
-    }
-    const hasCacheHeaders = Object.keys(headers).length > 0;
-    if (payload === void 0) {
-      return new Response(null, { headers: hasCacheHeaders ? headers : void 0, status: 204 });
-    }
-    return Response.json(payload, { headers: hasCacheHeaders ? headers : void 0 });
-  } catch (error) {
-    return errorResponse(error);
-  }
-};
-const sseFrame = (chunk, event) => {
-  const data = JSON.stringify(chunk);
-  const prefix = event ? `event: ${event}
-` : "";
-  return `${prefix}data: ${data}
-
-`;
-};
-const buildStreamHandler = (state, userHandler) => (
-  // eslint-disable-next-line @typescript-eslint/require-await -- LunoraRouteHandler is contractually `(c) => Promise<Response>`; this handler returns synchronously (all awaits live inside the ReadableStream pump), so `async` is required by the type, not the body.
-  async (c) => {
-    let searchParams;
-    let params;
-    try {
-      searchParams = Object.keys(state.searchParams).length > 0 ? parseSearchParams(state.searchParams, c) : {};
-      params = Object.keys(state.params).length > 0 ? parseParams(state.params, c) : {};
-    } catch (error) {
-      return errorResponse(error);
-    }
-    const context = c.get("lunora");
-    const request = c.req.raw;
-    const encoder = new TextEncoder();
-    const ac = new AbortController();
-    if (request.signal.aborted) {
-      ac.abort();
-      return new Response(
-        new ReadableStream({
-          start: (controller) => {
-            controller.close();
-          }
-        }),
-        {
-          headers: {
-            "cache-control": "no-cache, no-transform",
-            "content-type": "text/event-stream; charset=utf-8",
-            "x-accel-buffering": "no"
-          }
-        }
-      );
-    }
-    const onAbort = () => {
-      ac.abort();
-    };
-    request.signal.addEventListener("abort", onAbort, { once: true });
-    const stream = new ReadableStream({
-      cancel() {
-        request.signal.removeEventListener("abort", onAbort);
-        ac.abort();
-      },
-      async start(controller) {
-        try {
-          const iterator = userHandler({ ctx: context, params, request, searchParams, signal: ac.signal });
-          for await (const chunk of iterator) {
-            if (ac.signal.aborted) {
-              break;
-            }
-            controller.enqueue(encoder.encode(sseFrame(chunk)));
-          }
-          controller.enqueue(encoder.encode(sseFrame({}, "complete")));
-        } catch (error) {
-          const { body, redacted } = toErrorBody(error, { fallbackCode: "INTERNAL_SERVER_ERROR", redactedMessage: "Internal error" });
-          if (redacted) {
-            console.error("[lunora] unhandled stream handler error:", error);
-          }
-          controller.enqueue(encoder.encode(sseFrame({ code: body.code, message: body.message }, "error")));
-        } finally {
-          request.signal.removeEventListener("abort", onAbort);
-          controller.close();
-        }
-      }
-    });
-    const headers = {
-      // SSE responses must stay uncacheable so proxies don't buffer or
-      // coalesce live frames. `cacheControl()` is intentionally ignored
-      // for stream() routes; `cacheTag`/`vary` are also omitted because
-      // they only make sense alongside a cacheable response.
-      "cache-control": "no-cache, no-transform",
-      "content-type": "text/event-stream; charset=utf-8",
-      // Hint to proxies (including Cloudflare's own buffering layer)
-      // that this response must not be coalesced.
-      "x-accel-buffering": "no"
-    };
-    return new Response(stream, { headers });
-  }
-);
-const makeRouteBuilder = (state) => {
-  return {
-    body: (validators) => makeRouteBuilder({ ...state, body: { ...state.body, ...validators } }),
-    cacheControl: (value) => makeRouteBuilder({ ...state, cacheControl: value }),
-    cacheTag: (value) => makeRouteBuilder({ ...state, cacheTag: value }),
-    handler: (userHandler) => buildRouteHandler(state, userHandler),
-    output: (validator) => makeRouteBuilder({ ...state, output: validator }),
-    params: (validators) => makeRouteBuilder({ ...state, params: { ...state.params, ...validators } }),
-    searchParams: (validators) => makeRouteBuilder({ ...state, searchParams: { ...state.searchParams, ...validators } }),
-    stream: (userHandler) => buildStreamHandler(state, userHandler),
-    vary: (value) => makeRouteBuilder({ ...state, vary: value })
-  };
-};
-const makeRouteFactory = (method) => (path) => makeRouteBuilder({ body: {}, method, params: {}, path, searchParams: {} });
-const httpRoute = {
-  delete: makeRouteFactory("DELETE"),
-  get: makeRouteFactory("GET"),
-  head: makeRouteFactory("HEAD"),
-  options: makeRouteFactory("OPTIONS"),
-  patch: makeRouteFactory("PATCH"),
-  post: makeRouteFactory("POST"),
-  put: makeRouteFactory("PUT")
-};
-const SINGLE_BYTE_RANGE_RE = /^bytes=(\d*)-(\d*)$/;
-const toHttpEtag = (etag) => {
-  if (etag.startsWith('"') || etag.startsWith('W/"')) {
-    return etag;
-  }
-  return `"${etag}"`;
-};
-const isSafeHeaderValue = (value) => {
-  for (let index = 0; index < value.length; index += 1) {
-    const code = value.codePointAt(index);
-    if (code === 13 || code === 10 || code === 0) {
-      return false;
-    }
-  }
-  return true;
-};
-const parseRange = (header, size) => {
-  if (header === null) {
-    return { kind: "full" };
-  }
-  const match = SINGLE_BYTE_RANGE_RE.exec(header.trim());
-  if (!match) {
-    return { kind: "full" };
-  }
-  const startRaw = match[1] ?? "";
-  const endRaw = match[2] ?? "";
-  if (startRaw === "" && endRaw === "") {
-    return { kind: "full" };
-  }
-  let start;
-  let end;
-  if (startRaw === "") {
-    const suffix = Number(endRaw);
-    if (suffix === 0) {
-      return { kind: "unsatisfiable" };
-    }
-    start = Math.max(0, size - suffix);
-    end = size - 1;
-  } else {
-    start = Number(startRaw);
-    end = endRaw === "" ? size - 1 : Math.min(Number(endRaw), size - 1);
-  }
-  if (start > end || start >= size) {
-    return { kind: "unsatisfiable" };
-  }
-  return { end, kind: "partial", start };
-};
-const serveStorageObject = async (context, key, request) => {
-  const object = await context.storage.download(key);
-  if (!object) {
-    return new Response("Not Found", { status: 404 });
-  }
-  const rawContentType = object.httpMetadata?.contentType;
-  const contentType = rawContentType !== void 0 && isSafeHeaderValue(rawContentType) ? rawContentType : "application/octet-stream";
-  const baseHeaders = {
-    "accept-ranges": "bytes",
-    "content-type": contentType,
-    etag: toHttpEtag(object.etag)
-  };
-  if (object.sha256Base64 !== void 0) {
-    baseHeaders["repr-digest"] = `sha-256=:${object.sha256Base64}:`;
-  }
-  const range = parseRange(request.headers.get("range"), object.size);
-  if (range.kind === "unsatisfiable") {
-    object.body?.cancel().catch(() => {
-    });
-    return new Response("Range Not Satisfiable", {
-      headers: {
-        "accept-ranges": "bytes",
-        "content-range": `bytes */${String(object.size)}`,
-        "content-type": "text/plain; charset=utf-8",
-        etag: toHttpEtag(object.etag)
-      },
-      status: 416
-    });
-  }
-  if (range.kind === "full") {
-    return new Response(object.body, {
-      headers: { ...baseHeaders, "content-length": String(object.size) },
-      status: 200
-    });
-  }
-  object.body?.cancel().catch(() => {
-  });
-  const length = range.end - range.start + 1;
-  const slice = await context.storage.download(key, { range: { length, offset: range.start } });
-  if (!slice) {
-    return new Response("Not Found", { status: 404 });
-  }
-  return new Response(slice.body, {
-    headers: {
-      ...baseHeaders,
-      "content-length": String(length),
-      "content-range": `bytes ${String(range.start)}-${String(range.end)}/${String(object.size)}`
-    },
-    status: 206
-  });
-};
-
-export { httpAction, httpRoute, httpRouter, isSafeHeaderValue, serveStorageObject };

package/dist/packem_shared/initLunora-D0Wuki7S.mjs

@@ -1,115 +0,0 @@
-import { v as validateArgs } from './functions-Di9FUNkf.mjs';
-import { r as readRlsTag } from './policy-tag-DvpVH2tv.mjs';
-import { r as runMiddlewareChain } from './run-middleware-I6EiQfxL.mjs';
-
-const runMiddleware = (middlewares, baseContext) => runMiddlewareChain(middlewares, baseContext, (context) => context);
-const makeHandler = (args, middlewares, userHandler, output) => async (context, rawArgs) => {
-  const parsed = validateArgs(args, rawArgs);
-  const resolvedContext = await runMiddleware(middlewares, context);
-  const result = await userHandler({ args: parsed, ctx: resolvedContext });
-  return output ? output.parse(result) : result;
-};
-const makeStreamHandler = (args, middlewares, userHandler) => (context, rawArgs, signal) => {
-  const parsed = validateArgs(args, rawArgs);
-  return (async function* drive() {
-    const resolvedContext = await runMiddleware(middlewares, context);
-    const source = userHandler({ args: parsed, ctx: resolvedContext, signal });
-    const iterator = source[Symbol.asyncIterator]();
-    try {
-      while (true) {
-        if (signal.aborted) {
-          return;
-        }
-        const next = await iterator.next();
-        if (next.done) {
-          return;
-        }
-        if (signal.aborted) {
-          return;
-        }
-        yield next.value;
-      }
-    } finally {
-      await iterator.return?.();
-    }
-  })();
-};
-const collectRls = (middlewares) => {
-  const tags = [];
-  for (const middleware of middlewares) {
-    const tag = readRlsTag(middleware);
-    if (!tag) {
-      continue;
-    }
-    tags.push(tag);
-  }
-  return tags.length > 0 ? { tags } : void 0;
-};
-const makeBuilder = (kind, state, visibility) => {
-  return {
-    __lunoraProcedure: kind,
-    ...visibility ? { __lunoraVisibility: visibility } : {},
-    input: (validators) => makeBuilder(kind, { ...state, args: { ...state.args, ...validators } }, visibility),
-    [kind]: (userHandler) => {
-      const rls = collectRls(state.middlewares);
-      return {
-        args: state.args,
-        ...state.expose ? { expose: state.expose } : {},
-        handler: makeHandler(state.args, state.middlewares, userHandler, state.output),
-        kind,
-        ...rls ? { rls } : {},
-        ...visibility ? { visibility } : {},
-        ...state.x402 ? { x402: state.x402 } : {}
-      };
-    },
-    output: (validator) => makeBuilder(kind, { ...state, output: validator }, visibility),
-    // `.stream()` is meaningful only on query builders. It's harmless to expose
-    // on every builder shape (callers can't hit it from action/mutation builders
-    // anyway since the type system narrows it away), but emitting it
-    // unconditionally keeps the runtime free of per-kind branching.
-    ...kind === "query" ? {
-      stream: (userHandler) => {
-        const rls = collectRls(state.middlewares);
-        return {
-          args: state.args,
-          ...state.expose ? { expose: state.expose } : {},
-          handler: makeStreamHandler(state.args, state.middlewares, userHandler),
-          kind: "stream",
-          ...rls ? { rls } : {},
-          ...visibility ? { visibility } : {},
-          ...state.x402 ? { x402: state.x402 } : {}
-        };
-      }
-    } : {},
-    use: (middleware) => makeBuilder(kind, { ...state, middlewares: [...state.middlewares, middleware] }, visibility),
-    // `.expose({ rest: true })` publishes a PUBLIC procedure on the REST surface
-    // (plan 167). Public-only for the same reason as `.x402`: an internal
-    // function is server-to-server and never reachable over HTTP, so there is
-    // nothing to expose. Default-closed — omitting the modifier keeps the
-    // procedure RPC-only.
-    ...visibility ? {} : { expose: (config) => makeBuilder(kind, { ...state, expose: config }, visibility) },
-    // `.x402({ price })` marks a public procedure as paid. It's public-only:
-    // internal functions are server-to-server (cron/scheduler/`ctx.run*`) and
-    // never reachable via a client RPC, so there's nothing to charge. Omitting
-    // it on internal builders keeps the runtime shape aligned with the types.
-    ...visibility ? {} : { x402: (config) => makeBuilder(kind, { ...state, x402: config }, visibility) }
-  };
-};
-const initLunora = {
-  dataModel: () => {
-    return {
-      create: (_options) => {
-        return {
-          action: makeBuilder("action", { args: {}, middlewares: [] }),
-          internalAction: makeBuilder("action", { args: {}, middlewares: [] }, "internal"),
-          internalMutation: makeBuilder("mutation", { args: {}, middlewares: [] }, "internal"),
-          internalQuery: makeBuilder("query", { args: {}, middlewares: [] }, "internal"),
-          mutation: makeBuilder("mutation", { args: {}, middlewares: [] }),
-          query: makeBuilder("query", { args: {}, middlewares: [] })
-        };
-      }
-    };
-  }
-};
-
-export { initLunora };