@hanzo/cms-drizzle 3.85.2

package/dist/schema/traverseFields.js

@@ -0,0 +1,810 @@
+import { InvalidConfiguration } from '@hanzo/cms';
+import { fieldAffectsData, fieldIsVirtual, fieldShouldBeLocalized, optionIsObject } from '@hanzo/cms/shared';
+import toSnakeCase from 'to-snake-case';
+import { createTableName } from '../createTableName.js';
+import { buildIndexName } from '../utilities/buildIndexName.js';
+import { getArrayRelationName } from '../utilities/getArrayRelationName.js';
+import { hasLocalesTable } from '../utilities/hasLocalesTable.js';
+import { isUUIDType } from '../utilities/isUUIDType.js';
+import { InternalBlockTableNameIndex, setInternalBlockIndex, validateExistingBlockIsIdentical } from '../utilities/validateExistingBlockIsIdentical.js';
+import { buildTable } from './build.js';
+import { idToUUID } from './idToUUID.js';
+import { withDefault } from './withDefault.js';
+export const traverseFields = ({ adapter, blocksTableNameMap, columnPrefix, columns, disableNotNull, disableRelsTableUnique, disableUnique = false, fieldPrefix, fields, forceLocalized, indexes, localesColumns, localesIndexes, newTableName, parentIsLocalized, parentTableName, relationships, relationsToBuild, rootRelationsToBuild, rootTableIDColType, rootTableName, setColumnID, uniqueRelationships, versions, withinLocalizedArrayOrBlock })=>{
+    const throwValidationError = true;
+    let hasLocalizedField = false;
+    let hasLocalizedRelationshipField = false;
+    let hasManyTextField = false;
+    let hasLocalizedManyTextField = false;
+    let hasManyNumberField = false;
+    let hasLocalizedManyNumberField = false;
+    let parentIDColType = 'integer';
+    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') {
+            return;
+        }
+        if (fieldIsVirtual(field)) {
+            return;
+        }
+        let targetTable = columns;
+        let targetIndexes = indexes;
+        const columnName = `${columnPrefix || ''}${field.name[0] === '_' ? '_' : ''}${toSnakeCase(field.name)}`;
+        const fieldName = `${fieldPrefix?.replace('.', '_') || ''}${field.name}`;
+        const isFieldLocalized = fieldShouldBeLocalized({
+            field,
+            parentIsLocalized
+        });
+        // If field is localized,
+        // add the column to the locale table instead of main table
+        if (adapter.cms.config.localization && (isFieldLocalized || forceLocalized) && field.type !== 'array' && (field.type !== 'blocks' || adapter.blocksAsJSON) && ('hasMany' in field && field.hasMany !== true || !('hasMany' in field))) {
+            hasLocalizedField = true;
+            targetTable = localesColumns;
+            targetIndexes = localesIndexes;
+        }
+        if ((field.unique || field.index || [
+            'relationship',
+            'upload'
+        ].includes(field.type)) && ![
+            'array',
+            'blocks',
+            'group'
+        ].includes(field.type) && !('hasMany' in field && field.hasMany === true) && !('relationTo' in field && Array.isArray(field.relationTo))) {
+            const unique = disableUnique !== true && field.unique;
+            if (unique) {
+                const constraintValue = `${fieldPrefix || ''}${field.name}`;
+                if (!adapter.fieldConstraints?.[rootTableName]) {
+                    adapter.fieldConstraints[rootTableName] = {};
+                }
+                adapter.fieldConstraints[rootTableName][`${columnName}_idx`] = constraintValue;
+            }
+            const indexName = buildIndexName({
+                name: `${newTableName}_${columnName}`,
+                adapter
+            });
+            targetIndexes[indexName] = {
+                name: indexName,
+                on: isFieldLocalized ? [
+                    fieldName,
+                    '_locale'
+                ] : fieldName,
+                unique
+            };
+        }
+        switch(field.type){
+            case 'array':
+                {
+                    const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull;
+                    const arrayTableName = createTableName({
+                        adapter,
+                        config: field,
+                        parentTableName: newTableName,
+                        prefix: `${newTableName}_`,
+                        throwValidationError,
+                        versionsCustomName: versions
+                    });
+                    const baseColumns = {
+                        _order: {
+                            name: '_order',
+                            type: 'integer',
+                            notNull: true
+                        },
+                        _parentID: {
+                            name: '_parent_id',
+                            type: parentIDColType,
+                            notNull: true
+                        }
+                    };
+                    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(isFieldLocalized && adapter.cms.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
+                    if (isLocalized) {
+                        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,
+                        baseForeignKeys,
+                        baseIndexes,
+                        blocksTableNameMap,
+                        disableNotNull: disableNotNullFromHere,
+                        disableRelsTableUnique: true,
+                        disableUnique,
+                        fields: disableUnique ? idToUUID(field.flattenedFields) : field.flattenedFields,
+                        parentIsLocalized: parentIsLocalized || field.localized,
+                        rootRelationships: relationships,
+                        rootRelationsToBuild,
+                        rootTableIDColType,
+                        rootTableName,
+                        rootUniqueRelationships: uniqueRelationships,
+                        setColumnID,
+                        tableName: arrayTableName,
+                        versions,
+                        withinLocalizedArrayOrBlock: isLocalized
+                    });
+                    if (subHasLocalizedManyNumberField) {
+                        hasLocalizedManyNumberField = subHasLocalizedManyNumberField;
+                    }
+                    if (subHasLocalizedRelationshipField) {
+                        hasLocalizedRelationshipField = subHasLocalizedRelationshipField;
+                    }
+                    if (subHasLocalizedManyTextField) {
+                        hasLocalizedManyTextField = subHasLocalizedManyTextField;
+                    }
+                    if (subHasManyTextField) {
+                        if (!hasManyTextField || subHasManyTextField === 'index') {
+                            hasManyTextField = subHasManyTextField;
+                        }
+                    }
+                    if (subHasManyNumberField) {
+                        if (!hasManyNumberField || subHasManyNumberField === 'index') {
+                            hasManyNumberField = subHasManyNumberField;
+                        }
+                    }
+                    const relationName = getArrayRelationName({
+                        field,
+                        path: fieldName,
+                        tableName: arrayTableName
+                    });
+                    relationsToBuild.set(relationName, {
+                        type: 'many',
+                        // arrays have their own localized table, independent of the base table.
+                        localized: false,
+                        target: arrayTableName
+                    });
+                    const arrayRelations = {
+                        _parentID: {
+                            type: 'one',
+                            fields: [
+                                {
+                                    name: '_parentID',
+                                    table: arrayTableName
+                                }
+                            ],
+                            references: [
+                                'id'
+                            ],
+                            relationName,
+                            to: parentTableName
+                        }
+                    };
+                    if (hasLocalesTable({
+                        fields: field.fields,
+                        parentIsLocalized: parentIsLocalized || field.localized
+                    })) {
+                        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: [
+                                    {
+                                        name: key,
+                                        table: arrayWithLocalized
+                                    }
+                                ],
+                                references: [
+                                    'id'
+                                ],
+                                relationName: key,
+                                to: target
+                            };
+                        }
+                        if (type === 'many') {
+                            arrayRelations[key] = {
+                                type: 'many',
+                                relationName: key,
+                                to: target
+                            };
+                        }
+                    });
+                    adapter.rawRelations[arrayTableName] = arrayRelations;
+                    break;
+                }
+            case 'blocks':
+                {
+                    if (adapter.blocksAsJSON) {
+                        targetTable[fieldName] = withDefault({
+                            name: columnName,
+                            type: 'jsonb'
+                        }, field);
+                        break;
+                    }
+                    const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull;
+                    (field.blockReferences ?? field.blocks).forEach((_block)=>{
+                        const block = typeof _block === 'string' ? adapter.cms.blocks[_block] : _block;
+                        let blockTableName = createTableName({
+                            adapter,
+                            config: block,
+                            parentTableName: rootTableName,
+                            prefix: `${rootTableName}_blocks_`,
+                            throwValidationError,
+                            versionsCustomName: versions
+                        });
+                        if (typeof blocksTableNameMap[blockTableName] === 'undefined') {
+                            blocksTableNameMap[blockTableName] = 1;
+                        } else if (!adapter.rawTables[blockTableName] || !validateExistingBlockIsIdentical({
+                            block,
+                            localized: field.localized,
+                            rootTableName,
+                            table: adapter.rawTables[blockTableName],
+                            tableLocales: adapter.rawTables[`${blockTableName}${adapter.localesSuffix}`]
+                        })) {
+                            blocksTableNameMap[blockTableName]++;
+                            setInternalBlockIndex(block, blocksTableNameMap[blockTableName]);
+                            blockTableName = `${blockTableName}_${blocksTableNameMap[blockTableName]}`;
+                        }
+                        let relationName = `_blocks_${block.slug}`;
+                        if (typeof block[InternalBlockTableNameIndex] !== 'undefined') {
+                            relationName = `_blocks_${block.slug}_${block[InternalBlockTableNameIndex]}`;
+                        }
+                        if (!adapter.rawTables[blockTableName]) {
+                            const baseColumns = {
+                                _order: {
+                                    name: '_order',
+                                    type: 'integer',
+                                    notNull: true
+                                },
+                                _parentID: {
+                                    name: '_parent_id',
+                                    type: rootTableIDColType,
+                                    notNull: true
+                                },
+                                _path: {
+                                    name: '_path',
+                                    type: 'text',
+                                    notNull: true
+                                }
+                            };
+                            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(isFieldLocalized && adapter.cms.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
+                            if (isLocalized) {
+                                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,
+                                baseForeignKeys,
+                                baseIndexes,
+                                blocksTableNameMap,
+                                disableNotNull: disableNotNullFromHere,
+                                disableRelsTableUnique: true,
+                                disableUnique,
+                                fields: disableUnique ? idToUUID(block.flattenedFields) : block.flattenedFields,
+                                parentIsLocalized: parentIsLocalized || field.localized,
+                                rootRelationships: relationships,
+                                rootRelationsToBuild,
+                                rootTableIDColType,
+                                rootTableName,
+                                rootUniqueRelationships: uniqueRelationships,
+                                setColumnID,
+                                tableName: blockTableName,
+                                versions,
+                                withinLocalizedArrayOrBlock: isLocalized
+                            });
+                            if (subHasLocalizedManyNumberField) {
+                                hasLocalizedManyNumberField = subHasLocalizedManyNumberField;
+                            }
+                            if (subHasLocalizedRelationshipField) {
+                                hasLocalizedRelationshipField = subHasLocalizedRelationshipField;
+                            }
+                            if (subHasLocalizedManyTextField) {
+                                hasLocalizedManyTextField = subHasLocalizedManyTextField;
+                            }
+                            if (subHasManyTextField) {
+                                if (!hasManyTextField || subHasManyTextField === 'index') {
+                                    hasManyTextField = subHasManyTextField;
+                                }
+                            }
+                            if (subHasManyNumberField) {
+                                if (!hasManyNumberField || subHasManyNumberField === 'index') {
+                                    hasManyNumberField = subHasManyNumberField;
+                                }
+                            }
+                            const blockRelations = {
+                                _parentID: {
+                                    type: 'one',
+                                    fields: [
+                                        {
+                                            name: '_parentID',
+                                            table: blockTableName
+                                        }
+                                    ],
+                                    references: [
+                                        'id'
+                                    ],
+                                    relationName,
+                                    to: rootTableName
+                                }
+                            };
+                            if (hasLocalesTable({
+                                fields: block.fields,
+                                parentIsLocalized: parentIsLocalized || field.localized
+                            })) {
+                                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: [
+                                            {
+                                                name: key,
+                                                table: blockWithLocalized
+                                            }
+                                        ],
+                                        references: [
+                                            'id'
+                                        ],
+                                        relationName: key,
+                                        to: target
+                                    };
+                                }
+                                if (type === 'many') {
+                                    blockRelations[key] = {
+                                        type: 'many',
+                                        relationName: key,
+                                        to: target
+                                    };
+                                }
+                            });
+                            adapter.rawRelations[blockTableName] = blockRelations;
+                        }
+                        // blocks relationships are defined from the collection or globals table down to the block, bypassing any subBlocks
+                        rootRelationsToBuild.set(relationName, {
+                            type: 'many',
+                            // blocks are not localized on the parent table
+                            localized: false,
+                            target: blockTableName
+                        });
+                    });
+                    break;
+                }
+            case 'checkbox':
+                {
+                    targetTable[fieldName] = withDefault({
+                        name: columnName,
+                        type: 'boolean'
+                    }, field);
+                    break;
+                }
+            case 'code':
+            case 'email':
+            case 'textarea':
+                {
+                    targetTable[fieldName] = withDefault({
+                        name: columnName,
+                        type: 'varchar'
+                    }, field);
+                    break;
+                }
+            case 'date':
+                {
+                    targetTable[fieldName] = withDefault({
+                        name: columnName,
+                        type: 'timestamp',
+                        mode: 'string',
+                        precision: 3,
+                        withTimezone: true
+                    }, field);
+                    break;
+                }
+            case 'group':
+            case 'tab':
+                {
+                    const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull;
+                    const { hasLocalizedField: groupHasLocalizedField, hasLocalizedManyNumberField: groupHasLocalizedManyNumberField, hasLocalizedManyTextField: groupHasLocalizedManyTextField, hasLocalizedRelationshipField: groupHasLocalizedRelationshipField, hasManyNumberField: groupHasManyNumberField, hasManyTextField: groupHasManyTextField } = traverseFields({
+                        adapter,
+                        blocksTableNameMap,
+                        columnPrefix: `${columnName}_`,
+                        columns,
+                        disableNotNull: disableNotNullFromHere,
+                        disableUnique,
+                        fieldPrefix: `${fieldName}.`,
+                        fields: field.flattenedFields,
+                        forceLocalized: isFieldLocalized || Boolean(forceLocalized),
+                        indexes,
+                        localesColumns,
+                        localesIndexes,
+                        newTableName: `${parentTableName}_${columnName}`,
+                        parentIsLocalized: parentIsLocalized || field.localized,
+                        parentTableName,
+                        relationships,
+                        relationsToBuild,
+                        rootRelationsToBuild,
+                        rootTableIDColType,
+                        rootTableName,
+                        setColumnID,
+                        uniqueRelationships,
+                        versions,
+                        withinLocalizedArrayOrBlock: withinLocalizedArrayOrBlock || isFieldLocalized
+                    });
+                    if (groupHasLocalizedField) {
+                        hasLocalizedField = true;
+                    }
+                    if (groupHasLocalizedRelationshipField) {
+                        hasLocalizedRelationshipField = true;
+                    }
+                    if (groupHasManyTextField) {
+                        hasManyTextField = true;
+                    }
+                    if (groupHasLocalizedManyTextField) {
+                        hasLocalizedManyTextField = true;
+                    }
+                    if (groupHasManyNumberField) {
+                        hasManyNumberField = true;
+                    }
+                    if (groupHasLocalizedManyNumberField) {
+                        hasLocalizedManyNumberField = true;
+                    }
+                    break;
+                }
+            case 'json':
+            case 'richText':
+                {
+                    targetTable[fieldName] = withDefault({
+                        name: columnName,
+                        type: 'jsonb'
+                    }, field);
+                    break;
+                }
+            case 'number':
+                {
+                    if (field.hasMany) {
+                        const isLocalized = Boolean(isFieldLocalized && adapter.cms.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
+                        if (isLocalized) {
+                            hasLocalizedManyNumberField = true;
+                        }
+                        if (field.index) {
+                            hasManyNumberField = 'index';
+                        } else if (!hasManyNumberField) {
+                            hasManyNumberField = true;
+                        }
+                        if (field.unique) {
+                            throw new InvalidConfiguration('Unique is not supported in Postgres for hasMany number fields.');
+                        }
+                    } else {
+                        targetTable[fieldName] = withDefault({
+                            name: columnName,
+                            type: 'numeric'
+                        }, field);
+                    }
+                    break;
+                }
+            case 'point':
+                {
+                    targetTable[fieldName] = withDefault({
+                        name: columnName,
+                        type: 'geometry'
+                    }, field);
+                    break;
+                }
+            case 'radio':
+            case 'select':
+                {
+                    const enumName = createTableName({
+                        adapter,
+                        config: field,
+                        parentTableName: newTableName,
+                        prefix: `enum_${newTableName}_`,
+                        target: 'enumName',
+                        throwValidationError
+                    });
+                    const options = field.options.map((option)=>{
+                        if (optionIsObject(option)) {
+                            return option.value;
+                        }
+                        return option;
+                    });
+                    if (field.type === 'select' && field.hasMany) {
+                        const selectTableName = createTableName({
+                            adapter,
+                            config: field,
+                            parentTableName: newTableName,
+                            prefix: `${newTableName}_`,
+                            throwValidationError,
+                            versionsCustomName: versions
+                        });
+                        const baseColumns = {
+                            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 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(isFieldLocalized && adapter.cms.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
+                        if (isLocalized) {
+                            baseColumns.locale = {
+                                name: 'locale',
+                                type: 'enum',
+                                locale: true,
+                                notNull: true
+                            };
+                            baseIndexes.localeIdx = {
+                                name: `${selectTableName}_locale_idx`,
+                                on: 'locale'
+                            };
+                        }
+                        if (field.index) {
+                            baseIndexes.value = {
+                                name: `${selectTableName}_value_idx`,
+                                on: 'value'
+                            };
+                        }
+                        buildTable({
+                            adapter,
+                            baseColumns,
+                            baseForeignKeys,
+                            baseIndexes,
+                            blocksTableNameMap,
+                            disableNotNull,
+                            disableUnique,
+                            fields: [],
+                            parentIsLocalized: parentIsLocalized || field.localized,
+                            rootTableName,
+                            setColumnID,
+                            tableName: selectTableName,
+                            versions
+                        });
+                        relationsToBuild.set(fieldName, {
+                            type: 'many',
+                            // selects have their own localized table, independent of the base table.
+                            localized: false,
+                            target: selectTableName
+                        });
+                        adapter.rawRelations[selectTableName] = {
+                            parent: {
+                                type: 'one',
+                                fields: [
+                                    {
+                                        name: 'parent',
+                                        table: selectTableName
+                                    }
+                                ],
+                                references: [
+                                    'id'
+                                ],
+                                relationName: fieldName,
+                                to: parentTableName
+                            }
+                        };
+                    } else {
+                        targetTable[fieldName] = withDefault({
+                            name: columnName,
+                            type: 'enum',
+                            enumName,
+                            options
+                        }, field);
+                    }
+                    break;
+                }
+            case 'relationship':
+            case 'upload':
+                if (Array.isArray(field.relationTo)) {
+                    field.relationTo.forEach((relation)=>{
+                        relationships.add(relation);
+                        if (field.unique && !disableUnique && !disableRelsTableUnique) {
+                            uniqueRelationships.add(relation);
+                        }
+                    });
+                } else if (field.hasMany) {
+                    relationships.add(field.relationTo);
+                    if (field.unique && !disableUnique && !disableRelsTableUnique) {
+                        uniqueRelationships.add(field.relationTo);
+                    }
+                } else {
+                    // simple relationships get a column on the targetTable with a foreign key to the relationTo table
+                    const relationshipConfig = adapter.cms.collections[field.relationTo].config;
+                    const tableName = adapter.tableNameMap.get(toSnakeCase(field.relationTo));
+                    // get the id type of the related collection
+                    let colType = isUUIDType(adapter.idType) ? 'uuid' : 'integer';
+                    const relatedCollectionCustomID = relationshipConfig.fields.find((field)=>fieldAffectsData(field) && field.name === 'id');
+                    if (relatedCollectionCustomID?.type === 'number') {
+                        colType = 'numeric';
+                    }
+                    if (relatedCollectionCustomID?.type === 'text') {
+                        colType = 'varchar';
+                    }
+                    // make the foreign key column for relationship using the correct id column type
+                    targetTable[fieldName] = {
+                        name: `${columnName}_id`,
+                        type: colType,
+                        reference: {
+                            name: 'id',
+                            onDelete: 'set null',
+                            table: tableName
+                        }
+                    };
+                    // add relationship to table
+                    relationsToBuild.set(fieldName, {
+                        type: 'one',
+                        localized: adapter.cms.config.localization && (isFieldLocalized || forceLocalized),
+                        target: tableName
+                    });
+                    // add notNull when not required
+                    if (!disableNotNull && field.required && !field.admin?.condition) {
+                        targetTable[fieldName].notNull = true;
+                    }
+                    break;
+                }
+                if (Boolean(isFieldLocalized && adapter.cms.config.localization) || withinLocalizedArrayOrBlock) {
+                    hasLocalizedRelationshipField = true;
+                }
+                break;
+            case 'text':
+                {
+                    if (field.hasMany) {
+                        const isLocalized = Boolean(isFieldLocalized && adapter.cms.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
+                        if (isLocalized) {
+                            hasLocalizedManyTextField = true;
+                        }
+                        if (field.index) {
+                            hasManyTextField = 'index';
+                        } else if (!hasManyTextField) {
+                            hasManyTextField = true;
+                        }
+                        if (field.unique) {
+                            throw new InvalidConfiguration('Unique is not supported in Postgres for hasMany text fields.');
+                        }
+                    } else {
+                        targetTable[fieldName] = withDefault({
+                            name: columnName,
+                            type: 'varchar'
+                        }, field);
+                    }
+                    break;
+                }
+            default:
+                break;
+        }
+        const condition = field.admin && field.admin.condition;
+        if (!disableNotNull && targetTable[fieldName] && 'required' in field && field.required && !condition) {
+            targetTable[fieldName].notNull = true;
+        }
+    });
+    return {
+        hasLocalizedField,
+        hasLocalizedManyNumberField,
+        hasLocalizedManyTextField,
+        hasLocalizedRelationshipField,
+        hasManyNumberField,
+        hasManyTextField
+    };
+};
+
+//# sourceMappingURL=traverseFields.js.map