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

package/dist/packem_shared/bindOrm-CaY7Wq9Z.mjs

@@ -1,147 +0,0 @@
-import { LunoraError as LunoraError$1 } from '@lunora/errors';
-
-const isUniqueConflict = (error) => typeof error === "object" && error !== null && error.code === "CONFLICT" && error.kind === "unique";
-const buildUpsertWhere = (tableName, target, create) => {
-  const fields = typeof target === "string" ? [target] : target;
-  if (fields.length === 0) {
-    throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.upsert: "target" must name at least one field`);
-  }
-  const where = {};
-  for (const field of fields) {
-    if (!(field in create)) {
-      throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.upsert: target field "${field}" is missing from the create document`);
-    }
-    where[field] = create[field];
-  }
-  return where;
-};
-const bindTableFacade = (writer, tableName) => {
-  const insert = async (document, options) => {
-    if (options?.skipDuplicates !== true) {
-      return writer.insert(tableName, document);
-    }
-    try {
-      return await writer.insert(tableName, document);
-    } catch (error) {
-      if (isUniqueConflict(error)) {
-        return null;
-      }
-      throw error;
-    }
-  };
-  const upsert = async ({ create, target, update }) => {
-    const where = buildUpsertWhere(tableName, target, create);
-    const existing = await writer.findFirst(tableName, { where });
-    if (existing && typeof existing["_id"] === "string") {
-      await writer.patch(existing["_id"], update ?? create, tableName);
-      return { created: false, id: existing["_id"] };
-    }
-    const id = await writer.insert(tableName, create);
-    return { created: true, id };
-  };
-  return {
-    aggregate: (options) => writer.aggregate(tableName, options),
-    count: (where) => writer.count(tableName, where),
-    delete: (id) => writer.delete(id, tableName),
-    // `deleteMany`/`patchMany` forward the bound `tableName` as `expectedTable`
-    // for id-based calls (threaded through the writer + the RLS middleware's
-    // per-id gate) so every batched id is scoped to this table — the same IDOR
-    // guard the single-row `delete`/`patch` apply. The where-based form routes
-    // through the structural writer's `deleteMany(tableName, { where })`.
-    // `patchMany` maps the facade's `values` payload to the writer's
-    // `{ id, patch }` shape.
-    deleteMany: (first, options) => {
-      if (Array.isArray(first)) {
-        if (writer.deleteMany === void 0) {
-          throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.deleteMany is unavailable: this writer has no batch delete`);
-        }
-        return writer.deleteMany(first, options, tableName);
-      }
-      if (writer.deleteWhere === void 0) {
-        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.deleteMany({ where }) is unavailable: this writer has no where-based delete`);
-      }
-      const whereArgs = first;
-      return writer.deleteWhere(tableName, whereArgs.where, { limit: whereArgs.limit });
-    },
-    // `exists` reuses `findFirst` (RLS-filtered, indexed when a `.withIndex`-able
-    // `where` is supplied) and only asks whether a row came back — no count scan.
-    exists: async (where) => await writer.findFirst(tableName, where === void 0 ? void 0 : { where }) !== null,
-    findFirst: (args) => writer.findFirst(tableName, args),
-    findFirstOrThrow: (args) => writer.findFirstOrThrow(tableName, args),
-    findMany: (args) => writer.findMany(tableName, args),
-    get: (id) => writer.get(id, tableName),
-    groupBy: (options) => writer.groupBy(tableName, options),
-    // Physical removal — bypasses `.softDelete()`. RLS gates it as a delete.
-    hardDelete: (id) => writer.delete(id, tableName, { hard: true }),
-    insert,
-    insertMany: (documents, options) => {
-      if (writer.insertMany === void 0) {
-        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.insertMany is unavailable: this writer has no batch insert`);
-      }
-      return writer.insertMany(tableName, documents, options);
-    },
-    patch: (id, patch) => writer.patch(id, patch, tableName),
-    patchMany: (first, options) => {
-      if (Array.isArray(first)) {
-        if (writer.patchMany === void 0) {
-          throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.patchMany is unavailable: this writer has no batch patch`);
-        }
-        return writer.patchMany(
-          first.map((entry) => {
-            return { id: entry.id, patch: entry.values };
-          }),
-          options,
-          tableName
-        );
-      }
-      if (writer.patchWhere === void 0) {
-        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.patchMany({ where, values }) is unavailable: this writer has no where-based patch`);
-      }
-      const whereArgs = first;
-      return writer.patchWhere(tableName, { patch: whereArgs.values, where: whereArgs.where }, { limit: whereArgs.limit });
-    },
-    rank: (indexName, options) => writer.rank(tableName, indexName, options),
-    rankPage: (indexName, options) => writer.rankPage(tableName, indexName, options),
-    replace: (id, document) => writer.replace(id, document, tableName),
-    restore: async (id) => {
-      if (!writer.restore) {
-        throw new LunoraError$1("INTERNAL", `ctx.db.${tableName}.restore is unavailable: this writer has no restore (is the table .softDelete()?)`);
-      }
-      await writer.restore(id, tableName);
-    },
-    upsert,
-    upsertMany: async ({ rows, target }) => {
-      const results = [];
-      for (const row of rows) {
-        results.push(await upsert({ create: row.create, target, update: row.update }));
-      }
-      return results;
-    },
-    withGeoIndex: (indexName, build) => writer.query(tableName).withGeoIndex(indexName, build),
-    withSearchIndex: (indexName, search) => writer.query(tableName).withSearchIndex(indexName, search)
-  };
-};
-const bindOrm = (facade) => {
-  const resolve = (table) => {
-    const bound = facade[table];
-    if (!bound) {
-      throw new LunoraError$1("INTERNAL", `unknown table: ${table}`);
-    }
-    return bound;
-  };
-  return {
-    delete: (table, id) => resolve(table).delete(id),
-    insert: (table) => {
-      return { values: (document) => resolve(table).insert(document) };
-    },
-    query: facade,
-    replace: (table, id) => {
-      return { with: (document) => resolve(table).replace(id, document) };
-    },
-    update: (table, id) => {
-      return { set: (values) => resolve(table).patch(id, values) };
-    }
-  };
-};
-
-export { bindOrm, bindTableFacade };

package/dist/packem_shared/buildRlsReadRegistry-2uk_GfiH.mjs

@@ -1,107 +0,0 @@
-import { indexRolePermissions, computeReadBaseWhere, permissionName } from './rls-BaDQf7MG.mjs';
-import { r as readRlsTag } from './policy-tag-DvpVH2tv.mjs';
-
-const FALSE_PREDICATE = { OR: [] };
-const readEntryTags = (entry) => {
-  const hoisted = entry?.rls?.tags;
-  if (hoisted) {
-    return hoisted;
-  }
-  const tag = readRlsTag(entry);
-  return tag ? [tag] : [];
-};
-const addTagToRegistry = (byTable, tag) => {
-  const rolePermissions = indexRolePermissions(tag.roles);
-  const seenWhenByTable = /* @__PURE__ */ new Map();
-  const policiesByTable = /* @__PURE__ */ new Map();
-  for (const policy of tag.policies) {
-    if (policy.on !== "read") {
-      continue;
-    }
-    const seen = seenWhenByTable.get(policy.table) ?? /* @__PURE__ */ new Set();
-    if (seen.has(policy.when)) {
-      continue;
-    }
-    seen.add(policy.when);
-    seenWhenByTable.set(policy.table, seen);
-    const list = policiesByTable.get(policy.table) ?? [];
-    list.push(policy);
-    policiesByTable.set(policy.table, list);
-  }
-  for (const [table, policies] of policiesByTable) {
-    const groups = byTable.get(table) ?? [];
-    groups.push({ policies, rolePermissions });
-    byTable.set(table, groups);
-  }
-};
-const isFalsePredicate = (where) => {
-  const or = where.OR;
-  return Array.isArray(or) && or.length === 0 && Object.keys(where).length === 1;
-};
-const andMerge = (injected, caller) => {
-  if (!injected || Object.keys(injected).length === 0) {
-    return caller;
-  }
-  if (isFalsePredicate(injected)) {
-    return injected;
-  }
-  if (Object.keys(caller).length === 0) {
-    return injected;
-  }
-  return { AND: [injected, caller] };
-};
-const evaluateGroupBaseWhere = (group, request) => {
-  const granted = /* @__PURE__ */ new Set();
-  for (const roleName of request.roles) {
-    for (const name of group.rolePermissions.get(roleName) ?? []) {
-      granted.add(name);
-    }
-  }
-  return computeReadBaseWhere(group.policies, {
-    auth: {
-      can: (permission) => granted.has(permissionName(permission)),
-      identity: request.identity,
-      roles: request.roles,
-      userId: request.userId
-    },
-    ctx: request.ctx
-  });
-};
-const resolveReadBaseWhere = (registry, request) => {
-  const groups = registry.byTable.get(request.table);
-  if (!groups || groups.length === 0) {
-    return request.rlsRequired && !request.tablePublic ? FALSE_PREDICATE : void 0;
-  }
-  const predicates = [];
-  for (const group of groups) {
-    const base = evaluateGroupBaseWhere(group, request);
-    if (base === void 0) {
-      return void 0;
-    }
-    if (isFalsePredicate(base)) {
-      continue;
-    }
-    predicates.push(base);
-  }
-  if (predicates.length === 0) {
-    return FALSE_PREDICATE;
-  }
-  return predicates.length === 1 ? predicates[0] : { OR: predicates };
-};
-const buildRlsReadRegistry = (functions) => {
-  const byTable = /* @__PURE__ */ new Map();
-  const seenTags = /* @__PURE__ */ new Set();
-  for (const entry of functions) {
-    for (const tag of readEntryTags(entry)) {
-      if (seenTags.has(tag)) {
-        continue;
-      }
-      seenTags.add(tag);
-      addTagToRegistry(byTable, tag);
-    }
-  }
-  return { byTable };
-};
-const composeShapeReadWhere = (registry, request) => andMerge(resolveReadBaseWhere(registry, request), request.shapeWhere);
-
-export { buildRlsReadRegistry, composeShapeReadWhere };

package/dist/packem_shared/composePluginMiddleware-z62dttBo.mjs

@@ -1,103 +0,0 @@
-import { LunoraError as LunoraError$1 } from '@lunora/errors';
-import { r as runMiddlewareChain } from './run-middleware-I6EiQfxL.mjs';
-
-const prefixTableName = (key, bareName) => `${key}_${bareName}`;
-const rewriteReference = (target, key, bareNames) => bareNames.has(target) ? prefixTableName(key, target) : target;
-const rewriteTableReferences = (table, key, bareNames, ownBareName) => {
-  const ownPrefixed = prefixTableName(key, ownBareName);
-  const rewriteOn = (on) => on === "" ? ownPrefixed : rewriteReference(on, key, bareNames);
-  const relationMap = {};
-  for (const [accessor, relation] of Object.entries(table.relationMap)) {
-    relationMap[accessor] = { ...relation, table: rewriteReference(relation.table, key, bareNames) };
-  }
-  const aggregateIndexes = table.aggregateIndexes.map((index) => {
-    return { ...index, on: rewriteOn(index.on) };
-  });
-  const rankIndexes = table.rankIndexes.map((index) => {
-    return { ...index, on: rewriteOn(index.on) };
-  });
-  return { ...table, aggregateIndexes, rankIndexes, relationMap };
-};
-const defineSchemaExtension = (key, options) => {
-  if (!key) {
-    throw new LunoraError$1("INTERNAL", "defineSchemaExtension: `key` is required and must be a non-empty string");
-  }
-  return {
-    key,
-    tables: options.tables,
-    ...options.vectorIndexes ? { vectorIndexes: options.vectorIndexes } : {}
-  };
-};
-const definePlugin = ((key, options) => {
-  if (!key) {
-    throw new LunoraError$1("INTERNAL", "definePlugin: `key` is required and must be a non-empty string");
-  }
-  if (options.extension && options.extension.key !== key) {
-    throw new LunoraError$1("INTERNAL", `definePlugin("${key}"): extension key "${options.extension.key}" does not match plugin key`);
-  }
-  return {
-    key,
-    ...options.extension ? { extension: options.extension } : {},
-    ...options.middleware ? { middleware: options.middleware } : {}
-  };
-});
-const defineComponent = (key, options) => {
-  const plugin = definePlugin(key, {
-    ...options.extension ? { extension: options.extension } : {},
-    ...options.middleware ? { middleware: options.middleware } : {}
-  });
-  return {
-    ...plugin,
-    functions: options.functions ?? {}
-  };
-};
-const mergeSchemaExtension = (base, extension) => {
-  const { key } = extension;
-  const bareNames = new Set(Object.keys(extension.tables));
-  const merged = { ...base.tables };
-  for (const [bareName, table] of Object.entries(extension.tables)) {
-    const prefixed = prefixTableName(key, bareName);
-    if (Object.hasOwn(merged, prefixed)) {
-      throw new LunoraError$1(
-        "INTERNAL",
-        `defineSchema(...).extend("${key}"): table "${prefixed}" already exists in the base schema — another extension with the same key already contributed it`
-      );
-    }
-    merged[prefixed] = rewriteTableReferences(table, key, bareNames, bareName);
-  }
-  const mergedVectorIndexes = { ...base.vectorIndexes };
-  if (extension.vectorIndexes) {
-    for (const [bareIndexName, index] of Object.entries(extension.vectorIndexes)) {
-      const prefixed = prefixTableName(key, bareIndexName);
-      if (Object.hasOwn(mergedVectorIndexes, prefixed)) {
-        throw new LunoraError$1(
-          "INTERNAL",
-          `defineSchema(...).extend("${key}"): vector index "${prefixed}" already exists in the base schema — another extension with the same key already contributed it`
-        );
-      }
-      mergedVectorIndexes[prefixed] = { ...index, table: rewriteReference(index.table, key, bareNames) };
-    }
-  }
-  return {
-    // Preserve secure-by-default RLS across `.extend(...)` — a plugin's
-    // tables join an `.rls("required")` schema as protected-by-default too.
-    rlsMode: base.rlsMode,
-    tables: merged,
-    vectorIndexes: mergedVectorIndexes
-  };
-};
-const installPlugins = (base, plugins) => {
-  let schema = base;
-  for (const plugin of plugins) {
-    if (plugin.extension) {
-      schema = mergeSchemaExtension(schema, plugin.extension);
-    }
-  }
-  return schema;
-};
-const composePluginMiddleware = (plugins) => {
-  const middlewares = plugins.map((plugin) => plugin.middleware).filter((middleware) => middleware !== void 0);
-  return (async ({ ctx, next }) => runMiddlewareChain(middlewares, ctx, (context) => next({ ctx: context })));
-};
-
-export { composePluginMiddleware, defineComponent, definePlugin, defineSchemaExtension, installPlugins, mergeSchemaExtension };

package/dist/packem_shared/createPolicyDsl-By3QB4he.mjs

@@ -1,32 +0,0 @@
-import { LunoraError as LunoraError$1 } from '@lunora/errors';
-
-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 LunoraError$1(
-        "INTERNAL",
-        `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/createSecrets-DwaR2rNG.mjs

@@ -1,58 +0,0 @@
-import { LunoraError as LunoraError$1 } from '@lunora/errors';
-
-const NON_SECRET_BINDING_METHODS = [
-  "put",
-  // KV / R2
-  "list",
-  // KV / R2
-  "delete",
-  // KV / R2
-  "getWithMetadata",
-  // KV
-  "head",
-  // R2
-  "createMultipartUpload",
-  // R2
-  "idFromName",
-  // Durable Object namespace
-  "newUniqueId",
-  // Durable Object namespace
-  "getByName",
-  // Durable Object namespace
-  "send",
-  // Queue producer
-  "sendBatch",
-  // Queue producer
-  "writeDataPoint",
-  // Analytics Engine dataset
-  "create",
-  // Workflows binding (get(id) + create/createBatch)
-  "createBatch"
-  // Workflows binding
-];
-const isSecretBinding = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const record = value;
-  if (typeof record.get !== "function") {
-    return false;
-  }
-  return !NON_SECRET_BINDING_METHODS.some((method) => typeof record[method] === "function");
-};
-const createSecrets = (env) => {
-  return {
-    get: async (name) => {
-      const binding = env[name];
-      if (!isSecretBinding(binding)) {
-        throw new LunoraError$1(
-          "INTERNAL",
-          `ctx.secrets: no Secrets Store binding named "${name}". Add a \`secrets_store_secrets[]\` entry (binding "${name}", pointing at your store + secret) to wrangler.jsonc — \`ctx.secrets\` reads a Secrets Store binding, not a plain \`.dev.vars\` value.`
-        );
-      }
-      return binding.get();
-    }
-  };
-};
-
-export { createSecrets };