@vibeorm/schema 2.0.0-alpha.8 → 2.1.0

package/dist/index.js

@@ -16,14 +16,75 @@ function providerToDialect(params) {
 function isEnumType(fieldType) {
   return typeof fieldType === "object" && "enum" in fieldType;
 }
+function fieldTypeIdentity(params) {
+  const { type } = params;
+  return isEnumType(type) ? `enum:${type.enum}` : type;
+}
 var ENUM_STORAGES = ["database", "string"];
 function enumStorageOf(params) {
   return params.enumDef.storage ?? "database";
 }
+// packages/schema/src/predicate.ts
+var PREDICATE_COMPARISON_OPS = [
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+];
+function isPredicateFieldRef(operand) {
+  return operand.kind === "field";
+}
+function predicateFieldNames(params) {
+  const seen = new Set;
+  const walk = (node) => {
+    switch (node.kind) {
+      case "compare":
+        seen.add(node.left.name);
+        if (isPredicateFieldRef(node.right))
+          seen.add(node.right.name);
+        return;
+      case "inList":
+      case "isNull":
+        seen.add(node.field.name);
+        return;
+      case "and":
+      case "or":
+        for (const operand of node.operands)
+          walk(operand);
+        return;
+      case "not":
+        walk(node.operand);
+        return;
+    }
+  };
+  walk(params.predicate);
+  return [...seen];
+}
+function predicateKey(params) {
+  const encode = (node) => {
+    switch (node.kind) {
+      case "compare":
+        return `cmp(${node.op},${node.left.name},${isPredicateFieldRef(node.right) ? `f:${node.right.name}` : `v:${typeof node.right.value}:${String(node.right.value)}`})`;
+      case "inList":
+        return `in${node.negate === true ? "!" : ""}(${node.field.name},[${node.values.map((entry) => `${typeof entry.value}:${String(entry.value)}`).join("|")}])`;
+      case "isNull":
+        return `null${node.negate === true ? "!" : ""}(${node.field.name})`;
+      case "and":
+      case "or":
+        return `${node.kind}(${node.operands.map(encode).join(",")})`;
+      case "not":
+        return `not(${encode(node.operand)})`;
+    }
+  };
+  return encode(params.predicate);
+}
 // packages/schema/src/errors.ts
 var VIBE_ERROR_CODES = [
   "VIBE_NOT_FOUND",
   "VIBE_UNIQUE_VIOLATION",
+  "VIBE_EXCLUSION_VIOLATION",
   "VIBE_FK_VIOLATION",
   "VIBE_VALIDATION",
   "VIBE_DATA_INVALID",
@@ -33,7 +94,9 @@ var VIBE_ERROR_CODES = [
   "VIBE_CONFIG",
   "VIBE_MIGRATION",
   "VIBE_TRANSACTION",
+  "VIBE_LOCK_NOT_AVAILABLE",
   "VIBE_SCOPED",
+  "VIBE_READ_ONLY",
   "VIBE_RLS_CONTEXT",
   "VIBE_PERMISSION_DENIED",
   "VIBE_ADAPTER",
@@ -137,6 +200,100 @@ class ScopedQueryError extends VibeError {
     this.reason = params.reason;
   }
 }
+var READ_ONLY_REFUSAL_REASONS = [
+  "write",
+  "raw",
+  "control",
+  "unclassified",
+  "foreign_operation"
+];
+
+class ReadOnlyClientError extends VibeError {
+  path;
+  reason;
+  constructor(params) {
+    super({
+      code: "VIBE_READ_ONLY",
+      message: params.message,
+      meta: { ...params.meta, path: params.path, reason: params.reason }
+    });
+    this.name = "ReadOnlyClientError";
+    this.path = params.path;
+    this.reason = params.reason;
+  }
+}
+
+// packages/schema/src/migration-objects.ts
+function sqlObjectKey(params) {
+  const object = params.identity;
+  switch (object.kind) {
+    case "table":
+    case "view":
+    case "sequence":
+    case "postgresExtension":
+      return JSON.stringify([object.kind, object.name.namespace, object.name.name]);
+    case "function":
+      return JSON.stringify([object.kind, object.name.namespace, object.name.name, object.argumentTypes.map((type) => [type.namespace, type.name])]);
+    case "index":
+    case "trigger":
+      return JSON.stringify([object.kind, object.table.namespace, object.table.name, object.name]);
+    case "constraint":
+      return JSON.stringify([object.kind, object.table.namespace, object.table.name, object.name, object.constraintType]);
+    case "column":
+    case "columnDefault":
+    case "generatedColumn":
+      return JSON.stringify([object.kind, object.table.namespace, object.table.name, object.column]);
+  }
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function name(value) {
+  return record(value) && typeof value.namespace === "string" && value.namespace.length > 0 && typeof value.name === "string" && value.name.length > 0;
+}
+function isSqlObjectIdentity(value) {
+  if (!record(value))
+    return false;
+  switch (value.kind) {
+    case "table":
+    case "view":
+    case "sequence":
+    case "postgresExtension":
+      return name(value.name);
+    case "function":
+      return name(value.name) && Array.isArray(value.argumentTypes) && value.argumentTypes.every(name);
+    case "index":
+    case "trigger":
+      return name(value.table) && typeof value.name === "string" && value.name.length > 0;
+    case "constraint":
+      return name(value.table) && typeof value.name === "string" && value.name.length > 0 && ["check", "foreignKey", "exclusion", "unique", "primaryKey"].includes(String(value.constraintType));
+    case "column":
+    case "columnDefault":
+    case "generatedColumn":
+      return name(value.table) && typeof value.column === "string" && value.column.length > 0;
+    default:
+      return false;
+  }
+}
+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);
+}
+function assertMigrationObjects(params) {
+  if (!Array.isArray(params.objects))
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "migrationObjects must be an array" });
+  const ids = new Set;
+  const owners = new Set;
+  for (const object of params.objects) {
+    if (!record(object) || typeof object.id !== "string" || object.id.length === 0 || !["postgres", "sqlite", "mysql"].includes(String(object.dialect)) || !isSqlObjectIdentity(object.identity) || !Array.isArray(object.create) || !object.create.every((sql) => typeof sql === "string") || !Array.isArray(object.drop) || !object.drop.every((sql) => typeof sql === "string") || !Array.isArray(object.dependsOn) || !object.dependsOn.every(isSqlObjectIdentity) || object.expected !== undefined && (!isSqlObjectDefinition(object.expected) || sqlObjectKey({ identity: object.expected.identity }) !== sqlObjectKey({ identity: object.identity }))) {
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Invalid migration-only object declaration" });
+    }
+    const key = sqlObjectKey({ identity: object.identity });
+    if (ids.has(object.id) || owners.has(key))
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Duplicate migration object identity or id", meta: { id: object.id, key } });
+    ids.add(object.id);
+    owners.add(key);
+  }
+}
 // packages/schema/src/prisma-literal.ts
 var STRING_ESCAPES = {
   '"': '"',
@@ -255,6 +412,8 @@ var RESERVED_CLIENT_NAMES = [
   "$connect",
   "$disconnect",
   "$transaction",
+  "$querySql",
+  "$executeSql",
   "$queryRaw",
   "$queryRawUnsafe",
   "$executeRaw",
@@ -264,7 +423,8 @@ var RESERVED_CLIENT_NAMES = [
   "$defineView",
   "$withPolicy",
   "$bypassPolicy",
-  "$scoped"
+  "$scoped",
+  "$readOnly"
 ];
 var RESERVED_COLUMN_PREFIX = "__vibe_";
 function isReservedDelegateName(params) {
@@ -302,26 +462,26 @@ function extensionManifestEntry(params) {
 }
 var EXTENSION_NAME_PATTERN = /^[a-z][a-zA-Z0-9]*$/;
 function defineExtension(extension) {
-  const { name } = extension;
-  if (!EXTENSION_NAME_PATTERN.test(name)) {
+  const { name: name2 } = extension;
+  if (!EXTENSION_NAME_PATTERN.test(name2)) {
     throw new VibeError({
       code: "VIBE_CONFIG",
-      message: `extension name "${name}" is invalid \u2014 must match ${EXTENSION_NAME_PATTERN} (it becomes a client identifier)`,
-      meta: { name }
+      message: `extension name "${name2}" is invalid \u2014 must match ${EXTENSION_NAME_PATTERN} (it becomes a client identifier)`,
+      meta: { name: name2 }
     });
   }
-  if (RESERVED_DELEGATE_NAMES.includes(name)) {
+  if (RESERVED_DELEGATE_NAMES.includes(name2)) {
     throw new VibeError({
       code: "VIBE_CONFIG",
-      message: `extension name "${name}" collides with a core delegate method`,
-      meta: { name }
+      message: `extension name "${name2}" collides with a core delegate method`,
+      meta: { name: name2 }
     });
   }
-  if (RESERVED_CLIENT_NAMES.includes(`$${name}`)) {
+  if (RESERVED_CLIENT_NAMES.includes(`$${name2}`)) {
     throw new VibeError({
       code: "VIBE_CONFIG",
-      message: `extension name "${name}" collides with the core client method "$${name}"`,
-      meta: { name }
+      message: `extension name "${name2}" collides with the core client method "$${name2}"`,
+      meta: { name: name2 }
     });
   }
   return Object.freeze(extension);
@@ -467,8 +627,87 @@ function validateComputedConfig(params) {
     });
   }
 }
+// packages/schema/src/default-values.ts
+function serializeJsonDefault(params) {
+  const ancestors = new Set;
+  const visit = (value) => {
+    if (value === null)
+      return "null";
+    if (typeof value === "string" || typeof value === "boolean")
+      return JSON.stringify(value);
+    if (typeof value === "number" && Number.isFinite(value))
+      return JSON.stringify(value);
+    if (typeof value !== "object" || value === null || ancestors.has(value)) {
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "JSON defaults require finite, acyclic JSON values" });
+    }
+    ancestors.add(value);
+    let text;
+    if (Array.isArray(value)) {
+      text = `[${Array.from(value, visit).join(",")}]`;
+    } else {
+      if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+        throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "JSON defaults require plain objects, not class instances" });
+      }
+      if (Reflect.ownKeys(value).some((key) => {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        return typeof key !== "string" || !descriptor.enumerable || !("value" in descriptor);
+      })) {
+        throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "JSON defaults require enumerable data properties, without symbols or accessors" });
+      }
+      text = `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${visit(Object.getOwnPropertyDescriptor(value, key).value)}`).join(",")}}`;
+    }
+    ancestors.delete(value);
+    return text;
+  };
+  return visit(params.value);
+}
+function scalarListDefault(params) {
+  const { type } = params;
+  return Array.from(params.values, (value) => {
+    if (type === "BigInt" && typeof value === "bigint")
+      return exactIntegerLiteral({ text: value.toString() });
+    if (type === "BigInt" && typeof value === "string" && /^-?\d+$/.test(value))
+      return exactIntegerLiteral({ text: value });
+    if ((type === "Int" || type === "BigInt") && typeof value === "number" && Number.isSafeInteger(value) && (type !== "Int" || value >= -2147483648 && value <= 2147483647))
+      return value;
+    if (type === "Float" && typeof value === "number" && Number.isFinite(value))
+      return value;
+    if (type === "Boolean" && typeof value === "boolean")
+      return value;
+    if ((type === "String" || isEnumType(type)) && typeof value === "string")
+      return value;
+    if (type === "Decimal" && (typeof value === "string" || typeof value === "number") && /^-?\d+(\.\d+)?$/.test(String(value))) {
+      const text = String(value);
+      const [integer, fraction = ""] = text.replace(/^-/, "").split(".");
+      const whole = BigInt(integer).toString();
+      const tail = fraction.replace(/0+$/, "");
+      const sign = text.startsWith("-") && (whole !== "0" || tail !== "") ? "-" : "";
+      return `${sign}${whole}${tail === "" ? "" : `.${tail}`}`;
+    }
+    if (type === "Json" && typeof value === "string")
+      return value;
+    if (type === "DateTime") {
+      const text = value instanceof Date && Number.isFinite(value.getTime()) ? value.toISOString() : value;
+      if (typeof text === "string") {
+        const match = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.(\d{1,6}))?(Z|[+-]\d{2}(?::?\d{2})?)?$/.exec(text);
+        const timestamp = match === null ? NaN : Date.parse(match[2] === undefined ? `${text}Z` : text);
+        if (Number.isFinite(timestamp))
+          return new Date(timestamp).toISOString().replace(/\.\d{3}Z$/, `.${(match?.[1] ?? "").padEnd(6, "0")}Z`);
+      }
+    }
+    if (type === "Bytes" && value instanceof Uint8Array)
+      return `\\x${Array.from(value, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+    if (type === "Bytes" && typeof value === "string" && /^\\x(?:[0-9a-f]{2})*$/i.test(value))
+      return value.toLowerCase();
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: `Invalid scalar-list default element for ${isEnumType(type) ? type.enum : type}` });
+  });
+}
+
 // packages/schema/src/capabilities.ts
 var POSTGRES_CAPABILITIES = Object.freeze({
+  exclusionConstraints: true,
+  exclusionExtensions: Object.freeze(["btree_gist"]),
+  checkNormalization: "rollback",
   nativeRowLevelSecurity: true,
   returning: true,
   scalarArrays: true,
@@ -482,9 +721,15 @@ var POSTGRES_CAPABILITIES = Object.freeze({
   createManyAndReturn: true,
   jsonColumnType: true,
   orderByNulls: true,
-  fullTextEngines: Object.freeze(["bm25", "tsvector"])
+  fullTextEngines: Object.freeze(["bm25", "tsvector"]),
+  rowLockStrengths: Object.freeze(["update", "noKeyUpdate", "share", "keyShare"]),
+  rowLockWaitPolicies: Object.freeze(["wait", "nowait", "skipLocked"]),
+  advisoryLocks: true
 });
 var SQLITE_CAPABILITIES = Object.freeze({
+  exclusionConstraints: false,
+  exclusionExtensions: Object.freeze([]),
+  checkNormalization: "sourceText",
   nativeRowLevelSecurity: false,
   returning: true,
   scalarArrays: false,
@@ -498,9 +743,15 @@ var SQLITE_CAPABILITIES = Object.freeze({
   createManyAndReturn: true,
   jsonColumnType: false,
   orderByNulls: true,
-  fullTextEngines: Object.freeze(["fts5"])
+  fullTextEngines: Object.freeze(["fts5"]),
+  rowLockStrengths: Object.freeze([]),
+  rowLockWaitPolicies: Object.freeze([]),
+  advisoryLocks: false
 });
 var MYSQL_CAPABILITIES = Object.freeze({
+  exclusionConstraints: false,
+  exclusionExtensions: Object.freeze([]),
+  checkNormalization: "temporary",
   nativeRowLevelSecurity: false,
   returning: false,
   scalarArrays: false,
@@ -514,7 +765,10 @@ var MYSQL_CAPABILITIES = Object.freeze({
   createManyAndReturn: false,
   jsonColumnType: true,
   orderByNulls: false,
-  fullTextEngines: Object.freeze(["fulltext"])
+  fullTextEngines: Object.freeze(["fulltext"]),
+  rowLockStrengths: Object.freeze(["update", "share"]),
+  rowLockWaitPolicies: Object.freeze(["wait", "nowait", "skipLocked"]),
+  advisoryLocks: false
 });
 var DIALECT_CAPABILITIES = Object.freeze({
   postgres: POSTGRES_CAPABILITIES,
@@ -524,6 +778,15 @@ var DIALECT_CAPABILITIES = Object.freeze({
 
 // packages/schema/src/validate.ts
 var RESERVED_ENUM_NAMES = [
+  "sql",
+  "decode",
+  "sqlProjection",
+  "sqlModels",
+  "createSqlModel",
+  "SqlColumn",
+  "SqlFragment",
+  "ResultDecoder",
+  "ExtendedDateTime",
   "enumValidators",
   "enumValidator",
   "OmittedKeys",
@@ -565,6 +828,7 @@ var RESERVED_ENUM_NAMES = [
   "SortOrderWithNulls",
   "KeysetToken",
   "KeysetOptions",
+  "RowLockRequest",
   "JsonValue",
   "InputJsonValue",
   "InputJsonArray",
@@ -577,6 +841,9 @@ var RESERVED_ENUM_NAMES = [
   "ScopedClientInstance",
   "ScopedModelsConfig",
   "ScopedNestedMode",
+  "VibeTransactionClientInstance",
+  "ScopedTransactionClientInstance",
+  "ReadOnlyClientInstance",
   "ViewClient",
   "ViewDefinitionInput",
   "ViewRow",
@@ -586,6 +853,7 @@ var RESERVED_ENUM_NAMES = [
   "QueryEvent",
   "Skip",
   "TransactionOptions",
+  "AdvisoryLockOptions",
   "SchemaIR",
   "VibeExtension",
   "ComputedConfig",
@@ -619,6 +887,9 @@ var GENERATED_TYPE_NAMES = {
     "WhereInput",
     "WhereUniqueInput",
     "OrderByInput",
+    "ScalarOrderByInput",
+    "RelationOrderByInput",
+    "RelationFindManyArgs",
     "CreateInput",
     "UncheckedCreateInput",
     "CreateManyInput",
@@ -674,7 +945,8 @@ var GENERATED_TYPE_NAMES = {
     "ViewRelationResult",
     "ViewIncludeResult",
     "ViewResult",
-    "ViewDelegate"
+    "ViewDelegate",
+    "ReadOnlyDelegate"
   ],
   nestedPrefixes: [
     "Create",
@@ -693,10 +965,11 @@ var GENERATED_TYPE_NAMES = {
 };
 function validateGeneratedNames(params) {
   const { schema, issues } = params;
-  const owners = new Map(RESERVED_ENUM_NAMES.map((name) => [name, "generated client"]));
+  const owners = new Map(RESERVED_ENUM_NAMES.map((name2) => [name2, "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) => {
     const previous = owners.get(params2.name);
@@ -1081,6 +1354,15 @@ function validateModel(params) {
       });
     }
     checkNames.add(check.name);
+    if (check.predicate !== undefined) {
+      validatePredicateFields({
+        predicate: check.predicate,
+        model,
+        fieldNames,
+        site: `CHECK "${check.name}"`,
+        issues
+      });
+    }
   }
   for (const index of model.indexes) {
     for (const indexField of index.fields) {
@@ -1093,13 +1375,98 @@ function validateModel(params) {
         });
       }
     }
+    if (index.wherePredicate !== undefined) {
+      validatePredicateFields({
+        predicate: index.wherePredicate,
+        model,
+        fieldNames,
+        site: `partial index on [${index.fields.map((entry) => entry.name).join(", ")}]`,
+        issues
+      });
+    }
+  }
+}
+function validatePredicateFields(params) {
+  const { predicate, model, fieldNames, site, issues } = params;
+  for (const name2 of predicateFieldNames({ predicate })) {
+    if (!fieldNames.has(name2)) {
+      issues.push({
+        rule: "predicate-unknown-field",
+        message: `${site} on "${model.name}" references unknown field "${name2}"`,
+        model: model.name,
+        field: name2
+      });
+      continue;
+    }
+    if (model.fields.find((field) => field.name === name2)?.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`,
+        model: model.name,
+        field: name2
+      });
+    }
   }
 }
 function assertValidSchemaIR(params) {
   const dialect = providerToDialect({ provider: params.schema.datasource.provider });
+  for (const model of params.schema.models) {
+    if (model.exclusions !== undefined && !Array.isArray(model.exclusions))
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Exclusions must be an array", meta: { rule: "exclusion-definition" } });
+    if ((model.exclusions?.length ?? 0) === 0)
+      continue;
+    if (!DIALECT_CAPABILITIES[dialect].exclusionConstraints)
+      throw unsupportedCapability({ dialect, feature: "exclusionConstraints" });
+    const names = new Set;
+    const exclusions = model.exclusions ?? [];
+    for (const exclusion of exclusions) {
+      if (exclusion === null || typeof exclusion !== "object")
+        throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Invalid exclusion declaration", meta: { rule: "exclusion-definition" } });
+      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)))
+          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"))
+        throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Invalid exclusion declaration", meta: { rule: "exclusion-definition", model: model.name } });
+      names.add(exclusion.name);
+    }
+  }
+  if (params.schema.migrationObjects !== undefined)
+    assertMigrationObjects({ objects: params.schema.migrationObjects });
   if (params.schema.rls !== undefined && !DIALECT_CAPABILITIES[dialect].nativeRowLevelSecurity) {
     throw unsupportedCapability({ dialect, feature: "nativeRowLevelSecurity" });
   }
+  for (const model of params.schema.models) {
+    const counters = model.fields.filter((field) => field.default?.kind === "autoincrement");
+    if (dialect === "mysql" && counters.length > 1)
+      throw unsupportedCapability({ dialect, feature: "multiple auto-increment columns" });
+    for (const field of model.fields) {
+      if (field.default?.kind === "list") {
+        if (dialect !== "postgres")
+          throw unsupportedCapability({ dialect, feature: "scalar-list defaults" });
+        if (!field.isList)
+          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 ?? [];
+          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}` });
+        }
+      }
+      if (field.default?.kind !== "autoincrement")
+        continue;
+      if (field.isList || field.isOptional || field.type !== "Int" && field.type !== "BigInt")
+        throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: `autoincrement requires a required scalar Int or BigInt: ${model.name}.${field.name}` });
+      const pk = model.primaryKey?.fields ?? model.fields.filter((entry) => entry.isId).map((entry) => entry.name);
+      if (dialect === "sqlite" && (pk.length !== 1 || pk[0] !== field.name))
+        throw unsupportedCapability({ dialect, feature: `non-primary auto-increment column ${model.name}.${field.name}` });
+      if (dialect === "mysql" && pk[0] !== field.name && !field.isUnique && !model.indexes.some((index) => index.fields[0]?.name === field.name))
+        throw unsupportedCapability({ dialect, feature: `unindexed auto-increment column ${model.name}.${field.name}` });
+    }
+  }
   const issues = validateSchemaIR(params);
   if (issues.length > 0) {
     throw new VibeError({
@@ -1184,10 +1551,10 @@ function validateNativeRls(params) {
     tables.add(table);
     const columns = new Set;
     for (const field of model.fields) {
-      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);
+      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);
     }
     if (model.policy !== undefined)
       add({ rule: "rls-policy-conflict", message: "Native RLS cannot combine with application-level ModelIR.policy" });
@@ -1240,7 +1607,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((name) => model.fields.find((field) => field.name === name)?.isOptional)) {
+      if (relation.isOptional || relation.fields?.some((name2) => model.fields.find((field) => field.name === name2)?.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;
       }
@@ -1272,8 +1639,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((name, index) => {
-    const field = model.fields.find((f) => f.name === name);
+  const validFields = fields.every((name2, index) => {
+    const field = model.fields.find((f) => f.name === name2);
     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);
   });
@@ -1282,7 +1649,7 @@ 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((name) => refs.includes(name)));
+  return validFields && uniqueSets.some((set) => set.length === refs.length && set.every((name2) => refs.includes(name2)));
 }
 // packages/schema/src/m2m.ts
 function implicitJoinTable(params) {
@@ -1303,15 +1670,24 @@ export {
   validateRlsContextIR,
   validateComputedConfig,
   unsupportedCapability,
+  sqlObjectKey,
+  serializeJsonDefault,
+  scalarListDefault,
   providerToDialect,
+  predicateKey,
+  predicateFieldNames,
   mergeExtensionDeclarations,
+  isSqlObjectIdentity,
+  isSqlObjectDefinition,
   isReservedDelegateName,
   isReservedClientName,
+  isPredicateFieldRef,
   isImplicitManyToManyRelation,
   isEnumType,
   invalidStoredData,
   internalError,
   implicitJoinTable,
+  fieldTypeIdentity,
   extensionOptionsHash,
   extensionManifestEntry,
   extensionDeclarations,
@@ -1323,16 +1699,20 @@ export {
   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,
@@ -1341,4 +1721,4 @@ export {
   DIALECTS
 };
 
-//# debugId=917A26DA81AB84E364756E2164756E21
+//# debugId=D5526EF61FB41A9D64756E2164756E21