@lunora/server 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/packem_shared/createPolicyDsl-De67zPDS.mjs

@@ -1,29 +0,0 @@
-const definePolicy = (input) => {
-  return { on: input.on, table: input.table, when: input.when };
-};
-const createPolicyDsl = () => (input) => {
-  return { on: input.on, table: input.table, when: input.when };
-};
-const definePermission = (name, options = {}) => {
-  return { name, ...options };
-};
-const definePolicies = (policies) => {
-  const seenWhenByKey = /* @__PURE__ */ new Map();
-  for (const policy of policies) {
-    const key = JSON.stringify([policy.table, policy.on]);
-    const whens = seenWhenByKey.get(key) ?? /* @__PURE__ */ new Set();
-    if (whens.has(policy.when)) {
-      throw new Error(
-        `definePolicies: duplicate policy for (table "${policy.table}", on "${policy.on}") — the same decision function is registered more than once. Multiple distinct policies per (table, on) are allowed (reads OR, writes AND); remove the duplicate.`
-      );
-    }
-    whens.add(policy.when);
-    seenWhenByKey.set(key, whens);
-  }
-  return policies;
-};
-const defineRole = (name, options = {}) => {
-  return { name, ...options };
-};
-
-export { createPolicyDsl, definePermission, definePolicies, definePolicy, defineRole };

package/dist/packem_shared/defineAggregateIndex-C2gT1GzM.mjs

@@ -1,252 +0,0 @@
-import { isOrWrapsFromValidator, v } from '@lunora/values';
-import { mergeSchemaExtension } from './composePluginMiddleware-Ck5_TUO8.mjs';
-
-const relationBuilder = {
-  many: (table, options) => {
-    return { field: options.field, kind: "many", references: options.references ?? "_id", table };
-  },
-  one: (table, options) => {
-    return { field: options.field, kind: "one", onDelete: options.onDelete, references: options.references ?? "_id", table };
-  }
-};
-const makeTrigger = (timing, op, handler) => {
-  return { handler, op, timing };
-};
-const createTriggerBuilder = () => {
-  return {
-    afterDelete: (handler) => makeTrigger("after", "delete", handler),
-    afterInsert: (handler) => makeTrigger("after", "insert", handler),
-    afterUpdate: (handler) => makeTrigger("after", "update", handler),
-    beforeDelete: (handler) => makeTrigger("before", "delete", handler),
-    beforeInsert: (handler) => makeTrigger("before", "insert", handler),
-    beforeUpdate: (handler) => makeTrigger("before", "update", handler)
-  };
-};
-const defineTable = (inputShape) => {
-  const shape = { ...inputShape };
-  for (const [columnName, validator] of Object.entries(shape)) {
-    if (isOrWrapsFromValidator(validator)) {
-      throw new Error(`defineTable: column "${columnName}" uses v.from() which is args-only — table columns need a concrete v.* type`);
-    }
-  }
-  const aggregateIndexes = [];
-  const indexes = [];
-  const rankIndexes = [];
-  const relations = {};
-  const searchIndexes = [];
-  const triggers = {};
-  const triggerBuilder = createTriggerBuilder();
-  const vectorIndexes = [];
-  let shardMode = { kind: "root" };
-  let isExternallyManaged = false;
-  let isPublic = false;
-  let softDelete;
-  const builder = {
-    aggregateIndex(name, options) {
-      const op = options?.op ?? "count";
-      if (op !== "count" && !options?.field) {
-        throw new Error(`aggregateIndex "${name}": op "${op}" requires a "field"`);
-      }
-      aggregateIndexes.push({
-        by: options?.by,
-        field: options?.field,
-        name,
-        // `on` is filled in by `defineSchema` once the table is keyed; we
-        // stash the placeholder so the AggregateIndexDefinition shape stays
-        // straightforward for D1/DO consumers (who read `on`).
-        on: "",
-        op,
-        where: options?.where
-      });
-      return builder;
-    },
-    get aggregateIndexes() {
-      return aggregateIndexes;
-    },
-    externallyManaged() {
-      isExternallyManaged = true;
-      return builder;
-    },
-    global(options) {
-      shardMode = { backend: options?.backend ?? "d1", kind: "global" };
-      return builder;
-    },
-    get isExternallyManaged() {
-      return isExternallyManaged;
-    },
-    get isPublic() {
-      return isPublic;
-    },
-    index(name, fields, options) {
-      indexes.push({ fields, name, unique: options?.unique ?? false });
-      return builder;
-    },
-    get indexes() {
-      return indexes;
-    },
-    public() {
-      isPublic = true;
-      return builder;
-    },
-    rankIndex(name, options) {
-      if (!options.sortBy || options.sortBy.length === 0) {
-        throw new Error(`rankIndex "${name}": "sortBy" is required and must list at least one key`);
-      }
-      const sortBy = options.sortBy.map((key) => {
-        return {
-          direction: key.direction ?? "asc",
-          field: key.field
-        };
-      });
-      rankIndexes.push({
-        name,
-        // `on` is filled in by `defineSchema` once the table is keyed —
-        // same pattern as `aggregateIndex`.
-        on: "",
-        partitionBy: options.partitionBy,
-        sortBy,
-        where: options.where
-      });
-      return builder;
-    },
-    get rankIndexes() {
-      return rankIndexes;
-    },
-    get relationMap() {
-      return relations;
-    },
-    relations(build) {
-      Object.assign(relations, build(relationBuilder));
-      return builder;
-    },
-    searchIndex(name, options) {
-      searchIndexes.push({ field: options.field, filterFields: options.filterFields, name });
-      return builder;
-    },
-    get searchIndexes() {
-      return searchIndexes;
-    },
-    shape,
-    shardBy(field) {
-      shardMode = { field, kind: "shardBy" };
-      return builder;
-    },
-    get shardMode() {
-      return shardMode;
-    },
-    get softDeleteMode() {
-      return softDelete;
-    },
-    softDelete(options) {
-      const field = options?.field ?? "deletedAt";
-      softDelete = { field };
-      if (!(field in shape)) {
-        shape[field] = v.optional(v.number().nullable());
-      }
-      return builder;
-    },
-    get triggerMap() {
-      return triggers;
-    },
-    triggers(build) {
-      Object.assign(triggers, build(triggerBuilder));
-      return builder;
-    },
-    get vectorIndexes() {
-      return vectorIndexes;
-    },
-    vectorize(field, options) {
-      vectorIndexes.push({
-        dimensions: options.dimensions,
-        embed: options.embed,
-        field,
-        metadata: options.metadata,
-        metric: options.metric,
-        name: options.index
-      });
-      return builder;
-    }
-  };
-  return builder;
-};
-const defineVectorIndex = (options) => {
-  return {
-    dimensions: options.dimensions,
-    embed: options.embed,
-    kind: "vectorIndex",
-    metadata: options.metadata,
-    metric: options.metric,
-    select: options.source.select,
-    table: options.source.table
-  };
-};
-const defineAggregateIndex = (name, options) => {
-  const op = options.op ?? "count";
-  if (op !== "count" && !options.field) {
-    throw new Error(`aggregateIndex "${name}": op "${op}" requires a "field"`);
-  }
-  return { by: options.by, field: options.field, name, on: options.on, op, where: options.where };
-};
-const defineRankIndex = (name, options) => {
-  if (!options.sortBy || options.sortBy.length === 0) {
-    throw new Error(`rankIndex "${name}": "sortBy" is required and must list at least one key`);
-  }
-  const sortBy = options.sortBy.map((key) => {
-    return {
-      direction: key.direction ?? "asc",
-      field: key.field
-    };
-  });
-  return { name, on: options.table, partitionBy: options.partitionBy, sortBy, where: options.where };
-};
-const withExtend = (schema) => {
-  return {
-    ...schema,
-    extend(extension) {
-      return withExtend(mergeSchemaExtension(schema, extension));
-    },
-    jurisdiction(_jurisdiction) {
-      return withExtend(schema);
-    },
-    rls(mode) {
-      return withExtend({ ...schema, rlsMode: mode });
-    }
-  };
-};
-const fillIndexTableNames = (tables) => {
-  for (const [tableName, table] of Object.entries(tables)) {
-    for (const index of table.aggregateIndexes) {
-      if (index.on === "") {
-        index.on = tableName;
-      }
-    }
-    for (const index of table.rankIndexes) {
-      if (index.on === "") {
-        index.on = tableName;
-      }
-    }
-  }
-};
-const attachStandaloneIndexes = (tables, aggregateIndexes, rankIndexes) => {
-  for (const index of Object.values(aggregateIndexes)) {
-    const table = tables[index.on];
-    if (!table) {
-      throw new Error(`defineAggregateIndex "${index.name}": unknown table "${index.on}"`);
-    }
-    table.aggregateIndexes.push(index);
-  }
-  for (const index of Object.values(rankIndexes)) {
-    const table = tables[index.on];
-    if (!table) {
-      throw new Error(`defineRankIndex "${index.name}": unknown table "${index.on}"`);
-    }
-    table.rankIndexes.push(index);
-  }
-};
-const defineSchema = (tables, vectorIndexes = {}, aggregateIndexes = {}, rankIndexes = {}) => {
-  fillIndexTableNames(tables);
-  attachStandaloneIndexes(tables, aggregateIndexes, rankIndexes);
-  return withExtend({ tables, vectorIndexes });
-};
-
-export { defineAggregateIndex, defineRankIndex, defineSchema, defineTable, defineVectorIndex };

package/dist/packem_shared/defineMigration-CAJLr6fx.mjs

@@ -1,8 +0,0 @@
-const defineMigration = (definition) => {
-  if (definition.id.trim() === "") {
-    throw new Error("defineMigration: `id` must be a non-empty string");
-  }
-  return { __lunoraMigration: true, ...definition };
-};
-
-export { defineMigration };

package/dist/packem_shared/defineStorageRule-qu0mpilX.mjs

@@ -1,20 +0,0 @@
-const defineStorageRule = (input) => {
-  return { bucket: input.bucket, on: input.on, prefix: input.prefix, when: input.when };
-};
-const defineStorageRules = (rules) => {
-  const seenWhenByKey = /* @__PURE__ */ new Map();
-  for (const rule of rules) {
-    const key = JSON.stringify([rule.bucket, rule.on, rule.prefix]);
-    const whens = seenWhenByKey.get(key) ?? /* @__PURE__ */ new Set();
-    if (whens.has(rule.when)) {
-      throw new Error(
-        `defineStorageRules: duplicate rule for (bucket "${rule.bucket}", on "${rule.on}"${rule.prefix === void 0 ? "" : `, prefix "${rule.prefix}"`}) — the same decision function is registered more than once. Multiple distinct rules per (bucket, on) are allowed (they OR); remove the duplicate.`
-      );
-    }
-    whens.add(rule.when);
-    seenWhenByKey.set(key, whens);
-  }
-  return rules;
-};
-
-export { defineStorageRule, defineStorageRules };

package/dist/packem_shared/httpAction-B7FYUEgr.mjs

@@ -1,340 +0,0 @@
-import { parseValidatorMap, ValidationError } from '@lunora/values';
-import { Hono } from 'hono';
-import { LunoraError } from './LunoraError-DhggBJZF.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 };