neoorm 0.8.0 → 0.8.2

package/dist/codegen/schema-to-manifest.js

@@ -1,19 +1,22 @@
-import { isSqliteProvider, } from "../datasource-provider.js";
+import { isMariadbProvider, isMysqlFamilyProvider, isSqliteProvider, } from "../datasource-provider.js";
+import { MYSQL_UNSUPPORTED_COLUMN_KINDS, mysqlUnsupportedColumnKindMessage, SQLITE_UNSUPPORTED_COLUMN_KINDS, sqliteUnsupportedColumnKindMessage, } from "../dialect/column-kind-support.js";
 import { parseFkTarget } from "../dialect/fk.js";
 import { resolveIndexSqlName } from "../dialect/postgres.js";
 import { collectExtensionsForKinds, getColumnType, getPluginRegistry, } from "../plugins/registry.js";
 import { schemaError } from "../runtime/error-builders.js";
 import { formatCandidateList, listColumnTsNames, listTableAccessors, suggestSchemaColumn, suggestSchemaTableAccessor, } from "../runtime/error-hints.js";
 import { resolveFkTargetSqlColumn } from "../runtime/query/primary-key.js";
+import { compileColumnCheckConstraints, quoteSqlColumn, } from "../schema/column-constraints.js";
 import { fk, resolveFkAccessorTarget, } from "../schema/relation.js";
-import { findPrimaryKeyColumn, } from "../schema/table.js";
+import { findPrimaryKeyColumn, isIndexExpr, } from "../schema/table.js";
 import { resolveSqlColumnName } from "../utils/case.js";
 import { singularize } from "../utils/inflect.js";
-function buildEnumCheckExpression(sqlName, values) {
+const POSTGIS_COLUMN_KINDS = new Set(["geometry", "geography", "point"]);
+function buildEnumCheckExpression(sqlName, values, provider) {
     const quoted = values
         .map((value) => `'${value.replace(/'/g, "''")}'`)
         .join(", ");
-    return `"${sqlName.replace(/"/g, '""')}" IN (${quoted})`;
+    return `${quoteSqlColumn(sqlName, provider)} IN (${quoted})`;
 }
 function resolveEnumTypeName(tableSqlName, columnSqlName, explicitName) {
     return explicitName ?? `${tableSqlName}_${columnSqlName}`;
@@ -28,7 +31,7 @@ function requireColumnDef(columns, tsName, tableAccessor) {
 function inferFkAs(tsName) {
     return tsName.replace(/_(Id|id)$/, "").replace(/Id$/, "");
 }
-function pluralize(word) {
+function _pluralize(word) {
     if (/(s|x|z|ch|sh)$/.test(word)) {
         return `${word}es`;
     }
@@ -40,11 +43,11 @@ function pluralize(word) {
 function autoJunctionName(leftSql, rightSql) {
     return [leftSql, rightSql].sort().join("_");
 }
-function finalizeEnumColumns(manifestTables, enumMode) {
+function finalizeEnumColumns(manifestTables, enumMode, provider) {
     const enumTypes = {};
     for (const table of Object.values(manifestTables)) {
         for (const col of table.columns) {
-            if (col.kind !== "enum") {
+            if (col.kind !== "enum" && col.kind !== "enumArray") {
                 continue;
             }
             const values = col.typeOptions?.values;
@@ -52,7 +55,10 @@ function finalizeEnumColumns(manifestTables, enumMode) {
                 continue;
             }
             if (enumMode === "check") {
-                const enumCheck = buildEnumCheckExpression(col.sqlName, values);
+                if (col.kind === "enumArray") {
+                    continue;
+                }
+                const enumCheck = buildEnumCheckExpression(col.sqlName, values, provider);
                 col.checkExpression = col.checkExpression
                     ? `(${col.checkExpression}) AND (${enumCheck})`
                     : enumCheck;
@@ -92,7 +98,7 @@ function resolveSqlName(tsName, col, columnNaming) {
     const mapName = "_meta" in col ? col._meta.mapName : undefined;
     return resolveSqlColumnName(tsName, columnNaming, mapName);
 }
-function resolveFkTargetSql(col, tables, defaultColumnNaming, sourceColumnNaming) {
+function resolveFkTargetSql(col, tables, defaultColumnNaming, _sourceColumnNaming) {
     const { accessor, column } = resolveFkAccessorTarget(col._meta, tables);
     const targetTable = tables[accessor];
     if (!targetTable) {
@@ -117,12 +123,14 @@ function compileIndexWhere(where, columns, columnNaming, provider) {
     for (const [tsName, value] of Object.entries(where)) {
         const col = requireColumnDef(columns, tsName);
         const sqlName = resolveSqlName(tsName, col, columnNaming);
-        const quoted = `"${sqlName.replace(/"/g, '""')}"`;
+        const quoted = isMysqlFamilyProvider(provider)
+            ? `\`${sqlName.replace(/`/g, "``")}\``
+            : `"${sqlName.replace(/"/g, '""')}"`;
         if (value === null) {
             parts.push(`${quoted} IS NULL`);
         }
         else if (typeof value === "boolean") {
-            parts.push(isSqliteProvider(provider)
+            parts.push(isSqliteProvider(provider) || isMysqlFamilyProvider(provider)
                 ? `${quoted} = ${value ? 1 : 0}`
                 : `${quoted} = ${value}`);
         }
@@ -135,7 +143,7 @@ function compileIndexWhere(where, columns, columnNaming, provider) {
     }
     return parts.join(" AND ");
 }
-function columnToManifest(tsName, col, columnNaming, tables, defaultColumnNaming) {
+function columnToManifest(tsName, col, columnNaming, tables, defaultColumnNaming, provider) {
     if (isFkBuilder(col)) {
         const meta = col._meta;
         const fkTarget = resolveFkTargetSql(col, tables, defaultColumnNaming, columnNaming);
@@ -162,6 +170,15 @@ function columnToManifest(tsName, col, columnNaming, tables, defaultColumnNaming
         if (meta.onDelete !== undefined) {
             result.onDelete = meta.onDelete;
         }
+        if (meta.onUpdate !== undefined) {
+            result.onUpdate = meta.onUpdate;
+        }
+        if (meta.deferrable !== undefined) {
+            if (isMysqlFamilyProvider(provider)) {
+                throw schemaError("invalid_column", `${isMariadbProvider(provider) ? "MariaDB" : "MySQL"} does not support deferrable foreign keys`);
+            }
+            result.deferrable = meta.deferrable;
+        }
         if (meta.hidden === true) {
             result.hidden = true;
         }
@@ -177,6 +194,18 @@ function columnToManifest(tsName, col, columnNaming, tables, defaultColumnNaming
     if ("updatedAt" in meta && meta.updatedAt === true) {
         validateUpdatedAtColumn(tsName, meta.kind);
     }
+    if (isMysqlFamilyProvider(provider) &&
+        POSTGIS_COLUMN_KINDS.has(meta.kind)) {
+        throw schemaError("invalid_column", `PostGIS column kind "${meta.kind}" is not supported on ${isMariadbProvider(provider) ? "MariaDB" : "MySQL"}`);
+    }
+    if (isMysqlFamilyProvider(provider) &&
+        MYSQL_UNSUPPORTED_COLUMN_KINDS.has(meta.kind)) {
+        throw schemaError("invalid_column", mysqlUnsupportedColumnKindMessage(meta.kind, isMariadbProvider(provider) ? "MariaDB" : "MySQL"));
+    }
+    if (isSqliteProvider(provider) &&
+        SQLITE_UNSUPPORTED_COLUMN_KINDS.has(meta.kind)) {
+        throw schemaError("invalid_column", sqliteUnsupportedColumnKindMessage(meta.kind));
+    }
     const result = {
         tsName,
         sqlName: resolveSqlName(tsName, col, columnNaming),
@@ -204,28 +233,130 @@ function columnToManifest(tsName, col, columnNaming, tables, defaultColumnNaming
     if (meta.hidden === true) {
         result.hidden = true;
     }
-    if (meta.checkExpression) {
-        result.checkExpression = meta.checkExpression;
+    const compiledCheck = compileColumnCheckConstraints(result, meta, provider);
+    if (compiledCheck !== undefined) {
+        result.checkExpression = compiledCheck;
     }
+    copyStructuredConstraints(result, meta);
     return result;
 }
+function jsonSafeConstraint(value) {
+    return typeof value === "bigint" ? value.toString() : value;
+}
+function copyStructuredConstraints(result, meta) {
+    if (meta.checkMin !== undefined) {
+        result.checkMin = jsonSafeConstraint(meta.checkMin);
+    }
+    if (meta.checkMax !== undefined) {
+        result.checkMax = jsonSafeConstraint(meta.checkMax);
+    }
+    if (meta.checkPositive === true) {
+        result.checkPositive = true;
+    }
+    if (meta.checkMinLength !== undefined) {
+        result.checkMinLength = meta.checkMinLength;
+    }
+    if (meta.checkMaxLength !== undefined) {
+        result.checkMaxLength = meta.checkMaxLength;
+    }
+    if (meta.checkNotEmpty === true) {
+        result.checkNotEmpty = true;
+    }
+    if (meta.checkEmail === true) {
+        result.checkEmail = true;
+    }
+    if (meta.checkUrl === true) {
+        result.checkUrl = true;
+    }
+    if (meta.validation !== undefined) {
+        result.validation = meta.validation;
+    }
+}
+function extraIndexUsing(extra) {
+    if (extra.kind !== "index")
+        return undefined;
+    if ("using" in extra && typeof extra.using === "string") {
+        return extra.using;
+    }
+    if ("_using" in extra && typeof extra._using === "string") {
+        return extra._using;
+    }
+    return undefined;
+}
+function extraIndexOpclass(extra) {
+    if (extra.kind !== "index")
+        return undefined;
+    if ("opclass" in extra && typeof extra.opclass === "string") {
+        return extra.opclass;
+    }
+    if ("_opclass" in extra && typeof extra._opclass === "string") {
+        return extra._opclass;
+    }
+    return undefined;
+}
+function extraIndexKeys(extra) {
+    if (extra.kind !== "index")
+        return [];
+    if ("keys" in extra && extra.keys)
+        return extra.keys;
+    return extra.columns;
+}
+function sanitizeIndexNamePart(sql) {
+    const token = sql
+        .replace(/[^A-Za-z0-9]+/g, "_")
+        .replace(/^_|_$/g, "")
+        .slice(0, 40);
+    return token.length > 0 ? token : "expr";
+}
+const NON_UNIQUE_INDEX_METHODS = new Set(["gin", "gist", "brin"]);
 function extrasToManifest(extras, columns, tableSqlName, columnNaming, provider) {
     const indexes = [];
     let primaryKey = [];
+    const compositeFks = [];
     for (const extra of extras) {
         if (extra.kind === "index") {
+            const using = extraIndexUsing(extra);
+            const opclass = extraIndexOpclass(extra);
+            if (extra.unique && using && NON_UNIQUE_INDEX_METHODS.has(using)) {
+                throw schemaError("invalid_column", `UNIQUE indexes cannot use ${using}`);
+            }
+            if (using && using !== "btree") {
+                if (isSqliteProvider(provider)) {
+                    throw schemaError("invalid_column", `SQLite does not support ${using} indexes`);
+                }
+                if (isMysqlFamilyProvider(provider) && using !== "hash") {
+                    throw schemaError("invalid_column", `${isMariadbProvider(provider) ? "MariaDB" : "MySQL"} does not support ${using} indexes`);
+                }
+            }
             const wherePredicate = "where" in extra &&
                 extra.where !== undefined &&
                 typeof extra.where !== "function"
                 ? extra.where
                 : undefined;
-            const sqlColumns = extra.columns.map((tsName) => resolveSqlName(tsName, requireColumnDef(columns, tsName), columnNaming));
+            const keys = extraIndexKeys(extra).map((key) => {
+                if (isIndexExpr(key)) {
+                    return { expr: key.sql };
+                }
+                return {
+                    sqlName: resolveSqlName(key, requireColumnDef(columns, key), columnNaming),
+                };
+            });
+            const sqlColumns = keys
+                .map((key) => key.sqlName)
+                .filter((name) => name !== undefined);
+            const nameParts = keys.map((key) => key.sqlName ?? sanitizeIndexNamePart(key.expr ?? "expr"));
             const index = {
-                name: sqlColumns.join("_"),
+                name: nameParts.join("_") || "expr",
                 columns: sqlColumns,
                 unique: extra.unique,
+                keys,
+                ...(using && using !== "btree" ? { using } : {}),
+                ...(opclass ? { opclass } : {}),
             };
             if (wherePredicate) {
+                if (isMysqlFamilyProvider(provider)) {
+                    throw schemaError("invalid_column", `${isMariadbProvider(provider) ? "MariaDB" : "MySQL"} does not support partial indexes (index({ where }))`);
+                }
                 index.whereSql = compileIndexWhere(wherePredicate, columns, columnNaming, provider);
             }
             index.sqlName = resolveIndexSqlName(tableSqlName, index);
@@ -234,8 +365,89 @@ function extrasToManifest(extras, columns, tableSqlName, columnNaming, provider)
         else if (extra.kind === "primaryKey") {
             primaryKey = extra.columns.map((tsName) => resolveSqlName(tsName, requireColumnDef(columns, tsName), columnNaming));
         }
+        else if (extra.kind === "foreignKey") {
+            compositeFks.push(extra);
+        }
+    }
+    return { indexes, primaryKey, compositeFks };
+}
+function rejectMysqlDeferrable(provider, deferrable) {
+    if (!deferrable)
+        return;
+    if (isMysqlFamilyProvider(provider)) {
+        throw schemaError("invalid_column", `${isMariadbProvider(provider) ? "MariaDB" : "MySQL"} does not support deferrable foreign keys`);
+    }
+}
+function resolveCompositeForeignKeys(args) {
+    const result = [];
+    for (const extra of args.extras) {
+        if (!extra._as) {
+            throw schemaError("invalid_column", `foreignKey() on "${args.accessor}" requires .as("relationName")`);
+        }
+        if (!extra._inverse) {
+            throw schemaError("invalid_column", `foreignKey() on "${args.accessor}" requires .inverse("relationName")`);
+        }
+        if (!extra.targetTable) {
+            throw schemaError("invalid_column", `foreignKey() on "${args.accessor}" requires .references("table", ...)`);
+        }
+        if (extra.columns.length < 2) {
+            throw schemaError("invalid_column", `foreignKey() on "${args.accessor}" needs at least two local columns (use fk() for a single-column relation)`);
+        }
+        if (extra.columns.length !== extra.targetColumns.length) {
+            throw schemaError("invalid_column", `foreignKey() on "${args.accessor}" local and referenced column counts must match`);
+        }
+        rejectMysqlDeferrable(args.provider, extra._deferrable);
+        const targetDef = args.schemaTables[extra.targetTable];
+        if (!targetDef) {
+            throw schemaError("unknown_fk_target", `foreignKey() on "${args.accessor}" references unknown table accessor "${extra.targetTable}"`, { tableAccessor: args.accessor }, suggestSchemaTableAccessor(extra.targetTable, args.schemaTables));
+        }
+        const localSql = [];
+        for (const tsName of extra.columns) {
+            const def = requireColumnDef(args.localDefs, tsName, args.accessor);
+            if (isFkBuilder(def)) {
+                throw schemaError("invalid_column", `foreignKey() column "${tsName}" on "${args.accessor}" must not also be fk()`);
+            }
+            localSql.push(resolveSqlName(tsName, def, args.columnNaming));
+        }
+        const targetNaming = targetDef._columnNaming ?? args.columnNaming;
+        const targetSql = [];
+        for (const tsName of extra.targetColumns) {
+            const def = requireColumnDef(targetDef._columns, tsName, extra.targetTable);
+            targetSql.push(resolveSqlName(tsName, def, targetNaming));
+        }
+        const fk = {
+            name: extra.constraintName ??
+                `${args.tableSqlName}_${localSql.join("_")}_fkey`,
+            columns: localSql,
+            targetTable: targetDef._tableName,
+            targetColumns: targetSql,
+        };
+        if (extra._onDelete !== undefined)
+            fk.onDelete = extra._onDelete;
+        if (extra._onUpdate !== undefined)
+            fk.onUpdate = extra._onUpdate;
+        if (extra._deferrable !== undefined)
+            fk.deferrable = extra._deferrable;
+        result.push(fk);
     }
-    return { indexes, primaryKey };
+    return result;
+}
+function columnSetIsUnique(table, sqlNames) {
+    if (sqlNames.length === 0)
+        return false;
+    if (table.primaryKey.length === sqlNames.length &&
+        sqlNames.every((name) => table.primaryKey.includes(name))) {
+        return true;
+    }
+    if (sqlNames.length === 1) {
+        return isUniqueColumn(table, sqlNames[0] ?? "");
+    }
+    return table.indexes.some((idx) => idx.unique &&
+        !idx.whereSql &&
+        !(idx.using && idx.using !== "btree") &&
+        !(idx.keys?.some((key) => key.expr) ?? false) &&
+        idx.columns.length === sqlNames.length &&
+        sqlNames.every((name) => idx.columns.includes(name)));
 }
 function buildRelations(columns, sourceAccessor, sqlNameToAccessor, manifestTables) {
     const relations = [];
@@ -262,6 +474,52 @@ function buildRelations(columns, sourceAccessor, sqlNameToAccessor, manifestTabl
         if (col.onDelete !== undefined) {
             rel.onDelete = col.onDelete;
         }
+        if (col.onUpdate !== undefined) {
+            rel.onUpdate = col.onUpdate;
+        }
+        if (col.deferrable !== undefined) {
+            rel.deferrable = col.deferrable;
+        }
+        relations.push(rel);
+    }
+    return relations;
+}
+function extraFkRelations(table, schemaTable) {
+    const relations = [];
+    const extras = schemaTable._extras.filter((extra) => extra.kind === "foreignKey");
+    const fks = table.foreignKeys ?? [];
+    for (let i = 0; i < extras.length; i++) {
+        const extra = extras[i];
+        const fk = fks[i];
+        if (!extra || !fk)
+            continue;
+        const targetAccessor = extra.targetTable;
+        const localTs = extra.columns;
+        const firstLocal = localTs[0];
+        const firstSql = fk.columns[0];
+        const firstTarget = fk.targetColumns[0];
+        if (!firstLocal || !firstSql || !firstTarget)
+            continue;
+        const rel = {
+            name: extra._as,
+            targetTable: fk.targetTable,
+            targetAccessor,
+            fkColumn: firstLocal,
+            fkSqlColumn: firstSql,
+            targetColumn: firstTarget,
+            fkColumns: localTs,
+            fkSqlColumns: fk.columns,
+            targetColumns: fk.targetColumns,
+            referencedSqlColumns: fk.targetColumns,
+            cardinality: "one",
+            inverse: extra._inverse,
+        };
+        if (extra._onDelete !== undefined)
+            rel.onDelete = extra._onDelete;
+        if (extra._onUpdate !== undefined)
+            rel.onUpdate = extra._onUpdate;
+        if (extra._deferrable !== undefined)
+            rel.deferrable = extra._deferrable;
         relations.push(rel);
     }
     return relations;
@@ -272,8 +530,10 @@ function isUniqueColumn(table, fkSqlColumn) {
         return true;
     return table.indexes.some((idx) => idx.unique &&
         !idx.whereSql &&
+        !idx.using &&
         idx.columns.length === 1 &&
-        idx.columns[0] === fkSqlColumn);
+        idx.columns[0] === fkSqlColumn &&
+        !(idx.keys?.some((key) => key.expr) ?? false));
 }
 function resolveM2M(incoming) {
     return {
@@ -298,7 +558,7 @@ function resolveM2M(incoming) {
  * @param plugins - Column type plugins (defaults to built-in registry).
  * @param options - Enum mode and datasource provider hints.
  */
-export function schemaToManifest(schema, plugins = getPluginRegistry(), options = {}) {
+export function schemaToManifest(schema, _plugins = getPluginRegistry(), options = {}) {
     const enumMode = options.enumMode ?? "check";
     const provider = options.provider;
     const datasourceUrl = options.url;
@@ -314,8 +574,8 @@ export function schemaToManifest(schema, plugins = getPluginRegistry(), options
         const columnNaming = tableDef._columnNaming ?? defaultColumnNaming;
         const columns = Object.entries(tableDef._columns)
             .filter(([, col]) => !isManyToMany(col))
-            .map(([name, col]) => columnToManifest(name, col, columnNaming, tables, defaultColumnNaming));
-        const { indexes, primaryKey } = extrasToManifest(tableDef._extras, tableDef._columns, tableDef._tableName, columnNaming, provider);
+            .map(([name, col]) => columnToManifest(name, col, columnNaming, tables, defaultColumnNaming, provider));
+        const { indexes, primaryKey, compositeFks } = extrasToManifest(tableDef._extras, tableDef._columns, tableDef._tableName, columnNaming, provider);
         for (const col of columns) {
             if (!col.index)
                 continue;
@@ -323,6 +583,7 @@ export function schemaToManifest(schema, plugins = getPluginRegistry(), options
                 name: col.sqlName,
                 columns: [col.sqlName],
                 unique: false,
+                keys: [{ sqlName: col.sqlName }],
             };
             const already = indexes.some((idx) => !idx.unique &&
                 idx.columns.length === 1 &&
@@ -358,6 +619,20 @@ export function schemaToManifest(schema, plugins = getPluginRegistry(), options
             relations: [],
             indexes,
             primaryKey: pk,
+            ...(compositeFks.length > 0
+                ? {
+                    foreignKeys: resolveCompositeForeignKeys({
+                        accessor,
+                        tableSqlName: tableDef._tableName,
+                        columns,
+                        extras: compositeFks,
+                        columnNaming,
+                        localDefs: tableDef._columns,
+                        schemaTables: tables,
+                        ...(provider ? { provider } : {}),
+                    }),
+                }
+                : {}),
         };
     }
     const autoJunctionAccessors = new Set();
@@ -369,6 +644,11 @@ export function schemaToManifest(schema, plugins = getPluginRegistry(), options
             columnToManifest(leftTsName, leftFk, columnNaming, tables, defaultColumnNaming),
             columnToManifest(rightTsName, rightFk, columnNaming, tables, defaultColumnNaming),
         ];
+        const leftCol = columns[0];
+        const rightCol = columns[1];
+        if (!leftCol || !rightCol) {
+            throw new Error(`M2M junction "${accessor}" must have exactly two FK columns`);
+        }
         const table = {
             accessor,
             sqlName,
@@ -376,7 +656,7 @@ export function schemaToManifest(schema, plugins = getPluginRegistry(), options
             columns,
             relations: [],
             indexes: [],
-            primaryKey: [columns[0].sqlName, columns[1].sqlName],
+            primaryKey: [leftCol.sqlName, rightCol.sqlName],
         };
         manifestTables[accessor] = table;
         sqlNameToAccessor[sqlName] = accessor;
@@ -451,14 +731,27 @@ export function schemaToManifest(schema, plugins = getPluginRegistry(), options
         });
     }
     for (const table of Object.values(manifestTables)) {
-        table.relations = buildRelations(table.columns, table.accessor, sqlNameToAccessor, manifestTables);
+        for (const fk of table.foreignKeys ?? []) {
+            const target = Object.values(manifestTables).find((item) => item.sqlName === fk.targetTable);
+            if (!target) {
+                throw schemaError("unknown_fk_target", `foreignKey on "${table.accessor}" references unknown table ${fk.targetTable}`);
+            }
+            if (!columnSetIsUnique(target, fk.targetColumns)) {
+                throw schemaError("invalid_column", `foreignKey on "${table.accessor}" target (${fk.targetColumns.join(", ")}) must be a primary key or unique index on "${target.accessor}"`);
+            }
+        }
+        const schemaTable = tables[table.accessor];
+        table.relations = [
+            ...buildRelations(table.columns, table.accessor, sqlNameToAccessor, manifestTables),
+            ...(schemaTable ? extraFkRelations(table, schemaTable) : []),
+        ];
     }
     for (const table of Object.values(manifestTables)) {
         if (autoJunctionAccessors.has(table.accessor))
             continue;
         const fkRelations = table.relations.filter((rel) => {
-            const col = table.columns.find((c) => c.fkAs === rel.name);
-            return col?.kind === "fk";
+            const names = rel.fkColumns ?? [rel.fkColumn];
+            return names.every((name) => table.columns.some((col) => col.tsName === name || col.sqlName === name));
         });
         for (const rel of fkRelations) {
             const inverseTable = manifestTables[rel.targetAccessor];
@@ -478,18 +771,36 @@ export function schemaToManifest(schema, plugins = getPluginRegistry(), options
                     "Each inverse relation name must be unique on the target table",
                 ]);
             }
-            inverseTable.relations.push({
+            const localSql = rel.fkSqlColumns ?? [rel.fkSqlColumn];
+            const inverseRel = {
                 name: rel.inverse,
                 targetTable: table.sqlName,
                 targetAccessor: table.accessor,
                 fkColumn: rel.fkColumn,
                 fkSqlColumn: rel.fkSqlColumn,
                 targetColumn: table.primaryKey[0] ?? rel.targetColumn,
-                cardinality: isUniqueColumn(table, rel.fkSqlColumn)
+                cardinality: columnSetIsUnique(table, localSql)
                     ? "one"
                     : "many",
                 inverse: rel.name,
-            });
+            };
+            if (rel.fkColumns)
+                inverseRel.fkColumns = rel.fkColumns;
+            if (rel.fkSqlColumns)
+                inverseRel.fkSqlColumns = rel.fkSqlColumns;
+            if (table.primaryKey.length > 1) {
+                inverseRel.targetColumns = table.primaryKey;
+            }
+            inverseRel.referencedSqlColumns = rel.referencedSqlColumns ??
+                rel.targetColumns ?? [rel.targetColumn];
+            if (rel.onDelete !== undefined)
+                inverseRel.onDelete = rel.onDelete;
+            if (rel.onUpdate !== undefined)
+                inverseRel.onUpdate = rel.onUpdate;
+            if (rel.deferrable !== undefined) {
+                inverseRel.deferrable = rel.deferrable;
+            }
+            inverseTable.relations.push(inverseRel);
         }
     }
     const manyToMany = incomingM2Ms.map(resolveM2M);
@@ -521,7 +832,7 @@ export function schemaToManifest(schema, plugins = getPluginRegistry(), options
             });
         }
     }
-    const enumTypes = finalizeEnumColumns(manifestTables, enumMode);
+    const enumTypes = finalizeEnumColumns(manifestTables, enumMode, provider);
     const pluginExtensions = collectExtensionsForKinds(Object.values(manifestTables).flatMap((table) => table.columns.map((col) => col.kind)));
     const userExtensions = schema._extensions ?? [];
     const extensions = [...new Set([...pluginExtensions, ...userExtensions])];
@@ -590,6 +901,15 @@ export function validateManifest(manifest) {
                 });
             }
         }
+        for (const fk of table.foreignKeys ?? []) {
+            const target = Object.values(manifest.tables).find((item) => item.sqlName === fk.targetTable);
+            if (!target) {
+                errors.push({
+                    code: "unknown_fk_target",
+                    message: `FK constraint ${fk.name} on ${table.accessor} references unknown table ${fk.targetTable}`,
+                });
+            }
+        }
     }
     return errors;
 }