@vibeorm/schema 5.7.0 → 5.9.0

package/dist/index.js

@@ -442,6 +442,8 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   fixedNamespaces: true,
   externalObjects: true,
   indexOperatorClasses: true,
+  indexIncludeColumns: true,
+  tableStorageParameters: true,
   exclusionConstraints: true,
   exclusionExtensions: Object.freeze(["btree_gist"]),
   checkNormalization: "rollback",
@@ -474,7 +476,10 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   uuidColumns: "native",
   localDateColumns: true,
   dateTruncation: true,
-  rowCapture: true
+  filteredAggregates: "filterClause",
+  groupingSets: "groupingSets",
+  rowCapture: true,
+  returningReadsJoinedSource: true
 });
 var SQLITE_CAPABILITIES = Object.freeze({
   rowRuleAppendOnly: true,
@@ -484,6 +489,8 @@ var SQLITE_CAPABILITIES = Object.freeze({
   fixedNamespaces: false,
   externalObjects: false,
   indexOperatorClasses: false,
+  indexIncludeColumns: false,
+  tableStorageParameters: false,
   exclusionConstraints: false,
   exclusionExtensions: Object.freeze([]),
   checkNormalization: "sourceText",
@@ -516,7 +523,10 @@ var SQLITE_CAPABILITIES = Object.freeze({
   uuidColumns: "text",
   localDateColumns: true,
   dateTruncation: false,
-  rowCapture: false
+  filteredAggregates: "filterClause",
+  groupingSets: "none",
+  rowCapture: false,
+  returningReadsJoinedSource: false
 });
 var MYSQL_CAPABILITIES = Object.freeze({
   rowRuleAppendOnly: true,
@@ -526,6 +536,8 @@ var MYSQL_CAPABILITIES = Object.freeze({
   fixedNamespaces: false,
   externalObjects: false,
   indexOperatorClasses: false,
+  indexIncludeColumns: false,
+  tableStorageParameters: false,
   exclusionConstraints: false,
   exclusionExtensions: Object.freeze([]),
   checkNormalization: "temporary",
@@ -558,7 +570,10 @@ var MYSQL_CAPABILITIES = Object.freeze({
   uuidColumns: "unsupported",
   localDateColumns: true,
   dateTruncation: false,
-  rowCapture: false
+  filteredAggregates: "caseWhen",
+  groupingSets: "rollup",
+  rowCapture: false,
+  returningReadsJoinedSource: false
 });
 var DIALECT_CAPABILITIES = Object.freeze({
   postgres: POSTGRES_CAPABILITIES,
@@ -1070,10 +1085,12 @@ function shapeIssue(params) {
   const { index } = params;
   if (!dataOnly({ value: index }))
     return "Expression indexes accept JSON-safe plain data only, not accessors, callbacks or cycles";
-  if (!record({ value: index, required: ["kind", "fields", "expressions"], optional: ["name", "clientName", "constraintName", "where", "wherePredicate", "nullsNotDistinct"] }))
+  if (!record({ value: index, required: ["kind", "fields", "expressions"], optional: ["name", "clientName", "constraintName", "where", "wherePredicate", "nullsNotDistinct", "include"] }))
     return "Expression indexes require canonical index data properties";
   if (typeof index.kind !== "string")
     return "Index kind must be a string";
+  if (index.include !== undefined && (!Array.isArray(index.include) || index.include.some((name) => !text({ value: name }))))
+    return "Expression index INCLUDE columns must be a list of field names";
   if (index.nullsNotDistinct !== undefined && typeof index.nullsNotDistinct !== "boolean" || index.name !== undefined && !text({ value: index.name }) || index.where !== undefined && !text({ value: index.where }))
     return "Expression index names, predicates and flags must have their canonical data types";
   const descriptor = Object.getOwnPropertyDescriptor(index, "expressions");
@@ -1139,14 +1156,15 @@ function structuralData(params) {
 }
 function indexKeyDefinitionKey(params) {
   const { index, model } = params;
+  const include = index.include === undefined ? [] : [{ include: index.include.map((name) => model?.fields.find((entry) => entry.name === name)?.dbName ?? name) }];
   if (!isExpressionIndex({ index })) {
     const columns = index.fields.map((field) => [model?.fields.find((entry) => entry.name === field.name)?.dbName ?? field.name, field.sort === "desc", field.operatorClass === undefined ? null : [field.operatorClass.namespace, field.operatorClass.name]]);
-    return JSON.stringify([index.kind === "unique", index.nullsNotDistinct === true, index.kind === "unique" ? "btree" : index.kind, columns, index.where?.trim() ?? ""]);
+    return JSON.stringify([index.kind === "unique", index.nullsNotDistinct === true, index.kind === "unique" ? "btree" : index.kind, columns, index.where?.trim() ?? "", ...include]);
   }
   const issue = shapeIssue({ index });
   if (issue !== undefined)
     throw invalid({ message: issue });
-  return JSON.stringify(["expression", index.kind, structuralData({ value: index.expressions, model }), index.nullsNotDistinct === true, index.where?.trim() ?? "", structuralData({ value: index.wherePredicate, model }) ?? null]);
+  return JSON.stringify(["expression", index.kind, structuralData({ value: index.expressions, model }), index.nullsNotDistinct === true, index.where?.trim() ?? "", structuralData({ value: index.wherePredicate, model }) ?? null, ...include]);
 }
 function scalarType(params) {
   const { expression, model, dialect, add } = params;
@@ -2335,6 +2353,172 @@ function assertIndexOperatorClasses(params) {
           throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Index operator class must be a qualified SQL name { namespace, name }", meta: { rule: "index-operator-class-identity", model: model.name, field: field.name } });
       }
 }
+// packages/schema/src/index-include.ts
+var INCLUDE_INDEX_KINDS = Object.freeze(["btree", "unique", "gist", "spgist"]);
+function hasIndexIncludeColumns(params) {
+  return params.schema.models.some((model) => model.indexes.some((index) => index.include !== undefined));
+}
+function assertIndexIncludeColumns(params) {
+  const { schema, dialect } = params;
+  for (const model of schema.models)
+    for (const index of model.indexes) {
+      const include = index.include;
+      if (include === undefined)
+        continue;
+      const site = `${index.kind === "unique" ? "@@unique" : "@@index"}${index.name === undefined ? "" : ` "${index.name}"`} on "${model.name}"`;
+      const invalid = (params) => new VibeError({ code: "VIBE_SCHEMA_INVALID", message: `${site}: ${params.message}`, meta: { rule: params.rule, model: model.name, ...index.name === undefined ? {} : { index: index.name }, ...params.field === undefined ? {} : { field: params.field } } });
+      if (!Array.isArray(include) || include.length === 0 || include.some((name) => typeof name !== "string" || name === ""))
+        throw invalid({ rule: "index-include-shape", message: "include must be a non-empty list of field names (omit it for an index without INCLUDE columns)" });
+      if (!DIALECT_CAPABILITIES[dialect].indexIncludeColumns)
+        throw unsupportedCapability({ dialect, feature: "indexIncludeColumns", hint: `${site} declares INCLUDE columns; covering indexes are PostgreSQL only` });
+      if (!INCLUDE_INDEX_KINDS.includes(index.kind))
+        throw unsupportedCapability({ dialect, feature: `INCLUDE columns on a ${index.kind} index`, hint: `${site}: PostgreSQL stores INCLUDE columns in btree, unique, GiST and SP-GiST indexes only` });
+      const keys = keyColumns({ index });
+      const seen = new Set;
+      for (const name of include) {
+        if (!model.fields.some((field) => field.name === name))
+          throw invalid({ rule: "index-include-field", message: `include names "${name}", which is not a scalar field of the model`, field: name });
+        if (seen.has(name))
+          throw invalid({ rule: "index-include-duplicate", message: `include lists "${name}" twice`, field: name });
+        if (keys.has(name))
+          throw invalid({ rule: "index-include-key-column", message: `"${name}" is already a key column of the index; PostgreSQL refuses a column that is both key and included`, field: name });
+        seen.add(name);
+      }
+    }
+}
+function keyColumns(params) {
+  return new Set(indexKeyTerms({ index: params.index }).flatMap((term) => term.kind === "field" ? [term.field.name] : []));
+}
+// packages/schema/src/table-storage.ts
+var INT_MAX = 2147483647;
+var HEAP_ONLY = {
+  fillfactor: { type: "integer", min: 10, max: 100 },
+  toast_tuple_target: { type: "integer", min: 128, max: 8160 },
+  parallel_workers: { type: "integer", min: 0, max: 1024 },
+  autovacuum_analyze_threshold: { type: "integer", min: 0, max: INT_MAX },
+  autovacuum_analyze_scale_factor: { type: "real", min: 0, max: 100 }
+};
+var VACUUM = {
+  autovacuum_enabled: { type: "boolean" },
+  vacuum_index_cleanup: { type: "enum", values: ["auto", "on", "off"] },
+  vacuum_truncate: { type: "boolean" },
+  autovacuum_vacuum_threshold: { type: "integer", min: 0, max: INT_MAX },
+  autovacuum_vacuum_scale_factor: { type: "real", min: 0, max: 100 },
+  autovacuum_vacuum_insert_threshold: { type: "integer", min: -1, max: INT_MAX },
+  autovacuum_vacuum_insert_scale_factor: { type: "real", min: 0, max: 100 },
+  autovacuum_vacuum_cost_delay: { type: "real", min: 0, max: 100 },
+  autovacuum_vacuum_cost_limit: { type: "integer", min: 1, max: 1e4 },
+  autovacuum_freeze_min_age: { type: "integer", min: 0, max: 1e9 },
+  autovacuum_freeze_max_age: { type: "integer", min: 1e5, max: 2000000000 },
+  autovacuum_freeze_table_age: { type: "integer", min: 0, max: 2000000000 },
+  autovacuum_multixact_freeze_min_age: { type: "integer", min: 0, max: 1e9 },
+  autovacuum_multixact_freeze_max_age: { type: "integer", min: 1e4, max: 2000000000 },
+  autovacuum_multixact_freeze_table_age: { type: "integer", min: 0, max: 2000000000 },
+  log_autovacuum_min_duration: { type: "integer", min: -1, max: INT_MAX }
+};
+var TABLE_STORAGE_PARAMETERS = Object.freeze({
+  ...HEAP_ONLY,
+  ...VACUUM,
+  ...Object.fromEntries(Object.entries(VACUUM).map(([key, spec]) => [`toast.${key}`, spec]))
+});
+var TABLE_STORAGE_KEYS = Object.freeze(Object.keys(TABLE_STORAGE_PARAMETERS));
+var TOAST_PREFIX = "toast.";
+function specOf(params) {
+  return Object.hasOwn(TABLE_STORAGE_PARAMETERS, params.key) ? TABLE_STORAGE_PARAMETERS[params.key] : undefined;
+}
+function isToastStorageKey(params) {
+  return params.key.startsWith(TOAST_PREFIX);
+}
+function tableStoragePrismaKey(params) {
+  return isToastStorageKey(params) ? `toast_${params.key.slice(TOAST_PREFIX.length)}` : params.key;
+}
+function tableStorageKeyFromPrisma(params) {
+  if (specOf({ key: params.name }) !== undefined)
+    return params.name;
+  if (!params.name.startsWith("toast_"))
+    return;
+  const key = `${TOAST_PREFIX}${params.name.slice("toast_".length)}`;
+  return specOf({ key }) === undefined ? undefined : key;
+}
+var TRUE_WORDS = new Set(["true", "t", "on", "yes", "y", "1"]);
+var FALSE_WORDS = new Set(["false", "f", "off", "no", "n", "0"]);
+function parseTableStorageValue(params) {
+  const spec = specOf({ key: params.key });
+  if (spec === undefined)
+    return;
+  const text = params.text.trim().toLowerCase();
+  switch (spec.type) {
+    case "boolean":
+      return TRUE_WORDS.has(text) ? true : FALSE_WORDS.has(text) ? false : undefined;
+    case "enum":
+      return spec.values?.includes(text) === true ? text : TRUE_WORDS.has(text) ? "on" : FALSE_WORDS.has(text) ? "off" : undefined;
+    case "integer":
+    case "real": {
+      if (text === "" || !/^[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(text))
+        return;
+      const value = Number(text);
+      return Number.isFinite(value) ? value : undefined;
+    }
+  }
+}
+function renderTableStorageValue(params) {
+  return typeof params.value === "boolean" ? params.value ? "true" : "false" : String(params.value);
+}
+function valueIssue(params) {
+  const { spec, value } = params;
+  switch (spec.type) {
+    case "boolean":
+      return typeof value === "boolean" ? undefined : "takes true or false";
+    case "enum":
+      return typeof value === "string" && spec.values?.includes(value) === true ? undefined : `takes one of ${spec.values?.map((entry) => `"${entry}"`).join(", ")}`;
+    case "integer":
+    case "real": {
+      const bounds = `between ${spec.min} and ${spec.max}`;
+      if (typeof value !== "number" || !Number.isFinite(value))
+        return `takes a number ${bounds}`;
+      if (spec.type === "integer" && !Number.isInteger(value))
+        return `takes a whole number ${bounds}`;
+      return value < (spec.min ?? -Infinity) || value > (spec.max ?? Infinity) ? `takes a value ${bounds}` : undefined;
+    }
+  }
+}
+function hasTableStorage(params) {
+  return params.schema.models.some((model) => model.storage !== undefined);
+}
+function assertTableStorage(params) {
+  const { schema, dialect } = params;
+  for (const model of schema.models) {
+    const storage = model.storage;
+    if (storage === undefined)
+      continue;
+    const invalid = (issue) => new VibeError({ code: "VIBE_SCHEMA_INVALID", message: `@@storage on "${model.name}": ${issue.message}`, meta: { rule: issue.rule, model: model.name, ...issue.parameter === undefined ? {} : { parameter: issue.parameter } } });
+    if (storage === null || typeof storage !== "object" || Array.isArray(storage) || Object.keys(storage).length === 0)
+      throw invalid({ rule: "table-storage-shape", message: "storage takes a non-empty record of parameters (omit it for a table without any)" });
+    if (model.isView)
+      throw invalid({ rule: "table-storage-view", message: "a view has no table storage parameters" });
+    if (!DIALECT_CAPABILITIES[dialect].tableStorageParameters)
+      throw unsupportedCapability({ dialect, feature: "tableStorageParameters", hint: `@@storage on "${model.name}" declares table storage parameters; they are PostgreSQL only` });
+    for (const [key, value] of Object.entries(storage)) {
+      const spec = specOf({ key });
+      if (spec === undefined)
+        throw invalid({ rule: "table-storage-parameter", message: `"${key}" is not a table storage parameter VibeORM declares (${TABLE_STORAGE_KEYS.filter((entry) => !isToastStorageKey({ key: entry })).join(", ")}, and toast. variants of the vacuum ones)`, parameter: key });
+      const issue = valueIssue({ spec, value });
+      if (issue !== undefined)
+        throw invalid({ rule: "table-storage-value", message: `"${key}" ${issue}`, parameter: key });
+    }
+  }
+}
+function tableStorageEntries(params) {
+  const storage = params.model.storage;
+  if (storage === undefined)
+    return [];
+  const known = TABLE_STORAGE_KEYS.flatMap((key) => {
+    const value = Object.hasOwn(storage, key) ? storage[key] : undefined;
+    return value === undefined ? [] : [[key, value]];
+  });
+  const unknown = Object.entries(storage).flatMap(([key, value]) => specOf({ key }) !== undefined || value === undefined ? [] : [[key, value]]);
+  return [...known, ...unknown];
+}
 // packages/schema/src/module-schema.ts
 function prepareDatabaseModuleSchema(params) {
   const { schema, module } = params;
@@ -2857,9 +3041,18 @@ var RESERVED_ENUM_NAMES = [
   "SelectionMember",
   "SelectionValue",
   "BagKeys",
+  "__VibeBagKeysIn",
+  "__VibeCertain",
   "IncludedRelation",
   "IncludedCount",
   "ViewDelegateMap",
+  "__VibeObjects",
+  "__VibeKeys",
+  "__VibeAt",
+  "__VibeItem",
+  "__VibeExact",
+  "__VibePreviousInput",
+  "__VibePrevious",
   "extensionManifest",
   "extensionMounts",
   "computedManifest",
@@ -2879,6 +3072,7 @@ var RESERVED_ENUM_NAMES = [
   "Date",
   "Uint8Array",
   "schema",
+  "jsonSchemas",
   "VibeClient",
   "VibeClientInstance",
   "VibeQueryPromise",
@@ -2899,6 +3093,12 @@ var RESERVED_ENUM_NAMES = [
   "RowLockRequest",
   "GroupByTruncateUnit",
   "GroupByKeyName",
+  "GroupByPath",
+  "GroupByExpressionValues",
+  "GroupByKeyOrderInput",
+  "GroupByOrderKeys",
+  "GroupByKeyOrderCheck",
+  "GroupingSetRow",
   "JsonValue",
   "InputJsonValue",
   "InputJsonArray",
@@ -2924,9 +3124,20 @@ var RESERVED_ENUM_NAMES = [
   "createClient",
   "DatabaseAdapter",
   "DbNow",
+  "BigIntFieldRef",
+  "BooleanFieldRef",
+  "DateTimeFieldRef",
+  "DecimalFieldRef",
+  "EnumFieldRef",
+  "FloatFieldRef",
+  "IntFieldRef",
+  "NumericFieldRef",
+  "StringFieldRef",
   "JoinedField",
   "TransactionLocalSettings",
   "VibeUpdateManySources",
+  "VibeModelRows",
+  "VibeHandleTypes",
   "ClientContext",
   "QueryOperation",
   "QueryEvent",
@@ -3010,6 +3221,12 @@ var GENERATED_TYPE_NAMES = {
     "HavingInput",
     "GroupByOrderByInput",
     "GroupByTruncatedKey",
+    "GroupByExpressionKey",
+    "FilteredAggregateInput",
+    "FilteredAggregateHavingInput",
+    "FilteredAggregateOrderByInput",
+    "FilteredResult",
+    "CoalesceOrderInput",
     "FindManyArgs",
     "FindPageArgs",
     "FindFirstArgs",
@@ -3059,6 +3276,7 @@ var GENERATED_TYPE_NAMES = {
     "ViewDelegate",
     "ReadOnlyDelegate"
   ],
+  generatedColumnSuffixes: ["WritableScalarFieldEnum", "GeneratedWriteGuard", "GeneratedBulkWriteRow"],
   nestedPrefixes: [
     "Create",
     "UncheckedCreate",
@@ -3134,33 +3352,118 @@ var INVALID_BINDING_NAMES = new Set([
   "object",
   "undefined"
 ]);
-function validateGeneratedNames(params) {
-  const { schema, issues } = params;
-  const owners = new Map(RESERVED_ENUM_NAMES.map((name) => [name, "generated client"]));
+var DISAMBIGUATED_TYPE_SUFFIXES = {
+  ListRelationFilter: true,
+  RelationFilter: true,
+  RelationOrderByInput: true,
+  RelationFindManyArgs: true,
+  CreateArgs: true,
+  UpdateArgs: true,
+  UpdateWhereInput: true,
+  UpsertArgs: true,
+  DeleteArgs: true,
+  CountArgs: true,
+  CountSelect: true,
+  AggregateArgs: true,
+  ViewSelect: true,
+  ViewInclude: true,
+  ViewFindManyArgs: true,
+  ViewFindUniqueArgs: true,
+  ViewDelegate: true
+};
+function isDisambiguatedTypeSuffix(suffix) {
+  return Object.hasOwn(DISAMBIGUATED_TYPE_SUFFIXES, suffix);
+}
+function generatedNameClaims(params) {
+  const { schema } = params;
+  const claims = [];
+  const fixed = (options) => {
+    for (const name of options.names)
+      claims.push({ name, owner: options.owner, kind: "client", stem: name, suffix: "" });
+  };
+  fixed({ names: RESERVED_ENUM_NAMES, owner: "generated client" });
   if (schema.rls !== undefined) {
-    owners.set("RlsContext", "native RLS client");
-    owners.set("BoundVibeClientInstance", "native RLS client");
-    owners.set("BoundVibeTransactionClientInstance", "native RLS client");
-    owners.set("OperatorVibeClientInstance", "native RLS client");
-    owners.set("OperatorVibeTransactionClientInstance", "native RLS client");
+    fixed({ names: ["RlsContext", "BoundVibeClientInstance", "BoundVibeTransactionClientInstance", "OperatorVibeClientInstance", "OperatorVibeTransactionClientInstance"], owner: "native RLS client" });
   }
   if (schema.models.some((model) => model.policy !== undefined))
-    owners.set("PolicyClientInstance", "policy client");
+    fixed({ names: ["PolicyClientInstance"], owner: "policy client" });
   if (schema.models.some((model) => model.fields.some((field) => isLocalDateField({ field })))) {
-    for (const name of ["LocalDate", "LocalDateFilter", "LocalDateNullableFilter"])
-      owners.set(name, "local-date filters");
+    fixed({ names: ["LocalDate", "LocalDateFilter", "LocalDateNullableFilter"], owner: "local-date filters" });
+  }
+  for (const model of schema.models) {
+    const owner = `model "${model.name}"`;
+    const claim = (suffix) => {
+      claims.push({ name: `${model.name}${suffix}`, owner, kind: "model", stem: model.name, suffix });
+    };
+    for (const suffix of GENERATED_TYPE_NAMES.modelSuffixes)
+      claim(suffix);
+    if (model.fields.some((field) => field.generated !== undefined && field.isUnsupported !== true)) {
+      for (const suffix of GENERATED_TYPE_NAMES.generatedColumnSuffixes)
+        claim(suffix);
+    }
+    const withouts = ["", ...model.relations.map((relation) => `Without${relation.name.charAt(0).toUpperCase()}${relation.name.slice(1)}`)];
+    for (const without of withouts) {
+      for (const prefix of GENERATED_TYPE_NAMES.nestedPrefixes)
+        claim(`${prefix}${without}Input`);
+    }
   }
-  const register = (params) => {
-    if (!/^[$_\p{ID_Start}][$_\u200c\u200d\p{ID_Continue}]*$/u.test(params.name) || INVALID_BINDING_NAMES.has(params.name)) {
-      issues.push({ rule: "invalid-generated-identifier", message: `Generated name "${params.name}" from ${params.owner} is not a legal TypeScript identifier` });
+  for (const declared of schema.enums) {
+    for (const suffix of GENERATED_TYPE_NAMES.enumSuffixes) {
+      claims.push({ name: `${declared.name}${suffix}`, owner: `enum "${declared.name}"`, kind: "enum", stem: declared.name, suffix });
     }
-    const previous = owners.get(params.name);
-    if (previous !== undefined && previous !== params.owner) {
-      issues.push({ rule: "generated-name-collision", message: `Generated name "${params.name}" from ${params.owner} conflicts with ${previous}` });
-    } else {
-      owners.set(params.name, params.owner);
+  }
+  return claims;
+}
+function renameHint(params) {
+  const named = [params.claim, params.keeper].filter((claim) => claim.kind !== "client");
+  const table = named.some((claim) => claim.kind === "model") ? " (@@map, or map in the DSL, keeps a model's table name)" : "";
+  return `rename ${[...new Set(named.map((claim) => claim.owner))].join(" or ")}${table}`;
+}
+function resolveGeneratedNames(params) {
+  const claims = generatedNameClaims({ schema: params.schema });
+  const issues = [];
+  const keepers = new Map;
+  for (const claim of claims) {
+    if (claim.kind !== "client" && (!/^[$_\p{ID_Start}][$_\u200c\u200d\p{ID_Continue}]*$/u.test(claim.name) || INVALID_BINDING_NAMES.has(claim.name))) {
+      issues.push({ rule: "invalid-generated-identifier", message: `Generated name "${claim.name}" from ${claim.owner} is not a legal TypeScript identifier` });
+    }
+    const keeper = keepers.get(claim.name);
+    if (keeper === undefined || claim.stem.length > keeper.stem.length)
+      keepers.set(claim.name, claim);
+  }
+  const renamed = new Map;
+  const moved = [];
+  for (const claim of claims) {
+    const keeper = keepers.get(claim.name) ?? claim;
+    if (keeper.owner === claim.owner)
+      continue;
+    if (claim.kind === "model" && isDisambiguatedTypeSuffix(claim.suffix) && keeper.suffix !== "" && claim.stem.length < keeper.stem.length) {
+      const name = `${claim.stem}_${claim.suffix}`;
+      renamed.set(`${claim.stem}\x00${claim.suffix}`, name);
+      moved.push({ claim, keeper, name });
+      continue;
     }
+    issues.push({ rule: "generated-name-collision", message: `Generated name "${claim.name}" from ${claim.owner} conflicts with ${keeper.owner}; ${renameHint({ claim, keeper })}` });
+  }
+  for (const { claim, keeper, name } of moved) {
+    const taken = keepers.get(name);
+    if (taken === undefined || taken.owner === claim.owner)
+      continue;
+    issues.push({
+      rule: "generated-name-collision",
+      message: `Generated name "${name}" from ${claim.owner} (renamed because ${keeper.owner} keeps "${claim.name}") conflicts with ${taken.owner}; ${renameHint({ claim, keeper: taken })}`
+    });
+  }
+  return { renamed, issues };
+}
+function generatedTypeNames(params) {
+  const { renamed } = resolveGeneratedNames({ schema: params.schema });
+  return {
+    model: ({ model, suffix }) => renamed.get(`${model}\x00${suffix}`) ?? `${model}${suffix}`
   };
+}
+function validateGeneratedNames(params) {
+  const { schema, issues } = params;
   const aliases = new Map;
   for (const model of schema.models) {
     const clientName = model.name.charAt(0).toLowerCase() + model.name.slice(1);
@@ -3174,19 +3477,8 @@ function validateGeneratedNames(params) {
     if (RESERVED_CLIENT_NAMES.includes(clientName)) {
       issues.push({ rule: "reserved-client-name", message: `Model "${model.name}" conflicts with client member "${clientName}"`, model: model.name });
     }
-    const owner = `model "${model.name}"`;
-    for (const suffix of GENERATED_TYPE_NAMES.modelSuffixes)
-      register({ name: `${model.name}${suffix}`, owner });
-    const withouts = ["", ...model.relations.map((relation) => `Without${relation.name.charAt(0).toUpperCase()}${relation.name.slice(1)}`)];
-    for (const without of withouts) {
-      for (const prefix of GENERATED_TYPE_NAMES.nestedPrefixes)
-        register({ name: `${model.name}${prefix}${without}Input`, owner });
-    }
-  }
-  for (const declared of schema.enums) {
-    for (const suffix of GENERATED_TYPE_NAMES.enumSuffixes)
-      register({ name: `${declared.name}${suffix}`, owner: `enum "${declared.name}"` });
   }
+  issues.push(...resolveGeneratedNames({ schema }).issues);
 }
 function foreignKeyKeys(params) {
   const distinct = new Set;
@@ -3489,7 +3781,7 @@ function validatePhysicalNameUniqueness(params) {
     for (const { index, site } of declarations) {
       const unique = index.kind === "unique";
       const columns = index.fields.map((entry) => [columnOf(entry.name), entry.sort === "desc", entry.operatorClass === undefined ? null : [entry.operatorClass.namespace, entry.operatorClass.name]]);
-      const key = isExpressionIndex({ index }) ? indexKeyDefinitionKey({ index, model }) : JSON.stringify([unique, index.nullsNotDistinct === true, unique ? "btree" : index.kind, columns, index.where?.trim() ?? ""]);
+      const key = isExpressionIndex({ index }) ? indexKeyDefinitionKey({ index, model }) : JSON.stringify([unique, index.nullsNotDistinct === true, unique ? "btree" : index.kind, columns, index.where?.trim() ?? "", ...index.include === undefined ? [] : [{ include: index.include.map(columnOf) }]]);
       if (seenIndexKeys.has(key))
         continue;
       seenIndexKeys.add(key);
@@ -3927,6 +4219,27 @@ function validateModel(params) {
         }
       }
     }
+    if (relation.inverseKey !== undefined) {
+      const { fields, references } = relation.inverseKey;
+      if (relation.isList || hasFields || hasReferences || !Array.isArray(fields) || !Array.isArray(references) || fields.length === 0 || fields.length !== references.length) {
+        issues.push({
+          rule: "inverse-key-shape",
+          message: `Relation "${model.name}.${relation.name}" declares an inverse key, which needs a to-one without foreign-key fields and as many references as fields`,
+          model: model.name,
+          field: relation.name
+        });
+      } else {
+        for (const name of fields) {
+          if (!fieldNames.has(name))
+            issues.push({ rule: "unknown-relation-field", message: `Relation "${model.name}.${relation.name}" uses unknown inverse-key field "${name}"`, model: model.name, field: relation.name });
+        }
+        const targetFields = target === undefined ? undefined : lookups.fieldsByModel.get(target);
+        for (const name of references) {
+          if (targetFields !== undefined && !targetFields.has(name))
+            issues.push({ rule: "unknown-relation-reference", message: `Relation "${model.name}.${relation.name}" references unknown inverse-key field "${relation.targetModel}.${name}"`, model: model.name, field: relation.name });
+        }
+      }
+    }
   }
   for (const field of model.fields) {
     if (field.collation !== undefined && (field.type !== "String" || isLocalDateField({ field }))) {
@@ -3937,6 +4250,14 @@ function validateModel(params) {
         field: field.name
       });
     }
+    if (field.bigIntMode !== undefined && (field.type !== "BigInt" || field.bigIntMode !== "number")) {
+      issues.push({
+        rule: "bigint-mode",
+        message: `@number on "${model.name}.${field.name}" \u2014 a number read mode is only valid on BigInt fields, and its one value is "number"`,
+        model: model.name,
+        field: field.name
+      });
+    }
   }
   if (model.policy !== undefined) {
     const policyField = model.fields.find((field) => field.name === model.policy?.field);
@@ -4226,6 +4547,8 @@ function assertValidSchemaIR(params) {
   }
   assertExtensionPlacement({ schema: params.schema, dialect });
   assertIndexOperatorClasses({ schema: params.schema, dialect });
+  assertIndexIncludeColumns({ schema: params.schema, dialect });
+  assertTableStorage({ schema: params.schema, dialect });
   for (const entry of [...params.schema.models, ...params.schema.enums])
     if (entry.namespace !== undefined)
       assertSqlNamespace({ namespace: entry.namespace, dialect });
@@ -4534,6 +4857,7 @@ export {
   EMPTY_EXTENSION_REGISTRY,
   ENUM_STORAGES,
   IDENTIFIER_LIMITS,
+  INCLUDE_INDEX_KINDS,
   MYSQL_CAPABILITIES,
   MYSQL_FUNCTIONAL_KEY_LIMITS,
   MYSQL_ROW_RULE_MESSAGE_MAX_BYTES,
@@ -4551,6 +4875,8 @@ export {
   SQLITE_ROW_RULE_ERROR_PREFIX,
   SQL_NAMESPACES,
   ScopedQueryError,
+  TABLE_STORAGE_KEYS,
+  TABLE_STORAGE_PARAMETERS,
   VIBE_ERROR_CODES,
   VibeError,
   assertExtensionModelPlacement,
@@ -4559,6 +4885,7 @@ export {
   assertGeneratedColumns,
   assertIdentifierFits,
   assertIndexExpressions,
+  assertIndexIncludeColumns,
   assertIndexOperatorClasses,
   assertJsonSchemaRef,
   assertMigrationObjects,
@@ -4568,6 +4895,7 @@ export {
   assertRowRuleEquality,
   assertRowRuleReferentialActions,
   assertSqlNamespace,
+  assertTableStorage,
   assertValidSchemaIR,
   assertValidatorRef,
   buildComputedManifest,
@@ -4593,7 +4921,10 @@ export {
   fitDefaultName,
   generatedColumnFromSql,
   generatedColumnShapeIssue,
+  generatedTypeNames,
+  hasIndexIncludeColumns,
   hasJsonSchemaAnnotation,
+  hasTableStorage,
   hasValidatorAnnotation,
   identifierLength,
   implicitJoinTable,
@@ -4618,6 +4949,7 @@ export {
   isReservedDelegateName,
   isSqlObjectDefinition,
   isSqlObjectIdentity,
+  isToastStorageKey,
   jsonSchemaRefIssue,
   jsonTypeAnnotationIssue,
   jsonTypeAnnotationRef,
@@ -4629,6 +4961,7 @@ export {
   normalizeJsonSchemaRef,
   normalizeRowRules,
   normalizeValidatorRef,
+  parseTableStorageValue,
   postgresGeneratedObjectName,
   predicateCapabilityIssue,
   predicateFieldNames,
@@ -4636,6 +4969,7 @@ export {
   prepareDatabaseModuleSchema,
   providerToDialect,
   qualifiedSqlName,
+  renderTableStorageValue,
   resolveOnDelete,
   resolveOnUpdate,
   resolveReferentialActions,
@@ -4656,6 +4990,9 @@ export {
   sqlObjectKey,
   sqlObjectNamespace,
   sqliteRowRuleConstraint,
+  tableStorageEntries,
+  tableStorageKeyFromPrisma,
+  tableStoragePrismaKey,
   timeOfDayType,
   unsupportedCapability,
   validateComputedConfig,
@@ -4667,4 +5004,4 @@ export {
   validatorRefIssue
 };
 
-//# debugId=8784FDF6327C16F164756E2164756E21
+//# debugId=61CF54A7622E428F64756E2164756E21