@lunora/server 1.0.0-alpha.16 → 1.0.0-alpha.161

package/dist/packem_shared/composePluginMiddleware-CcTj1_v2.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 };

package/dist/packem_shared/defineAggregateIndex-znq4ygKQ.mjs

@@ -1,295 +0,0 @@
-import { LunoraError as LunoraError$1 } from '@lunora/errors';
-import { isOrWrapsFromValidator, v } from '@lunora/values';
-import { mergeSchemaExtension } from './composePluginMiddleware-CcTj1_v2.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 LunoraError$1("INTERNAL", `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;
-  let externalSource;
-  const builder = {
-    aggregateIndex(name, options) {
-      const op = options?.op ?? "count";
-      if (op !== "count" && !options?.field) {
-        throw new LunoraError$1("INTERNAL", `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;
-    },
-    get externalSource() {
-      return externalSource;
-    },
-    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 LunoraError$1("INTERNAL", `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;
-    },
-    source(definition) {
-      if (!definition.binding) {
-        throw new LunoraError$1("INTERNAL", "source: `binding` is required (the wrangler Hyperdrive binding name)");
-      }
-      if (!definition.query) {
-        throw new LunoraError$1("INTERNAL", "source: `query` is required (the tenant-membership SQL)");
-      }
-      externalSource = definition;
-      isExternallyManaged = true;
-      return builder;
-    },
-    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 LunoraError$1("INTERNAL", `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 LunoraError$1("INTERNAL", `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 LunoraError$1("INTERNAL", `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 LunoraError$1("INTERNAL", `defineRankIndex "${index.name}": unknown table "${index.on}"`);
-    }
-    table.rankIndexes.push(index);
-  }
-};
-const validateExternalSources = (tables) => {
-  for (const [name, table] of Object.entries(tables)) {
-    const source = table.externalSource;
-    if (!source) {
-      continue;
-    }
-    if (table.shardMode.kind === "global") {
-      throw new LunoraError$1(
-        "INTERNAL",
-        `defineSchema: table "${name}" cannot be both .source() and .global() — a sourced table materializes into a shard DO's SQLite, a global table lives in the external tier`
-      );
-    }
-    if (table.shardMode.kind === "shardBy" && !source.tenantBy) {
-      throw new LunoraError$1(
-        "INTERNAL",
-        `defineSchema: sourced + .shardBy() table "${name}" needs a \`tenantBy\` mapper — without it every tenant's DO would run the same unscoped query and replicate the whole multitenant table (a cross-tenant leak). Add \`tenantBy: (shardKey) => [shardKey]\` binding the shard key into the query's parameters.`
-      );
-    }
-    if (source.mode === "incremental") {
-      throw new LunoraError$1(
-        "INTERNAL",
-        `defineSchema: table "${name}" uses \`mode: "incremental"\`, which is not yet implemented — only "full-pull" (the default) is supported. Remove \`mode\` or set it to "full-pull".`
-      );
-    }
-  }
-};
-const defineSchema = (tables, vectorIndexes = {}, aggregateIndexes = {}, rankIndexes = {}) => {
-  fillIndexTableNames(tables);
-  attachStandaloneIndexes(tables, aggregateIndexes, rankIndexes);
-  validateExternalSources(tables);
-  return withExtend({ tables, vectorIndexes });
-};
-
-export { defineAggregateIndex, defineRankIndex, defineSchema, defineTable, defineVectorIndex };

package/dist/packem_shared/defineIdentity-DiX4zM9x.mjs

@@ -1,35 +0,0 @@
-import { LunoraError as LunoraError$1 } from '@lunora/errors';
-import { parseValidatorMap, ValidationError } from '@lunora/values';
-
-const NON_STRING_USER_ID_KINDS = /* @__PURE__ */ new Set([
-  "array",
-  "bigint",
-  "boolean",
-  "bytes",
-  "date",
-  "null",
-  "number",
-  "object",
-  "optional",
-  "record",
-  "timestamp"
-]);
-const defineIdentity = (claims, options = {}) => {
-  const map = claims;
-  const userIdValidator = map["userId"];
-  if (userIdValidator === void 0 || NON_STRING_USER_ID_KINDS.has(userIdValidator.kind)) {
-    throw new LunoraError$1("INTERNAL", "defineIdentity: the claim map must declare a required string `userId` validator (e.g. `v.string()` or `v.id(...)`)");
-  }
-  const onInvalid = options.onInvalid ?? "anonymous";
-  const validate = (identity) => {
-    try {
-      parseValidatorMap(map, identity, "identity");
-      return { ok: true };
-    } catch (error) {
-      return { error: error instanceof ValidationError ? error.message : String(error), ok: false };
-    }
-  };
-  return { __lunoraIdentity: true, claims: map, onInvalid, validate };
-};
-
-export { defineIdentity };

package/dist/packem_shared/defineMigration-Hx01yIht.mjs

@@ -1,10 +0,0 @@
-import { LunoraError as LunoraError$1 } from '@lunora/errors';
-
-const defineMigration = (definition) => {
-  if (definition.id.trim() === "") {
-    throw new LunoraError$1("INTERNAL", "defineMigration: `id` must be a non-empty string");
-  }
-  return { __lunoraMigration: true, ...definition };
-};
-
-export { defineMigration };

package/dist/packem_shared/defineMutator-EIXAWhs9.mjs

@@ -1,11 +0,0 @@
-import { v as validateArgs } from './functions-Di9FUNkf.mjs';
-
-const defineMutator = (definition) => {
-  const handler = async (context, rawArgs) => {
-    const parsed = validateArgs(definition.args ?? {}, rawArgs);
-    return definition.server(context, parsed);
-  };
-  return { __lunoraMutator: true, ...definition, handler, kind: "mutation" };
-};
-
-export { defineMutator };

package/dist/packem_shared/defineShape-C5scNOrf.mjs

@@ -1,18 +0,0 @@
-import { LunoraError as LunoraError$1 } from '@lunora/errors';
-import { v as validateArgs } from './functions-Di9FUNkf.mjs';
-
-const defineShape = (definition) => {
-  if (definition.table.trim() === "") {
-    throw new LunoraError$1("INTERNAL", "defineShape: `table` must be a non-empty string");
-  }
-  if (definition.columns?.length === 0) {
-    throw new LunoraError$1("INTERNAL", "defineShape: `columns` must list at least one column when provided");
-  }
-  const compileWhere = (context, rawArgs) => {
-    const parsed = validateArgs(definition.args ?? {}, rawArgs);
-    return definition.where(context, parsed);
-  };
-  return { __lunoraShape: true, ...definition, compileWhere };
-};
-
-export { defineShape };

package/dist/packem_shared/defineStorageRule-B5nL4Z1P.mjs

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

@@ -1,5 +0,0 @@
-import { parseValidatorMap } from '@lunora/values';
-
-const validateArgs = (validators, args) => parseValidatorMap(validators, args, "args");
-
-export { validateArgs as v };