@payloadcms/drizzle 3.0.0-canary.67aae47 → 3.0.0-canary.6b9e4be

package/dist/postgres/schema/traverseFields.js

@@ -83,166 +83,6 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
             }
         }
         switch(field.type){
-            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 Postgres for hasMany text fields.');
-                        }
-                    } else {
-                        targetTable[fieldName] = withDefault(varchar(columnName), field);
-                    }
-                    break;
-                }
-            case 'email':
-            case 'code':
-            case 'textarea':
-                {
-                    targetTable[fieldName] = withDefault(varchar(columnName), field);
-                    break;
-                }
-            case 'number':
-                {
-                    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 'richText':
-            case 'json':
-                {
-                    targetTable[fieldName] = withDefault(jsonb(columnName), field);
-                    break;
-                }
-            case 'date':
-                {
-                    targetTable[fieldName] = withDefault(timestamp(columnName, {
-                        mode: 'string',
-                        precision: 3,
-                        withTimezone: true
-                    }), field);
-                    break;
-                }
-            case 'point':
-                {
-                    targetTable[fieldName] = withDefault(geometryColumn(columnName), field);
-                    if (!adapter.extensions.postgis) {
-                        adapter.extensions.postgis = true;
-                    }
-                    break;
-                }
-            case 'radio':
-            case 'select':
-                {
-                    const enumName = createTableName({
-                        adapter,
-                        config: field,
-                        parentTableName: newTableName,
-                        prefix: `enum_${newTableName}_`,
-                        target: 'enumName',
-                        throwValidationError
-                    });
-                    adapter.enums[enumName] = adapter.pgSchema.enum(enumName, 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: integer('order').notNull(),
-                            parent: parentIDColumnMap[parentIDColType]('parent_id').notNull(),
-                            value: adapter.enums[enumName]('value')
-                        };
-                        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 = adapter.enums.enum__locales('locale').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(adapter.enums[enumName](columnName), field);
-                    }
-                    break;
-                }
-            case 'checkbox':
-                {
-                    targetTable[fieldName] = withDefault(boolean(columnName), field);
-                    break;
-                }
             case 'array':
                 {
                     const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull;
@@ -488,8 +328,76 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                     });
                     break;
                 }
-            case 'tab':
+            case 'checkbox':
+                {
+                    targetTable[fieldName] = withDefault(boolean(columnName), field);
+                    break;
+                }
+            case 'code':
+            case 'email':
+            case 'textarea':
+                {
+                    targetTable[fieldName] = withDefault(varchar(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,
+                        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(timestamp(columnName, {
+                        mode: 'string',
+                        precision: 3,
+                        withTimezone: true
+                    }), field);
+                    break;
+                }
             case 'group':
+            case 'tab':
                 {
                     if (!('name' in field)) {
                         const { hasLocalizedField: groupHasLocalizedField, hasLocalizedManyNumberField: groupHasLocalizedManyNumberField, hasLocalizedManyTextField: groupHasLocalizedManyTextField, hasLocalizedRelationshipField: groupHasLocalizedRelationshipField, hasManyNumberField: groupHasManyNumberField, hasManyTextField: groupHasManyTextField } = traverseFields({
@@ -579,99 +487,122 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                     }
                     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,
-                        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;
+                    targetTable[fieldName] = withDefault(jsonb(columnName), field);
+                    break;
+                }
+            case 'number':
+                {
+                    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);
                     }
-                    if (tabHasLocalizedManyNumberField) {
-                        hasLocalizedManyNumberField = true;
+                    break;
+                }
+            case 'point':
+                {
+                    targetTable[fieldName] = withDefault(geometryColumn(columnName), field);
+                    if (!adapter.extensions.postgis) {
+                        adapter.extensions.postgis = true;
                     }
                     break;
                 }
-            case 'row':
-            case 'collapsible':
+            case 'radio':
+            case 'select':
                 {
-                    const disableNotNullFromHere = Boolean(field.admin?.condition) || disableNotNull;
-                    const { hasLocalizedField: rowHasLocalizedField, hasLocalizedManyNumberField: rowHasLocalizedManyNumberField, hasLocalizedManyTextField: rowHasLocalizedManyTextField, hasLocalizedRelationshipField: rowHasLocalizedRelationshipField, hasManyNumberField: rowHasManyNumberField, hasManyTextField: rowHasManyTextField } = traverseFields({
+                    const enumName = createTableName({
                         adapter,
-                        columnPrefix,
-                        columns,
-                        disableNotNull: disableNotNullFromHere,
-                        disableUnique,
-                        fieldPrefix,
-                        fields: field.fields,
-                        forceLocalized,
-                        indexes,
-                        localesColumns,
-                        localesIndexes,
-                        newTableName,
-                        parentTableName,
-                        relationships,
-                        relationsToBuild,
-                        rootRelationsToBuild,
-                        rootTableIDColType,
-                        rootTableName,
-                        uniqueRelationships,
-                        versions,
-                        withinLocalizedArrayOrBlock
+                        config: field,
+                        parentTableName: newTableName,
+                        prefix: `enum_${newTableName}_`,
+                        target: 'enumName',
+                        throwValidationError
                     });
-                    if (rowHasLocalizedField) {
-                        hasLocalizedField = true;
-                    }
-                    if (rowHasLocalizedRelationshipField) {
-                        hasLocalizedRelationshipField = true;
-                    }
-                    if (rowHasManyTextField) {
-                        hasManyTextField = true;
-                    }
-                    if (rowHasLocalizedManyTextField) {
-                        hasLocalizedManyTextField = true;
-                    }
-                    if (rowHasManyNumberField) {
-                        hasManyNumberField = true;
-                    }
-                    if (rowHasLocalizedManyNumberField) {
-                        hasLocalizedManyNumberField = true;
+                    adapter.enums[enumName] = adapter.pgSchema.enum(enumName, 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: integer('order').notNull(),
+                            parent: parentIDColumnMap[parentIDColType]('parent_id').notNull(),
+                            value: adapter.enums[enumName]('value')
+                        };
+                        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 = adapter.enums.enum__locales('locale').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(adapter.enums[enumName](columnName), field);
                     }
                     break;
                 }
@@ -722,6 +653,75 @@ export const traverseFields = ({ adapter, columnPrefix, columns, disableNotNull,
                     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,
+                        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 Postgres for hasMany text fields.');
+                        }
+                    } else {
+                        targetTable[fieldName] = withDefault(varchar(columnName), field);
+                    }
+                    break;
+                }
             default:
                 break;
         }