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

package/dist/packem_shared/defineAggregateIndex-cdo0g-un.mjs

@@ -1,349 +0,0 @@
-import { LunoraError as LunoraError$1 } from '@lunora/errors';
-import { isOrWrapsFromValidator, v } from '@lunora/values';
-import { mergeSchemaExtension } from './composePluginMiddleware-z62dttBo.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 geoIndexes = [];
-  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 ttl;
-  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;
-    },
-    geoIndex(name, options) {
-      geoIndexes.push({ field: options.field, name, precision: options.precision });
-      return builder;
-    },
-    get geoIndexes() {
-      return geoIndexes;
-    },
-    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;
-    },
-    ttl(field, options) {
-      ttl = { after: options?.after, field };
-      return builder;
-    },
-    get ttlPolicy() {
-      return ttl;
-    },
-    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 strayIncrementalKnob = (source) => {
-  if (source.cursor) {
-    return "cursor";
-  }
-  if (source.reconcileEveryMs !== void 0) {
-    return "reconcileEveryMs";
-  }
-  if (source.softDeleteColumn !== void 0) {
-    return "softDeleteColumn";
-  }
-  return void 0;
-};
-const validateExternalSourceMode = (name, source) => {
-  const isIncremental = source.mode === "incremental";
-  if (source.mode !== void 0 && source.mode !== "full-pull" && !isIncremental) {
-    throw new LunoraError$1(
-      "INTERNAL",
-      `defineSchema: table "${name}" uses \`mode: ${JSON.stringify(source.mode)}\` — supported modes are "full-pull" (default) and "incremental".`
-    );
-  }
-  if (!isIncremental) {
-    const strayKnob = strayIncrementalKnob(source);
-    if (strayKnob) {
-      throw new LunoraError$1(
-        "INTERNAL",
-        `defineSchema: table "${name}" sets \`${strayKnob}\` but is not \`mode: "incremental"\` — that knob only applies to incremental ingest. Set \`mode: "incremental"\` or remove \`${strayKnob}\`.`
-      );
-    }
-    return;
-  }
-  if (!source.cursor?.column || !source.cursor.query) {
-    throw new LunoraError$1(
-      "INTERNAL",
-      `defineSchema: table "${name}" is \`mode: "incremental"\` but has no \`cursor\` — add \`cursor: { column: "updated_at", query: "… WHERE … > $N" }\` binding the watermark as the trailing parameter.`
-    );
-  }
-  if (source.reconcileEveryMs === void 0 && source.softDeleteColumn === void 0) {
-    throw new LunoraError$1(
-      "INTERNAL",
-      `defineSchema: table "${name}" is \`mode: "incremental"\` with no delete-visibility path — an incremental pull never sees upstream deletes, so it would accumulate phantom rows. Add \`reconcileEveryMs\` (a periodic full-pull sweep) or \`softDeleteColumn\` (an upstream tombstone column).`
-    );
-  }
-};
-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.`
-      );
-    }
-    validateExternalSourceMode(name, source);
-  }
-};
-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 };