refactor: deduplicate and abstract SQL schema building

packages/db-postgres/src/index.ts

@@ -167,6 +167,8 @@ export function postgresAdapter(args: Args): DatabaseAdapterObj<PostgresAdapter>
       packageName: '@payloadcms/db-postgres',
       payload,
       queryDrafts,
+      rawRelations: {},
+      rawTables: {},
       rejectInitializing,
       requireDrizzleKit,
       resolveInitializing,

packages/db-sqlite/src/index.ts

@@ -100,6 +100,8 @@ export function sqliteAdapter(args: Args): DatabaseAdapterObj<SQLiteAdapter> {
       operators,
       prodMigrations: args.prodMigrations,
       push: args.push,
+      rawRelations: {},
+      rawTables: {},
       relations: {},
       relationshipsSuffix: args.relationshipsSuffix || '_rels',
       schema: {},

packages/db-sqlite/src/init.ts

@@ -1,138 +1,38 @@
 import type { DrizzleAdapter } from '@payloadcms/drizzle/types'
-import type { Init, SanitizedCollectionConfig } from 'payload'
+import type { Init } from 'payload'
 
-import { createTableName, executeSchemaHooks } from '@payloadcms/drizzle'
-import { uniqueIndex } from 'drizzle-orm/sqlite-core'
-import { buildVersionCollectionFields, buildVersionGlobalFields } from 'payload'
-import toSnakeCase from 'to-snake-case'
+import { buildDrizzleRelations, buildRawSchema, executeSchemaHooks } from '@payloadcms/drizzle'
 
-import type { BaseExtraConfig } from './schema/build.js'
 import type { SQLiteAdapter } from './types.js'
 
-import { buildTable } from './schema/build.js'
+import { buildDrizzleTable } from './schema/buildDrizzleTable.js'
+import { setColumnID } from './schema/setColumnID.js'
 
 export const init: Init = async function init(this: SQLiteAdapter) {
-  let locales: [string, ...string[]] | undefined
-  await executeSchemaHooks({ type: 'beforeSchemaInit', adapter: this })
+  let locales: string[] | undefined
+
+  this.rawRelations = {}
+  this.rawTables = {}
 
   if (this.payload.config.localization) {
-    locales = this.payload.config.localization.locales.map(({ code }) => code) as [
-      string,
-      ...string[],
-    ]
+    locales = this.payload.config.localization.locales.map(({ code }) => code)
   }
 
-  this.payload.config.collections.forEach((collection: SanitizedCollectionConfig) => {
-    createTableName({
-      adapter: this as unknown as DrizzleAdapter,
-      config: collection,
-    })
-
-    if (collection.versions) {
-      createTableName({
-        adapter: this as unknown as DrizzleAdapter,
-        config: collection,
-        versions: true,
-        versionsCustomName: true,
-      })
-    }
-  })
-  this.payload.config.collections.forEach((collection: SanitizedCollectionConfig) => {
-    const tableName = this.tableNameMap.get(toSnakeCase(collection.slug))
-    const config = this.payload.config
-
-    const baseExtraConfig: BaseExtraConfig = {}
-
-    if (collection.upload.filenameCompoundIndex) {
-      const indexName = `${tableName}_filename_compound_idx`
-
-      baseExtraConfig.filename_compound_index = (cols) => {
-        const colsConstraint = collection.upload.filenameCompoundIndex.map((f) => {
-          return cols[f]
-        })
-        return uniqueIndex(indexName).on(colsConstraint[0], ...colsConstraint.slice(1))
-      }
-    }
+  const adapter = this as unknown as DrizzleAdapter
 
-    if (collection.upload.filenameCompoundIndex) {
-      const indexName = `${tableName}_filename_compound_idx`
-
-      baseExtraConfig.filename_compound_index = (cols) => {
-        const colsConstraint = collection.upload.filenameCompoundIndex.map((f) => {
-          return cols[f]
-        })
-        return uniqueIndex(indexName).on(colsConstraint[0], ...colsConstraint.slice(1))
-      }
-    }
-
-    buildTable({
-      adapter: this,
-      disableNotNull: !!collection?.versions?.drafts,
-      disableUnique: false,
-      fields: collection.flattenedFields,
-      locales,
-      tableName,
-      timestamps: collection.timestamps,
-      versions: false,
-    })
-
-    if (collection.versions) {
-      const versionsTableName = this.tableNameMap.get(
-        `_${toSnakeCase(collection.slug)}${this.versionsSuffix}`,
-      )
-      const versionFields = buildVersionCollectionFields(config, collection, true)
-
-      buildTable({
-        adapter: this,
-        disableNotNull: !!collection.versions?.drafts,
-        disableUnique: true,
-        fields: versionFields,
-        locales,
-        tableName: versionsTableName,
-        timestamps: true,
-        versions: true,
-      })
-    }
+  buildRawSchema({
+    adapter,
+    setColumnID,
   })
 
-  this.payload.config.globals.forEach((global) => {
-    const tableName = createTableName({
-      adapter: this as unknown as DrizzleAdapter,
-      config: global,
-    })
-
-    buildTable({
-      adapter: this,
-      disableNotNull: !!global?.versions?.drafts,
-      disableUnique: false,
-      fields: global.flattenedFields,
-      locales,
-      tableName,
-      timestamps: false,
-      versions: false,
-    })
+  await executeSchemaHooks({ type: 'beforeSchemaInit', adapter: this })
 
-    if (global.versions) {
-      const versionsTableName = createTableName({
-        adapter: this as unknown as DrizzleAdapter,
-        config: global,
-        versions: true,
-        versionsCustomName: true,
-      })
-      const config = this.payload.config
-      const versionFields = buildVersionGlobalFields(config, global, true)
+  for (const tableName in this.rawTables) {
+    buildDrizzleTable({ adapter, locales, rawTable: this.rawTables[tableName] })
+  }
 
-      buildTable({
-        adapter: this,
-        disableNotNull: !!global.versions?.drafts,
-        disableUnique: true,
-        fields: versionFields,
-        locales,
-        tableName: versionsTableName,
-        timestamps: true,
-        versions: true,
-      })
-    }
+  buildDrizzleRelations({
+    adapter,
   })
 
   await executeSchemaHooks({ type: 'afterSchemaInit', adapter: this })