@vibeorm/schema 2.4.0 → 2.5.0

package/dist/index.js

@@ -1,85 +1,4 @@
 // @bun
-// packages/schema/src/ir.ts
-var DIALECTS = ["postgres", "sqlite", "mysql"];
-function providerToDialect(params) {
-  const { provider } = params;
-  switch (provider) {
-    case "postgresql":
-    case "pglite":
-      return "postgres";
-    case "sqlite":
-      return "sqlite";
-    case "mysql":
-      return "mysql";
-  }
-}
-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",
@@ -223,10 +142,203 @@ class ReadOnlyClientError extends VibeError {
   }
 }
 
+// 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/namespaces.ts
+var SQL_NAMESPACES = Object.freeze({
+  postgres: "public",
+  sqlite: "main",
+  private: Object.freeze(["_vibeorm_shadow", "_vibe_shadow"])
+});
+function sqlNamespaceIssue(params) {
+  const { namespace } = params;
+  if (typeof namespace !== "string" || namespace.trim().length === 0 || namespace.includes("\x00"))
+    return "Namespace must be a non-empty identifier without NUL bytes";
+  if (identifierLength({ name: namespace, dialect: "postgres" }) > IDENTIFIER_LIMITS.postgres.max)
+    return "PostgreSQL namespace exceeds its identifier byte limit";
+  if (namespace === "information_schema" || namespace.startsWith("pg_") || SQL_NAMESPACES.private.includes(namespace))
+    return "System and private VibeORM namespaces cannot be declared";
+  if (params.allowPublic === false && namespace === SQL_NAMESPACES.postgres)
+    return "A fixed package namespace must be non-public; omit namespace for a legacy public artifact";
+  return;
+}
+function assertSqlNamespace(params) {
+  if (params.dialect !== "postgres")
+    throw unsupportedCapability({ dialect: params.dialect, feature: "fixedNamespaces" });
+  const issue = sqlNamespaceIssue(params);
+  if (issue !== undefined)
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: issue, meta: { rule: "namespace", namespace: params.namespace } });
+}
+function qualifiedSqlName(params) {
+  return { namespace: params.namespace ?? params.defaultNamespace ?? SQL_NAMESPACES.postgres, name: params.name };
+}
+// packages/schema/src/capabilities.ts
+var POSTGRES_CAPABILITIES = Object.freeze({
+  fixedNamespaces: true,
+  externalObjects: true,
+  indexOperatorClasses: true,
+  exclusionConstraints: true,
+  exclusionExtensions: Object.freeze(["btree_gist"]),
+  checkNormalization: "rollback",
+  nativeRowLevelSecurity: true,
+  returning: true,
+  scalarArrays: true,
+  nativeEnums: true,
+  ilike: true,
+  lateralJoin: true,
+  distinctOn: true,
+  partialIndexes: true,
+  conflictTargetConstraint: true,
+  transactionalDdl: true,
+  createManyAndReturn: true,
+  jsonColumnType: true,
+  orderByNulls: true,
+  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({
+  fixedNamespaces: false,
+  externalObjects: false,
+  indexOperatorClasses: false,
+  exclusionConstraints: false,
+  exclusionExtensions: Object.freeze([]),
+  checkNormalization: "sourceText",
+  nativeRowLevelSecurity: false,
+  returning: true,
+  scalarArrays: false,
+  nativeEnums: false,
+  ilike: false,
+  lateralJoin: false,
+  distinctOn: false,
+  partialIndexes: true,
+  conflictTargetConstraint: false,
+  transactionalDdl: true,
+  createManyAndReturn: true,
+  jsonColumnType: false,
+  orderByNulls: true,
+  fullTextEngines: Object.freeze(["fts5"]),
+  rowLockStrengths: Object.freeze([]),
+  rowLockWaitPolicies: Object.freeze([]),
+  advisoryLocks: false
+});
+var MYSQL_CAPABILITIES = Object.freeze({
+  fixedNamespaces: false,
+  externalObjects: false,
+  indexOperatorClasses: false,
+  exclusionConstraints: false,
+  exclusionExtensions: Object.freeze([]),
+  checkNormalization: "temporary",
+  nativeRowLevelSecurity: false,
+  returning: false,
+  scalarArrays: false,
+  nativeEnums: true,
+  ilike: false,
+  lateralJoin: false,
+  distinctOn: false,
+  partialIndexes: false,
+  conflictTargetConstraint: false,
+  transactionalDdl: false,
+  createManyAndReturn: false,
+  jsonColumnType: true,
+  orderByNulls: false,
+  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,
+  sqlite: SQLITE_CAPABILITIES,
+  mysql: MYSQL_CAPABILITIES
+});
+
 // packages/schema/src/migration-objects.ts
 function sqlObjectKey(params) {
   const object = params.identity;
   switch (object.kind) {
+    case "namespace":
+      return JSON.stringify([object.kind, object.name]);
     case "table":
     case "view":
     case "sequence":
@@ -246,6 +358,12 @@ function sqlObjectKey(params) {
       return JSON.stringify([object.kind, object.table.namespace, object.table.name, object.column]);
   }
 }
+function sqlObjectNamespace(params) {
+  const identity = params.identity;
+  if (identity.kind === "namespace")
+    return identity.name;
+  return "table" in identity ? identity.table.namespace : identity.name.namespace;
+}
 function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -256,6 +374,8 @@ function isSqlObjectIdentity(value) {
   if (!record(value))
     return false;
   switch (value.kind) {
+    case "namespace":
+      return typeof value.name === "string" && value.name.length > 0;
     case "table":
     case "view":
     case "sequence":
@@ -277,24 +397,257 @@ function isSqlObjectIdentity(value) {
       return false;
   }
 }
-function isSqlObjectDefinition(value) {
-  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 isSqlObjectDefinition(value) {
+  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 qualifiedNameIssue(params) {
+  if (!record(params.value))
+    return { path: params.path, expected: "qualified SQL name { namespace, name }" };
+  const member = typeof params.value.namespace !== "string" || params.value.namespace.length === 0 ? "namespace" : "name";
+  return { path: `${params.path}.${member}`, expected: "non-empty string" };
+}
+function identityIssue(params) {
+  const { value, path } = params;
+  if (!record(value))
+    return { path, expected: "SQL object identity" };
+  switch (value.kind) {
+    case "namespace":
+      return { path: `${path}.name`, expected: "non-empty namespace string" };
+    case "table":
+    case "view":
+    case "sequence":
+    case "postgresExtension":
+    case "enum":
+      return qualifiedNameIssue({ value: value.name, path: `${path}.name` });
+    case "function": {
+      if (!name(value.name))
+        return qualifiedNameIssue({ value: value.name, path: `${path}.name` });
+      if (!Array.isArray(value.argumentTypes))
+        return { path: `${path}.argumentTypes`, expected: "array of qualified SQL type names" };
+      const index = value.argumentTypes.findIndex((entry) => !name(entry));
+      return qualifiedNameIssue({ value: value.argumentTypes[index], path: `${path}.argumentTypes[${index}]` });
+    }
+    case "index":
+    case "trigger":
+    case "constraint":
+    case "column":
+    case "columnDefault":
+    case "generatedColumn": {
+      if (!name(value.table))
+        return qualifiedNameIssue({ value: value.table, path: `${path}.table` });
+      if (value.kind === "column" || value.kind === "columnDefault" || value.kind === "generatedColumn")
+        return { path: `${path}.column`, expected: "non-empty column name" };
+      if (typeof value.name !== "string" || value.name.length === 0)
+        return { path: `${path}.name`, expected: "non-empty object name" };
+      return { path: `${path}.constraintType`, expected: ["check", "foreignKey", "exclusion", "unique", "primaryKey"] };
+    }
+    default:
+      return { path: `${path}.kind`, expected: ["namespace", "table", "view", "sequence", "postgresExtension", "enum", "function", "index", "trigger", "constraint", "column", "columnDefault", "generatedColumn"] };
+  }
+}
+function definitionIssue(params) {
+  const { value, path } = params;
+  if (!record(value))
+    return { path, expected: "independent SQL object definition" };
+  if (value.format !== "catalog-v1" && value.format !== "catalog-v2")
+    return { path: `${path}.format`, expected: ["catalog-v1", "catalog-v2"] };
+  if (!isSqlObjectIdentity(value.identity))
+    return identityIssue({ value: value.identity, path: `${path}.identity` });
+  if (!record(value.facts) || Object.keys(value.facts).length === 0)
+    return { path: `${path}.facts`, expected: "non-empty serializable catalog facts" };
+  for (const [key, fact] of Object.entries(value.facts)) {
+    if (!(fact === null || typeof fact === "string" || typeof fact === "boolean" || typeof fact === "number" && Number.isFinite(fact) || Array.isArray(fact) && fact.every((entry) => typeof entry === "string")))
+      return { path: `${path}.facts.${key}`, expected: "string, finite number, boolean, null or string array" };
+  }
+  if (!Array.isArray(value.dependencies))
+    return { path: `${path}.dependencies`, expected: "array of SQL object identities" };
+  const index = value.dependencies.findIndex((entry) => !isSqlObjectIdentity(entry));
+  return identityIssue({ value: value.dependencies[index], path: `${path}.dependencies[${index}]` });
+}
+function invalidDeclaration(params) {
+  const expected = typeof params.expected === "string" ? params.expected : params.expected.join(", ");
+  throw new VibeError({
+    code: "VIBE_SCHEMA_INVALID",
+    message: `Invalid migration-only object declaration at ${params.path}; expected ${expected}`,
+    meta: { path: params.path, expected: params.expected, ...params.id === undefined ? {} : { id: params.id } }
+  });
+}
+function assertMigrationObjects(params) {
+  if (!Array.isArray(params.objects))
+    invalidDeclaration({ path: "migrationObjects", expected: "array" });
+  const ids = new Set;
+  const owners = new Set;
+  for (const [index, value] of params.objects.entries()) {
+    const object = value;
+    const path = `migrationObjects[${index}]`;
+    if (!record(object))
+      invalidDeclaration({ path, expected: "object" });
+    if (typeof object.id !== "string" || object.id.length === 0)
+      invalidDeclaration({ path: `${path}.id`, expected: "non-empty string" });
+    const id = object.id;
+    if (!["postgres", "sqlite", "mysql"].includes(String(object.dialect)))
+      invalidDeclaration({ path: `${path}.dialect`, expected: ["postgres", "sqlite", "mysql"], id });
+    const identity = object.identity;
+    if (!isSqlObjectIdentity(identity))
+      invalidDeclaration({ ...identityIssue({ value: identity, path: `${path}.identity` }), id });
+    for (const member of ["create", "drop"]) {
+      const statements = object[member];
+      if (!Array.isArray(statements))
+        invalidDeclaration({ path: `${path}.${member}`, expected: "array of SQL strings", id });
+      const invalid = statements.findIndex((entry) => typeof entry !== "string");
+      if (invalid !== -1)
+        invalidDeclaration({ path: `${path}.${member}[${invalid}]`, expected: "SQL string", id });
+    }
+    if (!Array.isArray(object.dependsOn))
+      invalidDeclaration({ path: `${path}.dependsOn`, expected: "array of SQL object identities", id });
+    for (const [dependencyIndex, dependency] of object.dependsOn.entries())
+      if (!isSqlObjectIdentity(dependency))
+        invalidDeclaration({ ...identityIssue({ value: dependency, path: `${path}.dependsOn[${dependencyIndex}]` }), id });
+    if (object.expected !== undefined) {
+      if (!isSqlObjectDefinition(object.expected))
+        invalidDeclaration({ ...definitionIssue({ value: object.expected, path: `${path}.expected` }), id });
+      if (sqlObjectKey({ identity: object.expected.identity }) !== sqlObjectKey({ identity }))
+        invalidDeclaration({ path: `${path}.expected.identity`, expected: "the declaration's SQL object identity", id });
+    }
+    const key = sqlObjectKey({ identity });
+    if (ids.has(id) || owners.has(key))
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Duplicate migration object identity or id", meta: { id, key, path: `${path}.${ids.has(id) ? "id" : "identity"}` } });
+    ids.add(id);
+    owners.add(key);
+  }
+}
+
+// packages/schema/src/index-operator-classes.ts
+function assertIndexOperatorClasses(params) {
+  for (const model of params.schema.models)
+    for (const index of model.indexes)
+      for (const field of index.fields) {
+        if (field.operatorClass === undefined)
+          continue;
+        if (!DIALECT_CAPABILITIES[params.dialect].indexOperatorClasses)
+          throw unsupportedCapability({ dialect: params.dialect, feature: "indexOperatorClasses" });
+        if (index.kind === "unique" && params.physical !== true)
+          throw unsupportedCapability({ dialect: params.dialect, feature: "uniqueIndexOperatorClasses", hint: "custom unique operator classes can change client selector equality" });
+        if (!isSqlObjectIdentity({ kind: "table", name: field.operatorClass }))
+          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/ir.ts
+var DIALECTS = ["postgres", "sqlite", "mysql"];
+function providerToDialect(params) {
+  const { provider } = params;
+  switch (provider) {
+    case "postgresql":
+    case "pglite":
+      return "postgres";
+    case "sqlite":
+      return "sqlite";
+    case "mysql":
+      return "mysql";
+  }
+}
+function isEnumType(fieldType) {
+  return typeof fieldType === "object" && "enum" in fieldType;
 }
-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);
+function fieldTypeIdentity(params) {
+  const { type } = params;
+  return isEnumType(type) ? type.namespace === undefined || type.namespace === "public" ? `enum:${type.enum}` : JSON.stringify(["enum", type.namespace, type.enum]) : type;
+}
+var ENUM_STORAGES = ["database", "string"];
+function enumStorageOf(params) {
+  return params.enumDef.storage ?? "database";
+}
+
+// packages/schema/src/module-schema.ts
+function prepareDatabaseModuleSchema(params) {
+  const { schema, module } = params;
+  const namespace = module.namespace;
+  const dialect = providerToDialect({ provider: schema.datasource.provider });
+  if (namespace !== undefined)
+    assertSqlNamespace({ namespace, dialect, allowPublic: false });
+  const expected = namespace ?? SQL_NAMESPACES.postgres;
+  for (const entry of [...schema.models, ...schema.enums]) {
+    if (entry.namespace === undefined)
+      continue;
+    assertSqlNamespace({ namespace: entry.namespace, dialect });
+    if (qualifiedSqlName({ name: entry.dbName ?? entry.name, namespace: entry.namespace }).namespace !== expected)
+      throw new VibeError({ code: "VIBE_CONFIG", message: "Module schema placement differs from its immutable namespace; host configuration cannot remap it", meta: { reason: "module-placement-mismatch", moduleId: module.id, name: entry.name } });
   }
+  for (const model of schema.models)
+    for (const field of model.fields) {
+      if (!isEnumType(field.type) || field.type.namespace === undefined)
+        continue;
+      assertSqlNamespace({ namespace: field.type.namespace, dialect });
+      if (field.type.namespace !== expected)
+        throw new VibeError({ code: "VIBE_CONFIG", message: "Module enum reference placement differs from its immutable namespace", meta: { reason: "module-placement-mismatch", moduleId: module.id, model: model.name, field: field.name } });
+    }
+  if (namespace === undefined)
+    return schema;
+  const nativeEnums = new Set(schema.enums.filter((entry) => enumStorageOf({ enumDef: entry }) === "database").map((entry) => entry.name));
+  return {
+    ...schema,
+    models: schema.models.map((model) => ({ ...model, namespace, fields: model.fields.map((field) => {
+      const type = field.type;
+      return isEnumType(type) && nativeEnums.has(type.enum) ? { ...field, type: { ...type, namespace } } : field;
+    }) })),
+    enums: schema.enums.map((entry) => enumStorageOf({ enumDef: entry }) === "database" ? { ...entry, namespace } : entry)
+  };
+}
+// 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/prisma-literal.ts
 var STRING_ESCAPES = {
@@ -407,6 +760,7 @@ function exactDecimalLiteral(params) {
 // packages/schema/src/reserved.ts
 var RESERVED_DELEGATE_NAMES = [
   "findMany",
+  "findPage",
   "findFirst",
   "findUnique",
   "findFirstOrThrow",
@@ -740,160 +1094,6 @@ function implicitJoinTable(params) {
   };
 }
 
-// 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,
-  exclusionExtensions: Object.freeze(["btree_gist"]),
-  checkNormalization: "rollback",
-  nativeRowLevelSecurity: true,
-  returning: true,
-  scalarArrays: true,
-  nativeEnums: true,
-  ilike: true,
-  lateralJoin: true,
-  distinctOn: true,
-  partialIndexes: true,
-  conflictTargetConstraint: true,
-  transactionalDdl: true,
-  createManyAndReturn: true,
-  jsonColumnType: true,
-  orderByNulls: true,
-  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,
-  nativeEnums: false,
-  ilike: false,
-  lateralJoin: false,
-  distinctOn: false,
-  partialIndexes: true,
-  conflictTargetConstraint: false,
-  transactionalDdl: true,
-  createManyAndReturn: true,
-  jsonColumnType: false,
-  orderByNulls: true,
-  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,
-  nativeEnums: true,
-  ilike: false,
-  lateralJoin: false,
-  distinctOn: false,
-  partialIndexes: false,
-  conflictTargetConstraint: false,
-  transactionalDdl: false,
-  createManyAndReturn: false,
-  jsonColumnType: true,
-  orderByNulls: false,
-  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,
-  sqlite: SQLITE_CAPABILITIES,
-  mysql: MYSQL_CAPABILITIES
-});
-
 // packages/schema/src/validate.ts
 var RESERVED_ENUM_NAMES = [
   "sql",
@@ -948,6 +1148,7 @@ var RESERVED_ENUM_NAMES = [
   "SortOrder",
   "SortOrderWithNulls",
   "KeysetToken",
+  "KeysetPage",
   "KeysetOptions",
   "RowLockRequest",
   "JsonValue",
@@ -1026,6 +1227,7 @@ var GENERATED_TYPE_NAMES = {
     "MinAggregateInput",
     "MaxAggregateInput",
     "FindManyArgs",
+    "FindPageArgs",
     "FindFirstArgs",
     "FindUniqueArgs",
     "CreateArgs",
@@ -1196,6 +1398,15 @@ function validateGeneratedNames(params) {
 function validateSchemaIR(params) {
   const { schema } = params;
   const issues = [];
+  for (const entry of [...schema.models, ...schema.enums]) {
+    if (entry.namespace === undefined)
+      continue;
+    const issue = sqlNamespaceIssue({ namespace: entry.namespace });
+    if (issue !== undefined)
+      issues.push({ rule: "namespace", message: issue });
+    if (providerToDialect({ provider: schema.datasource.provider }) !== "postgres")
+      issues.push({ rule: "namespace-dialect", message: "Explicit fixed namespaces require PostgreSQL or PGlite" });
+  }
   const modelByName = new Map;
   for (const model of schema.models) {
     if (modelByName.has(model.name)) {
@@ -1378,7 +1589,7 @@ function validatePhysicalNameUniqueness(params) {
   const dialect = providerToDialect({ provider: schema.datasource.provider });
   const owners = new Map;
   const claim = (entry) => {
-    const key = `${entry.namespace}\x00${entry.name}`;
+    const key = JSON.stringify([entry.physicalNamespace ?? "public", entry.namespace, entry.name]);
     const previous = owners.get(key);
     if (previous === undefined) {
       owners.set(key, `${entry.what} of ${entry.owner}`);
@@ -1396,10 +1607,11 @@ function validatePhysicalNameUniqueness(params) {
   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 }))
+    const physicalNamespace = qualifiedSqlName({ name: table, namespace: model.namespace }).namespace;
+    if (!claim({ namespace: "relation", physicalNamespace, 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 });
+      claim({ namespace: `column:${table}`, physicalNamespace, name: fieldIR.dbName ?? fieldIR.name, what: "column", owner: `field "${model.name}.${fieldIR.name}"`, model: model.name, field: fieldIR.name });
     }
     if (model.isView)
       continue;
@@ -1417,15 +1629,15 @@ function validatePhysicalNameUniqueness(params) {
         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 });
+      claim({ namespace: indexNamespace(table), physicalNamespace, 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 });
+        claim({ namespace: constraintNamespace(table), physicalNamespace, 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 });
+      claim({ namespace: "relation", physicalNamespace, name, what: "primary key", owner: `model "${model.name}"`, model: model.name });
+      claim({ namespace: constraintNamespace(table), physicalNamespace, 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)
@@ -1434,22 +1646,22 @@ function validatePhysicalNameUniqueness(params) {
       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 });
+      claim({ namespace: constraintNamespace(table), physicalNamespace, 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 });
+      claim({ namespace: constraintNamespace(table), physicalNamespace, 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 });
+      claim({ namespace: constraintNamespace(table), physicalNamespace, 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 });
+        claim({ namespace: "relation", physicalNamespace, 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}"` });
+      claim({ namespace: "relation", physicalNamespace: qualifiedSqlName({ name: enumDef.dbName ?? enumDef.name, namespace: enumDef.namespace }).namespace, name: enumDef.dbName ?? enumDef.name, what: "enum type", owner: `enum "${enumDef.name}"` });
     }
   }
   const seenJoinTables = new Set;
@@ -1459,17 +1671,24 @@ function validatePhysicalNameUniqueness(params) {
         continue;
       if (!isImplicitManyToManyRelation({ model, relation, models: schema.models }))
         continue;
+      const target = schema.models.find((candidate) => candidate.name === relation.targetModel);
+      const physicalNamespace = model.namespace ?? "public";
+      if ((target?.namespace ?? "public") !== physicalNamespace) {
+        issues.push({ rule: "implicit-join-namespace", message: "Implicit many-to-many endpoints must share one fixed namespace", model: model.name, field: relation.name });
+        continue;
+      }
       const join = implicitJoinTable({ modelA: model.name, modelB: relation.targetModel, ...relation.relationName === undefined ? {} : { relationName: relation.relationName } });
-      if (seenJoinTables.has(join.tableName))
+      const joinKey = JSON.stringify([physicalNamespace, join.tableName]);
+      if (seenJoinTables.has(joinKey))
         continue;
-      seenJoinTables.add(join.tableName);
+      seenJoinTables.add(joinKey);
       const owner = `implicit relation "${model.name}.${relation.name}"`;
-      claim({ namespace: "relation", name: join.tableName, what: "join table", owner, model: model.name });
+      claim({ namespace: "relation", physicalNamespace, 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 });
+      claim({ namespace: indexNamespace(join.tableName), physicalNamespace, name: derived.uniqueIndex, what: "unique index", owner, model: model.name });
+      claim({ namespace: indexNamespace(join.tableName), physicalNamespace, name: derived.indexB, what: "index", owner, model: model.name });
+      claim({ namespace: constraintNamespace(join.tableName), physicalNamespace, name: derived.foreignKeyA, what: "foreign key", owner, model: model.name });
+      claim({ namespace: constraintNamespace(join.tableName), physicalNamespace, name: derived.foreignKeyB, what: "foreign key", owner, model: model.name });
     }
   }
 }
@@ -1835,6 +2054,20 @@ function validatePredicateFields(params) {
 }
 function assertValidSchemaIR(params) {
   const dialect = providerToDialect({ provider: params.schema.datasource.provider });
+  assertIndexOperatorClasses({ schema: params.schema, dialect });
+  for (const entry of [...params.schema.models, ...params.schema.enums])
+    if (entry.namespace !== undefined)
+      assertSqlNamespace({ namespace: entry.namespace, dialect });
+  for (const model of params.schema.models)
+    for (const field of model.fields) {
+      if (!isEnumType(field.type) || field.type.namespace === undefined)
+        continue;
+      assertSqlNamespace({ namespace: field.type.namespace, dialect });
+      const enumType = field.type;
+      const declared = params.schema.enums.find((entry) => entry.name === enumType.enum || entry.dbName === enumType.enum);
+      if (declared !== undefined && (declared.namespace ?? "public") !== enumType.namespace)
+        throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Enum reference namespace differs from its declared native type", meta: { rule: "enum-namespace", model: model.name, field: field.name } });
+    }
   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" } });
@@ -2094,11 +2327,14 @@ export {
   RlsContextError,
   SCOPED_REFUSAL_REASONS,
   SQLITE_CAPABILITIES,
+  SQL_NAMESPACES,
   ScopedQueryError,
   VIBE_ERROR_CODES,
   VibeError,
   assertIdentifierFits,
+  assertIndexOperatorClasses,
   assertMigrationObjects,
+  assertSqlNamespace,
   assertValidSchemaIR,
   buildComputedManifest,
   buildExtensionRegistry,
@@ -2132,14 +2368,18 @@ export {
   postgresGeneratedObjectName,
   predicateFieldNames,
   predicateKey,
+  prepareDatabaseModuleSchema,
   providerToDialect,
+  qualifiedSqlName,
   scalarListDefault,
   serializeJsonDefault,
+  sqlNamespaceIssue,
   sqlObjectKey,
+  sqlObjectNamespace,
   unsupportedCapability,
   validateComputedConfig,
   validateRlsContextIR,
   validateSchemaIR
 };
 
-//# debugId=47DE6CAFB1D4DC2864756E2164756E21
+//# debugId=20984641ACA6D36E64756E2164756E21