@auth/drizzle-adapter 1.0.0 → 1.0.1

package/src/lib/pg.ts

@@ -1,43 +1,41 @@
-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,
   AdapterSession,
+  AdapterUser,
   VerificationToken,
 } from "@auth/core/adapters"
-import { randomUUID } from "crypto"
 
-export const postgresUsersTable = pgTable("user" as string, {
+export const postgresUsersTable = pgTable("user", {
   id: text("id")
     .primaryKey()
-    .$defaultFn(() => randomUUID()),
+    .$defaultFn(() => crypto.randomUUID()),
   name: text("name"),
-  email: text("email").notNull().unique(),
+  email: text("email").notNull(),
   emailVerified: timestamp("emailVerified", { mode: "date" }),
   image: text("image"),
-})
+}) satisfies DefaultPostgresUsersTable
 
 export const postgresAccountsTable = pgTable(
-  "account" as string,
+  "account",
   {
     userId: text("userId")
       .notNull()
       .references(() => postgresUsersTable.id, { onDelete: "cascade" }),
-    type: text("type").notNull(),
+    type: text("type").$type<AdapterAccount["type"]>().notNull(),
     provider: text("provider").notNull(),
     providerAccountId: text("providerAccountId").notNull(),
     refresh_token: text("refresh_token"),
@@ -50,38 +48,26 @@ export const postgresAccountsTable = pgTable(
   },
   (table) => {
     return {
-      userIdIdx: index().on(table.userId),
       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),
-    }
-  }
-)
+export const postgresSessionsTable = pgTable("session", {
+  sessionToken: text("sessionToken").primaryKey(),
+  userId: text("userId")
+    .notNull()
+    .references(() => postgresUsersTable.id, { onDelete: "cascade" }),
+  expires: timestamp("expires", { mode: "date" }).notNull(),
+}) satisfies DefaultPostgresSessionsTable
 
 export const postgresVerificationTokensTable = pgTable(
-  "verificationToken" as string,
+  "verificationToken",
   {
     identifier: text("identifier").notNull(),
-    token: text("token").notNull().unique(),
+    token: text("token").notNull(),
     expires: timestamp("expires", { mode: "date" }).notNull(),
   },
   (table) => {
@@ -89,7 +75,7 @@ export const postgresVerificationTokensTable = pgTable(
       compositePk: primaryKey({ columns: [table.identifier, table.token] }),
     }
   }
-)
+) satisfies DefaultPostgresVerificationTokenTable
 
 export function PostgresDrizzleAdapter(
   client: PgDatabase<QueryResultHKT, any>,
@@ -104,10 +90,12 @@ export function PostgresDrizzleAdapter(
     schema
 
   return {
-    async createUser(data: Omit<AdapterUser, "id">) {
+    async createUser(data: AdapterUser) {
+      const hasDefaultId = getTableColumns(usersTable)["id"]["hasDefault"]
+
       return client
         .insert(usersTable)
-        .values(data)
+        .values(hasDefaultId ? data : { ...data, id: crypto.randomUUID() })
         .returning()
         .then((res) => res[0])
     },
@@ -239,18 +227,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
 }

package/src/lib/sqlite.ts

@@ -1,41 +1,39 @@
-import { eq, and } from "drizzle-orm"
+import { and, eq, getTableColumns } from "drizzle-orm"
 import {
+  BaseSQLiteDatabase,
+  SQLiteColumn,
+  SQLiteTableWithColumns,
   integer,
-  text,
   primaryKey,
-  BaseSQLiteDatabase,
   sqliteTable,
-  index,
-  TableConfig,
-  SQLiteTableWithColumns,
+  text,
 } from "drizzle-orm/sqlite-core"
 
 import type {
   Adapter,
   AdapterAccount,
-  AdapterUser,
   AdapterSession,
+  AdapterUser,
   VerificationToken,
 } from "@auth/core/adapters"
-import { randomUUID } from "crypto"
 
-export const sqliteUsersTable = sqliteTable("user" as string, {
+export const sqliteUsersTable = sqliteTable("user", {
   id: text("id")
     .primaryKey()
-    .$defaultFn(() => randomUUID()),
+    .$defaultFn(() => crypto.randomUUID()),
   name: text("name"),
-  email: text("email").notNull().unique(),
+  email: text("email").notNull(),
   emailVerified: integer("emailVerified", { mode: "timestamp_ms" }),
   image: text("image"),
-})
+}) satisfies DefaultSQLiteUsersTable
 
 export const sqliteAccountsTable = sqliteTable(
-  "account" as string,
+  "account",
   {
     userId: text("userId")
       .notNull()
       .references(() => sqliteUsersTable.id, { onDelete: "cascade" }),
-    type: text("type").notNull(),
+    type: text("type").$type<AdapterAccount["type"]>().notNull(),
     provider: text("provider").notNull(),
     providerAccountId: text("providerAccountId").notNull(),
     refresh_token: text("refresh_token"),
@@ -47,41 +45,31 @@ export const sqliteAccountsTable = sqliteTable(
     session_state: text("session_state"),
   },
   (account) => ({
-    userIdIdx: index("Account_userId_index").on(account.userId),
     compositePk: primaryKey({
       columns: [account.provider, account.providerAccountId],
     }),
   })
-)
+) satisfies DefaultSQLiteAccountsTable
 
-export const sqliteSessionsTable = sqliteTable(
-  "session" as string,
-  {
-    id: text("id")
-      .primaryKey()
-      .$defaultFn(() => randomUUID()),
-    sessionToken: text("sessionToken").notNull().unique(),
-    userId: text("userId")
-      .notNull()
-      .references(() => sqliteUsersTable.id, { onDelete: "cascade" }),
-    expires: integer("expires", { mode: "timestamp_ms" }).notNull(),
-  },
-  (table) => ({
-    userIdIdx: index("Session_userId_index").on(table.userId),
-  })
-)
+export const sqliteSessionsTable = sqliteTable("session", {
+  sessionToken: text("sessionToken").primaryKey(),
+  userId: text("userId")
+    .notNull()
+    .references(() => sqliteUsersTable.id, { onDelete: "cascade" }),
+  expires: integer("expires", { mode: "timestamp_ms" }).notNull(),
+}) satisfies DefaultSQLiteSessionsTable
 
 export const sqliteVerificationTokensTable = sqliteTable(
-  "verificationToken" as string,
+  "verificationToken",
   {
     identifier: text("identifier").notNull(),
-    token: text("token").notNull().unique(),
+    token: text("token").notNull(),
     expires: integer("expires", { mode: "timestamp_ms" }).notNull(),
   },
   (vt) => ({
     compositePk: primaryKey({ columns: [vt.identifier, vt.token] }),
   })
-)
+) satisfies DefaultSQLiteVerificationTokenTable
 
 export function SQLiteDrizzleAdapter(
   client: BaseSQLiteDatabase<"sync" | "async", any, any>,
@@ -96,8 +84,14 @@ export function SQLiteDrizzleAdapter(
     schema
 
   return {
-    async createUser(data: Omit<AdapterUser, "id">) {
-      return client.insert(usersTable).values(data).returning().get()
+    async createUser(data: AdapterUser) {
+      const hasDefaultId = getTableColumns(usersTable)["id"]["hasDefault"]
+
+      return client
+        .insert(usersTable)
+        .values(hasDefaultId ? data : { ...data, id: crypto.randomUUID() })
+        .returning()
+        .get()
     },
     async getUser(userId: string) {
       const result = await client
@@ -236,18 +230,192 @@ export function SQLiteDrizzleAdapter(
   }
 }
 
-export type SQLiteTableFn<T extends TableConfig> = SQLiteTableWithColumns<{
-  name: T["name"]
-  columns: T["columns"]
-  dialect: T["dialect"]
+type DefaultSQLiteColumn<
+  T extends {
+    data: string | number | Date
+    dataType: "string" | "number" | "date"
+    notNull: boolean
+    columnType: "SQLiteText" | "SQLiteTimestamp" | "SQLiteInteger"
+  },
+> = SQLiteColumn<{
+  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 DefaultSQLiteUsersTable = SQLiteTableWithColumns<{
+  name: string
+  columns: {
+    id: DefaultSQLiteColumn<{
+      columnType: "SQLiteText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    name: DefaultSQLiteColumn<{
+      columnType: "SQLiteText"
+      data: string
+      notNull: boolean
+      dataType: "string"
+    }>
+    email: DefaultSQLiteColumn<{
+      columnType: "SQLiteText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    emailVerified: DefaultSQLiteColumn<{
+      dataType: "date"
+      columnType: "SQLiteTimestamp"
+      data: Date
+      notNull: boolean
+    }>
+    image: DefaultSQLiteColumn<{
+      dataType: "string"
+      columnType: "SQLiteText"
+      data: string
+      notNull: boolean
+    }>
+  }
+  dialect: "sqlite"
+  schema: string | undefined
+}>
+
+export type DefaultSQLiteAccountsTable = SQLiteTableWithColumns<{
+  name: string
+  columns: {
+    userId: DefaultSQLiteColumn<{
+      columnType: "SQLiteText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    type: DefaultSQLiteColumn<{
+      columnType: "SQLiteText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    provider: DefaultSQLiteColumn<{
+      columnType: "SQLiteText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    providerAccountId: DefaultSQLiteColumn<{
+      dataType: "string"
+      columnType: "SQLiteText"
+      data: string
+      notNull: true
+    }>
+    refresh_token: DefaultSQLiteColumn<{
+      dataType: "string"
+      columnType: "SQLiteText"
+      data: string
+      notNull: boolean
+    }>
+    access_token: DefaultSQLiteColumn<{
+      dataType: "string"
+      columnType: "SQLiteText"
+      data: string
+      notNull: boolean
+    }>
+    expires_at: DefaultSQLiteColumn<{
+      dataType: "number"
+      columnType: "SQLiteInteger"
+      data: number
+      notNull: boolean
+    }>
+    token_type: DefaultSQLiteColumn<{
+      dataType: "string"
+      columnType: "SQLiteText"
+      data: string
+      notNull: boolean
+    }>
+    scope: DefaultSQLiteColumn<{
+      dataType: "string"
+      columnType: "SQLiteText"
+      data: string
+      notNull: boolean
+    }>
+    id_token: DefaultSQLiteColumn<{
+      dataType: "string"
+      columnType: "SQLiteText"
+      data: string
+      notNull: boolean
+    }>
+    session_state: DefaultSQLiteColumn<{
+      dataType: "string"
+      columnType: "SQLiteText"
+      data: string
+      notNull: boolean
+    }>
+  }
+  dialect: "sqlite"
+  schema: string | undefined
+}>
+
+export type DefaultSQLiteSessionsTable = SQLiteTableWithColumns<{
+  name: string
+  columns: {
+    sessionToken: DefaultSQLiteColumn<{
+      columnType: "SQLiteText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    userId: DefaultSQLiteColumn<{
+      columnType: "SQLiteText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    expires: DefaultSQLiteColumn<{
+      dataType: "date"
+      columnType: "SQLiteTimestamp"
+      data: Date
+      notNull: true
+    }>
+  }
+  dialect: "sqlite"
+  schema: string | undefined
+}>
+
+export type DefaultSQLiteVerificationTokenTable = SQLiteTableWithColumns<{
+  name: string
+  columns: {
+    identifier: DefaultSQLiteColumn<{
+      columnType: "SQLiteText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    token: DefaultSQLiteColumn<{
+      columnType: "SQLiteText"
+      data: string
+      notNull: true
+      dataType: "string"
+    }>
+    expires: DefaultSQLiteColumn<{
+      dataType: "date"
+      columnType: "SQLiteTimestamp"
+      data: Date
+      notNull: true
+    }>
+  }
+  dialect: "sqlite"
   schema: string | undefined
 }>
 
 export type DefaultSQLiteSchema = {
-  usersTable: SQLiteTableFn<(typeof sqliteUsersTable)["_"]["config"]>
-  accountsTable: SQLiteTableFn<(typeof sqliteAccountsTable)["_"]["config"]>
-  sessionsTable: SQLiteTableFn<(typeof sqliteSessionsTable)["_"]["config"]>
-  verificationTokensTable: SQLiteTableFn<
-    (typeof sqliteVerificationTokensTable)["_"]["config"]
-  >
+  usersTable: DefaultSQLiteUsersTable
+  accountsTable: DefaultSQLiteAccountsTable
+  sessionsTable: DefaultSQLiteSessionsTable
+  verificationTokensTable: DefaultSQLiteVerificationTokenTable
 }

package/src/lib/utils.ts

@@ -1,14 +1,14 @@
-import { MySqlDatabase } from "drizzle-orm/mysql-core"
-import { PgDatabase } from "drizzle-orm/pg-core"
-import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core"
 import type {
   QueryResultHKT as MySQLQueryResultHKT,
   PreparedQueryHKTBase,
 } from "drizzle-orm/mysql-core"
+import { MySqlDatabase } from "drizzle-orm/mysql-core"
 import type { QueryResultHKT as PostgresQueryResultHKT } from "drizzle-orm/pg-core"
-import { DefaultSQLiteSchema } from "./sqlite"
-import { DefaultPostgresSchema } from "./pg"
-import { DefaultMySqlSchema } from "./mysql"
+import { PgDatabase } from "drizzle-orm/pg-core"
+import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core"
+import { DefaultMySqlSchema } from "./mysql.js"
+import { DefaultPostgresSchema } from "./pg.js"
+import { DefaultSQLiteSchema } from "./sqlite.js"
 
 type AnyPostgresDatabase = PgDatabase<PostgresQueryResultHKT, any>
 type AnyMySqlDatabase = MySqlDatabase<
@@ -23,10 +23,11 @@ export type SqlFlavorOptions =
   | AnyMySqlDatabase
   | AnySQLiteDatabase
 
-export type DefaultSchema<Flavor> = Flavor extends AnyMySqlDatabase
-  ? DefaultMySqlSchema
-  : Flavor extends AnyPostgresDatabase
-    ? DefaultPostgresSchema
-    : Flavor extends AnySQLiteDatabase
-      ? DefaultSQLiteSchema
-      : never
+export type DefaultSchema<Flavor extends SqlFlavorOptions> =
+  Flavor extends AnyMySqlDatabase
+    ? DefaultMySqlSchema
+    : Flavor extends AnyPostgresDatabase
+      ? DefaultPostgresSchema
+      : Flavor extends AnySQLiteDatabase
+        ? DefaultSQLiteSchema
+        : never