@auth/drizzle-adapter 1.0.0 → 1.1.0

package/src/lib/pg.ts

@@ -1,113 +1,117 @@
-import { and, eq } from "drizzle-orm"
+import { and, eq, getTableColumns } from "drizzle-orm"
 import {
-  timestamp,
-  text,
-  primaryKey,
-  integer,
+  PgColumn,
   PgDatabase,
-  pgTable,
-  index,
   PgTableWithColumns,
   QueryResultHKT,
-  TableConfig,
+  integer,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp,
 } from "drizzle-orm/pg-core"
 
 import type {
   Adapter,
   AdapterAccount,
-  AdapterUser,
+  AdapterAccountType,
   AdapterSession,
+  AdapterUser,
   VerificationToken,
 } from "@auth/core/adapters"
-import { randomUUID } from "crypto"
 
-export const postgresUsersTable = pgTable("user" as string, {
-  id: text("id")
-    .primaryKey()
-    .$defaultFn(() => randomUUID()),
-  name: text("name"),
-  email: text("email").notNull().unique(),
-  emailVerified: timestamp("emailVerified", { mode: "date" }),
-  image: text("image"),
-})
+export function defineTables(
+  schema: Partial<DefaultPostgresSchema> = {}
+): Required<DefaultPostgresSchema> {
+  const usersTable =
+    schema.usersTable ??
+    (pgTable("user", {
+      id: text("id")
+        .primaryKey()
+        .$defaultFn(() => crypto.randomUUID()),
+      name: text("name"),
+      email: text("email").notNull(),
+      emailVerified: timestamp("emailVerified", { mode: "date" }),
+      image: text("image"),
+    }) satisfies DefaultPostgresUsersTable)
 
-export const postgresAccountsTable = pgTable(
-  "account" as string,
-  {
-    userId: text("userId")
-      .notNull()
-      .references(() => postgresUsersTable.id, { onDelete: "cascade" }),
-    type: text("type").notNull(),
-    provider: text("provider").notNull(),
-    providerAccountId: text("providerAccountId").notNull(),
-    refresh_token: text("refresh_token"),
-    access_token: text("access_token"),
-    expires_at: integer("expires_at"),
-    token_type: text("token_type"),
-    scope: text("scope"),
-    id_token: text("id_token"),
-    session_state: text("session_state"),
-  },
-  (table) => {
-    return {
-      userIdIdx: index().on(table.userId),
-      compositePk: primaryKey({
-        columns: [table.provider, table.providerAccountId],
-      }),
-    }
-  }
-)
+  const accountsTable =
+    schema.accountsTable ??
+    (pgTable(
+      "account",
+      {
+        userId: text("userId")
+          .notNull()
+          .references(() => usersTable.id, { onDelete: "cascade" }),
+        type: text("type").$type<AdapterAccountType>().notNull(),
+        provider: text("provider").notNull(),
+        providerAccountId: text("providerAccountId").notNull(),
+        refresh_token: text("refresh_token"),
+        access_token: text("access_token"),
+        expires_at: integer("expires_at"),
+        token_type: text("token_type"),
+        scope: text("scope"),
+        id_token: text("id_token"),
+        session_state: text("session_state"),
+      },
+      (table) => {
+        return {
+          compositePk: primaryKey({
+            columns: [table.provider, table.providerAccountId],
+          }),
+        }
+      }
+    ) satisfies DefaultPostgresAccountsTable)
 
-export const postgresSessionsTable = pgTable(
-  "session" as string,
-  {
-    id: text("id")
-      .primaryKey()
-      .$defaultFn(() => randomUUID()),
-    sessionToken: text("sessionToken").notNull().unique(),
-    userId: text("userId")
-      .notNull()
-      .references(() => postgresUsersTable.id, { onDelete: "cascade" }),
-    expires: timestamp("expires", { mode: "date" }).notNull(),
-  },
-  (table) => {
-    return {
-      userIdIdx: index().on(table.userId),
-    }
-  }
-)
+  const sessionsTable =
+    schema.sessionsTable ??
+    (pgTable("session", {
+      sessionToken: text("sessionToken").primaryKey(),
+      userId: text("userId")
+        .notNull()
+        .references(() => usersTable.id, { onDelete: "cascade" }),
+      expires: timestamp("expires", { mode: "date" }).notNull(),
+    }) satisfies DefaultPostgresSessionsTable)
 
-export const postgresVerificationTokensTable = pgTable(
-  "verificationToken" as string,
-  {
-    identifier: text("identifier").notNull(),
-    token: text("token").notNull().unique(),
-    expires: timestamp("expires", { mode: "date" }).notNull(),
-  },
-  (table) => {
-    return {
-      compositePk: primaryKey({ columns: [table.identifier, table.token] }),
-    }
+  const verificationTokensTable =
+    schema.verificationTokensTable ??
+    (pgTable(
+      "verificationToken",
+      {
+        identifier: text("identifier").notNull(),
+        token: text("token").notNull(),
+        expires: timestamp("expires", { mode: "date" }).notNull(),
+      },
+      (table) => {
+        return {
+          compositePk: primaryKey({ columns: [table.identifier, table.token] }),
+        }
+      }
+    ) satisfies DefaultPostgresVerificationTokenTable)
+
+  return {
+    usersTable,
+    accountsTable,
+    sessionsTable,
+    verificationTokensTable,
   }
-)
+}
 
 export function PostgresDrizzleAdapter(
   client: PgDatabase<QueryResultHKT, any>,
-  schema: DefaultPostgresSchema = {
-    usersTable: postgresUsersTable,
-    accountsTable: postgresAccountsTable,
-    sessionsTable: postgresSessionsTable,
-    verificationTokensTable: postgresVerificationTokensTable,
-  }
+  schema?: DefaultPostgresSchema
 ): Adapter {
   const { usersTable, accountsTable, sessionsTable, verificationTokensTable } =
-    schema
+    defineTables(schema)
 
   return {
-    async createUser(data: Omit<AdapterUser, "id">) {
+    async createUser(data: AdapterUser) {
+      const { id, ...insertData } = data
+      const hasDefaultId = getTableColumns(usersTable)["id"]["hasDefault"]
+
       return client
         .insert(usersTable)
-        .values(data)
+        .values(hasDefaultId ? insertData : { ...insertData, id })
         .returning()
         .then((res) => res[0])
     },
@@ -239,18 +243,192 @@ export function PostgresDrizzleAdapter(
   }
 }
 
-export type PostgresTableFn<T extends TableConfig> = PgTableWithColumns<{
-  name: T["name"]
-  columns: T["columns"]
-  dialect: T["dialect"]
+type DefaultPostgresColumn<
+  T extends {
+    data: string | number | Date
+    dataType: "string" | "number" | "date"
+    notNull: boolean
+    columnType: "PgVarchar" | "PgText" | "PgTimestamp" | "PgInteger" | "PgUUID"
+  },
+> = PgColumn<{
+  name: string
+  columnType: T["columnType"]
+  data: T["data"]
+  driverParam: string | number
+  notNull: T["notNull"]
+  hasDefault: boolean
+  enumValues: any
+  dataType: T["dataType"]
+  tableName: string
+}>
+
+export type DefaultPostgresUsersTable = PgTableWithColumns<{
+  name: string
+  columns: {
+    id: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText" | "PgUUID"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    name: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: boolean
+      dataType: "string"
+    }>
+    email: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    emailVerified: DefaultPostgresColumn<{
+      dataType: "date"
+      columnType: "PgTimestamp"
+      data: Date
+      notNull: boolean
+    }>
+    image: DefaultPostgresColumn<{
+      dataType: "string"
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: boolean
+    }>
+  }
+  dialect: "pg"
+  schema: string | undefined
+}>
+
+export type DefaultPostgresAccountsTable = PgTableWithColumns<{
+  name: string
+  columns: {
+    userId: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText" | "PgUUID"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    type: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    provider: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    providerAccountId: DefaultPostgresColumn<{
+      dataType: "string"
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+    }>
+    refresh_token: DefaultPostgresColumn<{
+      dataType: "string"
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: boolean
+    }>
+    access_token: DefaultPostgresColumn<{
+      dataType: "string"
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: boolean
+    }>
+    expires_at: DefaultPostgresColumn<{
+      dataType: "number"
+      columnType: "PgInteger"
+      data: number
+      notNull: boolean
+    }>
+    token_type: DefaultPostgresColumn<{
+      dataType: "string"
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: boolean
+    }>
+    scope: DefaultPostgresColumn<{
+      dataType: "string"
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: boolean
+    }>
+    id_token: DefaultPostgresColumn<{
+      dataType: "string"
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: boolean
+    }>
+    session_state: DefaultPostgresColumn<{
+      dataType: "string"
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: boolean
+    }>
+  }
+  dialect: "pg"
+  schema: string | undefined
+}>
+
+export type DefaultPostgresSessionsTable = PgTableWithColumns<{
+  name: string
+  columns: {
+    sessionToken: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    userId: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText" | "PgUUID"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    expires: DefaultPostgresColumn<{
+      dataType: "date"
+      columnType: "PgTimestamp"
+      data: Date
+      notNull: true
+    }>
+  }
+  dialect: "pg"
+  schema: string | undefined
+}>
+
+export type DefaultPostgresVerificationTokenTable = PgTableWithColumns<{
+  name: string
+  columns: {
+    identifier: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    token: DefaultPostgresColumn<{
+      columnType: "PgVarchar" | "PgText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    expires: DefaultPostgresColumn<{
+      dataType: "date"
+      columnType: "PgTimestamp"
+      data: Date
+      notNull: true
+    }>
+  }
+  dialect: "pg"
   schema: string | undefined
 }>
 
 export type DefaultPostgresSchema = {
-  usersTable: PostgresTableFn<(typeof postgresUsersTable)["_"]["config"]>
-  accountsTable: PostgresTableFn<(typeof postgresAccountsTable)["_"]["config"]>
-  sessionsTable: PostgresTableFn<(typeof postgresSessionsTable)["_"]["config"]>
-  verificationTokensTable: PostgresTableFn<
-    (typeof postgresVerificationTokensTable)["_"]["config"]
-  >
+  usersTable: DefaultPostgresUsersTable
+  accountsTable: DefaultPostgresAccountsTable
+  sessionsTable?: DefaultPostgresSessionsTable
+  verificationTokensTable?: DefaultPostgresVerificationTokenTable
 }