@auth/drizzle-adapter 0.3.8 → 0.3.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/lib/sqlite.d.ts.map +1 -1
  2. package/lib/sqlite.js +56 -34
  3. package/package.json +5 -4
  4. package/src/lib/sqlite.ts +70 -57
package/lib/sqlite.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/lib/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,kBAAkB,EAClB,aAAa,EACd,MAAM,yBAAyB,CAAA;AAEhC,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,qBAAqB,CAAA;AAElE,wBAAgB,YAAY,CAAC,WAAW,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoDtD;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE3D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,YAAY,CAAC,OAAO,kBAAkB,CAAC,EAC/C,OAAO,2BAAuB,GAC7B,OAAO,CA2IT"}
1
+ {"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../src/lib/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,kBAAkB,EAClB,aAAa,EACd,MAAM,yBAAyB,CAAA;AAEhC,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,qBAAqB,CAAA;AAElE,wBAAgB,YAAY,CAAC,WAAW,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoDtD;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;AAE3D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,YAAY,CAAC,OAAO,kBAAkB,CAAC,EAC/C,OAAO,2BAAuB,GAC7B,OAAO,CAwJT"}
package/lib/sqlite.js CHANGED
@@ -44,54 +44,64 @@ export function createTables(sqliteTable) {
44
44
  export function SQLiteDrizzleAdapter(client, tableFn = defaultSqliteTableFn) {
45
45
  const { users, accounts, sessions, verificationTokens } = createTables(tableFn);
46
46
  return {
47
- createUser(data) {
48
- return client
47
+ async createUser(data) {
48
+ return await client
49
49
  .insert(users)
50
50
  .values({ ...data, id: crypto.randomUUID() })
51
51
  .returning()
52
52
  .get();
53
53
  },
54
- getUser(data) {
55
- return client.select().from(users).where(eq(users.id, data)).get() ?? null;
54
+ async getUser(data) {
55
+ const result = await client
56
+ .select()
57
+ .from(users)
58
+ .where(eq(users.id, data))
59
+ .get();
60
+ return result ?? null;
56
61
  },
57
- getUserByEmail(data) {
58
- return (client.select().from(users).where(eq(users.email, data)).get() ?? null);
62
+ async getUserByEmail(data) {
63
+ const result = await client
64
+ .select()
65
+ .from(users)
66
+ .where(eq(users.email, data))
67
+ .get();
68
+ return result ?? null;
59
69
  },
60
70
  createSession(data) {
61
71
  return client.insert(sessions).values(data).returning().get();
62
72
  },
63
- getSessionAndUser(data) {
64
- return (client
65
- .select({
66
- session: sessions,
67
- user: users,
68
- })
73
+ async getSessionAndUser(data) {
74
+ const result = await client
75
+ .select({ session: sessions, user: users })
69
76
  .from(sessions)
70
77
  .where(eq(sessions.sessionToken, data))
71
78
  .innerJoin(users, eq(users.id, sessions.userId))
72
- .get() ?? null);
79
+ .get();
80
+ return result ?? null;
73
81
  },
74
- updateUser(data) {
82
+ async updateUser(data) {
75
83
  if (!data.id) {
76
84
  throw new Error("No user id.");
77
85
  }
78
- return client
86
+ const result = await client
79
87
  .update(users)
80
88
  .set(data)
81
89
  .where(eq(users.id, data.id))
82
90
  .returning()
83
91
  .get();
92
+ return result ?? null;
84
93
  },
85
- updateSession(data) {
86
- return client
94
+ async updateSession(data) {
95
+ const result = await client
87
96
  .update(sessions)
88
97
  .set(data)
89
98
  .where(eq(sessions.sessionToken, data.sessionToken))
90
99
  .returning()
91
100
  .get();
101
+ return result ?? null;
92
102
  },
93
- linkAccount(rawAccount) {
94
- const updatedAccount = client
103
+ async linkAccount(rawAccount) {
104
+ const updatedAccount = await client
95
105
  .insert(accounts)
96
106
  .values(rawAccount)
97
107
  .returning()
@@ -109,42 +119,54 @@ export function SQLiteDrizzleAdapter(client, tableFn = defaultSqliteTableFn) {
109
119
  };
110
120
  return account;
111
121
  },
112
- getUserByAccount(account) {
113
- const results = client
122
+ async getUserByAccount(account) {
123
+ const result = await client
114
124
  .select()
115
125
  .from(accounts)
116
126
  .leftJoin(users, eq(users.id, accounts.userId))
117
127
  .where(and(eq(accounts.provider, account.provider), eq(accounts.providerAccountId, account.providerAccountId)))
118
128
  .get();
119
- return results?.user ?? null;
129
+ return result?.user ?? null;
120
130
  },
121
- deleteSession(sessionToken) {
122
- return (client
131
+ async deleteSession(sessionToken) {
132
+ const result = await client
123
133
  .delete(sessions)
124
134
  .where(eq(sessions.sessionToken, sessionToken))
125
135
  .returning()
126
- .get() ?? null);
136
+ .get();
137
+ return result ?? null;
127
138
  },
128
- createVerificationToken(token) {
129
- return client.insert(verificationTokens).values(token).returning().get();
139
+ async createVerificationToken(token) {
140
+ const result = await client
141
+ .insert(verificationTokens)
142
+ .values(token)
143
+ .returning()
144
+ .get();
145
+ return result ?? null;
130
146
  },
131
- useVerificationToken(token) {
147
+ async useVerificationToken(token) {
132
148
  try {
133
- return (client
149
+ const result = await client
134
150
  .delete(verificationTokens)
135
151
  .where(and(eq(verificationTokens.identifier, token.identifier), eq(verificationTokens.token, token.token)))
136
152
  .returning()
137
- .get() ?? null);
153
+ .get();
154
+ return result ?? null;
138
155
  }
139
156
  catch (err) {
140
157
  throw new Error("No verification token found.");
141
158
  }
142
159
  },
143
- deleteUser(id) {
144
- return client.delete(users).where(eq(users.id, id)).returning().get();
160
+ async deleteUser(id) {
161
+ const result = await client
162
+ .delete(users)
163
+ .where(eq(users.id, id))
164
+ .returning()
165
+ .get();
166
+ return result ?? null;
145
167
  },
146
- unlinkAccount(account) {
147
- client
168
+ async unlinkAccount(account) {
169
+ await client
148
170
  .delete(accounts)
149
171
  .where(and(eq(accounts.providerAccountId, account.providerAccountId), eq(accounts.provider, account.provider)))
150
172
  .run();
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@auth/drizzle-adapter",
3
- "version": "0.3.8",
3
+ "version": "0.3.10",
4
4
  "description": "Drizzle adapter for Auth.js.",
5
5
  "homepage": "https://authjs.dev",
6
6
  "repository": "https://github.com/nextauthjs/next-auth",
@@ -36,14 +36,15 @@
36
36
  "access": "public"
37
37
  },
38
38
  "dependencies": {
39
- "@auth/core": "0.18.3"
39
+ "@auth/core": "0.18.5"
40
40
  },
41
41
  "devDependencies": {
42
+ "@libsql/client": "0.4.0-pre.5",
42
43
  "@types/better-sqlite3": "^7.6.4",
43
44
  "@types/uuid": "^8.3.3",
44
45
  "better-sqlite3": "^8.6.0",
45
- "drizzle-kit": "^0.19.5",
46
- "drizzle-orm": "^0.28.6",
46
+ "drizzle-kit": "^0.20.6",
47
+ "drizzle-orm": "^0.29.1",
47
48
  "mysql2": "^3.2.0",
48
49
  "postgres": "^3.3.4"
49
50
  },
package/src/lib/sqlite.ts CHANGED
@@ -74,59 +74,65 @@ export function SQLiteDrizzleAdapter(
74
74
  createTables(tableFn)
75
75
 
76
76
  return {
77
- createUser(data) {
78
- return client
77
+ async createUser(data) {
78
+ return await client
79
79
  .insert(users)
80
80
  .values({ ...data, id: crypto.randomUUID() })
81
81
  .returning()
82
82
  .get()
83
83
  },
84
- getUser(data) {
85
- return client.select().from(users).where(eq(users.id, data)).get() ?? null
84
+ async getUser(data) {
85
+ const result = await client
86
+ .select()
87
+ .from(users)
88
+ .where(eq(users.id, data))
89
+ .get()
90
+ return result ?? null
86
91
  },
87
- getUserByEmail(data) {
88
- return (
89
- client.select().from(users).where(eq(users.email, data)).get() ?? null
90
- )
92
+ async getUserByEmail(data) {
93
+ const result = await client
94
+ .select()
95
+ .from(users)
96
+ .where(eq(users.email, data))
97
+ .get()
98
+ return result ?? null
91
99
  },
92
100
  createSession(data) {
93
101
  return client.insert(sessions).values(data).returning().get()
94
102
  },
95
- getSessionAndUser(data) {
96
- return (
97
- client
98
- .select({
99
- session: sessions,
100
- user: users,
101
- })
102
- .from(sessions)
103
- .where(eq(sessions.sessionToken, data))
104
- .innerJoin(users, eq(users.id, sessions.userId))
105
- .get() ?? null
106
- )
107
- },
108
- updateUser(data) {
103
+ async getSessionAndUser(data) {
104
+ const result = await client
105
+ .select({ session: sessions, user: users })
106
+ .from(sessions)
107
+ .where(eq(sessions.sessionToken, data))
108
+ .innerJoin(users, eq(users.id, sessions.userId))
109
+ .get()
110
+ return result ?? null
111
+ },
112
+ async updateUser(data) {
109
113
  if (!data.id) {
110
114
  throw new Error("No user id.")
111
115
  }
112
116
 
113
- return client
117
+ const result = await client
114
118
  .update(users)
115
119
  .set(data)
116
120
  .where(eq(users.id, data.id))
117
121
  .returning()
118
122
  .get()
123
+ return result ?? null
119
124
  },
120
- updateSession(data) {
121
- return client
125
+ async updateSession(data) {
126
+ const result = await client
122
127
  .update(sessions)
123
128
  .set(data)
124
129
  .where(eq(sessions.sessionToken, data.sessionToken))
125
130
  .returning()
126
131
  .get()
132
+ return result ?? null
127
133
  },
128
- linkAccount(rawAccount) {
129
- const updatedAccount = client
134
+ async linkAccount(rawAccount) {
135
+ const updatedAccount = await client
130
136
  .insert(accounts)
131
137
  .values(rawAccount)
132
138
  .returning()
@@ -146,8 +152,8 @@ export function SQLiteDrizzleAdapter(
146
152
 
147
153
  return account
148
154
  },
149
- getUserByAccount(account) {
150
- const results = client
155
+ async getUserByAccount(account) {
156
+ const result = await client
151
157
  .select()
152
158
  .from(accounts)
153
159
  .leftJoin(users, eq(users.id, accounts.userId))
@@ -158,44 +164,51 @@ export function SQLiteDrizzleAdapter(
158
164
  )
159
165
  )
160
166
  .get()
161
-
162
- return results?.user ?? null
167
+ return result?.user ?? null
163
168
  },
164
- deleteSession(sessionToken) {
165
- return (
166
- client
167
- .delete(sessions)
168
- .where(eq(sessions.sessionToken, sessionToken))
169
- .returning()
170
- .get() ?? null
171
- )
169
+ async deleteSession(sessionToken) {
170
+ const result = await client
171
+ .delete(sessions)
172
+ .where(eq(sessions.sessionToken, sessionToken))
173
+ .returning()
174
+ .get()
175
+ return result ?? null
172
176
  },
173
- createVerificationToken(token) {
174
- return client.insert(verificationTokens).values(token).returning().get()
177
+ async createVerificationToken(token) {
178
+ const result = await client
179
+ .insert(verificationTokens)
180
+ .values(token)
181
+ .returning()
182
+ .get()
183
+ return result ?? null
175
184
  },
176
- useVerificationToken(token) {
185
+ async useVerificationToken(token) {
177
186
  try {
178
- return (
179
- client
180
- .delete(verificationTokens)
181
- .where(
182
- and(
183
- eq(verificationTokens.identifier, token.identifier),
184
- eq(verificationTokens.token, token.token)
185
- )
187
+ const result = await client
188
+ .delete(verificationTokens)
189
+ .where(
190
+ and(
191
+ eq(verificationTokens.identifier, token.identifier),
192
+ eq(verificationTokens.token, token.token)
186
193
  )
187
- .returning()
188
- .get() ?? null
189
- )
194
+ )
195
+ .returning()
196
+ .get()
197
+ return result ?? null
190
198
  } catch (err) {
191
199
  throw new Error("No verification token found.")
192
200
  }
193
201
  },
194
- deleteUser(id) {
195
- return client.delete(users).where(eq(users.id, id)).returning().get()
202
+ async deleteUser(id) {
203
+ const result = await client
204
+ .delete(users)
205
+ .where(eq(users.id, id))
206
+ .returning()
207
+ .get()
208
+ return result ?? null
196
209
  },
197
- unlinkAccount(account) {
198
- client
210
+ async unlinkAccount(account) {
211
+ await client
199
212
  .delete(accounts)
200
213
  .where(
201
214
  and(