chore: builds enum pattern

packages/db-postgres/src/index.ts

@@ -30,8 +30,9 @@ export function postgresAdapter(args: Args): PostgresAdapterResult {
     // @ts-expect-error
     return createDatabaseAdapter<PostgresAdapter>({
       ...args,
-      tables: {},
+      enums: {},
       relations: {},
+      tables: {},
       payload,
       connect,
       db: undefined,

packages/db-postgres/src/init.ts

@@ -3,12 +3,17 @@ import { buildVersionCollectionFields } from 'payload/dist/versions/buildCollect
 import { SanitizedCollectionConfig } from 'payload/dist/collections/config/types';
 import { getVersionsModelName } from 'payload/dist/versions/getVersionsModelName';
 import type { Init } from 'payload/dist/database/types';
+import { pgEnum } from 'drizzle-orm/pg-core';
 import type { PostgresAdapter } from './types';
 import { buildTable } from './schema/build';
 
 export const init: Init = async function init(
   this: PostgresAdapter,
 ) {
+  if (this.payload.config.localization) {
+    this.enums._locales = pgEnum('_locales', this.payload.config.localization.locales as [string, ...string[]]);
+  }
+
   this.payload.config.collections.forEach(
     (collection: SanitizedCollectionConfig) => {
       buildTable({

packages/db-postgres/src/schema/build.ts

@@ -24,6 +24,7 @@ import { traverseFields } from './traverseFields';
 
 type Args = {
   adapter: PostgresAdapter
+  baseColumns?: Record<string, AnyPgColumnBuilder>,
   buildRelationships?: boolean
   fields: Field[]
   tableName: string
@@ -31,15 +32,17 @@ type Args = {
 
 export const buildTable = ({
   adapter,
+  baseColumns = {},
   buildRelationships,
   fields,
   tableName,
 }: Args): void => {
   const formattedTableName = toSnakeCase(tableName);
-  const columns: Record<string, AnyPgColumnBuilder> = {};
+  const columns: Record<string, AnyPgColumnBuilder> = baseColumns;
   const indexes: Record<string, (cols: GenericColumns) => IndexBuilder> = {};
 
   let hasLocalizedField = false;
+
   const localesColumns: Record<string, AnyPgColumnBuilder> = {};
   const localesIndexes: Record<string, (cols: GenericColumns) => IndexBuilder> = {};
   let localesTable: GenericTable;
@@ -78,6 +81,9 @@ export const buildTable = ({
 
   if (hasLocalizedField) {
     const localeTableName = `${formattedTableName}_locales`;
+    localesColumns.id = integer('id').primaryKey();
+    localesColumns._locale = adapter.enums._locales('_locale').notNull();
+    localesColumns._parentID = integer('_parent_id').references(() => table.id).notNull();
 
     localesTable = pgTable(localeTableName, localesColumns, (cols) => {
       return Object.entries(localesIndexes).reduce((acc, [colName, func]) => {
@@ -109,7 +115,6 @@ export const buildTable = ({
     }
   }
 
-
   const tableRelations = relations(table, ({ many }) => {
     const result: Record<string, Relation<string>> = {};
 

packages/db-postgres/src/schema/traverseFields.ts

@@ -5,6 +5,7 @@ import toSnakeCase from 'to-snake-case';
 import { fieldAffectsData } from 'payload/dist/fields/config/types';
 import { GenericColumns, PostgresAdapter } from '../types';
 import { createIndex } from './createIndex';
+import { buildTable } from './build';
 
 type Args = {
   adapter: PostgresAdapter
@@ -61,15 +62,38 @@ export const traverseFields = ({
       case 'text':
       case 'email':
       case 'code':
-      case 'textarea':
+      case 'textarea': {
         targetTable[`${fieldPrefix || ''}${field.name}`] = varchar(columnName);
         break;
+      }
 
-      case 'number':
+      case 'number': {
         targetTable[`${fieldPrefix || ''}${field.name}`] = numeric(columnName);
         break;
+      }
+
+      case 'array': {
+        const baseColumns: Record<string, AnyPgColumnBuilder> = {
+          _order: integer('_order').notNull(),
+          _parentID: integer('_parent_id').references(() => adapter.tables[tableName].id).notNull(),
+        };
+
+        if (field.localized && adapter.payload.config.localization) {
+          baseColumns._locale = adapter.enums._locales('_locale').notNull();
+        }
+
+        buildTable({
+          adapter,
+          baseColumns,
+          fields: field.fields,
+          tableName: `${tableName}_${toSnakeCase(field.name)}`,
+        });
+
+        break;
+      }
 
       case 'group': {
+        // Todo: determine what should happen if groups are set to localized
         const { hasLocalizedField: groupHasLocalizedField } = traverseFields({
           adapter,
           buildRelationships,
@@ -80,7 +104,7 @@ export const traverseFields = ({
           indexes,
           localesColumns,
           localesIndexes,
-          tableName,
+          tableName: `${tableName}_${toSnakeCase(field.name)}`,
           relationships,
         });
 

packages/db-postgres/src/types.ts

@@ -1,6 +1,6 @@
 import { Relation, Relations } from 'drizzle-orm';
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { PgColumn, PgColumnHKT, PgTableWithColumns } from 'drizzle-orm/pg-core';
+import { PgColumn, PgColumnHKT, PgEnum, PgTableWithColumns } from 'drizzle-orm/pg-core';
 import { Payload } from 'payload';
 import { DatabaseAdapter } from 'payload/dist/database/types';
 import { ClientConfig, PoolConfig } from 'pg';
@@ -42,8 +42,9 @@ export type GenericTable = PgTableWithColumns<{
 
 export type PostgresAdapter = DatabaseAdapter & Args & {
   db: DrizzleDB
-  tables: Record<string, GenericTable>
+  enums: Record<string, PgEnum<[string, ...string[]]>>
   relations: Record<string, Relations<string, Record<string, Relation<string>>>>
+  tables: Record<string, GenericTable>
 }
 
 export type PostgresAdapterResult = (args: { payload: Payload }) => PostgresAdapter