@vibeorm/schema 2.2.0 → 2.4.0

package/dist/index.js

@@ -278,7 +278,7 @@ function isSqlObjectIdentity(value) {
   }
 }
 function isSqlObjectDefinition(value) {
-  return record(value) && value.format === "catalog-v1" && isSqlObjectIdentity(value.identity) && record(value.facts) && Object.keys(value.facts).length > 0 && Object.values(value.facts).every((fact) => fact === null || typeof fact === "string" || typeof fact === "boolean" || typeof fact === "number" && Number.isFinite(fact) || Array.isArray(fact) && fact.every((entry) => typeof entry === "string")) && Array.isArray(value.dependencies) && value.dependencies.every(isSqlObjectIdentity);
+  return record(value) && (value.format === "catalog-v1" || value.format === "catalog-v2") && isSqlObjectIdentity(value.identity) && record(value.facts) && Object.keys(value.facts).length > 0 && Object.values(value.facts).every((fact) => fact === null || typeof fact === "string" || typeof fact === "boolean" || typeof fact === "number" && Number.isFinite(fact) || Array.isArray(fact) && fact.every((entry) => typeof entry === "string")) && Array.isArray(value.dependencies) && value.dependencies.every(isSqlObjectIdentity);
 }
 function assertMigrationObjects(params) {
   if (!Array.isArray(params.objects))
@@ -389,6 +389,21 @@ function exactIntegerLiteral(params) {
     return asNumber;
   return BigInt(text).toString();
 }
+var DECIMAL_LITERAL = /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/;
+function exactDecimalLiteral(params) {
+  const { text } = params;
+  if (!DECIMAL_LITERAL.test(text)) {
+    throw new VibeError({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Not a numeric literal: ${JSON.stringify(text)}`,
+      meta: { issues: [{ rule: "malformed-numeric-literal", message: text }], literal: text }
+    });
+  }
+  if (INTEGER_LITERAL.test(text))
+    return exactIntegerLiteral({ text });
+  const mantissa = text.replace(/[eE].*$/, "").replace("-", "").replace(".", "").replace(/^0+/, "");
+  return mantissa.length <= 15 ? Number(text) : text;
+}
 // packages/schema/src/reserved.ts
 var RESERVED_DELEGATE_NAMES = [
   "findMany",
@@ -469,26 +484,26 @@ function extensionManifestEntry(params) {
 }
 var EXTENSION_NAME_PATTERN = /^[a-z][a-zA-Z0-9]*$/;
 function defineExtension(extension) {
-  const { name: name2 } = extension;
-  if (!EXTENSION_NAME_PATTERN.test(name2)) {
+  const { name } = extension;
+  if (!EXTENSION_NAME_PATTERN.test(name)) {
     throw new VibeError({
       code: "VIBE_CONFIG",
-      message: `extension name "${name2}" is invalid \u2014 must match ${EXTENSION_NAME_PATTERN} (it becomes a client identifier)`,
-      meta: { name: name2 }
+      message: `extension name "${name}" is invalid \u2014 must match ${EXTENSION_NAME_PATTERN} (it becomes a client identifier)`,
+      meta: { name }
     });
   }
-  if (RESERVED_DELEGATE_NAMES.includes(name2)) {
+  if (RESERVED_DELEGATE_NAMES.includes(name)) {
     throw new VibeError({
       code: "VIBE_CONFIG",
-      message: `extension name "${name2}" collides with a core delegate method`,
-      meta: { name: name2 }
+      message: `extension name "${name}" collides with a core delegate method`,
+      meta: { name }
     });
   }
-  if (RESERVED_CLIENT_NAMES.includes(`$${name2}`)) {
+  if (RESERVED_CLIENT_NAMES.includes(`$${name}`)) {
     throw new VibeError({
       code: "VIBE_CONFIG",
-      message: `extension name "${name2}" collides with the core client method "$${name2}"`,
-      meta: { name: name2 }
+      message: `extension name "${name}" collides with the core client method "$${name}"`,
+      meta: { name }
     });
   }
   return Object.freeze(extension);
@@ -710,6 +725,102 @@ function scalarListDefault(params) {
   });
 }
 
+// packages/schema/src/m2m.ts
+function implicitJoinTable(params) {
+  const sorted = [params.modelA, params.modelB].sort();
+  const first = sorted[0];
+  const second = sorted[1];
+  const key = params.relationName ?? `${first}To${second}`;
+  return {
+    tableName: `_${key}`,
+    modelA: first,
+    modelB: second,
+    columnA: "A",
+    columnB: "B"
+  };
+}
+
+// packages/schema/src/physical-names.ts
+var IDENTIFIER_LIMITS = Object.freeze({
+  postgres: { max: 63, unit: "bytes" },
+  mysql: { max: 64, unit: "characters" },
+  sqlite: undefined
+});
+var ENCODER = new TextEncoder;
+function identifierLength(params) {
+  const limit = IDENTIFIER_LIMITS[params.dialect];
+  return limit?.unit === "bytes" ? ENCODER.encode(params.name).length : [...params.name].length;
+}
+function cutIdentifier(params) {
+  let out = "";
+  let used = 0;
+  for (const char of params.name) {
+    const size = params.unit === "bytes" ? ENCODER.encode(char).length : 1;
+    if (used + size > params.length)
+      break;
+    out += char;
+    used += size;
+  }
+  return out;
+}
+function fitDefaultName(params) {
+  const limit = IDENTIFIER_LIMITS[params.dialect];
+  if (limit === undefined)
+    return `${params.prefix}${params.suffix}`;
+  const room = limit.max - identifierLength({ name: params.suffix, dialect: params.dialect });
+  if (identifierLength({ name: params.prefix, dialect: params.dialect }) <= room)
+    return `${params.prefix}${params.suffix}`;
+  return `${cutIdentifier({ name: params.prefix, length: room, unit: limit.unit })}${params.suffix}`;
+}
+function assertIdentifierFits(params) {
+  const limit = IDENTIFIER_LIMITS[params.dialect];
+  if (limit === undefined)
+    return;
+  const length = identifierLength({ name: params.name, dialect: params.dialect });
+  if (length <= limit.max)
+    return;
+  throw new VibeError({
+    code: "VIBE_SCHEMA_INVALID",
+    message: `${params.what} "${params.name}" is ${length} ${limit.unit} \u2014 ${params.dialect} keeps at most ${limit.max}; the created object would never carry this name and migrations could not converge. ${params.remedy}`,
+    meta: { name: params.name, dialect: params.dialect, length, max: limit.max }
+  });
+}
+function defaultIndexName(params) {
+  return fitDefaultName({
+    prefix: `${params.table}_${params.columns.join("_")}`,
+    suffix: params.unique ? "_key" : "_idx",
+    dialect: params.dialect
+  });
+}
+function defaultForeignKeyName(params) {
+  return fitDefaultName({ prefix: `${params.table}_${params.columns.join("_")}`, suffix: "_fkey", dialect: params.dialect });
+}
+function defaultPrimaryKeyName(params) {
+  return fitDefaultName({ prefix: params.table, suffix: "_pkey", dialect: params.dialect });
+}
+function implicitJoinTableObjectNames(params) {
+  return {
+    uniqueIndex: `${params.table}_AB_unique`,
+    indexB: `${params.table}_B_index`,
+    foreignKeyA: `${params.table}_A_fkey`,
+    foreignKeyB: `${params.table}_B_fkey`
+  };
+}
+function postgresGeneratedObjectName(params) {
+  const limit = IDENTIFIER_LIMITS.postgres;
+  const overhead = params.label.length + 2;
+  let chars1 = [...params.name1];
+  let chars2 = [...params.name2];
+  const bytes = (chars) => ENCODER.encode(chars.join("")).length;
+  while (bytes(chars1) + bytes(chars2) + overhead > limit.max) {
+    if (bytes(chars1) > bytes(chars2))
+      chars1 = chars1.slice(0, -1);
+    else
+      chars2 = chars2.slice(0, -1);
+  }
+  return `${chars1.join("")}_${chars2.join("")}_${params.label}`;
+}
+
 // packages/schema/src/capabilities.ts
 var POSTGRES_CAPABILITIES = Object.freeze({
   exclusionConstraints: true,
@@ -1038,21 +1149,21 @@ var INVALID_BINDING_NAMES = new Set([
 ]);
 function validateGeneratedNames(params) {
   const { schema, issues } = params;
-  const owners = new Map(RESERVED_ENUM_NAMES.map((name2) => [name2, "generated client"]));
+  const owners = new Map(RESERVED_ENUM_NAMES.map((name) => [name, "generated client"]));
   if (schema.rls !== undefined) {
     owners.set("RlsContext", "native RLS client");
     owners.set("BoundVibeClientInstance", "native RLS client");
     owners.set("BoundVibeTransactionClientInstance", "native RLS client");
   }
-  const register = (params2) => {
-    if (!/^[$_\p{ID_Start}][$_\u200c\u200d\p{ID_Continue}]*$/u.test(params2.name) || INVALID_BINDING_NAMES.has(params2.name)) {
-      issues.push({ rule: "invalid-generated-identifier", message: `Generated name "${params2.name}" from ${params2.owner} is not a legal TypeScript identifier` });
+  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` });
     }
-    const previous = owners.get(params2.name);
-    if (previous !== undefined && previous !== params2.owner) {
-      issues.push({ rule: "generated-name-collision", message: `Generated name "${params2.name}" from ${params2.owner} conflicts with ${previous}` });
+    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(params2.name, params2.owner);
+      owners.set(params.name, params.owner);
     }
   };
   const aliases = new Map;
@@ -1200,8 +1311,8 @@ function validateSchemaIR(params) {
       }
     }
     const seenSelectorNames = new Set;
-    const checkSelectorName = (params2) => {
-      const { clientName, fieldCount, where, isUnique, site } = params2;
+    const checkSelectorName = (params) => {
+      const { clientName, fieldCount, where, isUnique, site } = params;
       if (!isUnique) {
         issues.push({
           rule: "client-name-non-unique",
@@ -1256,10 +1367,189 @@ function validateSchemaIR(params) {
       });
     }
   }
+  validateIdentifierLengths({ schema, issues });
+  validatePhysicalNameUniqueness({ schema, issues });
   validateGeneratedNames({ schema, issues });
   validateNativeRls({ schema, issues });
   return issues;
 }
+function validatePhysicalNameUniqueness(params) {
+  const { schema, issues } = params;
+  const dialect = providerToDialect({ provider: schema.datasource.provider });
+  const owners = new Map;
+  const claim = (entry) => {
+    const key = `${entry.namespace}\x00${entry.name}`;
+    const previous = owners.get(key);
+    if (previous === undefined) {
+      owners.set(key, `${entry.what} of ${entry.owner}`);
+      return true;
+    }
+    issues.push({
+      rule: "duplicate-physical-name",
+      message: `${entry.what} "${entry.name}" of ${entry.owner} collides with the ${previous} \u2014 both resolve to one physical ${entry.namespace === "relation" ? "object" : "name"}, and only one can exist`,
+      ...entry.model === undefined ? {} : { model: entry.model },
+      ...entry.field === undefined ? {} : { field: entry.field }
+    });
+    return false;
+  };
+  const indexNamespace = (table) => dialect === "mysql" ? `index:${table}` : "relation";
+  const constraintNamespace = (table) => dialect === "mysql" ? "constraint" : `constraint:${table}`;
+  for (const model of schema.models) {
+    const table = model.dbName ?? model.name;
+    if (!claim({ namespace: "relation", name: table, what: model.isView ? "view" : "table", owner: `model "${model.name}"`, model: model.name }))
+      continue;
+    for (const fieldIR of model.fields) {
+      claim({ namespace: `column:${table}`, name: fieldIR.dbName ?? fieldIR.name, what: "column", owner: `field "${model.name}.${fieldIR.name}"`, model: model.name, field: fieldIR.name });
+    }
+    if (model.isView)
+      continue;
+    const columnOf = (name) => model.fields.find((candidate) => candidate.name === name)?.dbName ?? name;
+    const seenIndexKeys = new Set;
+    const declarations = [
+      ...model.indexes.map((index) => ({ index, site: index.kind === "unique" ? "@@unique" : "@@index" })),
+      ...model.fields.filter((fieldIR) => fieldIR.isUnique).map((fieldIR) => ({ index: { kind: "unique", fields: [{ name: fieldIR.name }] }, site: `@unique on "${fieldIR.name}"` }))
+    ];
+    for (const { index, site } of declarations) {
+      const unique = index.kind === "unique";
+      const columns = index.fields.map((entry) => `${columnOf(entry.name)}${entry.sort === "desc" ? " desc" : ""}`);
+      const key = `${unique ? "u" : "i"}${index.nullsNotDistinct === true ? "n" : ""}:${unique ? "btree" : index.kind}:${columns.join(",")}:${index.where?.trim() ?? ""}`;
+      if (seenIndexKeys.has(key))
+        continue;
+      seenIndexKeys.add(key);
+      const name = index.name ?? defaultIndexName({ table, columns: index.fields.map((entry) => columnOf(entry.name)), unique, dialect });
+      claim({ namespace: indexNamespace(table), name, what: unique ? "unique index" : "index", owner: `${site} on "${model.name}"`, model: model.name });
+      if (index.constraintName !== undefined) {
+        claim({ namespace: constraintNamespace(table), name: index.constraintName, what: "unique constraint", owner: `${site} on "${model.name}"`, model: model.name });
+      }
+    }
+    if (dialect === "postgres" && (model.primaryKey !== undefined || model.fields.some((fieldIR) => fieldIR.isId))) {
+      const name = model.primaryKeyConstraintName ?? defaultPrimaryKeyName({ table, dialect });
+      claim({ namespace: "relation", name, what: "primary key", owner: `model "${model.name}"`, model: model.name });
+      claim({ namespace: constraintNamespace(table), name, what: "primary key", owner: `model "${model.name}"`, model: model.name });
+    }
+    for (const relation of model.relations) {
+      if (relation.fields === undefined || relation.fields.length === 0)
+        continue;
+      const target = schema.models.find((candidate) => candidate.name === relation.targetModel);
+      if (target !== undefined && target.isView)
+        continue;
+      const name = relation.constraintName ?? defaultForeignKeyName({ table, columns: relation.fields.map((entry) => columnOf(entry)), dialect });
+      claim({ namespace: constraintNamespace(table), name, what: "foreign key", owner: `relation "${model.name}.${relation.name}"`, model: model.name });
+    }
+    for (const checkIR of model.checks ?? []) {
+      claim({ namespace: constraintNamespace(table), name: checkIR.name, what: "CHECK constraint", owner: `model "${model.name}"`, model: model.name });
+    }
+    for (const exclusion of model.exclusions ?? []) {
+      claim({ namespace: constraintNamespace(table), name: exclusion.name, what: "exclusion constraint", owner: `model "${model.name}"`, model: model.name });
+      if (dialect === "postgres")
+        claim({ namespace: "relation", name: exclusion.name, what: "exclusion constraint", owner: `model "${model.name}"`, model: model.name });
+    }
+  }
+  if (dialect === "postgres") {
+    for (const enumDef of schema.enums) {
+      if (enumStorageOf({ enumDef }) !== "database")
+        continue;
+      claim({ namespace: "relation", name: enumDef.dbName ?? enumDef.name, what: "enum type", owner: `enum "${enumDef.name}"` });
+    }
+  }
+  const seenJoinTables = new Set;
+  for (const model of schema.models) {
+    for (const relation of model.relations) {
+      if (relation.targetModel === model.name)
+        continue;
+      if (!isImplicitManyToManyRelation({ model, relation, models: schema.models }))
+        continue;
+      const join = implicitJoinTable({ modelA: model.name, modelB: relation.targetModel, ...relation.relationName === undefined ? {} : { relationName: relation.relationName } });
+      if (seenJoinTables.has(join.tableName))
+        continue;
+      seenJoinTables.add(join.tableName);
+      const owner = `implicit relation "${model.name}.${relation.name}"`;
+      claim({ namespace: "relation", name: join.tableName, what: "join table", owner, model: model.name });
+      const derived = implicitJoinTableObjectNames({ table: join.tableName });
+      claim({ namespace: indexNamespace(join.tableName), name: derived.uniqueIndex, what: "unique index", owner, model: model.name });
+      claim({ namespace: indexNamespace(join.tableName), name: derived.indexB, what: "index", owner, model: model.name });
+      claim({ namespace: constraintNamespace(join.tableName), name: derived.foreignKeyA, what: "foreign key", owner, model: model.name });
+      claim({ namespace: constraintNamespace(join.tableName), name: derived.foreignKeyB, what: "foreign key", owner, model: model.name });
+    }
+  }
+}
+function validateIdentifierLengths(params) {
+  const { schema, issues } = params;
+  const dialect = providerToDialect({ provider: schema.datasource.provider });
+  const limit = IDENTIFIER_LIMITS[dialect];
+  if (limit === undefined)
+    return;
+  const { max, unit } = limit;
+  const consequence = dialect === "postgres" ? `PostgreSQL silently truncates identifiers to ${max} bytes (NAMEDATALEN - 1), so the created object never carries this name and migrations cannot converge` : `MySQL refuses identifiers longer than ${max} characters (ER_TOO_LONG_IDENT)`;
+  const check = (entry) => {
+    const length = identifierLength({ name: entry.name, dialect });
+    if (length <= max)
+      return;
+    issues.push({
+      rule: "identifier-too-long",
+      message: `${entry.what} "${entry.name}" is ${length} ${unit} \u2014 ${consequence}. ${entry.remedy}`,
+      ...entry.model === undefined ? {} : { model: entry.model }
+    });
+  };
+  for (const model of schema.models) {
+    const table = model.dbName ?? model.name;
+    check({ name: table, what: model.isView ? "View name" : "Table name", model: model.name, remedy: `Map "${model.name}" to a shorter physical name (@@map).` });
+    for (const fieldIR of model.fields) {
+      check({ name: fieldIR.dbName ?? fieldIR.name, what: "Column name", model: model.name, remedy: `Map "${model.name}.${fieldIR.name}" to a shorter column name (@map).` });
+    }
+    if (model.isView)
+      continue;
+    for (const index of model.indexes) {
+      if (index.name !== undefined) {
+        check({ name: index.name, what: index.kind === "unique" ? "Unique index name" : "Index name", model: model.name, remedy: "Shorten the index name (map:)." });
+      }
+      if (index.constraintName !== undefined) {
+        check({ name: index.constraintName, what: "Unique constraint name", model: model.name, remedy: "Shorten the constraint name." });
+      }
+    }
+    if (model.primaryKeyConstraintName !== undefined) {
+      check({ name: model.primaryKeyConstraintName, what: "Primary key constraint name", model: model.name, remedy: "Shorten the constraint name (map:)." });
+    }
+    for (const relation of model.relations) {
+      if (relation.constraintName === undefined)
+        continue;
+      check({ name: relation.constraintName, what: "Foreign key constraint name", model: model.name, remedy: "Shorten the constraint name (map:)." });
+    }
+    for (const checkIR of model.checks ?? []) {
+      check({ name: checkIR.name, what: "CHECK constraint name", model: model.name, remedy: "Shorten the CHECK name." });
+    }
+    for (const exclusion of model.exclusions ?? []) {
+      check({ name: exclusion.name, what: "Exclusion constraint name", model: model.name, remedy: "Shorten the exclusion name." });
+    }
+  }
+  if (dialect === "postgres") {
+    for (const enumDef of schema.enums) {
+      if (enumStorageOf({ enumDef }) !== "database")
+        continue;
+      check({ name: enumDef.dbName ?? enumDef.name, what: "Enum type name", remedy: `Map enum "${enumDef.name}" to a shorter type name (@@map).` });
+    }
+  }
+  const seenJoinTables = new Set;
+  for (const model of schema.models) {
+    for (const relation of model.relations) {
+      if (relation.targetModel === model.name)
+        continue;
+      if (!isImplicitManyToManyRelation({ model, relation, models: schema.models }))
+        continue;
+      const join = implicitJoinTable({ modelA: model.name, modelB: relation.targetModel, ...relation.relationName === undefined ? {} : { relationName: relation.relationName } });
+      if (seenJoinTables.has(join.tableName))
+        continue;
+      seenJoinTables.add(join.tableName);
+      const remedy = `Give the relation an explicit shorter name (@relation("...")).`;
+      check({ name: join.tableName, what: "Implicit join table name", model: model.name, remedy });
+      const derived = implicitJoinTableObjectNames({ table: join.tableName });
+      check({ name: derived.uniqueIndex, what: "Implicit join table index name", model: model.name, remedy });
+      check({ name: derived.indexB, what: "Implicit join table index name", model: model.name, remedy });
+      check({ name: derived.foreignKeyA, what: "Implicit join table foreign key name", model: model.name, remedy });
+      check({ name: derived.foreignKeyB, what: "Implicit join table foreign key name", model: model.name, remedy });
+    }
+  }
+}
 function validateModel(params) {
   const { model, modelByName, enumByName, issues } = params;
   const memberNames = new Set;
@@ -1273,6 +1563,10 @@ function validateModel(params) {
       });
     }
     memberNames.add(field.name);
+    const typeIdentity = field.nativeTypeIdentity;
+    if (typeIdentity !== undefined && (typeIdentity === null || typeof typeIdentity !== "object" || field.isUnsupported !== true || typeof typeIdentity.source !== "string" || typeIdentity.source !== field.nativeType || typeof typeIdentity.namespace !== "string" || typeIdentity.namespace.length === 0 || typeIdentity.namespace.includes("\x00"))) {
+      issues.push({ rule: "invalid-native-type-identity", message: `PostgreSQL type identity on "${model.name}.${field.name}" must be bound to its unsupported declaration`, model: model.name, field: field.name });
+    }
     const defaultValue = field.default;
     if (defaultValue !== undefined && defaultValue.kind !== "dbgenerated" && defaultValue.kind !== "list") {
       let valid = !field.isList;
@@ -1326,8 +1620,8 @@ function validateModel(params) {
           field: field.name
         });
       } else {
-        const defaultValue2 = field.default;
-        const candidate = defaultValue2 === undefined ? undefined : defaultValue2.kind === "enumValue" ? defaultValue2.value : defaultValue2.kind === "literal" && typeof defaultValue2.value === "string" ? defaultValue2.value : undefined;
+        const defaultValue = field.default;
+        const candidate = defaultValue === undefined ? undefined : defaultValue.kind === "enumValue" ? defaultValue.value : defaultValue.kind === "literal" && typeof defaultValue.value === "string" ? defaultValue.value : undefined;
         if (candidate !== undefined && !enumDef.values.includes(candidate)) {
           issues.push({
             rule: "enum-default-not-member",
@@ -1519,22 +1813,22 @@ function validateModel(params) {
 }
 function validatePredicateFields(params) {
   const { predicate, model, fieldNames, site, issues } = params;
-  for (const name2 of predicateFieldNames({ predicate })) {
-    if (!fieldNames.has(name2)) {
+  for (const name of predicateFieldNames({ predicate })) {
+    if (!fieldNames.has(name)) {
       issues.push({
         rule: "predicate-unknown-field",
-        message: `${site} on "${model.name}" references unknown field "${name2}"`,
+        message: `${site} on "${model.name}" references unknown field "${name}"`,
         model: model.name,
-        field: name2
+        field: name
       });
       continue;
     }
-    if (model.fields.find((field) => field.name === name2)?.isList === true) {
+    if (model.fields.find((field) => field.name === name)?.isList === true) {
       issues.push({
         rule: "predicate-list-field",
-        message: `${site} on "${model.name}" compares scalar list "${name2}" \u2014 use a raw expression for array operators`,
+        message: `${site} on "${model.name}" compares scalar list "${name}" \u2014 use a raw expression for array operators`,
         model: model.name,
-        field: name2
+        field: name
       });
     }
   }
@@ -1556,10 +1850,10 @@ function assertValidSchemaIR(params) {
       const source = exclusion.source;
       if (source !== undefined) {
         const references = [...source.keys.flatMap((key) => ("field" in key) ? [key.field] : key.fields), ...[source.range.lower, source.range.upper].flatMap((endpoint) => ("field" in endpoint) ? [endpoint.field] : []), ...source.where === undefined ? [] : predicateFieldNames({ predicate: source.where })];
-        if (references.some((name2) => !model.fields.some((field) => field.name === name2 && !field.isList)))
+        if (references.some((name) => !model.fields.some((field) => field.name === name && !field.isList)))
           throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Exclusion references an unknown or list field", meta: { rule: "exclusion-field", model: model.name } });
       }
-      if (!exclusion.name || names.has(exclusion.name) || typeof exclusion.definition !== "string" || !exclusion.definition.startsWith("EXCLUDE USING ") || !Array.isArray(exclusion.requiredExtensions) || exclusion.requiredExtensions.some((name2) => name2 !== "btree_gist"))
+      if (!exclusion.name || names.has(exclusion.name) || typeof exclusion.definition !== "string" || !exclusion.definition.startsWith("EXCLUDE USING ") || !Array.isArray(exclusion.requiredExtensions) || exclusion.requiredExtensions.some((name) => name !== "btree_gist"))
         throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Invalid exclusion declaration", meta: { rule: "exclusion-definition", model: model.name } });
       names.add(exclusion.name);
     }
@@ -1581,8 +1875,8 @@ function assertValidSchemaIR(params) {
           throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: `List default on non-list field ${model.name}.${field.name}` });
         scalarListDefault({ type: field.type, values: field.default.values });
         if (isEnumType(field.type)) {
-          const name2 = field.type.enum;
-          const members = params.schema.enums.find((entry) => entry.name === name2)?.values ?? [];
+          const name = field.type.enum;
+          const members = params.schema.enums.find((entry) => entry.name === name)?.values ?? [];
           if (field.default.values.some((value) => typeof value !== "string" || !members.includes(value)))
             throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: `Invalid enum-list default on ${model.name}.${field.name}` });
         }
@@ -1673,8 +1967,8 @@ function validateNativeRls(params) {
   const tables = new Set;
   const throughTargets = new Map;
   for (const model of schema.models) {
-    const add = (params2) => {
-      issues.push({ ...params2, model: model.name });
+    const add = (params) => {
+      issues.push({ ...params, model: model.name });
     };
     const table = model.dbName ?? model.name;
     if (tables.has(table))
@@ -1682,10 +1976,10 @@ function validateNativeRls(params) {
     tables.add(table);
     const columns = new Set;
     for (const field of model.fields) {
-      const name2 = field.dbName ?? field.name;
-      if (columns.has(name2))
-        add({ rule: "rls-duplicate-column", message: `RLS model ${model.name} repeats physical column ${name2}`, field: field.name });
-      columns.add(name2);
+      const name = field.dbName ?? field.name;
+      if (columns.has(name))
+        add({ rule: "rls-duplicate-column", message: `RLS model ${model.name} repeats physical column ${name}`, field: field.name });
+      columns.add(name);
     }
     if (model.policy !== undefined)
       add({ rule: "rls-policy-conflict", message: "Native RLS cannot combine with application-level ModelIR.policy" });
@@ -1738,7 +2032,7 @@ function validateNativeRls(params) {
         add({ rule: "rls-invalid-through", message: "Native RLS through requires a to-one relation with an actual, complete foreign key on this model" });
         continue;
       }
-      if (relation.isOptional || relation.fields?.some((name2) => model.fields.find((field) => field.name === name2)?.isOptional)) {
+      if (relation.isOptional || relation.fields?.some((name) => model.fields.find((field) => field.name === name)?.isOptional)) {
         add({ rule: "rls-nullable-through", message: "Native RLS through requires a non-nullable parent relation and foreign key; NULL parent links cannot satisfy WITH CHECK. Make the link required or use a direct ownership rule", field: relation.name });
         continue;
       }
@@ -1770,8 +2064,8 @@ function validRlsForeignKey(params) {
   const refs = relation.references;
   if (fields === undefined || refs === undefined || fields.length === 0 || fields.length !== refs.length || new Set(fields).size !== fields.length || new Set(refs).size !== refs.length)
     return false;
-  const validFields = fields.every((name2, index) => {
-    const field = model.fields.find((f) => f.name === name2);
+  const validFields = fields.every((name, index) => {
+    const field = model.fields.find((f) => f.name === name);
     const ref = target.fields.find((f) => f.name === refs[index]);
     return field !== undefined && ref !== undefined && !field.isList && !ref.isList && !field.isUnsupported && !ref.isUnsupported && (field.type === ref.type || isEnumType(field.type) && isEnumType(ref.type) && field.type.enum === ref.type.enum);
   });
@@ -1780,76 +2074,72 @@ function validRlsForeignKey(params) {
     ...target.primaryKey === undefined ? [] : [target.primaryKey.fields],
     ...target.indexes.filter((index) => index.kind === "unique" && index.where === undefined).map((index) => index.fields.map((f) => f.name))
   ];
-  return validFields && uniqueSets.some((set) => set.length === refs.length && set.every((name2) => refs.includes(name2)));
-}
-// packages/schema/src/m2m.ts
-function implicitJoinTable(params) {
-  const sorted = [params.modelA, params.modelB].sort();
-  const first = sorted[0];
-  const second = sorted[1];
-  const key = params.relationName ?? `${first}To${second}`;
-  return {
-    tableName: `_${key}`,
-    modelA: first,
-    modelB: second,
-    columnA: "A",
-    columnB: "B"
-  };
+  return validFields && uniqueSets.some((set) => set.length === refs.length && set.every((name) => refs.includes(name)));
 }
 export {
-  validateSchemaIR,
-  validateRlsContextIR,
-  validateComputedConfig,
-  unsupportedCapability,
-  sqlObjectKey,
-  serializeJsonDefault,
-  scalarListDefault,
-  providerToDialect,
-  predicateKey,
-  predicateFieldNames,
-  mergeExtensionDeclarations,
-  isSqlObjectIdentity,
-  isSqlObjectDefinition,
-  isReservedDelegateName,
-  isReservedClientName,
-  isPredicateFieldRef,
-  isImplicitManyToManyRelation,
-  isEnumType,
-  invalidStoredData,
-  internalError,
-  implicitJoinTable,
-  fieldTypeIdentity,
-  extensionOptionsHash,
-  extensionManifestEntry,
-  extensionDeclarations,
-  exactIntegerLiteral,
-  enumStorageOf,
-  encodePrismaString,
-  defineExtension,
-  decodePrismaString,
-  buildExtensionRegistry,
-  buildComputedManifest,
-  assertValidSchemaIR,
-  assertMigrationObjects,
-  VibeError,
-  VIBE_ERROR_CODES,
-  ScopedQueryError,
-  SQLITE_CAPABILITIES,
-  SCOPED_REFUSAL_REASONS,
-  RlsContextError,
-  ReadOnlyClientError,
-  RLS_CONTEXT_REASONS,
-  RESERVED_ENUM_NAMES,
-  RESERVED_DELEGATE_NAMES,
-  RESERVED_CLIENT_NAMES,
-  READ_ONLY_REFUSAL_REASONS,
-  PREDICATE_COMPARISON_OPS,
-  POSTGRES_CAPABILITIES,
-  MYSQL_CAPABILITIES,
-  ENUM_STORAGES,
-  EMPTY_EXTENSION_REGISTRY,
+  DIALECTS,
   DIALECT_CAPABILITIES,
-  DIALECTS
+  EMPTY_EXTENSION_REGISTRY,
+  ENUM_STORAGES,
+  IDENTIFIER_LIMITS,
+  MYSQL_CAPABILITIES,
+  POSTGRES_CAPABILITIES,
+  PREDICATE_COMPARISON_OPS,
+  READ_ONLY_REFUSAL_REASONS,
+  RESERVED_CLIENT_NAMES,
+  RESERVED_DELEGATE_NAMES,
+  RESERVED_ENUM_NAMES,
+  RLS_CONTEXT_REASONS,
+  ReadOnlyClientError,
+  RlsContextError,
+  SCOPED_REFUSAL_REASONS,
+  SQLITE_CAPABILITIES,
+  ScopedQueryError,
+  VIBE_ERROR_CODES,
+  VibeError,
+  assertIdentifierFits,
+  assertMigrationObjects,
+  assertValidSchemaIR,
+  buildComputedManifest,
+  buildExtensionRegistry,
+  decodePrismaString,
+  defaultForeignKeyName,
+  defaultIndexName,
+  defaultPrimaryKeyName,
+  defineExtension,
+  encodePrismaString,
+  enumStorageOf,
+  exactDecimalLiteral,
+  exactIntegerLiteral,
+  extensionDeclarations,
+  extensionManifestEntry,
+  extensionOptionsHash,
+  fieldTypeIdentity,
+  fitDefaultName,
+  identifierLength,
+  implicitJoinTable,
+  implicitJoinTableObjectNames,
+  internalError,
+  invalidStoredData,
+  isEnumType,
+  isImplicitManyToManyRelation,
+  isPredicateFieldRef,
+  isReservedClientName,
+  isReservedDelegateName,
+  isSqlObjectDefinition,
+  isSqlObjectIdentity,
+  mergeExtensionDeclarations,
+  postgresGeneratedObjectName,
+  predicateFieldNames,
+  predicateKey,
+  providerToDialect,
+  scalarListDefault,
+  serializeJsonDefault,
+  sqlObjectKey,
+  unsupportedCapability,
+  validateComputedConfig,
+  validateRlsContextIR,
+  validateSchemaIR
 };
 
-//# debugId=21FF102BB1B417EA64756E2164756E21
+//# debugId=47DE6CAFB1D4DC2864756E2164756E21