@auth/drizzle-adapter 0.3.1 → 0.3.3

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 (18) hide show
  1. package/index.d.ts.map +1 -1
  2. package/index.js +8 -6
  3. package/lib/mysql.d.ts +170 -97
  4. package/lib/mysql.d.ts.map +1 -1
  5. package/lib/mysql.js +1 -4
  6. package/lib/pg.d.ts +171 -98
  7. package/lib/pg.d.ts.map +1 -1
  8. package/lib/sqlite.d.ts +169 -95
  9. package/lib/sqlite.d.ts.map +1 -1
  10. package/lib/utils.d.ts +0 -3
  11. package/lib/utils.d.ts.map +1 -1
  12. package/lib/utils.js +1 -12
  13. package/package.json +7 -7
  14. package/src/index.ts +11 -19
  15. package/src/lib/mysql.ts +3 -6
  16. package/src/lib/pg.ts +2 -2
  17. package/src/lib/sqlite.ts +1 -1
  18. package/src/lib/utils.ts +0 -14
package/lib/sqlite.d.ts CHANGED
@@ -1,225 +1,299 @@
1
1
  import { BaseSQLiteDatabase, SQLiteTableFn } from "drizzle-orm/sqlite-core";
2
2
  import type { Adapter } from "@auth/core/adapters";
3
3
  export declare function createTables(sqliteTable: SQLiteTableFn): {
4
- users: import("drizzle-orm/db.d-b5fdf746").ag<{
4
+ users: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
5
5
  name: "user";
6
6
  schema: undefined;
7
7
  columns: {
8
- id: import("drizzle-orm/sqlite-core").SQLiteText<{
9
- tableName: "user";
10
- enumValues: [string, ...string[]];
8
+ id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
11
9
  name: "id";
10
+ tableName: "user";
11
+ dataType: "string";
12
+ columnType: "SQLiteText";
12
13
  data: string;
13
14
  driverParam: string;
14
- hasDefault: false;
15
15
  notNull: true;
16
- }>;
17
- name: import("drizzle-orm/sqlite-core").SQLiteText<{
18
- tableName: "user";
16
+ hasDefault: false;
17
+ enumValues: [string, ...string[]];
18
+ baseColumn: never;
19
+ }, object>;
20
+ name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
19
21
  name: "name";
22
+ tableName: "user";
23
+ dataType: "string";
24
+ columnType: "SQLiteText";
20
25
  data: string;
21
26
  driverParam: string;
22
- enumValues: [string, ...string[]];
23
27
  notNull: false;
24
28
  hasDefault: false;
25
- }>;
26
- email: import("drizzle-orm/sqlite-core").SQLiteText<{
27
- tableName: "user";
28
29
  enumValues: [string, ...string[]];
30
+ baseColumn: never;
31
+ }, object>;
32
+ email: import("drizzle-orm/sqlite-core").SQLiteColumn<{
29
33
  name: "email";
34
+ tableName: "user";
35
+ dataType: "string";
36
+ columnType: "SQLiteText";
30
37
  data: string;
31
38
  driverParam: string;
32
- hasDefault: false;
33
39
  notNull: true;
34
- }>;
35
- emailVerified: import("drizzle-orm/sqlite-core").SQLiteTimestamp<{
36
- tableName: "user";
40
+ hasDefault: false;
41
+ enumValues: [string, ...string[]];
42
+ baseColumn: never;
43
+ }, object>;
44
+ emailVerified: import("drizzle-orm/sqlite-core").SQLiteColumn<{
37
45
  name: "emailVerified";
46
+ tableName: "user";
47
+ dataType: "date";
48
+ columnType: "SQLiteTimestamp";
38
49
  data: Date;
39
50
  driverParam: number;
40
51
  notNull: false;
41
52
  hasDefault: false;
42
- }>;
43
- image: import("drizzle-orm/sqlite-core").SQLiteText<{
44
- tableName: "user";
53
+ enumValues: undefined;
54
+ baseColumn: never;
55
+ }, object>;
56
+ image: import("drizzle-orm/sqlite-core").SQLiteColumn<{
45
57
  name: "image";
58
+ tableName: "user";
59
+ dataType: "string";
60
+ columnType: "SQLiteText";
46
61
  data: string;
47
62
  driverParam: string;
48
- enumValues: [string, ...string[]];
49
63
  notNull: false;
50
64
  hasDefault: false;
51
- }>;
65
+ enumValues: [string, ...string[]];
66
+ baseColumn: never;
67
+ }, object>;
52
68
  };
69
+ dialect: "sqlite";
53
70
  }>;
54
- accounts: import("drizzle-orm/db.d-b5fdf746").ag<{
71
+ accounts: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
55
72
  name: "account";
56
73
  schema: undefined;
57
74
  columns: {
58
- userId: import("drizzle-orm/sqlite-core").SQLiteText<{
59
- tableName: "account";
60
- enumValues: [string, ...string[]];
75
+ userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
61
76
  name: "userId";
77
+ tableName: "account";
78
+ dataType: "string";
79
+ columnType: "SQLiteText";
62
80
  data: string;
63
81
  driverParam: string;
64
- hasDefault: false;
65
82
  notNull: true;
66
- }>;
67
- type: import("drizzle-orm/sqlite-core").SQLiteText<{
68
- tableName: "account";
83
+ hasDefault: false;
69
84
  enumValues: [string, ...string[]];
85
+ baseColumn: never;
86
+ }, object>;
87
+ type: import("drizzle-orm/sqlite-core").SQLiteColumn<{
70
88
  name: "type";
89
+ tableName: "account";
90
+ dataType: "string";
91
+ columnType: "SQLiteText";
71
92
  data: "email" | "oidc" | "oauth";
72
93
  driverParam: string;
73
- hasDefault: false;
74
94
  notNull: true;
75
- }>;
76
- provider: import("drizzle-orm/sqlite-core").SQLiteText<{
77
- tableName: "account";
95
+ hasDefault: false;
78
96
  enumValues: [string, ...string[]];
97
+ baseColumn: never;
98
+ }, object>;
99
+ provider: import("drizzle-orm/sqlite-core").SQLiteColumn<{
79
100
  name: "provider";
101
+ tableName: "account";
102
+ dataType: "string";
103
+ columnType: "SQLiteText";
80
104
  data: string;
81
105
  driverParam: string;
82
- hasDefault: false;
83
106
  notNull: true;
84
- }>;
85
- providerAccountId: import("drizzle-orm/sqlite-core").SQLiteText<{
86
- tableName: "account";
107
+ hasDefault: false;
87
108
  enumValues: [string, ...string[]];
109
+ baseColumn: never;
110
+ }, object>;
111
+ providerAccountId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
88
112
  name: "providerAccountId";
113
+ tableName: "account";
114
+ dataType: "string";
115
+ columnType: "SQLiteText";
89
116
  data: string;
90
117
  driverParam: string;
91
- hasDefault: false;
92
118
  notNull: true;
93
- }>;
94
- refresh_token: import("drizzle-orm/sqlite-core").SQLiteText<{
95
- tableName: "account";
119
+ hasDefault: false;
120
+ enumValues: [string, ...string[]];
121
+ baseColumn: never;
122
+ }, object>;
123
+ refresh_token: import("drizzle-orm/sqlite-core").SQLiteColumn<{
96
124
  name: "refresh_token";
125
+ tableName: "account";
126
+ dataType: "string";
127
+ columnType: "SQLiteText";
97
128
  data: string;
98
129
  driverParam: string;
99
- enumValues: [string, ...string[]];
100
130
  notNull: false;
101
131
  hasDefault: false;
102
- }>;
103
- access_token: import("drizzle-orm/sqlite-core").SQLiteText<{
104
- tableName: "account";
132
+ enumValues: [string, ...string[]];
133
+ baseColumn: never;
134
+ }, object>;
135
+ access_token: import("drizzle-orm/sqlite-core").SQLiteColumn<{
105
136
  name: "access_token";
137
+ tableName: "account";
138
+ dataType: "string";
139
+ columnType: "SQLiteText";
106
140
  data: string;
107
141
  driverParam: string;
108
- enumValues: [string, ...string[]];
109
142
  notNull: false;
110
143
  hasDefault: false;
111
- }>;
112
- expires_at: import("drizzle-orm/sqlite-core").SQLiteInteger<{
113
- tableName: "account";
144
+ enumValues: [string, ...string[]];
145
+ baseColumn: never;
146
+ }, object>;
147
+ expires_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
114
148
  name: "expires_at";
149
+ tableName: "account";
150
+ dataType: "number";
151
+ columnType: "SQLiteInteger";
115
152
  data: number;
116
153
  driverParam: number;
117
154
  notNull: false;
118
155
  hasDefault: false;
119
- }>;
120
- token_type: import("drizzle-orm/sqlite-core").SQLiteText<{
121
- tableName: "account";
156
+ enumValues: undefined;
157
+ baseColumn: never;
158
+ }, object>;
159
+ token_type: import("drizzle-orm/sqlite-core").SQLiteColumn<{
122
160
  name: "token_type";
161
+ tableName: "account";
162
+ dataType: "string";
163
+ columnType: "SQLiteText";
123
164
  data: string;
124
165
  driverParam: string;
125
- enumValues: [string, ...string[]];
126
166
  notNull: false;
127
167
  hasDefault: false;
128
- }>;
129
- scope: import("drizzle-orm/sqlite-core").SQLiteText<{
130
- tableName: "account";
168
+ enumValues: [string, ...string[]];
169
+ baseColumn: never;
170
+ }, object>;
171
+ scope: import("drizzle-orm/sqlite-core").SQLiteColumn<{
131
172
  name: "scope";
173
+ tableName: "account";
174
+ dataType: "string";
175
+ columnType: "SQLiteText";
132
176
  data: string;
133
177
  driverParam: string;
134
- enumValues: [string, ...string[]];
135
178
  notNull: false;
136
179
  hasDefault: false;
137
- }>;
138
- id_token: import("drizzle-orm/sqlite-core").SQLiteText<{
139
- tableName: "account";
180
+ enumValues: [string, ...string[]];
181
+ baseColumn: never;
182
+ }, object>;
183
+ id_token: import("drizzle-orm/sqlite-core").SQLiteColumn<{
140
184
  name: "id_token";
185
+ tableName: "account";
186
+ dataType: "string";
187
+ columnType: "SQLiteText";
141
188
  data: string;
142
189
  driverParam: string;
143
- enumValues: [string, ...string[]];
144
190
  notNull: false;
145
191
  hasDefault: false;
146
- }>;
147
- session_state: import("drizzle-orm/sqlite-core").SQLiteText<{
148
- tableName: "account";
192
+ enumValues: [string, ...string[]];
193
+ baseColumn: never;
194
+ }, object>;
195
+ session_state: import("drizzle-orm/sqlite-core").SQLiteColumn<{
149
196
  name: "session_state";
197
+ tableName: "account";
198
+ dataType: "string";
199
+ columnType: "SQLiteText";
150
200
  data: string;
151
201
  driverParam: string;
152
- enumValues: [string, ...string[]];
153
202
  notNull: false;
154
203
  hasDefault: false;
155
- }>;
204
+ enumValues: [string, ...string[]];
205
+ baseColumn: never;
206
+ }, object>;
156
207
  };
208
+ dialect: "sqlite";
157
209
  }>;
158
- sessions: import("drizzle-orm/db.d-b5fdf746").ag<{
210
+ sessions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
159
211
  name: "session";
160
212
  schema: undefined;
161
213
  columns: {
162
- sessionToken: import("drizzle-orm/sqlite-core").SQLiteText<{
163
- tableName: "session";
164
- enumValues: [string, ...string[]];
214
+ sessionToken: import("drizzle-orm/sqlite-core").SQLiteColumn<{
165
215
  name: "sessionToken";
216
+ tableName: "session";
217
+ dataType: "string";
218
+ columnType: "SQLiteText";
166
219
  data: string;
167
220
  driverParam: string;
168
- hasDefault: false;
169
221
  notNull: true;
170
- }>;
171
- userId: import("drizzle-orm/sqlite-core").SQLiteText<{
172
- tableName: "session";
222
+ hasDefault: false;
173
223
  enumValues: [string, ...string[]];
224
+ baseColumn: never;
225
+ }, object>;
226
+ userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
174
227
  name: "userId";
228
+ tableName: "session";
229
+ dataType: "string";
230
+ columnType: "SQLiteText";
175
231
  data: string;
176
232
  driverParam: string;
177
- hasDefault: false;
178
233
  notNull: true;
179
- }>;
180
- expires: import("drizzle-orm/sqlite-core").SQLiteTimestamp<{
181
- tableName: "session";
234
+ hasDefault: false;
235
+ enumValues: [string, ...string[]];
236
+ baseColumn: never;
237
+ }, object>;
238
+ expires: import("drizzle-orm/sqlite-core").SQLiteColumn<{
182
239
  name: "expires";
240
+ tableName: "session";
241
+ dataType: "date";
242
+ columnType: "SQLiteTimestamp";
183
243
  data: Date;
184
244
  driverParam: number;
185
- hasDefault: false;
186
245
  notNull: true;
187
- }>;
246
+ hasDefault: false;
247
+ enumValues: undefined;
248
+ baseColumn: never;
249
+ }, object>;
188
250
  };
251
+ dialect: "sqlite";
189
252
  }>;
190
- verificationTokens: import("drizzle-orm/db.d-b5fdf746").ag<{
253
+ verificationTokens: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
191
254
  name: "verificationToken";
192
255
  schema: undefined;
193
256
  columns: {
194
- identifier: import("drizzle-orm/sqlite-core").SQLiteText<{
195
- tableName: "verificationToken";
196
- enumValues: [string, ...string[]];
257
+ identifier: import("drizzle-orm/sqlite-core").SQLiteColumn<{
197
258
  name: "identifier";
259
+ tableName: "verificationToken";
260
+ dataType: "string";
261
+ columnType: "SQLiteText";
198
262
  data: string;
199
263
  driverParam: string;
200
- hasDefault: false;
201
264
  notNull: true;
202
- }>;
203
- token: import("drizzle-orm/sqlite-core").SQLiteText<{
204
- tableName: "verificationToken";
265
+ hasDefault: false;
205
266
  enumValues: [string, ...string[]];
267
+ baseColumn: never;
268
+ }, object>;
269
+ token: import("drizzle-orm/sqlite-core").SQLiteColumn<{
206
270
  name: "token";
271
+ tableName: "verificationToken";
272
+ dataType: "string";
273
+ columnType: "SQLiteText";
207
274
  data: string;
208
275
  driverParam: string;
209
- hasDefault: false;
210
276
  notNull: true;
211
- }>;
212
- expires: import("drizzle-orm/sqlite-core").SQLiteTimestamp<{
213
- tableName: "verificationToken";
277
+ hasDefault: false;
278
+ enumValues: [string, ...string[]];
279
+ baseColumn: never;
280
+ }, object>;
281
+ expires: import("drizzle-orm/sqlite-core").SQLiteColumn<{
214
282
  name: "expires";
283
+ tableName: "verificationToken";
284
+ dataType: "date";
285
+ columnType: "SQLiteTimestamp";
215
286
  data: Date;
216
287
  driverParam: number;
217
- hasDefault: false;
218
288
  notNull: true;
219
- }>;
289
+ hasDefault: false;
290
+ enumValues: undefined;
291
+ baseColumn: never;
292
+ }, object>;
220
293
  };
294
+ dialect: "sqlite";
221
295
  }>;
222
296
  };
223
297
  export type DefaultSchema = ReturnType<typeof createTables>;
224
- export declare function SQLiteDrizzleAdapter(client: BaseSQLiteDatabase<any, any>, tableFn?: SQLiteTableFn<undefined>): Adapter;
298
+ export declare function SQLiteDrizzleAdapter(client: InstanceType<typeof BaseSQLiteDatabase>, tableFn?: SQLiteTableFn<undefined>): Adapter;
225
299
  //# sourceMappingURL=sqlite.d.ts.map
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,kBAAkB,CAAC,GAAG,EAAE,GAAG,CAAC,EACpC,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,CA2IT"}
package/lib/utils.d.ts CHANGED
@@ -18,7 +18,4 @@ export interface MinimumSchema {
18
18
  export type SqlFlavorOptions = AnyMySqlDatabase | AnyPgDatabase | AnySQLiteDatabase;
19
19
  export type ClientFlavors<Flavor> = Flavor extends AnyMySqlDatabase ? MinimumSchema["mysql"] : Flavor extends AnyPgDatabase ? MinimumSchema["pg"] : Flavor extends AnySQLiteDatabase ? MinimumSchema["sqlite"] : never;
20
20
  export type TableFn<Flavor> = Flavor extends AnyMySqlDatabase ? MySqlTableFn : Flavor extends AnyPgDatabase ? PgTableFn : Flavor extends AnySQLiteDatabase ? SQLiteTableFn : AnySQLiteTable;
21
- export declare function isMySqlDatabase(db: any): db is MySqlDatabase<any, any, any, any>;
22
- export declare function isPgDatabase(db: any): db is PgDatabase<any, any, any>;
23
- export declare function isSQLiteDatabase(db: any): db is AnySQLiteDatabase;
24
21
  //# sourceMappingURL=utils.d.ts.map
package/lib/utils.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAC5E,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,IAAI,WAAW,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,IAAI,YAAY,EAAE,MAAM,aAAa,CAAA;AAEhE,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AACtD,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AACrD,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AAEtE,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAClD,EAAE,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACzC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;CACtD;AAED,MAAM,MAAM,gBAAgB,GACxB,gBAAgB,GAChB,aAAa,GACb,iBAAiB,CAAA;AAErB,MAAM,MAAM,aAAa,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GAC/D,aAAa,CAAC,OAAO,CAAC,GACtB,MAAM,SAAS,aAAa,GAC5B,aAAa,CAAC,IAAI,CAAC,GACnB,MAAM,SAAS,iBAAiB,GAChC,aAAa,CAAC,QAAQ,CAAC,GACvB,KAAK,CAAA;AAET,MAAM,MAAM,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GACzD,YAAY,GACZ,MAAM,SAAS,aAAa,GAC5B,SAAS,GACT,MAAM,SAAS,iBAAiB,GAChC,aAAa,GACb,cAAc,CAAA;AAElB,wBAAgB,eAAe,CAC7B,EAAE,EAAE,GAAG,GACN,EAAE,IAAI,aAAa,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAEzC;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,IAAI,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAErE;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,IAAI,iBAAiB,CAEjE"}
1
+ {"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAC5E,OAAO,KAAK,EAAE,aAAa,IAAI,QAAQ,EAAE,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,IAAI,WAAW,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,IAAI,YAAY,EAAE,MAAM,aAAa,CAAA;AAEhE,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AACtD,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AACrD,MAAM,MAAM,iBAAiB,GAAG,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;AAEtE,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAClD,EAAE,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACzC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;CACtD;AAED,MAAM,MAAM,gBAAgB,GACxB,gBAAgB,GAChB,aAAa,GACb,iBAAiB,CAAA;AAErB,MAAM,MAAM,aAAa,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GAC/D,aAAa,CAAC,OAAO,CAAC,GACtB,MAAM,SAAS,aAAa,GAC5B,aAAa,CAAC,IAAI,CAAC,GACnB,MAAM,SAAS,iBAAiB,GAChC,aAAa,CAAC,QAAQ,CAAC,GACvB,KAAK,CAAA;AAET,MAAM,MAAM,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,gBAAgB,GACzD,YAAY,GACZ,MAAM,SAAS,aAAa,GAC5B,SAAS,GACT,MAAM,SAAS,iBAAiB,GAChC,aAAa,GACb,cAAc,CAAA"}
package/lib/utils.js CHANGED
@@ -1,12 +1 @@
1
- import { MySqlDatabase } from "drizzle-orm/mysql-core";
2
- import { PgDatabase } from "drizzle-orm/pg-core";
3
- import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
4
- export function isMySqlDatabase(db) {
5
- return db instanceof MySqlDatabase;
6
- }
7
- export function isPgDatabase(db) {
8
- return db instanceof PgDatabase;
9
- }
10
- export function isSQLiteDatabase(db) {
11
- return db instanceof BaseSQLiteDatabase;
12
- }
1
+ export {};
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@auth/drizzle-adapter",
3
- "version": "0.3.1",
3
+ "version": "0.3.3",
4
4
  "description": "Drizzle adapter for Auth.js.",
5
5
  "homepage": "https://authjs.dev",
6
6
  "repository": "https://github.com/nextauthjs/next-auth",
@@ -36,22 +36,22 @@
36
36
  "access": "public"
37
37
  },
38
38
  "dependencies": {
39
- "@auth/core": "0.11.1"
39
+ "@auth/core": "0.16.1"
40
40
  },
41
41
  "devDependencies": {
42
42
  "@types/better-sqlite3": "^7.6.4",
43
43
  "@types/uuid": "^8.3.3",
44
- "better-sqlite3": "^8.4.0",
44
+ "better-sqlite3": "^8.6.0",
45
45
  "drizzle-kit": "^0.19.5",
46
- "drizzle-orm": "^0.27.0",
46
+ "drizzle-orm": "^0.28.6",
47
47
  "jest": "^27.4.3",
48
48
  "mysql2": "^3.2.0",
49
49
  "postgres": "^3.3.4",
50
- "@next-auth/adapter-test": "0.0.0",
51
- "@next-auth/tsconfig": "0.0.0"
50
+ "@auth/adapter-test": "0.0.0",
51
+ "@auth/tsconfig": "0.0.0"
52
52
  },
53
53
  "jest": {
54
- "preset": "@next-auth/adapter-test/jest"
54
+ "preset": "@auth/adapter-test/jest"
55
55
  },
56
56
  "scripts": {
57
57
  "clean": "find . -type d -name \".drizzle\" | xargs rm -rf",
package/src/index.ts CHANGED
@@ -16,19 +16,14 @@
16
16
  * @module @auth/drizzle-adapter
17
17
  */
18
18
 
19
- import { MySqlTableFn } from "drizzle-orm/mysql-core/index.js"
20
- import { PgTableFn } from "drizzle-orm/pg-core/index.js"
21
- import { SQLiteTableFn } from "drizzle-orm/sqlite-core/index.js"
19
+ import { MySqlDatabase, MySqlTableFn } from "drizzle-orm/mysql-core"
20
+ import { PgDatabase, PgTableFn } from "drizzle-orm/pg-core"
21
+ import { BaseSQLiteDatabase, SQLiteTableFn } from "drizzle-orm/sqlite-core"
22
22
  import { mySqlDrizzleAdapter } from "./lib/mysql.js"
23
23
  import { pgDrizzleAdapter } from "./lib/pg.js"
24
24
  import { SQLiteDrizzleAdapter } from "./lib/sqlite.js"
25
- import {
26
- isMySqlDatabase,
27
- isPgDatabase,
28
- isSQLiteDatabase,
29
- SqlFlavorOptions,
30
- TableFn,
31
- } from "./lib/utils.js"
25
+ import { SqlFlavorOptions, TableFn } from "./lib/utils.js"
26
+ import { is } from "drizzle-orm"
32
27
 
33
28
  import type { Adapter } from "@auth/core/adapters"
34
29
 
@@ -260,18 +255,15 @@ export function DrizzleAdapter<SqlFlavor extends SqlFlavorOptions>(
260
255
  db: SqlFlavor,
261
256
  table?: TableFn<SqlFlavor>
262
257
  ): Adapter {
263
- if (isMySqlDatabase(db)) {
264
- // We need to cast to unknown since the type overlaps (PScale is MySQL based)
258
+ if (is(db, MySqlDatabase)) {
265
259
  return mySqlDrizzleAdapter(db, table as MySqlTableFn)
266
- }
267
-
268
- if (isPgDatabase(db)) {
260
+ } else if (is(db, PgDatabase)) {
269
261
  return pgDrizzleAdapter(db, table as PgTableFn)
270
- }
271
-
272
- if (isSQLiteDatabase(db)) {
262
+ } else if (is(db, BaseSQLiteDatabase)) {
273
263
  return SQLiteDrizzleAdapter(db, table as SQLiteTableFn)
274
264
  }
275
265
 
276
- throw new Error("Unsupported database type in Auth.js Drizzle adapter.")
266
+ throw new Error(
267
+ `Unsupported database type (${typeof db}) in Auth.js Drizzle adapter.`
268
+ )
277
269
  }
package/src/lib/mysql.ts CHANGED
@@ -6,10 +6,10 @@ import {
6
6
  primaryKey,
7
7
  varchar,
8
8
  MySqlTableFn,
9
+ MySqlDatabase,
9
10
  } from "drizzle-orm/mysql-core"
10
11
 
11
12
  import type { Adapter, AdapterAccount } from "@auth/core/adapters"
12
- import type { MySql2Database } from "drizzle-orm/mysql2"
13
13
 
14
14
  export function createTables(mySqlTable: MySqlTableFn) {
15
15
  const users = mySqlTable("user", {
@@ -77,7 +77,7 @@ export function createTables(mySqlTable: MySqlTableFn) {
77
77
  export type DefaultSchema = ReturnType<typeof createTables>
78
78
 
79
79
  export function mySqlDrizzleAdapter(
80
- client: MySql2Database<Record<string, never>>,
80
+ client: InstanceType<typeof MySqlDatabase>,
81
81
  tableFn = defaultMySqlTableFn
82
82
  ): Adapter {
83
83
  const { users, accounts, sessions, verificationTokens } =
@@ -164,10 +164,7 @@ export function mySqlDrizzleAdapter(
164
164
  .then((res) => res[0])
165
165
  },
166
166
  async linkAccount(rawAccount) {
167
- await client
168
- .insert(accounts)
169
- .values(rawAccount)
170
- .then((res) => res[0])
167
+ await client.insert(accounts).values(rawAccount)
171
168
  },
172
169
  async getUserByAccount(account) {
173
170
  const dbAccount =
package/src/lib/pg.ts CHANGED
@@ -6,9 +6,9 @@ import {
6
6
  primaryKey,
7
7
  integer,
8
8
  PgTableFn,
9
+ PgDatabase,
9
10
  } from "drizzle-orm/pg-core"
10
11
 
11
- import type { PostgresJsDatabase } from "drizzle-orm/postgres-js"
12
12
  import type { Adapter, AdapterAccount } from "@auth/core/adapters"
13
13
 
14
14
  export function createTables(pgTable: PgTableFn) {
@@ -68,7 +68,7 @@ export function createTables(pgTable: PgTableFn) {
68
68
  export type DefaultSchema = ReturnType<typeof createTables>
69
69
 
70
70
  export function pgDrizzleAdapter(
71
- client: PostgresJsDatabase<Record<string, never>>,
71
+ client: InstanceType<typeof PgDatabase>,
72
72
  tableFn = defaultPgTableFn
73
73
  ): Adapter {
74
74
  const { users, accounts, sessions, verificationTokens } =
package/src/lib/sqlite.ts CHANGED
@@ -67,7 +67,7 @@ export function createTables(sqliteTable: SQLiteTableFn) {
67
67
  export type DefaultSchema = ReturnType<typeof createTables>
68
68
 
69
69
  export function SQLiteDrizzleAdapter(
70
- client: BaseSQLiteDatabase<any, any>,
70
+ client: InstanceType<typeof BaseSQLiteDatabase>,
71
71
  tableFn = defaultSqliteTableFn
72
72
  ): Adapter {
73
73
  const { users, accounts, sessions, verificationTokens } =
package/src/lib/utils.ts CHANGED
@@ -39,17 +39,3 @@ export type TableFn<Flavor> = Flavor extends AnyMySqlDatabase
39
39
  : Flavor extends AnySQLiteDatabase
40
40
  ? SQLiteTableFn
41
41
  : AnySQLiteTable
42
-
43
- export function isMySqlDatabase(
44
- db: any
45
- ): db is MySqlDatabase<any, any, any, any> {
46
- return db instanceof MySqlDatabase
47
- }
48
-
49
- export function isPgDatabase(db: any): db is PgDatabase<any, any, any> {
50
- return db instanceof PgDatabase
51
- }
52
-
53
- export function isSQLiteDatabase(db: any): db is AnySQLiteDatabase {
54
- return db instanceof BaseSQLiteDatabase
55
- }