@lunora/server 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/httpAction-FLwfsePg.mjs

@@ -0,0 +1,340 @@
+import { parseValidatorMap, ValidationError } from '@lunora/values';
+import { Hono } from 'hono';
+import { LunoraError } from './LunoraError-DN7Zhhvu.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) {
+    return Response.json({ code: error.code, error: error.message }, { status: error.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;
+    return payload === void 0 ? new Response(null, { status: 204 }) : Response.json(payload);
+  } catch (error) {
+    return errorResponse(error);
+  }
+};
+const isLunoraErrorLike = (error) => {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const candidate = error;
+  return candidate.name === "LunoraError" && typeof candidate.code === "string" && typeof candidate.message === "string";
+};
+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) {
+          let payload;
+          if (isLunoraErrorLike(error)) {
+            payload = { code: error.code, message: error.message };
+          } else {
+            console.error("[lunora] unhandled stream handler error:", error);
+            payload = { code: "INTERNAL_SERVER_ERROR", message: "Internal error" };
+          }
+          controller.enqueue(encoder.encode(sseFrame(payload, "error")));
+        } finally {
+          request.signal.removeEventListener("abort", onAbort);
+          controller.close();
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "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"
+      }
+    });
+  }
+);
+const makeRouteBuilder = (state) => {
+  return {
+    body: (validators) => makeRouteBuilder({ ...state, body: { ...state.body, ...validators } }),
+    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)
+  };
+};
+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, serveStorageObject };

package/dist/packem_shared/initLunora-lxwHTEV3.mjs

@@ -0,0 +1,100 @@
+import { v as validateArgs } from './functions-Di9FUNkf.mjs';
+import { r as readRlsTag } from './policy-tag-DvpVH2tv.mjs';
+import { r as runMiddlewareChain } from './run-middleware-CYQOuoV6.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,
+        handler: makeHandler(state.args, state.middlewares, userHandler, state.output),
+        kind,
+        ...rls ? { rls } : {},
+        ...visibility ? { visibility } : {}
+      };
+    },
+    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,
+          handler: makeStreamHandler(state.args, state.middlewares, userHandler),
+          kind: "stream",
+          ...rls ? { rls } : {},
+          ...visibility ? { visibility } : {}
+        };
+      }
+    } : {},
+    use: (middleware) => makeBuilder(kind, { ...state, middlewares: [...state.middlewares, middleware] }, 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 };

package/dist/packem_shared/mask-BV_jNzsN.mjs

@@ -0,0 +1,211 @@
+import { LunoraError } from './LunoraError-DN7Zhhvu.mjs';
+import { bindTableFacade, bindOrm } from './bindOrm-Ce57S3N9.mjs';
+
+const permissionName = (permission) => typeof permission === "string" ? permission : permission.name;
+const indexRolePermissions = (roles) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const role of roles ?? []) {
+    map.set(role.name, new Set((role.permissions ?? []).map((permission) => permissionName(permission))));
+  }
+  return map;
+};
+const fnv1aHex = (input) => {
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.codePointAt(index) ?? 0;
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+};
+const applyStrategy = (strategy, value, context) => {
+  try {
+    if (strategy === "redact") {
+      return null;
+    }
+    if (strategy === "hash") {
+      if (value === null || value === void 0) {
+        return value;
+      }
+      return fnv1aHex(typeof value === "string" ? value : JSON.stringify(value));
+    }
+    return strategy(value, context);
+  } catch {
+    return null;
+  }
+};
+const maskRow = (row, columns, base) => {
+  const out = { ...row };
+  for (const [column, strategy] of Object.entries(columns)) {
+    if (!(column in out)) {
+      continue;
+    }
+    out[column] = applyStrategy(strategy, row[column], { ...base, column, row });
+  }
+  return out;
+};
+const maskPage = (page, columns, base) => {
+  return { ...page, page: page.page.map((row) => maskRow(row, columns, base)) };
+};
+const isFacadeEntry = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate["findMany"] === "function" && typeof candidate["withSearchIndex"] === "function";
+};
+const wrapDatabase = (base, perTable, context) => {
+  const wrapReader = (reader, columns) => {
+    return {
+      collect: async () => {
+        const rows = await reader.collect();
+        return rows.map((row) => maskRow(row, columns, context));
+      },
+      filter: (predicate) => wrapReader(
+        reader.filter((document) => predicate(document)),
+        columns
+      ),
+      first: async () => {
+        const row = await reader.first();
+        return row ? maskRow(row, columns, context) : null;
+      },
+      order: (direction) => wrapReader(reader.order(direction), columns),
+      paginate: async (options) => maskPage(await reader.paginate(options), columns, context),
+      take: async (limit) => {
+        const rows = await reader.take(limit);
+        return rows.map((row) => maskRow(row, columns, context));
+      },
+      unique: async () => {
+        const row = await reader.unique();
+        return row ? maskRow(row, columns, context) : null;
+      },
+      withIndex: (indexName, range) => wrapReader(reader.withIndex(indexName, range), columns),
+      withSearchIndex: (indexName, search) => wrapReader(reader.withSearchIndex(indexName, search), columns)
+    };
+  };
+  const locate = async (id, expectedTable) => {
+    if (base.lookupById) {
+      const located = await base.lookupById(id, expectedTable);
+      if (!located) {
+        return { row: null, tableName: void 0 };
+      }
+      return { row: located.row, tableName: perTable.has(located.tableName) ? located.tableName : void 0 };
+    }
+    const row = await base.get(id, expectedTable);
+    if (!row) {
+      return { row: null, tableName: void 0 };
+    }
+    let probeTables;
+    if (expectedTable === void 0) {
+      probeTables = [...perTable.keys()];
+    } else if (perTable.has(expectedTable)) {
+      probeTables = [expectedTable];
+    } else {
+      probeTables = [];
+    }
+    const probes = await Promise.all(
+      probeTables.map(async (tableName) => {
+        const probe = await base.findFirst(tableName, { limit: 1, where: { _id: id } });
+        return probe?.["_id"] === id ? tableName : void 0;
+      })
+    );
+    return { row, tableName: probes.find((entry) => entry !== void 0) };
+  };
+  const assertReductionAllowed = (tableName, fields, method) => {
+    const columns = perTable.get(tableName);
+    if (!columns) {
+      return;
+    }
+    const offending = fields.find((field) => typeof field === "string" && field in columns);
+    if (offending !== void 0) {
+      throw new LunoraError("MASK_UNSUPPORTED", `${method}() over masked column "${offending}" on "${tableName}" is not supported`);
+    }
+  };
+  const wrapped = {
+    ...base,
+    aggregate(tableName, options) {
+      assertReductionAllowed(tableName, [options.field], "aggregate");
+      return base.aggregate(tableName, options);
+    },
+    async findFirst(tableName, args) {
+      const row = await base.findFirst(tableName, args);
+      const columns = perTable.get(tableName);
+      return row && columns ? maskRow(row, columns, context) : row;
+    },
+    async findFirstOrThrow(tableName, args) {
+      const row = await base.findFirstOrThrow(tableName, args);
+      const columns = perTable.get(tableName);
+      return columns ? maskRow(row, columns, context) : row;
+    },
+    async findMany(tableName, args) {
+      const page = await base.findMany(tableName, args);
+      const columns = perTable.get(tableName);
+      return columns ? maskPage(page, columns, context) : page;
+    },
+    async get(id, expectedTable) {
+      const { row, tableName } = await locate(id, expectedTable);
+      const columns = tableName === void 0 ? void 0 : perTable.get(tableName);
+      if (!row || !columns) {
+        return row;
+      }
+      return maskRow(row, columns, context);
+    },
+    groupBy(tableName, options) {
+      assertReductionAllowed(tableName, [...options.by, options.agg?.field], "groupBy");
+      return base.groupBy(tableName, options);
+    },
+    query(tableName) {
+      const reader = base.query(tableName);
+      const columns = perTable.get(tableName);
+      return columns ? wrapReader(reader, columns) : reader;
+    },
+    async rankPage(tableName, indexName, options) {
+      const page = await base.rankPage(tableName, indexName, options);
+      const columns = perTable.get(tableName);
+      return columns ? maskPage(page, columns, context) : page;
+    }
+  };
+  const writableFacade = wrapped;
+  for (const tableName of perTable.keys()) {
+    if (isFacadeEntry(base[tableName])) {
+      writableFacade[tableName] = bindTableFacade(wrapped, tableName);
+    }
+  }
+  return wrapped;
+};
+const mask = (policies, options = {}) => {
+  const perTable = new Map(Object.entries(policies));
+  const rolePermissions = indexRolePermissions(options.roles);
+  return async ({ ctx, next }) => {
+    const auth = ctx.auth ?? {};
+    const identity = await auth.getIdentity?.() ?? null;
+    const roles = auth.roles ?? [];
+    const granted = /* @__PURE__ */ new Set();
+    for (const roleName of roles) {
+      for (const name of rolePermissions.get(roleName) ?? []) {
+        granted.add(name);
+      }
+    }
+    const maskContext = {
+      auth: {
+        can: (permission) => granted.has(permissionName(permission)),
+        identity,
+        roles,
+        // eslint-disable-next-line unicorn/no-null -- MaskContext.auth.userId is a public `null | string` type
+        userId: auth.userId ?? null
+      },
+      ctx
+    };
+    if (options.bypass?.(maskContext)) {
+      return next();
+    }
+    const wrapped = wrapDatabase(ctx.db, perTable, maskContext);
+    const extension = { db: wrapped };
+    const { orm } = ctx;
+    if (orm !== null && typeof orm === "object") {
+      extension.orm = bindOrm(wrapped);
+    }
+    return next({ ctx: extension });
+  };
+};
+
+export { mask };

package/dist/packem_shared/onConnect-CIPXKPyw.mjs

@@ -0,0 +1,13 @@
+const wrapLifecycle = (lifecycle, handler) => {
+  return {
+    args: {},
+    handler: (context, event) => handler(context, event),
+    kind: "mutation",
+    lifecycle,
+    visibility: "internal"
+  };
+};
+const onConnect = (handler) => wrapLifecycle("connect", handler);
+const onDisconnect = (handler) => wrapLifecycle("disconnect", handler);
+
+export { onConnect, onDisconnect };

package/dist/packem_shared/policy-tag-DvpVH2tv.mjs

@@ -0,0 +1,13 @@
+const RLS_TAG = /* @__PURE__ */ Symbol.for("lunora.rls.middleware-policies");
+const tagRlsMiddleware = (middleware, tag) => {
+  Object.defineProperty(middleware, RLS_TAG, { configurable: true, enumerable: false, value: tag });
+  return middleware;
+};
+const readRlsTag = (middleware) => {
+  if (middleware === null || typeof middleware !== "function" && typeof middleware !== "object") {
+    return void 0;
+  }
+  return middleware[RLS_TAG];
+};
+
+export { readRlsTag as r, tagRlsMiddleware as t };

package/dist/packem_shared/protectPublic-BjFkQ_Or.mjs

@@ -0,0 +1,15 @@
+import { r as runMiddlewareChain } from './run-middleware-CYQOuoV6.mjs';
+
+const protectPublic = (options) => {
+  const chain = [options.rateLimit, options.captcha, ...options.use ?? []].filter(
+    (middleware) => middleware !== void 0
+  );
+  const composed = async ({ ctx, next }) => runMiddlewareChain(
+    chain,
+    ctx,
+    (context) => next({ ctx: context })
+  );
+  return composed;
+};
+
+export { protectPublic };