@lunora/server 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/defineAggregateIndex-DxSso0rH.mjs

@@ -0,0 +1,236 @@
+import { isOrWrapsFromValidator } 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 = (shape) => {
+  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;
+  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 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));
+    },
+    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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,20 @@
+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

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

package/dist/packem_shared/initLunora-CATvPsVt.mjs

@@ -0,0 +1,86 @@
+import { parseValidatorMap } from '@lunora/values';
+import { r as runMiddlewareChain } from './run-middleware-CYQOuoV6.mjs';
+
+const validateArgs = (validators, args) => parseValidatorMap(validators, args, "args");
+
+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 makeBuilder = (kind, state, visibility) => {
+  return {
+    __lunoraProcedure: kind,
+    ...visibility ? { __lunoraVisibility: visibility } : {},
+    input: (validators) => makeBuilder(kind, { ...state, args: { ...state.args, ...validators } }, visibility),
+    [kind]: (userHandler) => {
+      return {
+        args: state.args,
+        handler: makeHandler(state.args, state.middlewares, userHandler, state.output),
+        kind,
+        ...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) => {
+        return {
+          args: state.args,
+          handler: makeStreamHandler(state.args, state.middlewares, userHandler),
+          kind: "stream",
+          ...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 };