@lunora/server 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/composePluginMiddleware-Ck5_TUO8.mjs

@@ -0,0 +1,100 @@
+import { r as runMiddlewareChain } from './run-middleware-CYQOuoV6.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 Error("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 Error("definePlugin: `key` is required and must be a non-empty string");
+  }
+  if (options.extension && options.extension.key !== key) {
+    throw new Error(`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 Error(
+        `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 Error(
+          `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-De67zPDS.mjs

@@ -0,0 +1,29 @@
+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/createSecrets-TsIP9lOa.mjs

@@ -0,0 +1,55 @@
+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 Error(
+          `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-ZdyU78gh.mjs

@@ -0,0 +1,291 @@
+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;
+  let externalSource;
+  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;
+    },
+    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 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;
+    },
+    source(definition) {
+      if (!definition.binding) {
+        throw new Error("source: `binding` is required (the wrangler Hyperdrive binding name)");
+      }
+      if (!definition.query) {
+        throw new Error("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 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 validateExternalSources = (tables) => {
+  for (const [name, table] of Object.entries(tables)) {
+    const source = table.externalSource;
+    if (!source) {
+      continue;
+    }
+    if (table.shardMode.kind === "global") {
+      throw new Error(
+        `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 Error(
+        `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 Error(
+        `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/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/defineMutator-EIXAWhs9.mjs

@@ -0,0 +1,11 @@
+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-CJ27Wx7o.mjs

@@ -0,0 +1,17 @@
+import { v as validateArgs } from './functions-Di9FUNkf.mjs';
+
+const defineShape = (definition) => {
+  if (definition.table.trim() === "") {
+    throw new Error("defineShape: `table` must be a non-empty string");
+  }
+  if (definition.columns?.length === 0) {
+    throw new Error("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-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/functions-Di9FUNkf.mjs

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