@payloadcms/db-sqlite 3.0.0-canary.ff8c8fd → 3.0.0

package/dist/schema/traverseFields.js

@@ -1,15 +1,15 @@
-import { createTableName, hasLocalesTable, validateExistingBlockIsIdentical } from '@payloadcms/drizzle';
+import { buildIndexName, createTableName, hasLocalesTable, validateExistingBlockIsIdentical } from '@payloadcms/drizzle';
 import { relations } from 'drizzle-orm';
-import { SQLiteIntegerBuilder, SQLiteNumericBuilder, SQLiteTextBuilder, foreignKey, index, integer, numeric, text } from 'drizzle-orm/sqlite-core';
+import { foreignKey, index, integer, numeric, SQLiteIntegerBuilder, SQLiteNumericBuilder, SQLiteTextBuilder, text } from 'drizzle-orm/sqlite-core';
 import { InvalidConfiguration } from 'payload';
-import { fieldAffectsData, optionIsObject } from 'payload/shared';
+import { fieldAffectsData, fieldIsVirtual, optionIsObject } from 'payload/shared';
 import toSnakeCase from 'to-snake-case';
 import { buildTable } from './build.js';
 import { createIndex } from './createIndex.js';
 import { getIDColumn } from './getIDColumn.js';
 import { idToUUID } from './idToUUID.js';
 import { withDefault } from './withDefault.js';
-export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull, disableUnique = false, fieldPrefix, fields, forceLocalized, indexes, locales, localesColumns, localesIndexes, newTableName, parentTableName, relationsToBuild, relationships, rootRelationsToBuild, rootTableIDColType, rootTableName, versions })=>{
+export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull, disableRelsTableUnique, disableUnique = false, fieldPrefix, fields, forceLocalized, indexes, locales, localesColumns, localesIndexes, newTableName, parentTableName, relationships, relationsToBuild, rootRelationsToBuild, rootTableIDColType, rootTableName, uniqueRelationships, versions, withinLocalizedArrayOrBlock })=>{
     let hasLocalizedField = false;
     let hasLocalizedRelationshipField = false;
     let hasManyTextField = false;
@@ -17,11 +17,22 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
     let hasManyNumberField = false;
     let hasLocalizedManyNumberField = false;
     let parentIDColType = 'integer';
-    if (columns.id instanceof SQLiteIntegerBuilder) parentIDColType = 'integer';
-    if (columns.id instanceof SQLiteNumericBuilder) parentIDColType = 'numeric';
-    if (columns.id instanceof SQLiteTextBuilder) parentIDColType = 'text';
+    if (columns.id instanceof SQLiteIntegerBuilder) {
+        parentIDColType = 'integer';
+    }
+    if (columns.id instanceof SQLiteNumericBuilder) {
+        parentIDColType = 'numeric';
+    }
+    if (columns.id instanceof SQLiteTextBuilder) {
+        parentIDColType = 'text';
+    }
     fields.forEach((field)=>{
-        if ('name' in field && field.name === 'id') return;
+        if ('name' in field && field.name === 'id') {
+            return;
+        }
+        if (fieldIsVirtual(field)) {
+            return;
+        }
         let columnName;
         let fieldName;
         let targetTable = columns;
@@ -36,14 +47,15 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                 targetTable = localesColumns;
                 targetIndexes = localesIndexes;
             }
-            if ((field.unique || field.index) && ![
+            if ((field.unique || field.index || [
+                'relationship',
+                'upload'
+            ].includes(field.type)) && ![
                 'array',
                 'blocks',
                 'group',
-                'point',
-                'relationship',
-                'upload'
-            ].includes(field.type) && !('hasMany' in field && field.hasMany === true)) {
+                'point'
+            ].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}`;
@@ -52,170 +64,21 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                     }
                     adapter.fieldConstraints[rootTableName][`${columnName}_idx`] = constraintValue;
                 }
-                targetIndexes[`${newTableName}_${field.name}Idx`] = createIndex({
-                    name: fieldName,
-                    columnName,
-                    tableName: newTableName,
+                const indexName = buildIndexName({
+                    name: `${newTableName}_${columnName}`,
+                    adapter: adapter
+                });
+                targetIndexes[indexName] = createIndex({
+                    name: field.localized ? [
+                        fieldName,
+                        '_locale'
+                    ] : fieldName,
+                    indexName,
                     unique
                 });
             }
         }
         switch(field.type){
-            case 'text':
-                {
-                    if (field.hasMany) {
-                        if (field.localized) {
-                            hasLocalizedManyTextField = true;
-                        }
-                        if (field.index) {
-                            hasManyTextField = 'index';
-                        } else if (!hasManyTextField) {
-                            hasManyTextField = true;
-                        }
-                        if (field.unique) {
-                            throw new InvalidConfiguration('Unique is not supported in SQLite for hasMany text fields.');
-                        }
-                    } else {
-                        targetTable[fieldName] = withDefault(text(columnName), field);
-                    }
-                    break;
-                }
-            case 'email':
-            case 'code':
-            case 'textarea':
-                {
-                    targetTable[fieldName] = withDefault(text(columnName), field);
-                    break;
-                }
-            case 'number':
-                {
-                    if (field.hasMany) {
-                        if (field.localized) {
-                            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(numeric(columnName), field);
-                    }
-                    break;
-                }
-            case 'richText':
-            case 'json':
-                {
-                    targetTable[fieldName] = withDefault(text(columnName, {
-                        mode: 'json'
-                    }), field);
-                    break;
-                }
-            case 'date':
-                {
-                    targetTable[fieldName] = withDefault(text(columnName), field);
-                    break;
-                }
-            case 'point':
-                {
-                    break;
-                }
-            case 'radio':
-            case 'select':
-                {
-                    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}_`,
-                            versionsCustomName: versions
-                        });
-                        const baseColumns = {
-                            order: integer('order').notNull(),
-                            parent: getIDColumn({
-                                name: 'parent_id',
-                                type: parentIDColType,
-                                notNull: true,
-                                primaryKey: false
-                            }),
-                            value: text('value', {
-                                enum: 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)
-                        };
-                        if (field.localized) {
-                            baseColumns.locale = text('locale', {
-                                enum: locales
-                            }).notNull();
-                            baseExtraConfig.localeIdx = (cols)=>index(`${selectTableName}_locale_idx`).on(cols.locale);
-                        }
-                        if (field.index) {
-                            baseExtraConfig.value = (cols)=>index(`${selectTableName}_value_idx`).on(cols.value);
-                        }
-                        buildTable({
-                            adapter,
-                            baseColumns,
-                            baseExtraConfig,
-                            disableNotNull,
-                            disableUnique,
-                            fields: [],
-                            rootTableName,
-                            tableName: selectTableName,
-                            versions
-                        });
-                        relationsToBuild.set(fieldName, {
-                            type: 'many',
-                            // selects have their own localized table, independent of the base table.
-                            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
-                                })
-                            }));
-                    } else {
-                        targetTable[fieldName] = withDefault(text(fieldName, {
-                            enum: options
-                        }), field);
-                    }
-                    break;
-                }
-            case 'checkbox':
-                {
-                    targetTable[fieldName] = withDefault(integer(columnName, {
-                        mode: 'boolean'
-                    }), field);
-                    break;
-                }
             case 'array':
                 {
                     const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull;
@@ -248,31 +111,48 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                             }).onDelete('cascade'),
                         _parentIDIdx: (cols)=>index(`${arrayTableName}_parent_id_idx`).on(cols._parentID)
                     };
-                    if (field.localized && adapter.payload.config.localization) {
+                    const isLocalized = Boolean(field.localized && adapter.payload.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
+                    if (isLocalized) {
                         baseColumns._locale = text('_locale', {
                             enum: locales
                         }).notNull();
                         baseExtraConfig._localeIdx = (cols)=>index(`${arrayTableName}_locale_idx`).on(cols._locale);
                     }
-                    const { hasManyNumberField: subHasManyNumberField, hasManyTextField: subHasManyTextField, relationsToBuild: subRelationsToBuild } = buildTable({
+                    const { hasLocalizedManyNumberField: subHasLocalizedManyNumberField, hasLocalizedManyTextField: subHasLocalizedManyTextField, hasLocalizedRelationshipField: subHasLocalizedRelationshipField, hasManyNumberField: subHasManyNumberField, hasManyTextField: subHasManyTextField, relationsToBuild: subRelationsToBuild } = buildTable({
                         adapter,
                         baseColumns,
                         baseExtraConfig,
                         disableNotNull: disableNotNullFromHere,
+                        disableRelsTableUnique: true,
                         disableUnique,
                         fields: disableUnique ? idToUUID(field.fields) : field.fields,
-                        rootRelationsToBuild,
                         rootRelationships: relationships,
+                        rootRelationsToBuild,
                         rootTableIDColType,
                         rootTableName,
+                        rootUniqueRelationships: uniqueRelationships,
                         tableName: arrayTableName,
-                        versions
+                        versions,
+                        withinLocalizedArrayOrBlock: isLocalized
                     });
+                    if (subHasLocalizedManyNumberField) {
+                        hasLocalizedManyNumberField = subHasLocalizedManyNumberField;
+                    }
+                    if (subHasLocalizedRelationshipField) {
+                        hasLocalizedRelationshipField = subHasLocalizedRelationshipField;
+                    }
+                    if (subHasLocalizedManyTextField) {
+                        hasLocalizedManyTextField = subHasLocalizedManyTextField;
+                    }
                     if (subHasManyTextField) {
-                        if (!hasManyTextField || subHasManyTextField === 'index') hasManyTextField = subHasManyTextField;
+                        if (!hasManyTextField || subHasManyTextField === 'index') {
+                            hasManyTextField = subHasManyTextField;
+                        }
                     }
                     if (subHasManyNumberField) {
-                        if (!hasManyNumberField || subHasManyNumberField === 'index') hasManyNumberField = subHasManyNumberField;
+                        if (!hasManyNumberField || subHasManyNumberField === 'index') {
+                            hasManyNumberField = subHasManyNumberField;
+                        }
                     }
                     relationsToBuild.set(fieldName, {
                         type: 'many',
@@ -344,7 +224,6 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                             };
                             const baseExtraConfig = {
                                 _orderIdx: (cols)=>index(`${blockTableName}_order_idx`).on(cols._order),
-                                _parentIDIdx: (cols)=>index(`${blockTableName}_parent_id_idx`).on(cols._parentID),
                                 _parentIdFk: (cols)=>foreignKey({
                                         name: `${blockTableName}_parent_id_fk`,
                                         columns: [
@@ -354,33 +233,51 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                                             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)
                             };
-                            if (field.localized && adapter.payload.config.localization) {
+                            const isLocalized = Boolean(field.localized && adapter.payload.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
+                            if (isLocalized) {
                                 baseColumns._locale = text('_locale', {
                                     enum: locales
                                 }).notNull();
                                 baseExtraConfig._localeIdx = (cols)=>index(`${blockTableName}_locale_idx`).on(cols._locale);
                             }
-                            const { hasManyNumberField: subHasManyNumberField, hasManyTextField: subHasManyTextField, relationsToBuild: subRelationsToBuild } = buildTable({
+                            const { hasLocalizedManyNumberField: subHasLocalizedManyNumberField, hasLocalizedManyTextField: subHasLocalizedManyTextField, hasLocalizedRelationshipField: subHasLocalizedRelationshipField, hasManyNumberField: subHasManyNumberField, hasManyTextField: subHasManyTextField, relationsToBuild: subRelationsToBuild } = buildTable({
                                 adapter,
                                 baseColumns,
                                 baseExtraConfig,
                                 disableNotNull: disableNotNullFromHere,
+                                disableRelsTableUnique: true,
                                 disableUnique,
                                 fields: disableUnique ? idToUUID(block.fields) : block.fields,
-                                rootRelationsToBuild,
                                 rootRelationships: relationships,
+                                rootRelationsToBuild,
                                 rootTableIDColType,
                                 rootTableName,
+                                rootUniqueRelationships: uniqueRelationships,
                                 tableName: blockTableName,
-                                versions
+                                versions,
+                                withinLocalizedArrayOrBlock: isLocalized
                             });
+                            if (subHasLocalizedManyNumberField) {
+                                hasLocalizedManyNumberField = subHasLocalizedManyNumberField;
+                            }
+                            if (subHasLocalizedRelationshipField) {
+                                hasLocalizedRelationshipField = subHasLocalizedRelationshipField;
+                            }
+                            if (subHasLocalizedManyTextField) {
+                                hasLocalizedManyTextField = subHasLocalizedManyTextField;
+                            }
                             if (subHasManyTextField) {
-                                if (!hasManyTextField || subHasManyTextField === 'index') hasManyTextField = subHasManyTextField;
+                                if (!hasManyTextField || subHasManyTextField === 'index') {
+                                    hasManyTextField = subHasManyTextField;
+                                }
                             }
                             if (subHasManyNumberField) {
-                                if (!hasManyNumberField || subHasManyNumberField === 'index') hasManyNumberField = subHasManyNumberField;
+                                if (!hasManyNumberField || subHasManyNumberField === 'index') {
+                                    hasManyNumberField = subHasManyNumberField;
+                                }
                             }
                             adapter.relations[`relations_${blockTableName}`] = relations(adapter.tables[blockTableName], ({ many, one })=>{
                                 const result = {
@@ -439,8 +336,75 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                     });
                     break;
                 }
-            case 'tab':
+            case 'checkbox':
+                {
+                    targetTable[fieldName] = withDefault(integer(columnName, {
+                        mode: 'boolean'
+                    }), field);
+                    break;
+                }
+            case 'code':
+            case 'email':
+            case 'textarea':
+                {
+                    targetTable[fieldName] = withDefault(text(columnName), field);
+                    break;
+                }
+            case 'collapsible':
+            case 'row':
+                {
+                    const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull;
+                    const { hasLocalizedField: rowHasLocalizedField, hasLocalizedManyNumberField: rowHasLocalizedManyNumberField, hasLocalizedManyTextField: rowHasLocalizedManyTextField, hasLocalizedRelationshipField: rowHasLocalizedRelationshipField, hasManyNumberField: rowHasManyNumberField, hasManyTextField: rowHasManyTextField } = traverseFields({
+                        adapter,
+                        columnPrefix,
+                        columns,
+                        disableNotNull: disableNotNullFromHere,
+                        disableUnique,
+                        fieldPrefix,
+                        fields: field.fields,
+                        forceLocalized,
+                        indexes,
+                        locales,
+                        localesColumns,
+                        localesIndexes,
+                        newTableName,
+                        parentTableName,
+                        relationships,
+                        relationsToBuild,
+                        rootRelationsToBuild,
+                        rootTableIDColType,
+                        rootTableName,
+                        uniqueRelationships,
+                        versions,
+                        withinLocalizedArrayOrBlock
+                    });
+                    if (rowHasLocalizedField) {
+                        hasLocalizedField = true;
+                    }
+                    if (rowHasLocalizedRelationshipField) {
+                        hasLocalizedRelationshipField = true;
+                    }
+                    if (rowHasManyTextField) {
+                        hasManyTextField = true;
+                    }
+                    if (rowHasLocalizedManyTextField) {
+                        hasLocalizedManyTextField = true;
+                    }
+                    if (rowHasManyNumberField) {
+                        hasManyNumberField = true;
+                    }
+                    if (rowHasLocalizedManyNumberField) {
+                        hasLocalizedManyNumberField = true;
+                    }
+                    break;
+                }
+            case 'date':
+                {
+                    targetTable[fieldName] = withDefault(text(columnName), field);
+                    break;
+                }
             case 'group':
+            case 'tab':
                 {
                     if (!('name' in field)) {
                         const { hasLocalizedField: groupHasLocalizedField, hasLocalizedManyNumberField: groupHasLocalizedManyNumberField, hasLocalizedManyTextField: groupHasLocalizedManyTextField, hasLocalizedRelationshipField: groupHasLocalizedRelationshipField, hasManyNumberField: groupHasManyNumberField, hasManyTextField: groupHasManyTextField } = traverseFields({
@@ -458,19 +422,33 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                             localesIndexes,
                             newTableName,
                             parentTableName,
-                            relationsToBuild,
                             relationships,
+                            relationsToBuild,
                             rootRelationsToBuild,
                             rootTableIDColType,
                             rootTableName,
-                            versions
+                            uniqueRelationships,
+                            versions,
+                            withinLocalizedArrayOrBlock
                         });
-                        if (groupHasLocalizedField) hasLocalizedField = true;
-                        if (groupHasLocalizedRelationshipField) hasLocalizedRelationshipField = true;
-                        if (groupHasManyTextField) hasManyTextField = true;
-                        if (groupHasLocalizedManyTextField) hasLocalizedManyTextField = true;
-                        if (groupHasManyNumberField) hasManyNumberField = true;
-                        if (groupHasLocalizedManyNumberField) hasLocalizedManyNumberField = true;
+                        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;
                     }
                     const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull;
@@ -489,97 +467,168 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                         localesIndexes,
                         newTableName: `${parentTableName}_${columnName}`,
                         parentTableName,
-                        relationsToBuild,
                         relationships,
+                        relationsToBuild,
                         rootRelationsToBuild,
                         rootTableIDColType,
                         rootTableName,
-                        versions
+                        uniqueRelationships,
+                        versions,
+                        withinLocalizedArrayOrBlock: withinLocalizedArrayOrBlock || field.localized
                     });
-                    if (groupHasLocalizedField) hasLocalizedField = true;
-                    if (groupHasLocalizedRelationshipField) hasLocalizedRelationshipField = true;
-                    if (groupHasManyTextField) hasManyTextField = true;
-                    if (groupHasLocalizedManyTextField) hasLocalizedManyTextField = true;
-                    if (groupHasManyNumberField) hasManyNumberField = true;
-                    if (groupHasLocalizedManyNumberField) hasLocalizedManyNumberField = true;
+                    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 'tabs':
+            case 'json':
+            case 'richText':
                 {
-                    const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull;
-                    const { hasLocalizedField: tabHasLocalizedField, hasLocalizedManyNumberField: tabHasLocalizedManyNumberField, hasLocalizedManyTextField: tabHasLocalizedManyTextField, hasLocalizedRelationshipField: tabHasLocalizedRelationshipField, hasManyNumberField: tabHasManyNumberField, hasManyTextField: tabHasManyTextField } = traverseFields({
-                        adapter,
-                        columnPrefix,
-                        columns,
-                        disableNotNull: disableNotNullFromHere,
-                        disableUnique,
-                        fieldPrefix,
-                        fields: field.tabs.map((tab)=>({
-                                ...tab,
-                                type: 'tab'
-                            })),
-                        forceLocalized,
-                        indexes,
-                        locales,
-                        localesColumns,
-                        localesIndexes,
-                        newTableName,
-                        parentTableName,
-                        relationsToBuild,
-                        relationships,
-                        rootRelationsToBuild,
-                        rootTableIDColType,
-                        rootTableName,
-                        versions
-                    });
-                    if (tabHasLocalizedField) hasLocalizedField = true;
-                    if (tabHasLocalizedRelationshipField) hasLocalizedRelationshipField = true;
-                    if (tabHasManyTextField) hasManyTextField = true;
-                    if (tabHasLocalizedManyTextField) hasLocalizedManyTextField = true;
-                    if (tabHasManyNumberField) hasManyNumberField = true;
-                    if (tabHasLocalizedManyNumberField) hasLocalizedManyNumberField = true;
+                    targetTable[fieldName] = withDefault(text(columnName, {
+                        mode: 'json'
+                    }), field);
                     break;
                 }
-            case 'row':
-            case 'collapsible':
+            case 'number':
                 {
-                    const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull;
-                    const { hasLocalizedField: rowHasLocalizedField, hasLocalizedManyNumberField: rowHasLocalizedManyNumberField, hasLocalizedManyTextField: rowHasLocalizedManyTextField, hasLocalizedRelationshipField: rowHasLocalizedRelationshipField, hasManyNumberField: rowHasManyNumberField, hasManyTextField: rowHasManyTextField } = traverseFields({
-                        adapter,
-                        columnPrefix,
-                        columns,
-                        disableNotNull: disableNotNullFromHere,
-                        disableUnique,
-                        fieldPrefix,
-                        fields: field.fields,
-                        forceLocalized,
-                        indexes,
-                        locales,
-                        localesColumns,
-                        localesIndexes,
-                        newTableName,
-                        parentTableName,
-                        relationsToBuild,
-                        relationships,
-                        rootRelationsToBuild,
-                        rootTableIDColType,
-                        rootTableName,
-                        versions
+                    if (field.hasMany) {
+                        const isLocalized = Boolean(field.localized && adapter.payload.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(numeric(columnName), field);
+                    }
+                    break;
+                }
+            case 'point':
+                {
+                    break;
+                }
+            case 'radio':
+            case 'select':
+                {
+                    const options = field.options.map((option)=>{
+                        if (optionIsObject(option)) {
+                            return option.value;
+                        }
+                        return option;
                     });
-                    if (rowHasLocalizedField) hasLocalizedField = true;
-                    if (rowHasLocalizedRelationshipField) hasLocalizedRelationshipField = true;
-                    if (rowHasManyTextField) hasManyTextField = true;
-                    if (rowHasLocalizedManyTextField) hasLocalizedManyTextField = true;
-                    if (rowHasManyNumberField) hasManyNumberField = true;
-                    if (rowHasLocalizedManyNumberField) hasLocalizedManyNumberField = true;
+                    if (field.type === 'select' && field.hasMany) {
+                        const selectTableName = createTableName({
+                            adapter,
+                            config: field,
+                            parentTableName: newTableName,
+                            prefix: `${newTableName}_`,
+                            versionsCustomName: versions
+                        });
+                        const baseColumns = {
+                            order: integer('order').notNull(),
+                            parent: getIDColumn({
+                                name: 'parent_id',
+                                type: parentIDColType,
+                                notNull: true,
+                                primaryKey: false
+                            }),
+                            value: text('value', {
+                                enum: 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 isLocalized = Boolean(field.localized && adapter.payload.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
+                        if (isLocalized) {
+                            baseColumns.locale = text('locale', {
+                                enum: locales
+                            }).notNull();
+                            baseExtraConfig.localeIdx = (cols)=>index(`${selectTableName}_locale_idx`).on(cols.locale);
+                        }
+                        if (field.index) {
+                            baseExtraConfig.value = (cols)=>index(`${selectTableName}_value_idx`).on(cols.value);
+                        }
+                        buildTable({
+                            adapter,
+                            baseColumns,
+                            baseExtraConfig,
+                            disableNotNull,
+                            disableUnique,
+                            fields: [],
+                            rootTableName,
+                            tableName: selectTableName,
+                            versions
+                        });
+                        relationsToBuild.set(fieldName, {
+                            type: 'many',
+                            // selects have their own localized table, independent of the base table.
+                            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
+                                })
+                            }));
+                    } else {
+                        targetTable[fieldName] = withDefault(text(columnName, {
+                            enum: options
+                        }), field);
+                    }
                     break;
                 }
             case 'relationship':
             case 'upload':
                 if (Array.isArray(field.relationTo)) {
-                    field.relationTo.forEach((relation)=>relationships.add(relation));
+                    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.payload.collections[field.relationTo].config;
@@ -587,8 +636,12 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                     // get the id type of the related collection
                     let colType = 'integer';
                     const relatedCollectionCustomID = relationshipConfig.fields.find((field)=>fieldAffectsData(field) && field.name === 'id');
-                    if (relatedCollectionCustomID?.type === 'number') colType = 'numeric';
-                    if (relatedCollectionCustomID?.type === 'text') colType = 'text';
+                    if (relatedCollectionCustomID?.type === 'number') {
+                        colType = 'numeric';
+                    }
+                    if (relatedCollectionCustomID?.type === 'text') {
+                        colType = 'text';
+                    }
                     // make the foreign key column for relationship using the correct id column type
                     targetTable[fieldName] = getIDColumn({
                         name: `${columnName}_id`,
@@ -600,7 +653,7 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                     // add relationship to table
                     relationsToBuild.set(fieldName, {
                         type: 'one',
-                        localized: adapter.payload.config.localization && field.localized,
+                        localized: adapter.payload.config.localization && (field.localized || forceLocalized),
                         target: tableName
                     });
                     // add notNull when not required
@@ -609,10 +662,80 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                     }
                     break;
                 }
-                if (adapter.payload.config.localization && field.localized) {
+                if (Boolean(field.localized && adapter.payload.config.localization) || withinLocalizedArrayOrBlock) {
                     hasLocalizedRelationshipField = true;
                 }
                 break;
+            case 'tabs':
+                {
+                    const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull;
+                    const { hasLocalizedField: tabHasLocalizedField, hasLocalizedManyNumberField: tabHasLocalizedManyNumberField, hasLocalizedManyTextField: tabHasLocalizedManyTextField, hasLocalizedRelationshipField: tabHasLocalizedRelationshipField, hasManyNumberField: tabHasManyNumberField, hasManyTextField: tabHasManyTextField } = traverseFields({
+                        adapter,
+                        columnPrefix,
+                        columns,
+                        disableNotNull: disableNotNullFromHere,
+                        disableUnique,
+                        fieldPrefix,
+                        fields: field.tabs.map((tab)=>({
+                                ...tab,
+                                type: 'tab'
+                            })),
+                        forceLocalized,
+                        indexes,
+                        locales,
+                        localesColumns,
+                        localesIndexes,
+                        newTableName,
+                        parentTableName,
+                        relationships,
+                        relationsToBuild,
+                        rootRelationsToBuild,
+                        rootTableIDColType,
+                        rootTableName,
+                        uniqueRelationships,
+                        versions,
+                        withinLocalizedArrayOrBlock
+                    });
+                    if (tabHasLocalizedField) {
+                        hasLocalizedField = true;
+                    }
+                    if (tabHasLocalizedRelationshipField) {
+                        hasLocalizedRelationshipField = true;
+                    }
+                    if (tabHasManyTextField) {
+                        hasManyTextField = true;
+                    }
+                    if (tabHasLocalizedManyTextField) {
+                        hasLocalizedManyTextField = true;
+                    }
+                    if (tabHasManyNumberField) {
+                        hasManyNumberField = true;
+                    }
+                    if (tabHasLocalizedManyNumberField) {
+                        hasLocalizedManyNumberField = true;
+                    }
+                    break;
+                }
+            case 'text':
+                {
+                    if (field.hasMany) {
+                        const isLocalized = Boolean(field.localized && adapter.payload.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 SQLite for hasMany text fields.');
+                        }
+                    } else {
+                        targetTable[fieldName] = withDefault(text(columnName), field);
+                    }
+                    break;
+                }
             default:
                 break;
         }