@payloadcms/drizzle 3.7.0 → 3.7.1-canary.6b01088

package/dist/{postgres/schema → schema}/traverseFields.js

@@ -1,19 +1,14 @@
-import { relations } from 'drizzle-orm';
-import { boolean, foreignKey, index, integer, jsonb, numeric, PgNumericBuilder, PgUUIDBuilder, PgVarcharBuilder, text, timestamp, varchar } from 'drizzle-orm/pg-core';
 import { InvalidConfiguration } from 'payload';
 import { fieldAffectsData, fieldIsVirtual, optionIsObject } from 'payload/shared';
 import toSnakeCase from 'to-snake-case';
-import { createTableName } from '../../createTableName.js';
-import { buildIndexName } from '../../utilities/buildIndexName.js';
-import { hasLocalesTable } from '../../utilities/hasLocalesTable.js';
-import { validateExistingBlockIsIdentical } from '../../utilities/validateExistingBlockIsIdentical.js';
+import { createTableName } from '../createTableName.js';
+import { buildIndexName } from '../utilities/buildIndexName.js';
+import { hasLocalesTable } from '../utilities/hasLocalesTable.js';
+import { validateExistingBlockIsIdentical } from '../utilities/validateExistingBlockIsIdentical.js';
 import { buildTable } from './build.js';
-import { createIndex } from './createIndex.js';
-import { geometryColumn } from './geometryColumn.js';
 import { idToUUID } from './idToUUID.js';
-import { parentIDColumnMap } from './parentIDColumnMap.js';
 import { withDefault } from './withDefault.js';
-export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull, disableRelsTableUnique, disableUnique = false, fieldPrefix, fields, forceLocalized, indexes, localesColumns, localesIndexes, newTableName, parentTableName, relationships, relationsToBuild, rootRelationsToBuild, rootTableIDColType, rootTableName, uniqueRelationships, versions, withinLocalizedArrayOrBlock })=>{
+export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull, disableRelsTableUnique, disableUnique = false, fieldPrefix, fields, forceLocalized, indexes, localesColumns, localesIndexes, newTableName, parentTableName, relationships, relationsToBuild, rootRelationsToBuild, rootTableIDColType, rootTableName, setColumnID, uniqueRelationships, versions, withinLocalizedArrayOrBlock })=>{
     const throwValidationError = true;
     let hasLocalizedField = false;
     let hasLocalizedRelationshipField = false;
@@ -22,14 +17,14 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
     let hasManyNumberField = false;
     let hasLocalizedManyNumberField = false;
     let parentIDColType = 'integer';
-    if (columns.id instanceof PgUUIDBuilder) {
-        parentIDColType = 'uuid';
-    }
-    if (columns.id instanceof PgNumericBuilder) {
-        parentIDColType = 'numeric';
-    }
-    if (columns.id instanceof PgVarcharBuilder) {
-        parentIDColType = 'varchar';
+    const idColumn = columns.id;
+    if (idColumn && [
+        'numeric',
+        'text',
+        'uuid',
+        'varchar'
+    ].includes(idColumn.type)) {
+        parentIDColType = idColumn.type;
     }
     fields.forEach((field)=>{
         if ('name' in field && field.name === 'id') {
@@ -69,14 +64,14 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                 name: `${newTableName}_${columnName}`,
                 adapter
             });
-            targetIndexes[indexName] = createIndex({
-                name: field.localized ? [
+            targetIndexes[indexName] = {
+                name: indexName,
+                on: field.localized ? [
                     fieldName,
                     '_locale'
                 ] : fieldName,
-                indexName,
                 unique
-            });
+            };
         }
         switch(field.type){
             case 'array':
@@ -91,31 +86,62 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                         versionsCustomName: versions
                     });
                     const baseColumns = {
-                        _order: integer('_order').notNull(),
-                        _parentID: parentIDColumnMap[parentIDColType]('_parent_id').notNull()
+                        _order: {
+                            name: '_order',
+                            type: 'integer',
+                            notNull: true
+                        },
+                        _parentID: {
+                            name: '_parent_id',
+                            type: parentIDColType,
+                            notNull: true
+                        }
                     };
-                    const baseExtraConfig = {
-                        _orderIdx: (cols)=>index(`${arrayTableName}_order_idx`).on(cols._order),
-                        _parentIDFk: (cols)=>foreignKey({
-                                name: `${arrayTableName}_parent_id_fk`,
-                                columns: [
-                                    cols['_parentID']
-                                ],
-                                foreignColumns: [
-                                    adapter.tables[parentTableName].id
-                                ]
-                            }).onDelete('cascade'),
-                        _parentIDIdx: (cols)=>index(`${arrayTableName}_parent_id_idx`).on(cols._parentID)
+                    const baseIndexes = {
+                        _orderIdx: {
+                            name: `${arrayTableName}_order_idx`,
+                            on: [
+                                '_order'
+                            ]
+                        },
+                        _parentIDIdx: {
+                            name: `${arrayTableName}_parent_id_idx`,
+                            on: '_parentID'
+                        }
+                    };
+                    const baseForeignKeys = {
+                        _parentIDFk: {
+                            name: `${arrayTableName}_parent_id_fk`,
+                            columns: [
+                                '_parentID'
+                            ],
+                            foreignColumns: [
+                                {
+                                    name: 'id',
+                                    table: parentTableName
+                                }
+                            ],
+                            onDelete: 'cascade'
+                        }
                     };
                     const isLocalized = Boolean(field.localized && adapter.payload.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
                     if (isLocalized) {
-                        baseColumns._locale = adapter.enums.enum__locales('_locale').notNull();
-                        baseExtraConfig._localeIdx = (cols)=>index(`${arrayTableName}_locale_idx`).on(cols._locale);
+                        baseColumns._locale = {
+                            name: '_locale',
+                            type: 'enum',
+                            locale: true,
+                            notNull: true
+                        };
+                        baseIndexes._localeIdx = {
+                            name: `${arrayTableName}_locale_idx`,
+                            on: '_locale'
+                        };
                     }
                     const { hasLocalizedManyNumberField: subHasLocalizedManyNumberField, hasLocalizedManyTextField: subHasLocalizedManyTextField, hasLocalizedRelationshipField: subHasLocalizedRelationshipField, hasManyNumberField: subHasManyNumberField, hasManyTextField: subHasManyTextField, relationsToBuild: subRelationsToBuild } = buildTable({
                         adapter,
                         baseColumns,
-                        baseExtraConfig,
+                        baseForeignKeys,
+                        baseIndexes,
                         disableNotNull: disableNotNullFromHere,
                         disableRelsTableUnique: true,
                         disableUnique,
@@ -125,6 +151,7 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                         rootTableIDColType,
                         rootTableName,
                         rootUniqueRelationships: uniqueRelationships,
+                        setColumnID,
                         tableName: arrayTableName,
                         versions,
                         withinLocalizedArrayOrBlock: isLocalized
@@ -154,44 +181,56 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                         localized: false,
                         target: arrayTableName
                     });
-                    adapter.relations[`relations_${arrayTableName}`] = relations(adapter.tables[arrayTableName], ({ many, one })=>{
-                        const result = {
-                            _parentID: one(adapter.tables[parentTableName], {
+                    const arrayRelations = {
+                        _parentID: {
+                            type: 'one',
+                            fields: [
+                                {
+                                    name: '_parentID',
+                                    table: arrayTableName
+                                }
+                            ],
+                            references: [
+                                'id'
+                            ],
+                            relationName: fieldName,
+                            to: parentTableName
+                        }
+                    };
+                    if (hasLocalesTable(field.fields)) {
+                        arrayRelations._locales = {
+                            type: 'many',
+                            relationName: '_locales',
+                            to: `${arrayTableName}${adapter.localesSuffix}`
+                        };
+                    }
+                    subRelationsToBuild.forEach(({ type, localized, target }, key)=>{
+                        if (type === 'one') {
+                            const arrayWithLocalized = localized ? `${arrayTableName}${adapter.localesSuffix}` : arrayTableName;
+                            arrayRelations[key] = {
+                                type: 'one',
                                 fields: [
-                                    adapter.tables[arrayTableName]._parentID
+                                    {
+                                        name: key,
+                                        table: arrayWithLocalized
+                                    }
                                 ],
                                 references: [
-                                    adapter.tables[parentTableName].id
+                                    'id'
                                 ],
-                                relationName: fieldName
-                            })
-                        };
-                        if (hasLocalesTable(field.fields)) {
-                            result._locales = many(adapter.tables[`${arrayTableName}${adapter.localesSuffix}`], {
-                                relationName: '_locales'
-                            });
+                                relationName: key,
+                                to: target
+                            };
+                        }
+                        if (type === 'many') {
+                            arrayRelations[key] = {
+                                type: 'many',
+                                relationName: key,
+                                to: target
+                            };
                         }
-                        subRelationsToBuild.forEach(({ type, localized, target }, key)=>{
-                            if (type === 'one') {
-                                const arrayWithLocalized = localized ? `${arrayTableName}${adapter.localesSuffix}` : arrayTableName;
-                                result[key] = one(adapter.tables[target], {
-                                    fields: [
-                                        adapter.tables[arrayWithLocalized][key]
-                                    ],
-                                    references: [
-                                        adapter.tables[target].id
-                                    ],
-                                    relationName: key
-                                });
-                            }
-                            if (type === 'many') {
-                                result[key] = many(adapter.tables[target], {
-                                    relationName: key
-                                });
-                            }
-                        });
-                        return result;
                     });
+                    adapter.rawRelations[arrayTableName] = arrayRelations;
                     break;
                 }
             case 'blocks':
@@ -206,35 +245,73 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                             throwValidationError,
                             versionsCustomName: versions
                         });
-                        if (!adapter.tables[blockTableName]) {
+                        if (!adapter.rawTables[blockTableName]) {
                             const baseColumns = {
-                                _order: integer('_order').notNull(),
-                                _parentID: parentIDColumnMap[rootTableIDColType]('_parent_id').notNull(),
-                                _path: text('_path').notNull()
+                                _order: {
+                                    name: '_order',
+                                    type: 'integer',
+                                    notNull: true
+                                },
+                                _parentID: {
+                                    name: '_parent_id',
+                                    type: rootTableIDColType,
+                                    notNull: true
+                                },
+                                _path: {
+                                    name: '_path',
+                                    type: 'text',
+                                    notNull: true
+                                }
                             };
-                            const baseExtraConfig = {
-                                _orderIdx: (cols)=>index(`${blockTableName}_order_idx`).on(cols._order),
-                                _parentIdFk: (cols)=>foreignKey({
-                                        name: `${blockTableName}_parent_id_fk`,
-                                        columns: [
-                                            cols._parentID
-                                        ],
-                                        foreignColumns: [
-                                            adapter.tables[rootTableName].id
-                                        ]
-                                    }).onDelete('cascade'),
-                                _parentIDIdx: (cols)=>index(`${blockTableName}_parent_id_idx`).on(cols._parentID),
-                                _pathIdx: (cols)=>index(`${blockTableName}_path_idx`).on(cols._path)
+                            const baseIndexes = {
+                                _orderIdx: {
+                                    name: `${blockTableName}_order_idx`,
+                                    on: '_order'
+                                },
+                                _parentIDIdx: {
+                                    name: `${blockTableName}_parent_id_idx`,
+                                    on: [
+                                        '_parentID'
+                                    ]
+                                },
+                                _pathIdx: {
+                                    name: `${blockTableName}_path_idx`,
+                                    on: '_path'
+                                }
+                            };
+                            const baseForeignKeys = {
+                                _parentIdFk: {
+                                    name: `${blockTableName}_parent_id_fk`,
+                                    columns: [
+                                        '_parentID'
+                                    ],
+                                    foreignColumns: [
+                                        {
+                                            name: 'id',
+                                            table: rootTableName
+                                        }
+                                    ],
+                                    onDelete: 'cascade'
+                                }
                             };
                             const isLocalized = Boolean(field.localized && adapter.payload.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
                             if (isLocalized) {
-                                baseColumns._locale = adapter.enums.enum__locales('_locale').notNull();
-                                baseExtraConfig._localeIdx = (cols)=>index(`${blockTableName}_locale_idx`).on(cols._locale);
+                                baseColumns._locale = {
+                                    name: '_locale',
+                                    type: 'enum',
+                                    locale: true,
+                                    notNull: true
+                                };
+                                baseIndexes._localeIdx = {
+                                    name: `${blockTableName}_locale_idx`,
+                                    on: '_locale'
+                                };
                             }
                             const { hasLocalizedManyNumberField: subHasLocalizedManyNumberField, hasLocalizedManyTextField: subHasLocalizedManyTextField, hasLocalizedRelationshipField: subHasLocalizedRelationshipField, hasManyNumberField: subHasManyNumberField, hasManyTextField: subHasManyTextField, relationsToBuild: subRelationsToBuild } = buildTable({
                                 adapter,
                                 baseColumns,
-                                baseExtraConfig,
+                                baseForeignKeys,
+                                baseIndexes,
                                 disableNotNull: disableNotNullFromHere,
                                 disableRelsTableUnique: true,
                                 disableUnique,
@@ -244,6 +321,7 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                                 rootTableIDColType,
                                 rootTableName,
                                 rootUniqueRelationships: uniqueRelationships,
+                                setColumnID,
                                 tableName: blockTableName,
                                 versions,
                                 withinLocalizedArrayOrBlock: isLocalized
@@ -267,51 +345,63 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                                     hasManyNumberField = subHasManyNumberField;
                                 }
                             }
-                            adapter.relations[`relations_${blockTableName}`] = relations(adapter.tables[blockTableName], ({ many, one })=>{
-                                const result = {
-                                    _parentID: one(adapter.tables[rootTableName], {
+                            const blockRelations = {
+                                _parentID: {
+                                    type: 'one',
+                                    fields: [
+                                        {
+                                            name: '_parentID',
+                                            table: blockTableName
+                                        }
+                                    ],
+                                    references: [
+                                        'id'
+                                    ],
+                                    relationName: `_blocks_${block.slug}`,
+                                    to: rootTableName
+                                }
+                            };
+                            if (hasLocalesTable(block.fields)) {
+                                blockRelations._locales = {
+                                    type: 'many',
+                                    relationName: '_locales',
+                                    to: `${blockTableName}${adapter.localesSuffix}`
+                                };
+                            }
+                            subRelationsToBuild.forEach(({ type, localized, target }, key)=>{
+                                if (type === 'one') {
+                                    const blockWithLocalized = localized ? `${blockTableName}${adapter.localesSuffix}` : blockTableName;
+                                    blockRelations[key] = {
+                                        type: 'one',
                                         fields: [
-                                            adapter.tables[blockTableName]._parentID
+                                            {
+                                                name: key,
+                                                table: blockWithLocalized
+                                            }
                                         ],
                                         references: [
-                                            adapter.tables[rootTableName].id
+                                            'id'
                                         ],
-                                        relationName: `_blocks_${block.slug}`
-                                    })
-                                };
-                                if (hasLocalesTable(block.fields)) {
-                                    result._locales = many(adapter.tables[`${blockTableName}${adapter.localesSuffix}`], {
-                                        relationName: '_locales'
-                                    });
+                                        relationName: key,
+                                        to: target
+                                    };
+                                }
+                                if (type === 'many') {
+                                    blockRelations[key] = {
+                                        type: 'many',
+                                        relationName: key,
+                                        to: target
+                                    };
                                 }
-                                subRelationsToBuild.forEach(({ type, localized, target }, key)=>{
-                                    if (type === 'one') {
-                                        const blockWithLocalized = localized ? `${blockTableName}${adapter.localesSuffix}` : blockTableName;
-                                        result[key] = one(adapter.tables[target], {
-                                            fields: [
-                                                adapter.tables[blockWithLocalized][key]
-                                            ],
-                                            references: [
-                                                adapter.tables[target].id
-                                            ],
-                                            relationName: key
-                                        });
-                                    }
-                                    if (type === 'many') {
-                                        result[key] = many(adapter.tables[target], {
-                                            relationName: key
-                                        });
-                                    }
-                                });
-                                return result;
                             });
+                            adapter.rawRelations[blockTableName] = blockRelations;
                         } else if (process.env.NODE_ENV !== 'production' && !versions) {
                             validateExistingBlockIsIdentical({
                                 block,
                                 localized: field.localized,
                                 rootTableName,
-                                table: adapter.tables[blockTableName],
-                                tableLocales: adapter.tables[`${blockTableName}${adapter.localesSuffix}`]
+                                table: adapter.rawTables[blockTableName],
+                                tableLocales: adapter.rawTables[`${blockTableName}${adapter.localesSuffix}`]
                             });
                         }
                         // blocks relationships are defined from the collection or globals table down to the block, bypassing any subBlocks
@@ -326,23 +416,31 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                 }
             case 'checkbox':
                 {
-                    targetTable[fieldName] = withDefault(boolean(columnName), field);
+                    targetTable[fieldName] = withDefault({
+                        name: columnName,
+                        type: 'boolean'
+                    }, field);
                     break;
                 }
             case 'code':
             case 'email':
             case 'textarea':
                 {
-                    targetTable[fieldName] = withDefault(varchar(columnName), field);
+                    targetTable[fieldName] = withDefault({
+                        name: columnName,
+                        type: 'varchar'
+                    }, field);
                     break;
                 }
             case 'date':
                 {
-                    targetTable[fieldName] = withDefault(timestamp(columnName, {
+                    targetTable[fieldName] = withDefault({
+                        name: columnName,
+                        type: 'timestamp',
                         mode: 'string',
                         precision: 3,
                         withTimezone: true
-                    }), field);
+                    }, field);
                     break;
                 }
             case 'group':
@@ -368,6 +466,7 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                         rootRelationsToBuild,
                         rootTableIDColType,
                         rootTableName,
+                        setColumnID,
                         uniqueRelationships,
                         versions,
                         withinLocalizedArrayOrBlock: withinLocalizedArrayOrBlock || field.localized
@@ -395,7 +494,10 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
             case 'json':
             case 'richText':
                 {
-                    targetTable[fieldName] = withDefault(jsonb(columnName), field);
+                    targetTable[fieldName] = withDefault({
+                        name: columnName,
+                        type: 'jsonb'
+                    }, field);
                     break;
                 }
             case 'number':
@@ -414,16 +516,19 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                             throw new InvalidConfiguration('Unique is not supported in Postgres for hasMany number fields.');
                         }
                     } else {
-                        targetTable[fieldName] = withDefault(numeric(columnName), field);
+                        targetTable[fieldName] = withDefault({
+                            name: columnName,
+                            type: 'numeric'
+                        }, field);
                     }
                     break;
                 }
             case 'point':
                 {
-                    targetTable[fieldName] = withDefault(geometryColumn(columnName), field);
-                    if (!adapter.extensions.postgis) {
-                        adapter.extensions.postgis = true;
-                    }
+                    targetTable[fieldName] = withDefault({
+                        name: columnName,
+                        type: 'geometry'
+                    }, field);
                     break;
                 }
             case 'radio':
@@ -437,12 +542,12 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                         target: 'enumName',
                         throwValidationError
                     });
-                    adapter.enums[enumName] = adapter.pgSchema.enum(enumName, field.options.map((option)=>{
+                    const options = field.options.map((option)=>{
                         if (optionIsObject(option)) {
                             return option.value;
                         }
                         return option;
-                    }));
+                    });
                     if (field.type === 'select' && field.hasMany) {
                         const selectTableName = createTableName({
                             adapter,
@@ -453,39 +558,84 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                             versionsCustomName: versions
                         });
                         const baseColumns = {
-                            order: integer('order').notNull(),
-                            parent: parentIDColumnMap[parentIDColType]('parent_id').notNull(),
-                            value: adapter.enums[enumName]('value')
+                            order: {
+                                name: 'order',
+                                type: 'integer',
+                                notNull: true
+                            },
+                            parent: {
+                                name: 'parent_id',
+                                type: parentIDColType,
+                                notNull: true
+                            },
+                            value: {
+                                name: 'value',
+                                type: 'enum',
+                                enumName: createTableName({
+                                    adapter,
+                                    config: field,
+                                    parentTableName: newTableName,
+                                    prefix: `enum_${newTableName}_`,
+                                    target: 'enumName',
+                                    throwValidationError
+                                }),
+                                options
+                            }
                         };
-                        const baseExtraConfig = {
-                            orderIdx: (cols)=>index(`${selectTableName}_order_idx`).on(cols.order),
-                            parentFk: (cols)=>foreignKey({
-                                    name: `${selectTableName}_parent_fk`,
-                                    columns: [
-                                        cols.parent
-                                    ],
-                                    foreignColumns: [
-                                        adapter.tables[parentTableName].id
-                                    ]
-                                }).onDelete('cascade'),
-                            parentIdx: (cols)=>index(`${selectTableName}_parent_idx`).on(cols.parent)
+                        const baseIndexes = {
+                            orderIdx: {
+                                name: `${selectTableName}_order_idx`,
+                                on: 'order'
+                            },
+                            parentIdx: {
+                                name: `${selectTableName}_parent_idx`,
+                                on: 'parent'
+                            }
+                        };
+                        const baseForeignKeys = {
+                            parentFk: {
+                                name: `${selectTableName}_parent_fk`,
+                                columns: [
+                                    'parent'
+                                ],
+                                foreignColumns: [
+                                    {
+                                        name: 'id',
+                                        table: parentTableName
+                                    }
+                                ],
+                                onDelete: 'cascade'
+                            }
                         };
                         const isLocalized = Boolean(field.localized && adapter.payload.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
                         if (isLocalized) {
-                            baseColumns.locale = adapter.enums.enum__locales('locale').notNull();
-                            baseExtraConfig.localeIdx = (cols)=>index(`${selectTableName}_locale_idx`).on(cols.locale);
+                            baseColumns.locale = {
+                                name: 'locale',
+                                type: 'enum',
+                                locale: true,
+                                notNull: true
+                            };
+                            baseIndexes.localeIdx = {
+                                name: `${selectTableName}_locale_idx`,
+                                on: 'locale'
+                            };
                         }
                         if (field.index) {
-                            baseExtraConfig.value = (cols)=>index(`${selectTableName}_value_idx`).on(cols.value);
+                            baseIndexes.value = {
+                                name: `${selectTableName}_value_idx`,
+                                on: 'value'
+                            };
                         }
                         buildTable({
                             adapter,
                             baseColumns,
-                            baseExtraConfig,
+                            baseForeignKeys,
+                            baseIndexes,
                             disableNotNull,
                             disableUnique,
                             fields: [],
                             rootTableName,
+                            setColumnID,
                             tableName: selectTableName,
                             versions
                         });
@@ -495,19 +645,29 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                             localized: false,
                             target: selectTableName
                         });
-                        adapter.relations[`relations_${selectTableName}`] = relations(adapter.tables[selectTableName], ({ one })=>({
-                                parent: one(adapter.tables[parentTableName], {
-                                    fields: [
-                                        adapter.tables[selectTableName].parent
-                                    ],
-                                    references: [
-                                        adapter.tables[parentTableName].id
-                                    ],
-                                    relationName: fieldName
-                                })
-                            }));
+                        adapter.rawRelations[selectTableName] = {
+                            parent: {
+                                type: 'one',
+                                fields: [
+                                    {
+                                        name: 'parent',
+                                        table: selectTableName
+                                    }
+                                ],
+                                references: [
+                                    'id'
+                                ],
+                                relationName: fieldName,
+                                to: parentTableName
+                            }
+                        };
                     } else {
-                        targetTable[fieldName] = withDefault(adapter.enums[enumName](columnName), field);
+                        targetTable[fieldName] = withDefault({
+                            name: columnName,
+                            type: 'enum',
+                            enumName,
+                            options
+                        }, field);
                     }
                     break;
                 }
@@ -539,9 +699,15 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                         colType = 'varchar';
                     }
                     // make the foreign key column for relationship using the correct id column type
-                    targetTable[fieldName] = parentIDColumnMap[colType](`${columnName}_id`).references(()=>adapter.tables[tableName].id, {
-                        onDelete: 'set null'
-                    });
+                    targetTable[fieldName] = {
+                        name: `${columnName}_id`,
+                        type: colType,
+                        reference: {
+                            name: 'id',
+                            onDelete: 'set null',
+                            table: tableName
+                        }
+                    };
                     // add relationship to table
                     relationsToBuild.set(fieldName, {
                         type: 'one',
@@ -550,7 +716,7 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                     });
                     // add notNull when not required
                     if (!disableNotNull && field.required && !field.admin?.condition) {
-                        targetTable[fieldName].notNull();
+                        targetTable[fieldName].notNull = true;
                     }
                     break;
                 }
@@ -574,7 +740,10 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                             throw new InvalidConfiguration('Unique is not supported in Postgres for hasMany text fields.');
                         }
                     } else {
-                        targetTable[fieldName] = withDefault(varchar(columnName), field);
+                        targetTable[fieldName] = withDefault({
+                            name: columnName,
+                            type: 'varchar'
+                        }, field);
                     }
                     break;
                 }
@@ -583,7 +752,7 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
         }
         const condition = field.admin && field.admin.condition;
         if (!disableNotNull && targetTable[fieldName] && 'required' in field && field.required && !condition) {
-            targetTable[fieldName].notNull();
+            targetTable[fieldName].notNull = true;
         }
     });
     return {