sqlite column to code converter

packages/db-postgres/src/index.ts

@@ -37,6 +37,7 @@ import {
   updateVersion,
 } from '@payloadcms/drizzle'
 import {
+  columnToCodeConverter,
   countDistinct,
   createDatabase,
   createExtensions,
@@ -108,7 +109,12 @@ export function postgresAdapter(args: Args): DatabaseAdapterObj<PostgresAdapter>
       },
       fieldConstraints: {},
       generateSchema: createSchemaGenerator({
+        columnToCodeConverter,
+        corePackageSuffix: 'pg-core',
         defaultOutputFile: args.generateSchemaOutputFile,
+        enumImport: 'pgEnum',
+        schemaImport: 'pgSchema',
+        tableImport: 'pgTable',
       }),
       idType: postgresIDType,
       initializing,

packages/db-sqlite/src/columnToCodeConverter.ts

@@ -0,0 +1,114 @@
+import type { ColumnToCodeConverter } from '@payloadcms/drizzle/types'
+
+export const columnToCodeConverter: ColumnToCodeConverter = ({
+  adapter,
+  addImport,
+  column,
+  locales,
+}) => {
+  let columnBuilderFn: string = column.type
+
+  const columnBuilderArgsArray: string[] = []
+
+  let defaultStatement: null | string = null
+
+  switch (column.type) {
+    case 'boolean': {
+      columnBuilderFn = 'integer'
+      columnBuilderArgsArray.push("mode: 'boolean'")
+      break
+    }
+
+    case 'enum': {
+      let options: string[]
+      if ('isLocale' in column) {
+        options = locales
+      } else {
+        options = column.options
+      }
+
+      columnBuilderFn = 'text'
+      columnBuilderArgsArray.push(`enum: [${options.map((locale) => `'${locale}'`).join(', ')}]`)
+
+      break
+    }
+
+    case 'geometry':
+    case 'jsonb': {
+      columnBuilderFn = 'text'
+      columnBuilderArgsArray.push("mode: 'json'")
+      break
+    }
+
+    case 'serial': {
+      columnBuilderFn = 'integer'
+      break
+    }
+
+    case 'timestamp': {
+      columnBuilderFn = 'text'
+      defaultStatement = `default(sql\`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))\`)`
+      break
+    }
+
+    case 'uuid': {
+      columnBuilderFn = 'text'
+
+      if (column.defaultRandom) {
+        addImport('crypto', 'randomUUID')
+        defaultStatement = `defaultFn(() => randomUUID())`
+      }
+
+      break
+    }
+
+    case 'varchar': {
+      columnBuilderFn = 'text'
+      break
+    }
+
+    default: {
+      columnBuilderFn = column.type
+    }
+  }
+
+  addImport(`${adapter.packageName}/drizzle/sqlite-core`, columnBuilderFn)
+
+  let columnBuilderArgs = ''
+
+  if (columnBuilderArgsArray.length) {
+    columnBuilderArgs = `, {${columnBuilderArgsArray.join(',')}}`
+  }
+
+  let code = `${columnBuilderFn}('${column.name}'${columnBuilderArgs})`
+
+  if (column.notNull) {
+    code = `${code}.notNull()`
+  }
+
+  if (column.primaryKey) {
+    code = `${code}.primaryKey()`
+  }
+
+  if (defaultStatement) {
+    code = `${code}.${defaultStatement}`
+  } else if (typeof column.default !== 'undefined') {
+    let sanitizedDefault = column.default
+
+    if (column.type === 'jsonb' || column.type === 'geometry') {
+      sanitizedDefault = `'${JSON.stringify(column.default)}'`
+    } else if (typeof column.default === 'string' || column.type === 'numeric') {
+      sanitizedDefault = `'${column.default}'`
+    }
+
+    code = `${code}.default(${sanitizedDefault})`
+  }
+
+  if (column.reference) {
+    code = `${code}.references(() => ${column.reference.table}.${column.reference.name}, {
+      ${column.reference.onDelete ? `onDelete: '${column.reference.onDelete}'` : ''}
+  })`
+  }
+
+  return code
+}

packages/db-sqlite/src/index.ts

@@ -43,6 +43,7 @@ import { fileURLToPath } from 'url'
 
 import type { Args, SQLiteAdapter } from './types.js'
 
+import { columnToCodeConverter } from './columnToCodeConverter.js'
 import { connect } from './connect.js'
 import { countDistinct } from './countDistinct.js'
 import { convertPathToJSONTraversal } from './createJSONQuery/convertPathToJSONTraversal.js'
@@ -95,7 +96,10 @@ export function sqliteAdapter(args: Args): DatabaseAdapterObj<SQLiteAdapter> {
       },
       fieldConstraints: {},
       generateSchema: createSchemaGenerator({
+        columnToCodeConverter,
+        corePackageSuffix: 'sqlite-core',
         defaultOutputFile: args.generateSchemaOutputFile,
+        tableImport: 'sqliteTable',
       }),
       idType: postgresIDType,
       initializing,

packages/db-vercel-postgres/src/index.ts

@@ -37,6 +37,7 @@ import {
   updateVersion,
 } from '@payloadcms/drizzle'
 import {
+  columnToCodeConverter,
   countDistinct,
   createDatabase,
   createExtensions,
@@ -101,7 +102,12 @@ export function vercelPostgresAdapter(args: Args = {}): DatabaseAdapterObj<Verce
       },
       fieldConstraints: {},
       generateSchema: createSchemaGenerator({
+        columnToCodeConverter,
+        corePackageSuffix: 'pg-core',
         defaultOutputFile: args.generateSchemaOutputFile,
+        enumImport: 'pgEnum',
+        schemaImport: 'pgSchema',
+        tableImport: 'pgTable',
       }),
       idType: postgresIDType,
       indexes: new Set<string>(),

packages/drizzle/src/exports/postgres.ts

@@ -1,3 +1,4 @@
+export { columnToCodeConverter } from '../postgres/columnToCodeConverter.js'
 export { countDistinct } from '../postgres/countDistinct.js'
 export { createDatabase } from '../postgres/createDatabase.js'
 export { createExtensions } from '../postgres/createExtensions.js'

packages/drizzle/src/postgres/columnToCodeConverter.ts

@@ -0,0 +1,85 @@
+import type { ColumnToCodeConverter } from '../types.js'
+
+export const columnToCodeConverter: ColumnToCodeConverter = ({
+  adapter,
+  addEnum,
+  addImport,
+  column,
+}) => {
+  let columnBuilderFn: string = column.type
+
+  if (column.type === 'geometry') {
+    columnBuilderFn = 'geometryColumn'
+    addImport(`@payloadcms/drizzle/postgres`, columnBuilderFn)
+  } else if (column.type === 'enum') {
+    if ('isLocale' in column) {
+      columnBuilderFn = `enum__locales`
+    } else {
+      addEnum(column.enumName, column.options)
+      columnBuilderFn = column.enumName
+    }
+  } else {
+    addImport(`${adapter.packageName}/drizzle/pg-core`, columnBuilderFn)
+  }
+
+  const columnBuilderArgsArray: string[] = []
+
+  if (column.type === 'timestamp') {
+    columnBuilderArgsArray.push(`mode: '${column.mode}'`)
+    if (column.withTimezone) {
+      columnBuilderArgsArray.push('withTimezone: true')
+    }
+
+    if (typeof column.precision === 'number') {
+      columnBuilderArgsArray.push(`precision: ${column.precision}`)
+    }
+  }
+
+  let columnBuilderArgs = ''
+
+  if (columnBuilderArgsArray.length) {
+    columnBuilderArgs = `, {${columnBuilderArgsArray.join(',')}}`
+  }
+
+  let code = `${columnBuilderFn}('${column.name}'${columnBuilderArgs})`
+
+  if (column.type === 'timestamp' && column.defaultNow) {
+    code = `${code}.defaultNow()`
+  }
+
+  if (column.type === 'uuid' && column.defaultRandom) {
+    code = `${code}.defaultRandom()`
+  }
+
+  if (column.notNull) {
+    code = `${code}.notNull()`
+  }
+
+  if (column.primaryKey) {
+    code = `${code}.primaryKey()`
+  }
+
+  if (typeof column.default !== 'undefined') {
+    let sanitizedDefault = column.default
+
+    if (column.type === 'geometry') {
+      sanitizedDefault = `sql\`${column.default}\``
+    } else if (column.type === 'jsonb') {
+      sanitizedDefault = `sql\`'${JSON.stringify(column.default)}'::jsonb\``
+    } else if (column.type === 'numeric') {
+      sanitizedDefault = `sql\`${column.default}\``
+    } else if (typeof column.default === 'string') {
+      sanitizedDefault = `'${column.default}'`
+    }
+
+    code = `${code}.default(${sanitizedDefault})`
+  }
+
+  if (column.reference) {
+    code = `${code}.references(() => ${column.reference.table}.${column.reference.name}, {
+      ${column.reference.onDelete ? `onDelete: '${column.reference.onDelete}'` : ''}
+  })`
+  }
+
+  return code
+}

packages/drizzle/src/types.ts

@@ -250,6 +250,14 @@ export type SetColumnID = (args: {
   fields: FlattenedField[]
 }) => IDType
 
+export type ColumnToCodeConverter = (args: {
+  adapter: DrizzleAdapter
+  addEnum: (name: string, options: string[]) => void
+  addImport: (from: string, name: string) => void
+  column: RawColumn
+  locales?: string[]
+}) => string
+
 export type BuildDrizzleTable<T extends DrizzleAdapter = DrizzleAdapter> = (args: {
   adapter: T
   locales: string[]