@dbsp/core 1.10.1 → 2.0.0

package/dist/index.js

@@ -58,6 +58,9 @@ __reExport(intent_ast_exports, types_star);
 import * as types_star from "@dbsp/types";
 
 // src/model-impl.ts
+function hasExternalSchema(schemaName) {
+  return schemaName != null && schemaName.trim().length > 0;
+}
 var ModelIRImpl = class {
   tables;
   externalTables;
@@ -178,7 +181,7 @@ var ModelIRImpl = class {
     }
     for (const table of this.tables.values()) {
       for (const fk of table.foreignKeys) {
-        if (!this.tables.has(fk.references.table) && !this.externalTables.has(fk.references.table)) {
+        if (!hasExternalSchema(fk.references.schema) && !this.tables.has(fk.references.table) && !this.externalTables.has(fk.references.table)) {
           errors.push(
             `Table "${table.name}" has FK referencing non-existent table "${fk.references.table}"`
           );
@@ -623,11 +626,25 @@ function createTablesProxy(model, tableNames, options) {
 }
 
 // src/dx/schema.ts
+function normalizeReferenceSchema(schemaName) {
+  if (schemaName == null) return void 0;
+  const t = schemaName.trim();
+  return t.length > 0 ? t : void 0;
+}
+function hasExternalSchema2(schemaName) {
+  return normalizeReferenceSchema(schemaName) !== void 0;
+}
+function normalizeRefOptions(options) {
+  const schemaName = normalizeReferenceSchema(options.schema);
+  if (schemaName === options.schema) return options;
+  const { schema: _schema, ...rest } = options;
+  return schemaName === void 0 ? rest : { ...rest, schema: schemaName };
+}
 function ref(target, options) {
   return {
     __brand: "ref",
     target,
-    options: options ?? {}
+    options: options ? normalizeRefOptions(options) : {}
   };
 }
 function isRef(value) {
@@ -653,6 +670,7 @@ function schema(definition, constraints, options, extras) {
   );
   return {
     definition,
+    ...constraints !== void 0 ? { constraints } : {},
     model,
     tableNames,
     tables,
@@ -669,6 +687,13 @@ var SchemaValidationError = class extends Error {
   table;
   column;
 };
+function validateSchemaIndexOptions(tableName, idx) {
+  if (idx.nullsNotDistinct === true && idx.unique !== true) {
+    throw new SchemaValidationError(
+      `Index "${idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`}" on "${tableName}" cannot use nullsNotDistinct unless unique is true`
+    );
+  }
+}
 function schemaToModelIR(definition, constraints, extras, options) {
   if (typeof options?.defaultPkColumnName === "string" && options.defaultPkColumnName.trim().length === 0) {
     throw new SchemaValidationError(
@@ -721,21 +746,21 @@ function validateRefs(definition, tableNames) {
   for (const [tableName, tableDef] of Object.entries(definition)) {
     for (const [columnName, columnDef] of Object.entries(tableDef)) {
       if (isRef(columnDef)) {
-        if (!tableSet.has(columnDef.target)) {
+        if (!hasExternalSchema2(columnDef.options.schema) && !tableSet.has(columnDef.target)) {
           throw new SchemaValidationError(
             `Foreign key '${columnName}' references non-existent table '${columnDef.target}'`,
             tableName,
             columnName
           );
         }
-        if (columnDef.target === tableName && !columnDef.options.roles) {
+        if (!hasExternalSchema2(columnDef.options.schema) && columnDef.target === tableName && !columnDef.options.roles) {
           throw new SchemaValidationError(
             `Self-referential FK '${columnName}' must have 'roles' option with parent/children names`,
             tableName,
             columnName
           );
         }
-        if (columnDef.target !== tableName && columnDef.options.roles) {
+        if ((hasExternalSchema2(columnDef.options.schema) || columnDef.target !== tableName) && columnDef.options.roles) {
           throw new SchemaValidationError(
             `'roles' option is only valid for self-referential FKs, but '${columnName}' references '${columnDef.target}'`,
             tableName,
@@ -751,14 +776,6 @@ function validateFkTargets(tables) {
   const tableMap = new Map(tables.map((t) => [t.name, t]));
   for (const table of tables) {
     for (const fk of table.foreignKeys) {
-      const target = tableMap.get(fk.references.table);
-      if (!target) {
-        throw new SchemaValidationError(
-          `Foreign key in '${table.name}' references non-existent table '${fk.references.table}'`,
-          table.name,
-          fk.columns[0]
-        );
-      }
       for (const srcCol of fk.columns) {
         if (!table.columns.some((c) => c.name === srcCol)) {
           throw new SchemaValidationError(
@@ -782,6 +799,15 @@ function validateFkTargets(tables) {
           fk.columns[0]
         );
       }
+      if (hasExternalSchema2(fk.references.schema)) continue;
+      const target = tableMap.get(fk.references.table);
+      if (!target) {
+        throw new SchemaValidationError(
+          `Foreign key in '${table.name}' references non-existent table '${fk.references.table}'`,
+          table.name,
+          fk.columns[0]
+        );
+      }
       for (const refCol of fk.references.columns) {
         if (!target.columns.some((c) => c.name === refCol)) {
           throw new SchemaValidationError(
@@ -955,6 +981,14 @@ function getReferencedColumnType(targetDef, referencedCol, definition, visited)
 }
 function buildRefColumn(columnName, columnDef, definition) {
   const targetDef = definition[columnDef.target];
+  const externalSchema = normalizeReferenceSchema(columnDef.options.schema);
+  if (externalSchema !== void 0) {
+    throw new SchemaValidationError(
+      `Cannot infer column type for foreign key column '${columnName}' to external table '${externalSchema}.${columnDef.target}'. Declare the source column with an explicit type and add the external foreign key at the table level with SchemaConstraints.foreignKeys.`,
+      void 0,
+      columnName
+    );
+  }
   const targetCol = columnDef.options.references?.length === 1 ? columnDef.options.references[0] : void 0;
   const inferredType = targetCol && targetDef ? getReferencedColumnType(targetDef, targetCol, definition) ?? getTargetPkType(definition, columnDef.target) : getTargetPkType(definition, columnDef.target);
   const col2 = {
@@ -972,7 +1006,8 @@ function buildRefColumn(columnName, columnDef, definition) {
     columns: [columnName],
     references: {
       table: columnDef.target,
-      columns: columnDef.options.references ?? ["id"]
+      columns: columnDef.options.references ?? ["id"],
+      ...externalSchema !== void 0 ? { schema: externalSchema } : {}
     }
   };
   if (columnDef.options.onDelete) fk.onDelete = columnDef.options.onDelete;
@@ -1028,7 +1063,7 @@ function buildPseudoColumns(tableName, refsByTable, finalPk) {
   const refs = refsByTable.get(tableName) ?? [];
   const pkColumn = typeof finalPk === "string" ? finalPk : finalPk?.[0] ?? "id";
   for (const ref3 of refs) {
-    if (ref3.options.roles && ref3.target === tableName) {
+    if (!hasExternalSchema2(ref3.options.schema) && ref3.options.roles && ref3.target === tableName) {
       pseudoColumns.push(
         createPseudoColumnMetadata(
           tableName,
@@ -1067,13 +1102,18 @@ function buildTableConstraints(tableName, constraints) {
   }
   if (tableConstraints.indexes) {
     for (const idx of tableConstraints.indexes) {
+      validateSchemaIndexOptions(tableName, idx);
       const indexIR = {
         name: idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`,
         columns: idx.columns,
         unique: idx.unique ?? false
       };
+      if (idx.nullsNotDistinct !== void 0) {
+        indexIR.nullsNotDistinct = idx.nullsNotDistinct;
+      }
       if (idx.method) indexIR.method = idx.method;
       if (idx.where) indexIR.where = idx.where;
+      if (idx.include !== void 0) indexIR.include = idx.include;
       if (idx.opclass) indexIR.opclass = idx.opclass;
       if (idx.with) indexIR.with = idx.with;
       extraIndexes.push(indexIR);
@@ -1095,11 +1135,13 @@ function buildTableConstraints(tableName, constraints) {
           tableName
         );
       }
+      const externalSchema = normalizeReferenceSchema(fkRef.options.schema);
       const fk = {
         columns: [...fkRef.options.columns],
         references: {
           table: fkRef.target,
-          columns: fkRef.options.references ? [...fkRef.options.references] : ["id"]
+          columns: fkRef.options.references ? [...fkRef.options.references] : ["id"],
+          ...externalSchema !== void 0 ? { schema: externalSchema } : {}
         }
       };
       if (fkRef.options.onDelete) fk.onDelete = fkRef.options.onDelete;
@@ -1147,6 +1189,7 @@ function buildRelations(_definition, refsByTable, tableNames, constraints) {
   for (const tableName of tableNames) {
     const refs = refsByTable.get(tableName) || [];
     for (const ref3 of refs) {
+      if (hasExternalSchema2(ref3.options.schema)) continue;
       if (ref3.options.roles) {
         const roles = ref3.options.roles;
         relations.push({
@@ -1267,6 +1310,7 @@ function addCompositeConstraintRelations(relations, tableNames, constraints) {
     const foreignKeys = constraints[tableName]?.foreignKeys;
     if (!foreignKeys) continue;
     for (const fkRef of foreignKeys) {
+      if (hasExternalSchema2(fkRef.options.schema)) continue;
       if (!tableSet.has(fkRef.target)) continue;
       const columns = fkRef.options.columns;
       if (!columns?.length) continue;
@@ -1338,38 +1382,102 @@ async function getSchemaFromDb(adapter, options) {
   const model = introspectionResult;
   const introspectedAt = introspectionResult.introspectedAt;
   const fkLookup = /* @__PURE__ */ new Map();
+  const compositeExternalFkLookup = /* @__PURE__ */ new Map();
   for (const table of model.tables.values()) {
     const tableFks = /* @__PURE__ */ new Map();
     for (const fk of table.foreignKeys) {
+      const externalSchema = normalizeReferenceSchema(fk.references.schema);
+      if (externalSchema !== void 0 && fk.columns.length > 1) {
+        const tableCompositeFks = compositeExternalFkLookup.get(table.name) ?? [];
+        tableCompositeFks.push({
+          ...fk,
+          references: {
+            ...fk.references,
+            schema: externalSchema
+          }
+        });
+        compositeExternalFkLookup.set(table.name, tableCompositeFks);
+        continue;
+      }
       const fkColumn = fk.columns[0];
       if (!fkColumn) continue;
       const column = table.columns.find((c) => c.name === fkColumn);
       tableFks.set(fkColumn, {
         target: fk.references.table,
+        refs: fk.references.columns,
+        ...externalSchema !== void 0 ? { schema: externalSchema } : {},
         nullable: column?.nullable ?? true,
-        unique: column?.unique ?? false
+        unique: column?.unique ?? false,
+        ...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
+        ...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
       });
     }
     fkLookup.set(table.name, tableFks);
   }
   const definition = {};
+  const constraints = {};
   for (const table of model.tables.values()) {
     const tableDef = {};
     const tableFks = fkLookup.get(table.name) ?? /* @__PURE__ */ new Map();
+    const compositeExternalFks = compositeExternalFkLookup.get(table.name) ?? [];
     for (const column of table.columns) {
       const fk = tableFks.get(column.name);
       if (fk) {
+        if (fk.schema !== void 0) {
+          const sourceColumn = {
+            type: columnTypeToJsType(column.type),
+            nullable: fk.nullable
+          };
+          if (fk.unique) sourceColumn.unique = true;
+          tableDef[column.name] = sourceColumn;
+          constraints[table.name] ??= {};
+          const tableConstraints = constraints[table.name];
+          tableConstraints.foreignKeys ??= [];
+          const foreignKeys = tableConstraints.foreignKeys;
+          foreignKeys.push(
+            ref(fk.target, {
+              schema: fk.schema,
+              columns: [column.name],
+              references: fk.refs,
+              ...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
+              ...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
+            })
+          );
+          continue;
+        }
+        const usesDefaultReferences = fk.refs.length === 1 && fk.refs[0] === "id";
         tableDef[column.name] = ref(fk.target, {
           nullable: fk.nullable,
-          unique: fk.unique
+          unique: fk.unique,
+          ...!usesDefaultReferences ? { references: fk.refs } : {},
+          ...fk.onDelete !== void 0 && fk.onDelete !== "NO ACTION" ? { onDelete: fk.onDelete } : {},
+          ...fk.onUpdate !== void 0 && fk.onUpdate !== "NO ACTION" ? { onUpdate: fk.onUpdate } : {}
         });
       } else {
         tableDef[column.name] = columnTypeToJsType(column.type);
       }
     }
+    for (const fk of compositeExternalFks) {
+      const externalSchema = fk.references.schema;
+      if (externalSchema === void 0) continue;
+      constraints[table.name] ??= {};
+      const tableConstraints = constraints[table.name];
+      tableConstraints.foreignKeys ??= [];
+      const foreignKeys = tableConstraints.foreignKeys;
+      foreignKeys.push(
+        ref(fk.references.table, {
+          schema: externalSchema,
+          columns: fk.columns,
+          references: fk.references.columns,
+          ...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
+          ...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {}
+        })
+      );
+    }
     definition[table.name] = tableDef;
   }
   const tableNames = Object.keys(definition);
+  const generatedConstraints = Object.keys(constraints).length > 0 ? constraints : void 0;
   const tables = createTablesProxy(
     model,
     tableNames
@@ -1380,6 +1488,9 @@ async function getSchemaFromDb(adapter, options) {
     tableNames,
     tables
   };
+  if (generatedConstraints !== void 0) {
+    result.constraints = generatedConstraints;
+  }
   if (adapter.dbCasing !== void 0) {
     result.dbCasing = adapter.dbCasing;
   }
@@ -1390,12 +1501,6 @@ async function getSchemaFromDb(adapter, options) {
 }
 
 // src/conventions.ts
-var DEFAULT_CONVENTIONS = {
-  fkPattern: "{singular}Id",
-  pluralize: true,
-  timestamps: ["createdAt", "updatedAt"],
-  fkAutoIndex: true
-};
 var IRREGULAR_PLURALS = {
   people: "person",
   children: "child",
@@ -1454,257 +1559,6 @@ function capitalize(name) {
 function decapitalize(name) {
   return name.charAt(0).toLowerCase() + name.slice(1);
 }
-function getSelfRefInverseName(belongsToName) {
-  if (belongsToName === "parent") return "children";
-  return pluralize(belongsToName);
-}
-function detectForeignKeys(tableName, table, conventions, tableNames) {
-  const fks = [];
-  const pattern = conventions.fkPattern;
-  for (const [colName, colDef] of Object.entries(table)) {
-    if (colDef.references) {
-      const targetTable = colDef.references.table;
-      if (tableNames.has(targetTable)) {
-        const inferredName = colName.endsWith("Id") ? colName.slice(0, -2) : singularize(targetTable);
-        const isSelfRef = targetTable === tableName;
-        const detectedFK = {
-          column: colName,
-          targetTable,
-          inferredName,
-          explicit: true,
-          targetColumn: colDef.references.column ?? "id"
-        };
-        if (isSelfRef) {
-          detectedFK.parentRole = colDef.references.parentRole ?? inferredName;
-          detectedFK.childRole = colDef.references.childRole ?? getSelfRefInverseName(inferredName);
-        }
-        fks.push(detectedFK);
-      }
-      continue;
-    }
-    for (const candidateTable of tableNames) {
-      if (candidateTable === tableName) continue;
-      const singular = singularize(candidateTable);
-      const expectedColumn = pattern.replace("{singular}", singular);
-      if (colName === expectedColumn) {
-        fks.push({
-          column: colName,
-          targetTable: candidateTable,
-          inferredName: singular,
-          explicit: false,
-          targetColumn: "id"
-        });
-        break;
-      }
-    }
-    if (colName.endsWith("Id")) {
-      const prefix = colName.slice(0, -2);
-      const singular = singularize(tableName);
-      if (["parent", "manager", "supervisor", "owner", singular].includes(prefix)) {
-        if (!fks.some((fk) => fk.column === colName)) {
-          fks.push({
-            column: colName,
-            targetTable: tableName,
-            inferredName: prefix,
-            explicit: false,
-            targetColumn: "id",
-            // Auto-infer roles for convention-based self-ref FKs
-            parentRole: prefix,
-            childRole: getSelfRefInverseName(prefix)
-          });
-        }
-      }
-    }
-  }
-  return fks;
-}
-function isBusinessColumn(colName, colDef, timestamps) {
-  if (colDef.primaryKey) return false;
-  if (timestamps.includes(colName)) return false;
-  if (colDef.references) return false;
-  if (colName.endsWith("Id")) return false;
-  if (["id", "createdBy", "updatedBy", "deletedAt"].includes(colName))
-    return false;
-  return true;
-}
-function detectManyToMany(tables, conventions, tableNames) {
-  const results = [];
-  for (const [tableName, table] of Object.entries(tables)) {
-    const fks = detectForeignKeys(tableName, table, conventions, tableNames);
-    if (fks.length !== 2) continue;
-    const hasBusinessColumns = Object.entries(table).some(
-      ([colName, colDef]) => isBusinessColumn(colName, colDef, conventions.timestamps)
-    );
-    if (hasBusinessColumns) continue;
-    const fkA = fks[0];
-    const fkB = fks[1];
-    if (fkA && fkB) {
-      results.push({
-        junction: tableName,
-        tableA: fkA.targetTable,
-        tableB: fkB.targetTable,
-        fkA: fkA.column,
-        fkB: fkB.column
-      });
-    }
-  }
-  return results;
-}
-function inferRelationsFromSchema(tables, conventions, explicitRelations = {}) {
-  const result = { ...explicitRelations };
-  const tableNames = new Set(Object.keys(tables));
-  const manyToManys = detectManyToMany(tables, conventions, tableNames);
-  const junctionTables = new Set(manyToManys.map((m) => m.junction));
-  for (const m2m of manyToManys) {
-    const { junction, tableA, tableB, fkA, fkB } = m2m;
-    const relNameAtoB = conventions.pluralize ? pluralize(singularize(tableB)) : tableB;
-    const relNameBtoA = conventions.pluralize ? pluralize(singularize(tableA)) : tableA;
-    const keyAtoB = `${tableA}.${relNameAtoB}`;
-    const keyBtoA = `${tableB}.${relNameBtoA}`;
-    if (!(keyAtoB in result)) {
-      const rel = {
-        kind: "manyToMany",
-        target: tableB,
-        through: junction,
-        sourceFk: fkA,
-        targetFk: fkB
-      };
-      result[keyAtoB] = rel;
-    }
-    if (!(keyBtoA in result)) {
-      const rel = {
-        kind: "manyToMany",
-        target: tableA,
-        through: junction,
-        sourceFk: fkB,
-        targetFk: fkA
-      };
-      result[keyBtoA] = rel;
-    }
-  }
-  for (const [tableName, table] of Object.entries(tables)) {
-    if (junctionTables.has(tableName)) continue;
-    const fks = detectForeignKeys(tableName, table, conventions, tableNames);
-    for (const fk of fks) {
-      if (junctionTables.has(fk.targetTable)) continue;
-      const belongsToKey = `${tableName}.${fk.inferredName}`;
-      if (!(belongsToKey in result)) {
-        const rel = {
-          kind: "belongsTo",
-          target: fk.targetTable,
-          foreignKey: fk.column,
-          targetKey: fk.targetColumn
-        };
-        result[belongsToKey] = rel;
-      }
-      const isSelfRef = fk.targetTable === tableName;
-      const hasManyName = isSelfRef ? getSelfRefInverseName(fk.inferredName) : (() => {
-        const hasCustomAlias = fk.inferredName !== singularize(fk.targetTable);
-        if (hasCustomAlias) {
-          return conventions.pluralize ? pluralize(fk.inferredName) : fk.inferredName;
-        }
-        return conventions.pluralize ? pluralize(singularize(tableName)) : tableName;
-      })();
-      const hasManyKey = `${fk.targetTable}.${hasManyName}`;
-      if (!(hasManyKey in result)) {
-        const rel = {
-          kind: "hasMany",
-          target: tableName,
-          foreignKey: fk.column,
-          sourceKey: "id"
-        };
-        result[hasManyKey] = rel;
-      }
-    }
-  }
-  return result;
-}
-
-// src/schema-dsl.ts
-function defineSchema(tables, config) {
-  const relations = config?.relations ?? {};
-  const hints = config?.hints ?? {};
-  const conventions = config?.conventions ?? {};
-  const indexes = config?.indexes ?? {};
-  const defaultFilters = config?.defaultFilters ?? {};
-  const resolvedConventions = {
-    ...DEFAULT_CONVENTIONS,
-    ...conventions
-  };
-  const allRelations = inferRelationsFromSchema(
-    tables,
-    resolvedConventions,
-    relations
-  );
-  validateRelations(tables, relations);
-  validateHints(allRelations, hints);
-  validateDefaultFilters(tables, defaultFilters);
-  return {
-    tables,
-    relations: allRelations,
-    hints,
-    conventions: resolvedConventions,
-    indexes,
-    defaultFilters
-  };
-}
-function validateRelations(tables, relations) {
-  const tableNames = new Set(Object.keys(tables));
-  for (const [key, rel] of Object.entries(relations)) {
-    const sourceTable = key.split(".")[0] ?? key;
-    if (!tableNames.has(sourceTable)) {
-      throw new SchemaValidationError2(
-        `Relation '${key}' references non-existent source table '${sourceTable}'`
-      );
-    }
-    if (!tableNames.has(rel.target)) {
-      throw new SchemaValidationError2(
-        `Relation '${key}' references non-existent target table '${rel.target}'`
-      );
-    }
-    if (rel.kind === "manyToMany" && !tableNames.has(rel.through)) {
-      throw new SchemaValidationError2(
-        `Relation '${key}' references non-existent junction table '${rel.through}'`
-      );
-    }
-  }
-}
-function validateHints(relations, hints) {
-  for (const path of Object.keys(hints)) {
-    if (!(path in relations)) {
-      throw new SchemaValidationError2(
-        `Hint path '${path}' does not match any relation. Available: ${Object.keys(relations).join(", ")}`
-      );
-    }
-  }
-}
-function validateDefaultFilters(tables, defaultFilters) {
-  const tableNames = new Set(Object.keys(tables));
-  for (const tableName of Object.keys(defaultFilters)) {
-    if (!tableNames.has(tableName)) {
-      throw new SchemaValidationError2(
-        `Default filter for non-existent table '${tableName}'. Available: ${[...tableNames].join(", ")}`
-      );
-    }
-  }
-}
-var SchemaValidationError2 = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SchemaValidationError";
-  }
-};
-
-// src/schema-dsl-types.ts
-function isBelongsTo(rel) {
-  return rel.kind === "belongsTo";
-}
-function isHasMany(rel) {
-  return rel.kind === "hasMany";
-}
-function isManyToMany(rel) {
-  return rel.kind === "manyToMany";
-}
 
 // src/planner.ts
 import { resolveJsonAggOrderKey, toColumnList } from "@dbsp/types";
@@ -6327,7 +6181,7 @@ function hydrateJsonAggIncludes(results, planReport) {
     if (typeof row !== "object" || row === null) {
       continue;
     }
-    const record2 = row;
+    const record = row;
     for (const [relationName, info] of relationInfo) {
       const candidates = [relationName];
       if (info.includeAlias && info.includeAlias !== relationName) {
@@ -6340,17 +6194,17 @@ function hydrateJsonAggIncludes(results, planReport) {
           /_([a-z])/g,
           (_, c) => c.toUpperCase()
         );
-        if (snakeJson in record2) {
+        if (snakeJson in record) {
           actualColumnName = snakeJson;
           break;
         }
-        if (camelJson in record2) {
+        if (camelJson in record) {
           actualColumnName = camelJson;
           break;
         }
       }
       if (actualColumnName) {
-        const jsonValue = record2[actualColumnName];
+        const jsonValue = record[actualColumnName];
         let parsed;
         if (typeof jsonValue === "string") {
           try {
@@ -6369,8 +6223,8 @@ function hydrateJsonAggIncludes(results, planReport) {
           parsed = parsed.length > 0 ? parsed[0] : null;
         }
         const outputKey = info.includeAlias ?? relationName;
-        record2[outputKey] = parsed;
-        delete record2[actualColumnName];
+        record[outputKey] = parsed;
+        delete record[actualColumnName];
       }
     }
   }
@@ -8299,12 +8153,12 @@ var ResultHydrator = class {
       if (typeof row !== "object" || row === null) {
         continue;
       }
-      const record2 = row;
+      const record = row;
       const valuesByPath = /* @__PURE__ */ new Map();
-      for (const key of Object.keys(record2)) {
+      for (const key of Object.keys(record)) {
         const info = findLongestJoinInfo(key, joinInfos);
         if (!info) continue;
-        const value = record2[key];
+        const value = record[key];
         let entry = valuesByPath.get(info.relationPath);
         if (!entry) {
           entry = { values: {}, allNull: true };
@@ -8316,13 +8170,13 @@ var ResultHydrator = class {
           value
         );
         if (value !== null && value !== void 0) entry.allNull = false;
-        delete record2[key];
+        delete record[key];
       }
       for (const info of infosByDepth) {
         const entry = valuesByPath.get(info.relationPath);
         if (!entry) continue;
         assignNestedValue(
-          record2,
+          record,
           info.segments,
           entry.allNull ? null : entry.values
         );
@@ -8552,10 +8406,10 @@ var ResultHydrator = class {
       return obj[columns[0]];
     }
     const values = columns.map((k) => obj[k]);
-    if (values.some((v2) => v2 === void 0 || v2 === null)) {
+    if (values.some((v) => v === void 0 || v === null)) {
       return void 0;
     }
-    const parts = values.map((v2) => String(v2));
+    const parts = values.map((v) => String(v));
     if (parts.some((p) => p.includes(COMPOSITE_KEY_SEP))) {
       return JSON.stringify(parts);
     }
@@ -8570,7 +8424,7 @@ var ResultHydrator = class {
       return obj[columns[0]];
     }
     const values = columns.map((k) => obj[k]);
-    return values.some((v2) => v2 === void 0 || v2 === null) ? void 0 : values;
+    return values.some((v) => v === void 0 || v === null) ? void 0 : values;
   }
 };
 
@@ -10283,7 +10137,7 @@ function generateCreateIndexSQL(tableName, schemaName, opts) {
     parts.push("NULLS NOT DISTINCT");
   }
   if (opts.with && Object.keys(opts.with).length > 0) {
-    const withClauses = Object.entries(opts.with).map(([k, v2]) => `${k} = ${v2}`).join(", ");
+    const withClauses = Object.entries(opts.with).map(([k, v]) => `${k} = ${v}`).join(", ");
     parts.push(`WITH (${withClauses})`);
   }
   if (opts.where) parts.push(`WHERE ${opts.where}`);
@@ -10329,16 +10183,13 @@ function buildIndexAPI(tableName, schemaName, adapter, requireAdapter2) {
           "indexes.list() requires an adapter."
         );
       }
-      if (adapter.listIndexes) {
-        return adapter.listIndexes(tableName, schemaName, options);
-      }
-      const sql2 = `SELECT indexname AS name, indexdef AS definition, (SELECT indisunique FROM pg_index WHERE indexrelid = (SELECT oid FROM pg_class WHERE relname = indexname)) AS unique, CASE WHEN indexdef LIKE '%USING %' THEN split_part(indexdef, 'USING ', 2) ELSE 'btree' END AS method FROM pg_indexes WHERE tablename = '${tableName.replace(/'/g, "''")}' ` + (schemaName ? `AND schemaname = '${schemaName.replace(/'/g, "''")}' ` : "") + `ORDER BY indexname`;
-      if ("executeRaw" in adapter && typeof adapter.executeRaw === "function") {
-        const rows = await adapter.executeRaw(sql2, []);
-        return rows;
+      if (!adapter.listIndexes) {
+        throw new InvalidOperationError(
+          "indexes.list",
+          "indexes.list() requires an adapter that implements listIndexes()."
+        );
       }
-      if (adapter.executeDDL) await adapter.executeDDL(sql2);
-      return [];
+      return adapter.listIndexes(tableName, schemaName, options);
     },
     async exists(name) {
       if (!adapter) {
@@ -10960,705 +10811,6 @@ function rangeContainedBy(fieldOrColumn, valueOrRange, rangeType = "daterange")
   };
 }
 
-// src/dx/schema-bridge.ts
-import { buildRelationKeyFields, toColumnList as toColumnList3 } from "@dbsp/types";
-import * as v from "valibot";
-function generatedTypeToColumnType(genType) {
-  switch (genType) {
-    case "string":
-    case "text":
-      return "string";
-    case "number":
-    case "decimal":
-      return "number";
-    case "integer":
-      return "integer";
-    case "bigint":
-      return "bigint";
-    case "boolean":
-      return "boolean";
-    case "date":
-      return "date";
-    case "timestamp":
-    case "datetime":
-      return "datetime";
-    case "json":
-      return "json";
-    case "jsonb":
-      return "jsonb";
-    case "time":
-      return "time";
-    case "uuid":
-      return "uuid";
-    case "daterange":
-      return "daterange";
-    case "tstzrange":
-      return "tstzrange";
-    case "int4range":
-      return "int4range";
-    case "tsrange":
-      return "tsrange";
-    case "int8range":
-      return "int8range";
-    case "numrange":
-      return "numrange";
-  }
-}
-function mapRelationType2(kind) {
-  switch (kind) {
-    case "belongsTo":
-      return "belongsTo";
-    case "hasMany":
-      return "hasMany";
-    case "manyToMany":
-      return "belongsToMany";
-  }
-}
-function sourceTableFromQualifiedName(qualifiedName) {
-  const dotIndex = qualifiedName.indexOf(".");
-  return dotIndex > 0 ? qualifiedName.slice(0, dotIndex) : qualifiedName;
-}
-function relationNameFromQualifiedName(qualifiedName) {
-  const dotIndex = qualifiedName.indexOf(".");
-  return dotIndex > 0 ? qualifiedName.slice(dotIndex + 1) : qualifiedName;
-}
-function columnListsEqual(left, right) {
-  const leftColumns = toColumnList3(left);
-  const rightColumns = toColumnList3(right);
-  return leftColumns.length === rightColumns.length && leftColumns.every((column, index) => column === rightColumns[index]);
-}
-function generatedReferencedColumns(key) {
-  const columns = toColumnList3(key);
-  return columns.length > 0 ? columns : ["id"];
-}
-function findRelationForeignKey(sourceTable, genRelation, tables) {
-  switch (genRelation.kind) {
-    case "belongsTo":
-      return tables.get(sourceTable)?.foreignKeys.find(
-        (fk) => fk.references.table === genRelation.target && columnListsEqual(fk.columns, genRelation.foreignKey)
-      );
-    case "hasMany":
-      return tables.get(genRelation.target)?.foreignKeys.find(
-        (fk) => fk.references.table === sourceTable && columnListsEqual(fk.columns, genRelation.foreignKey)
-      );
-    case "manyToMany":
-      return void 0;
-  }
-}
-function isGeneratedTableWithConfig(table) {
-  const columns = table.columns;
-  return typeof columns === "object" && columns !== null && typeof columns.type !== "string";
-}
-function buildTableIRFromDefinition(tableName, genTable, fkAutoIndex) {
-  const columns = [];
-  const foreignKeys = [];
-  const indexes = [];
-  const primaryKeys = [];
-  const tableColumns = isGeneratedTableWithConfig(genTable) ? genTable.columns : genTable;
-  const indexedColumns = /* @__PURE__ */ new Set();
-  for (const [colName, colDef] of Object.entries(tableColumns)) {
-    const col2 = {
-      name: colName,
-      type: generatedTypeToColumnType(colDef.type),
-      nullable: colDef.nullable ?? false,
-      default: colDef.default
-    };
-    if (colDef.unique !== void 0) {
-      col2.unique = colDef.unique;
-    }
-    if (colDef.autoIncrement !== void 0) {
-      col2.autoIncrement = colDef.autoIncrement;
-    }
-    columns.push(col2);
-    if (colDef.primaryKey) {
-      primaryKeys.push(colName);
-    }
-    if (colDef.references) {
-      const fk = {
-        columns: [colName],
-        references: {
-          table: colDef.references.table,
-          columns: [colDef.references.column ?? "id"]
-        }
-      };
-      if (colDef.references.onDelete) {
-        fk.onDelete = colDef.references.onDelete;
-      }
-      foreignKeys.push(fk);
-    }
-    if (colDef.index) {
-      const indexName = typeof colDef.index === "string" ? colDef.index : `idx_${tableName}_${colName}`;
-      indexes.push({
-        name: indexName,
-        columns: [colName],
-        unique: false
-      });
-      indexedColumns.add(colName);
-    }
-    if (fkAutoIndex && colDef.references && !colDef.index) {
-      indexes.push({
-        name: `idx_${tableName}_${colName}`,
-        columns: [colName],
-        unique: false
-      });
-      indexedColumns.add(colName);
-    }
-  }
-  const pseudoColumns = [];
-  for (const fk of foreignKeys) {
-    const fkColumn = fk.columns[0];
-    const targetColumn = fk.references.columns[0];
-    if (fk.references.table === tableName && fkColumn !== void 0 && targetColumn !== void 0) {
-      const colDef = tableColumns[fkColumn];
-      const inferredName = fkColumn.endsWith("Id") ? fkColumn.slice(0, -2) : "parent";
-      const parentRole = colDef?.references?.parentRole ?? inferredName;
-      const childRole = colDef?.references?.childRole ?? (parentRole === "parent" ? "children" : `${parentRole}s`);
-      pseudoColumns.push(
-        createPseudoColumnMetadata(
-          tableName,
-          fkColumn,
-          targetColumn,
-          parentRole,
-          childRole
-        )
-      );
-    }
-  }
-  let primaryKey;
-  const configuredPrimaryKey = isGeneratedTableWithConfig(genTable) ? genTable.primaryKey : void 0;
-  if (configuredPrimaryKey !== void 0) {
-    primaryKey = configuredPrimaryKey;
-  } else if (primaryKeys.length > 0) {
-    primaryKey = primaryKeys.length === 1 ? primaryKeys[0] : primaryKeys;
-  } else {
-    const fkColumns = foreignKeys.flatMap((fk) => fk.columns);
-    if (fkColumns.length > 0) {
-      primaryKey = fkColumns.length === 1 ? fkColumns[0] : fkColumns;
-    } else {
-      const hasId = columns.some((c) => c.name === "id");
-      primaryKey = hasId ? "id" : void 0;
-    }
-  }
-  if (isGeneratedTableWithConfig(genTable)) {
-    for (const fk of genTable.foreignKeys ?? []) {
-      const foreignKey = {
-        columns: [...fk.columns],
-        references: {
-          table: fk.references.table,
-          columns: [...fk.references.columns]
-        }
-      };
-      if (fk.onDelete) foreignKey.onDelete = fk.onDelete;
-      if (fk.onUpdate) foreignKey.onUpdate = fk.onUpdate;
-      foreignKeys.push(foreignKey);
-    }
-    for (const index of genTable.indexes ?? []) {
-      indexes.push({
-        columns: [...index.columns],
-        unique: index.unique ?? false,
-        ...index.name !== void 0 && { name: index.name }
-      });
-    }
-  }
-  const frozenColumns = Object.freeze(columns);
-  return Object.freeze({
-    name: tableName,
-    columns: frozenColumns,
-    ...primaryKey !== void 0 ? { primaryKey } : {},
-    foreignKeys: Object.freeze(foreignKeys),
-    indexes: Object.freeze(indexes),
-    ...pseudoColumns.length > 0 && {
-      pseudoColumns: Object.freeze(pseudoColumns)
-    }
-  });
-}
-function buildRelationIR(qualifiedName, genRelation, hints, relationFk) {
-  const sourceTable = sourceTableFromQualifiedName(qualifiedName);
-  const relationName = relationNameFromQualifiedName(qualifiedName);
-  const hint = hints[qualifiedName];
-  const relCardinality = genRelation.kind === "hasMany" ? genRelation.cardinality : void 0;
-  const cardinality = hint?.cardinality === "one" ? "one" : relCardinality === "one" ? "one" : genRelation.kind === "belongsTo" ? "one" : "many";
-  const optionality = genRelation.kind === "belongsTo" ? "optional" : "optional";
-  let relationType = mapRelationType2(genRelation.kind);
-  if (genRelation.kind === "hasMany" && cardinality === "one") {
-    relationType = "hasOne";
-  }
-  const baseRelation = {
-    name: relationName,
-    source: sourceTable,
-    target: genRelation.target,
-    type: relationType,
-    cardinality,
-    optionality,
-    includeStrategy: genRelation.includeStrategy ?? "auto",
-    filterStrategy: hint?.defaultStrategy ?? "auto",
-    joinDefault: "auto"
-  };
-  switch (genRelation.kind) {
-    case "belongsTo":
-      return {
-        ...baseRelation,
-        ...buildRelationKeyFields(
-          relationFk ?? {
-            columns: genRelation.foreignKey,
-            references: {
-              table: genRelation.target,
-              columns: generatedReferencedColumns(genRelation.targetKey)
-            }
-          },
-          "belongsTo",
-          {
-            foreignKeyShape: genRelation.foreignKey,
-            ...genRelation.targetKey !== void 0 ? { referencedKeyShape: genRelation.targetKey } : {}
-          }
-        )
-      };
-    case "hasMany":
-      return {
-        ...baseRelation,
-        ...buildRelationKeyFields(
-          relationFk ?? {
-            columns: genRelation.foreignKey,
-            references: {
-              table: sourceTable,
-              columns: generatedReferencedColumns(genRelation.sourceKey)
-            }
-          },
-          "inverse",
-          {
-            foreignKeyShape: genRelation.foreignKey,
-            ...genRelation.sourceKey !== void 0 ? { referencedKeyShape: genRelation.sourceKey } : {}
-          }
-        )
-      };
-    case "manyToMany":
-      return {
-        ...baseRelation,
-        through: genRelation.through,
-        foreignKey: genRelation.sourceFk,
-        otherKey: genRelation.targetFk
-      };
-  }
-}
-function buildModelFromSchema(schema2) {
-  const tables = /* @__PURE__ */ new Map();
-  const relations = /* @__PURE__ */ new Map();
-  const fkAutoIndex = schema2.conventions.fkAutoIndex;
-  for (const [tableName, genTable] of Object.entries(schema2.tables)) {
-    tables.set(
-      tableName,
-      buildTableIRFromDefinition(tableName, genTable, fkAutoIndex)
-    );
-  }
-  for (const [qualifiedName, genRelation] of Object.entries(schema2.relations)) {
-    const sourceTable = sourceTableFromQualifiedName(qualifiedName);
-    relations.set(
-      qualifiedName,
-      buildRelationIR(
-        qualifiedName,
-        genRelation,
-        schema2.hints,
-        findRelationForeignKey(sourceTable, genRelation, tables)
-      )
-    );
-  }
-  return new ModelIRImpl(tables, relations);
-}
-function buildModelFromResolvedSchema(schema2) {
-  const generatedSchema = assertResolvedSchemaToGeneratedSchema(schema2);
-  return buildModelFromSchema(generatedSchema);
-}
-function isGeneratedSchema(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const obj = value;
-  return typeof obj.tables === "object" && obj.tables !== null && typeof obj.relations === "object" && obj.relations !== null && typeof obj.hints === "object" && obj.hints !== null && typeof obj.conventions === "object" && obj.conventions !== null;
-}
-var RESOLVED_SCHEMA_ONLY_TYPES = /* @__PURE__ */ new Set(["time", "jsonb"]);
-var GENERATED_SCHEMA_ONLY_TYPES = /* @__PURE__ */ new Set(["number", "datetime"]);
-function hasResolvedSchemaOnlyTypes(tables) {
-  for (const table of Object.values(tables)) {
-    for (const column of Object.values(table)) {
-      if (column?.type && RESOLVED_SCHEMA_ONLY_TYPES.has(column.type)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function hasGeneratedSchemaOnlyTypes(tables) {
-  for (const table of Object.values(tables)) {
-    for (const column of Object.values(table)) {
-      if (column?.type && GENERATED_SCHEMA_ONLY_TYPES.has(column.type)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function isResolvedSchema(value) {
-  if (!isGeneratedSchema(value)) {
-    return false;
-  }
-  if (hasResolvedSchemaOnlyTypes(
-    value.tables
-  )) {
-    return true;
-  }
-  if (hasGeneratedSchemaOnlyTypes(
-    value.tables
-  )) {
-    return false;
-  }
-  return false;
-}
-function normalizeSchema(input) {
-  if (!isGeneratedSchema(input)) {
-    throw new Error(
-      "Invalid schema: must have tables, relations, hints, and conventions properties"
-    );
-  }
-  if (isResolvedSchema(input)) {
-    const result = resolvedSchemaToGeneratedSchema(input);
-    if (!result.success) {
-      const messages = result.errors.map((e) => e.message).join(", ");
-      throw new Error(`Schema conversion failed: ${messages}`);
-    }
-    return result.schema;
-  }
-  return input;
-}
-var SchemaColumnTypeSchema = v.picklist([
-  "uuid",
-  "string",
-  "text",
-  "integer",
-  "bigint",
-  "decimal",
-  "boolean",
-  "timestamp",
-  "date",
-  "time",
-  "json",
-  "jsonb",
-  "daterange",
-  "tstzrange",
-  "int4range",
-  "tsrange",
-  "int8range",
-  "numrange"
-]);
-var PROTO_POLLUTION_KEYS = ["__proto__", "constructor", "prototype"];
-function safeRecord(valueSchema) {
-  return v.pipe(
-    v.unknown(),
-    v.check((input) => {
-      if (typeof input !== "object" || input === null) return true;
-      return !Object.keys(input).some(
-        (k) => PROTO_POLLUTION_KEYS.includes(k)
-      );
-    }, "Schema keys must not include prototype-pollution names (__proto__, constructor, prototype)"),
-    v.record(v.string(), valueSchema)
-  );
-}
-var ForeignKeyReferenceSchema = v.object({
-  table: v.string(),
-  column: v.optional(v.string()),
-  onDelete: v.optional(
-    v.picklist(["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"])
-  ),
-  index: v.optional(v.boolean()),
-  parentRole: v.optional(v.string()),
-  childRole: v.optional(v.string())
-});
-var StringOrStringArraySchema = v.union([v.string(), v.array(v.string())]);
-var ColumnDefinitionSchema = v.object({
-  type: SchemaColumnTypeSchema,
-  primaryKey: v.optional(v.boolean()),
-  nullable: v.optional(v.boolean()),
-  unique: v.optional(v.boolean()),
-  autoIncrement: v.optional(v.boolean()),
-  default: v.optional(v.union([v.string(), v.number(), v.boolean()])),
-  references: v.optional(ForeignKeyReferenceSchema),
-  index: v.optional(v.union([v.boolean(), v.string()]))
-});
-var FlatTableDefinitionSchema = safeRecord(ColumnDefinitionSchema);
-var TableDefWithConfigSchema = v.object({
-  columns: FlatTableDefinitionSchema,
-  primaryKey: v.optional(StringOrStringArraySchema),
-  foreignKeys: v.optional(
-    v.array(
-      v.object({
-        columns: v.array(v.string()),
-        references: v.object({
-          table: v.string(),
-          columns: v.array(v.string())
-        }),
-        onDelete: v.optional(
-          v.picklist(["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"])
-        ),
-        onUpdate: v.optional(
-          v.picklist(["CASCADE", "SET NULL", "RESTRICT", "NO ACTION"])
-        )
-      })
-    )
-  ),
-  indexes: v.optional(
-    v.array(
-      v.object({
-        columns: v.array(v.string()),
-        unique: v.optional(v.boolean()),
-        name: v.optional(v.string())
-      })
-    )
-  )
-});
-var TableDefinitionSchema = v.union([
-  TableDefWithConfigSchema,
-  FlatTableDefinitionSchema
-]);
-var TablesDefinitionSchema = safeRecord(TableDefinitionSchema);
-var IncludeStrategySchema = v.optional(
-  v.picklist(["join", "subquery", "cte", "lateral", "json_agg", "auto"])
-);
-var BelongsToRelationSchema = v.object({
-  kind: v.literal("belongsTo"),
-  target: v.string(),
-  foreignKey: StringOrStringArraySchema,
-  targetKey: v.optional(StringOrStringArraySchema),
-  includeStrategy: IncludeStrategySchema
-});
-var HasManyRelationSchema = v.object({
-  kind: v.literal("hasMany"),
-  target: v.string(),
-  foreignKey: StringOrStringArraySchema,
-  sourceKey: v.optional(StringOrStringArraySchema),
-  includeStrategy: IncludeStrategySchema
-});
-var ManyToManyRelationSchema = v.object({
-  kind: v.literal("manyToMany"),
-  target: v.string(),
-  through: v.string(),
-  sourceFk: v.string(),
-  targetFk: v.string(),
-  includeStrategy: IncludeStrategySchema
-});
-var RelationDefinitionSchema = v.variant("kind", [
-  BelongsToRelationSchema,
-  HasManyRelationSchema,
-  ManyToManyRelationSchema
-]);
-var RelationsDefinitionSchema = safeRecord(RelationDefinitionSchema);
-var HintDefinitionSchema = v.object({
-  defaultStrategy: v.optional(v.picklist(["exists", "join"])),
-  cardinality: v.optional(v.picklist(["one", "many"]))
-});
-var HintsDefinitionSchema = safeRecord(HintDefinitionSchema);
-var ConventionsDefinitionSchema = v.object({
-  fkPattern: v.string(),
-  pluralize: v.boolean(),
-  timestamps: v.array(v.string()),
-  fkAutoIndex: v.boolean()
-});
-var IndexDefinitionSchema = v.object({
-  columns: v.array(v.string()),
-  unique: v.optional(v.boolean()),
-  name: v.optional(v.string())
-});
-var IndexesDefinitionSchema = safeRecord(v.array(IndexDefinitionSchema));
-var ResolvedSchemaValidation = v.object({
-  tables: TablesDefinitionSchema,
-  relations: RelationsDefinitionSchema,
-  hints: HintsDefinitionSchema,
-  conventions: ConventionsDefinitionSchema,
-  indexes: v.optional(IndexesDefinitionSchema)
-});
-function mapSchemaColumnType(schemaType) {
-  switch (schemaType) {
-    case "uuid":
-      return "uuid";
-    case "string":
-      return "string";
-    case "text":
-      return "text";
-    case "integer":
-      return "integer";
-    case "bigint":
-      return "bigint";
-    case "decimal":
-      return "decimal";
-    case "boolean":
-      return "boolean";
-    case "timestamp":
-      return "timestamp";
-    case "date":
-      return "date";
-    case "time":
-      return "time";
-    case "json":
-      return "json";
-    case "jsonb":
-      return "jsonb";
-    case "daterange":
-      return "daterange";
-    case "tstzrange":
-      return "tstzrange";
-    case "int4range":
-      return "int4range";
-    case "tsrange":
-      return "tsrange";
-    case "int8range":
-      return "int8range";
-    case "numrange":
-      return "numrange";
-  }
-}
-function convertColumn(col2) {
-  const result = {
-    type: mapSchemaColumnType(col2.type)
-  };
-  if (col2.primaryKey !== void 0) {
-    result.primaryKey = col2.primaryKey;
-  }
-  if (col2.nullable !== void 0) {
-    result.nullable = col2.nullable;
-  }
-  if (col2.unique !== void 0) {
-    result.unique = col2.unique;
-  }
-  if (col2.autoIncrement !== void 0) {
-    result.autoIncrement = col2.autoIncrement;
-  }
-  if (col2.default !== void 0) {
-    result.default = col2.default;
-  }
-  if (col2.references) {
-    result.references = {
-      table: col2.references.table,
-      ...col2.references.column !== void 0 ? { column: col2.references.column } : {},
-      ...col2.references.onDelete ? { onDelete: col2.references.onDelete } : {},
-      ...col2.references.index !== void 0 ? { index: col2.references.index } : {},
-      ...col2.references.parentRole ? { parentRole: col2.references.parentRole } : {},
-      ...col2.references.childRole ? { childRole: col2.references.childRole } : {}
-    };
-  }
-  return result;
-}
-function convertRelation(rel) {
-  switch (rel.kind) {
-    case "belongsTo": {
-      const result = {
-        kind: "belongsTo",
-        target: rel.target,
-        foreignKey: rel.foreignKey
-      };
-      if (rel.targetKey !== void 0) {
-        result.targetKey = rel.targetKey;
-      }
-      if (rel.includeStrategy !== void 0) {
-        result.includeStrategy = rel.includeStrategy;
-      }
-      return result;
-    }
-    case "hasMany": {
-      const result = {
-        kind: "hasMany",
-        target: rel.target,
-        foreignKey: rel.foreignKey
-      };
-      if (rel.sourceKey !== void 0) {
-        result.sourceKey = rel.sourceKey;
-      }
-      if (rel.includeStrategy !== void 0) {
-        result.includeStrategy = rel.includeStrategy;
-      }
-      return result;
-    }
-    case "manyToMany": {
-      const result = {
-        kind: "manyToMany",
-        target: rel.target,
-        through: rel.through,
-        sourceFk: rel.sourceFk,
-        targetFk: rel.targetFk
-      };
-      if (rel.includeStrategy !== void 0) {
-        result.includeStrategy = rel.includeStrategy;
-      }
-      return result;
-    }
-  }
-}
-function convertHint(hint) {
-  const result = {};
-  if (hint.defaultStrategy !== void 0) {
-    result.defaultStrategy = hint.defaultStrategy;
-  }
-  if (hint.cardinality !== void 0) {
-    result.cardinality = hint.cardinality;
-  }
-  return result;
-}
-function resolvedSchemaToGeneratedSchema(input) {
-  const parseResult = v.safeParse(ResolvedSchemaValidation, input);
-  if (!parseResult.success) {
-    return {
-      success: false,
-      errors: parseResult.issues
-    };
-  }
-  const validated = parseResult.output;
-  const tables = /* @__PURE__ */ Object.create(null);
-  for (const [tableName, tableDef] of Object.entries(validated.tables)) {
-    const convertedTable = /* @__PURE__ */ Object.create(null);
-    const tableObj = tableDef;
-    const isWithConfig = Array.isArray(tableObj.primaryKey);
-    const columns = isWithConfig ? tableObj.columns : tableObj;
-    for (const [colName, colDef] of Object.entries(columns)) {
-      convertedTable[colName] = convertColumn(
-        colDef
-      );
-    }
-    tables[tableName] = convertedTable;
-  }
-  const relations = /* @__PURE__ */ Object.create(null);
-  for (const [relName, relDef] of Object.entries(validated.relations)) {
-    relations[relName] = convertRelation(relDef);
-  }
-  const hints = /* @__PURE__ */ Object.create(null);
-  for (const [hintName, hintDef] of Object.entries(validated.hints)) {
-    hints[hintName] = convertHint(hintDef);
-  }
-  const conventions = {
-    fkPattern: validated.conventions.fkPattern,
-    pluralize: validated.conventions.pluralize,
-    timestamps: validated.conventions.timestamps,
-    fkAutoIndex: validated.conventions.fkAutoIndex
-  };
-  return {
-    success: true,
-    schema: {
-      tables,
-      relations,
-      hints,
-      conventions
-    }
-  };
-}
-function assertResolvedSchemaToGeneratedSchema(input) {
-  const result = resolvedSchemaToGeneratedSchema(input);
-  if (!result.success) {
-    const messages = result.errors.map((e) => {
-      const path = e.path?.map((p) => p.key).join(".") || "root";
-      return `[${path}] ${e.message} (expected: ${e.expected}, received: ${e.received})`;
-    }).join("\n");
-    throw new Error(`Schema validation failed:
-${messages}`);
-  }
-  return result.schema;
-}
-
 // src/dialects/index.ts
 var POSTGRESQL_CAPABILITIES = {
   name: "postgresql",
@@ -13039,7 +12191,6 @@ export {
   ColumnNotFoundError,
   CteBuilder,
   CteQueryBuilder,
-  DEFAULT_CONVENTIONS,
   DEFAULT_FEATURE_CHECKERS,
   DUCKDB_CAPABILITIES,
   DeleteBuilder,
@@ -13062,12 +12213,11 @@ export {
   RawCteQueryBuilder,
   RecursiveShapeMismatchError,
   RelationNotFoundError,
-  ResolvedSchemaValidation,
   ResultHydrator,
   SQLITE_CAPABILITIES,
   SQL_RAW_MARKER,
   SchemaValidationError as SchemaError,
-  SchemaValidationError2 as SchemaValidationError,
+  SchemaValidationError,
   SubqueryBuilder,
   SubqueryExpression,
   TABLE_META,
@@ -13106,7 +12256,6 @@ export {
   assertParamsLength,
   assertParamsType,
   assertParamsValue,
-  assertResolvedSchemaToGeneratedSchema,
   assertSQLColumn,
   assertSQLEquals,
   assertSQLJoin,
@@ -13114,8 +12263,6 @@ export {
   assertSuccess,
   assertTypeSupported,
   batchValues,
-  buildModelFromResolvedSchema,
-  buildModelFromSchema,
   capitalize,
   caseWhen,
   cast,
@@ -13137,11 +12284,8 @@ export {
   decapitalize,
   defaultLogger,
   defineModel,
-  defineSchema,
   denseRank,
   deriveRelationPathFromIntentPath,
-  detectForeignKeys,
-  detectManyToMany,
   distinct,
   emitWarning,
   eq,
@@ -13164,13 +12308,11 @@ export {
   inArray,
   inSubquery,
   inferForeignKey,
-  inferRelationsFromSchema,
   export_isAdjacencyTraversal as isAdjacencyTraversal,
   export_isAggregateWindowFunction as isAggregateWindowFunction,
   isAliasedColumn,
   isAllColumns,
   isBatchValuesRef,
-  isBelongsTo,
   isCardinalityShorthand,
   export_isCoalesceExpression as isCoalesceExpression,
   export_isColumnAliasExpression as isColumnAliasExpression,
@@ -13181,11 +12323,8 @@ export {
   isDistinctFrom,
   export_isEdgeTableTraversal as isEdgeTableTraversal,
   isExpressionSpec,
-  isGeneratedSchema,
-  isHasMany,
   export_isInsertIntent as isInsertIntent,
   isKnownDialect,
-  isManyToMany,
   export_isMutationIntent as isMutationIntent,
   isNotNull,
   isNull,
@@ -13200,7 +12339,6 @@ export {
   isRelationObjectDef,
   isRelationRef,
   isRelationTupleDef,
-  isResolvedSchema,
   export_isSelectAggregate as isSelectAggregate,
   export_isSelectAll as isSelectAll,
   export_isSelectFields as isSelectFields,
@@ -13240,7 +12378,6 @@ export {
   neq,
   none,
   normalizeSQL,
-  normalizeSchema,
   not,
   notExists,
   nqlRaw,
@@ -13273,7 +12410,6 @@ export {
   requiresDatabase,
   resetLogger,
   resolveQueryIndex,
-  resolvedSchemaToGeneratedSchema,
   rowNumber,
   runAssertions,
   schema,
@@ -13298,6 +12434,7 @@ export {
   validateAssertionBlocks,
   validateRecursiveInclude,
   validateRecursiveShape,
+  validateSchemaIndexOptions,
   validateTypeName,
   wAvg,
   wCount,