drizzle-kit 0.21.1 → 0.21.2-dd5c3c4
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.
- package/bin.cjs +10801 -11603
- package/package.json +2 -2
- package/payload.d.mts +177 -177
- package/payload.d.ts +177 -177
- package/payload.js +407 -385
- package/payload.mjs +399 -377
- package/utils-studio.js +835 -944
- package/utils-studio.mjs +808 -917
- package/utils.js +214 -842
- package/utils.mjs +189 -817
package/payload.d.ts
CHANGED
|
@@ -4,7 +4,7 @@ import { TypeOf } from 'zod';
|
|
|
4
4
|
import { MySql2Database } from 'drizzle-orm/mysql2';
|
|
5
5
|
import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
|
|
6
6
|
|
|
7
|
-
declare const pgSchema: zod.ZodObject<zod.
|
|
7
|
+
declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
8
8
|
version: zod.ZodLiteral<"6">;
|
|
9
9
|
dialect: zod.ZodLiteral<"postgresql">;
|
|
10
10
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -21,25 +21,25 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
21
21
|
uniqueName: zod.ZodOptional<zod.ZodString>;
|
|
22
22
|
nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
|
|
23
23
|
}, "strict", zod.ZodTypeAny, {
|
|
24
|
-
type: string;
|
|
25
|
-
name: string;
|
|
26
|
-
primaryKey: boolean;
|
|
27
|
-
notNull: boolean;
|
|
28
24
|
isUnique?: any;
|
|
29
25
|
default?: any;
|
|
30
26
|
typeSchema?: string | undefined;
|
|
31
27
|
uniqueName?: string | undefined;
|
|
32
28
|
nullsNotDistinct?: boolean | undefined;
|
|
33
|
-
}, {
|
|
34
29
|
type: string;
|
|
35
30
|
name: string;
|
|
36
31
|
primaryKey: boolean;
|
|
37
32
|
notNull: boolean;
|
|
33
|
+
}, {
|
|
38
34
|
isUnique?: any;
|
|
39
35
|
default?: any;
|
|
40
36
|
typeSchema?: string | undefined;
|
|
41
37
|
uniqueName?: string | undefined;
|
|
42
38
|
nullsNotDistinct?: boolean | undefined;
|
|
39
|
+
type: string;
|
|
40
|
+
name: string;
|
|
41
|
+
primaryKey: boolean;
|
|
42
|
+
notNull: boolean;
|
|
43
43
|
}>>;
|
|
44
44
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
45
45
|
name: zod.ZodString;
|
|
@@ -64,23 +64,23 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
64
64
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
65
65
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
66
66
|
}, "strict", zod.ZodTypeAny, {
|
|
67
|
+
onUpdate?: string | undefined;
|
|
68
|
+
onDelete?: string | undefined;
|
|
69
|
+
schemaTo?: string | undefined;
|
|
67
70
|
name: string;
|
|
68
71
|
tableFrom: string;
|
|
69
72
|
columnsFrom: string[];
|
|
70
73
|
tableTo: string;
|
|
71
74
|
columnsTo: string[];
|
|
75
|
+
}, {
|
|
72
76
|
onUpdate?: string | undefined;
|
|
73
77
|
onDelete?: string | undefined;
|
|
74
78
|
schemaTo?: string | undefined;
|
|
75
|
-
}, {
|
|
76
79
|
name: string;
|
|
77
80
|
tableFrom: string;
|
|
78
81
|
columnsFrom: string[];
|
|
79
82
|
tableTo: string;
|
|
80
83
|
columnsTo: string[];
|
|
81
|
-
onUpdate?: string | undefined;
|
|
82
|
-
onDelete?: string | undefined;
|
|
83
|
-
schemaTo?: string | undefined;
|
|
84
84
|
}>>;
|
|
85
85
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
86
86
|
name: zod.ZodString;
|
|
@@ -108,15 +108,15 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
108
108
|
}, "strict", zod.ZodTypeAny, {
|
|
109
109
|
name: string;
|
|
110
110
|
columns: Record<string, {
|
|
111
|
-
type: string;
|
|
112
|
-
name: string;
|
|
113
|
-
primaryKey: boolean;
|
|
114
|
-
notNull: boolean;
|
|
115
111
|
isUnique?: any;
|
|
116
112
|
default?: any;
|
|
117
113
|
typeSchema?: string | undefined;
|
|
118
114
|
uniqueName?: string | undefined;
|
|
119
115
|
nullsNotDistinct?: boolean | undefined;
|
|
116
|
+
type: string;
|
|
117
|
+
name: string;
|
|
118
|
+
primaryKey: boolean;
|
|
119
|
+
notNull: boolean;
|
|
120
120
|
}>;
|
|
121
121
|
indexes: Record<string, {
|
|
122
122
|
name: string;
|
|
@@ -124,14 +124,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
124
124
|
isUnique: boolean;
|
|
125
125
|
}>;
|
|
126
126
|
foreignKeys: Record<string, {
|
|
127
|
+
onUpdate?: string | undefined;
|
|
128
|
+
onDelete?: string | undefined;
|
|
129
|
+
schemaTo?: string | undefined;
|
|
127
130
|
name: string;
|
|
128
131
|
tableFrom: string;
|
|
129
132
|
columnsFrom: string[];
|
|
130
133
|
tableTo: string;
|
|
131
134
|
columnsTo: string[];
|
|
132
|
-
onUpdate?: string | undefined;
|
|
133
|
-
onDelete?: string | undefined;
|
|
134
|
-
schemaTo?: string | undefined;
|
|
135
135
|
}>;
|
|
136
136
|
schema: string;
|
|
137
137
|
compositePrimaryKeys: Record<string, {
|
|
@@ -144,17 +144,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
144
144
|
nullsNotDistinct: boolean;
|
|
145
145
|
}>;
|
|
146
146
|
}, {
|
|
147
|
+
uniqueConstraints?: Record<string, {
|
|
148
|
+
name: string;
|
|
149
|
+
columns: string[];
|
|
150
|
+
nullsNotDistinct: boolean;
|
|
151
|
+
}> | undefined;
|
|
147
152
|
name: string;
|
|
148
153
|
columns: Record<string, {
|
|
149
|
-
type: string;
|
|
150
|
-
name: string;
|
|
151
|
-
primaryKey: boolean;
|
|
152
|
-
notNull: boolean;
|
|
153
154
|
isUnique?: any;
|
|
154
155
|
default?: any;
|
|
155
156
|
typeSchema?: string | undefined;
|
|
156
157
|
uniqueName?: string | undefined;
|
|
157
158
|
nullsNotDistinct?: boolean | undefined;
|
|
159
|
+
type: string;
|
|
160
|
+
name: string;
|
|
161
|
+
primaryKey: boolean;
|
|
162
|
+
notNull: boolean;
|
|
158
163
|
}>;
|
|
159
164
|
indexes: Record<string, {
|
|
160
165
|
name: string;
|
|
@@ -162,25 +167,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
162
167
|
isUnique: boolean;
|
|
163
168
|
}>;
|
|
164
169
|
foreignKeys: Record<string, {
|
|
170
|
+
onUpdate?: string | undefined;
|
|
171
|
+
onDelete?: string | undefined;
|
|
172
|
+
schemaTo?: string | undefined;
|
|
165
173
|
name: string;
|
|
166
174
|
tableFrom: string;
|
|
167
175
|
columnsFrom: string[];
|
|
168
176
|
tableTo: string;
|
|
169
177
|
columnsTo: string[];
|
|
170
|
-
onUpdate?: string | undefined;
|
|
171
|
-
onDelete?: string | undefined;
|
|
172
|
-
schemaTo?: string | undefined;
|
|
173
178
|
}>;
|
|
174
179
|
schema: string;
|
|
175
180
|
compositePrimaryKeys: Record<string, {
|
|
176
181
|
name: string;
|
|
177
182
|
columns: string[];
|
|
178
183
|
}>;
|
|
179
|
-
uniqueConstraints?: Record<string, {
|
|
180
|
-
name: string;
|
|
181
|
-
columns: string[];
|
|
182
|
-
nullsNotDistinct: boolean;
|
|
183
|
-
}> | undefined;
|
|
184
184
|
}>>;
|
|
185
185
|
enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
186
186
|
name: zod.ZodString;
|
|
@@ -258,18 +258,27 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
258
258
|
id: zod.ZodString;
|
|
259
259
|
prevId: zod.ZodString;
|
|
260
260
|
}>, "strip", zod.ZodTypeAny, {
|
|
261
|
+
internal?: {
|
|
262
|
+
tables: Record<string, {
|
|
263
|
+
columns: Record<string, {
|
|
264
|
+
isArray?: boolean | undefined;
|
|
265
|
+
dimensions?: number | undefined;
|
|
266
|
+
rawType?: string | undefined;
|
|
267
|
+
} | undefined>;
|
|
268
|
+
} | undefined>;
|
|
269
|
+
} | undefined;
|
|
261
270
|
tables: Record<string, {
|
|
262
271
|
name: string;
|
|
263
272
|
columns: Record<string, {
|
|
264
|
-
type: string;
|
|
265
|
-
name: string;
|
|
266
|
-
primaryKey: boolean;
|
|
267
|
-
notNull: boolean;
|
|
268
273
|
isUnique?: any;
|
|
269
274
|
default?: any;
|
|
270
275
|
typeSchema?: string | undefined;
|
|
271
276
|
uniqueName?: string | undefined;
|
|
272
277
|
nullsNotDistinct?: boolean | undefined;
|
|
278
|
+
type: string;
|
|
279
|
+
name: string;
|
|
280
|
+
primaryKey: boolean;
|
|
281
|
+
notNull: boolean;
|
|
273
282
|
}>;
|
|
274
283
|
indexes: Record<string, {
|
|
275
284
|
name: string;
|
|
@@ -277,14 +286,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
277
286
|
isUnique: boolean;
|
|
278
287
|
}>;
|
|
279
288
|
foreignKeys: Record<string, {
|
|
289
|
+
onUpdate?: string | undefined;
|
|
290
|
+
onDelete?: string | undefined;
|
|
291
|
+
schemaTo?: string | undefined;
|
|
280
292
|
name: string;
|
|
281
293
|
tableFrom: string;
|
|
282
294
|
columnsFrom: string[];
|
|
283
295
|
tableTo: string;
|
|
284
296
|
columnsTo: string[];
|
|
285
|
-
onUpdate?: string | undefined;
|
|
286
|
-
onDelete?: string | undefined;
|
|
287
|
-
schemaTo?: string | undefined;
|
|
288
297
|
}>;
|
|
289
298
|
schema: string;
|
|
290
299
|
compositePrimaryKeys: Record<string, {
|
|
@@ -312,6 +321,7 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
312
321
|
name: string;
|
|
313
322
|
schema: string;
|
|
314
323
|
}>;
|
|
324
|
+
}, {
|
|
315
325
|
internal?: {
|
|
316
326
|
tables: Record<string, {
|
|
317
327
|
columns: Record<string, {
|
|
@@ -321,19 +331,23 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
321
331
|
} | undefined>;
|
|
322
332
|
} | undefined>;
|
|
323
333
|
} | undefined;
|
|
324
|
-
}, {
|
|
325
334
|
tables: Record<string, {
|
|
335
|
+
uniqueConstraints?: Record<string, {
|
|
336
|
+
name: string;
|
|
337
|
+
columns: string[];
|
|
338
|
+
nullsNotDistinct: boolean;
|
|
339
|
+
}> | undefined;
|
|
326
340
|
name: string;
|
|
327
341
|
columns: Record<string, {
|
|
328
|
-
type: string;
|
|
329
|
-
name: string;
|
|
330
|
-
primaryKey: boolean;
|
|
331
|
-
notNull: boolean;
|
|
332
342
|
isUnique?: any;
|
|
333
343
|
default?: any;
|
|
334
344
|
typeSchema?: string | undefined;
|
|
335
345
|
uniqueName?: string | undefined;
|
|
336
346
|
nullsNotDistinct?: boolean | undefined;
|
|
347
|
+
type: string;
|
|
348
|
+
name: string;
|
|
349
|
+
primaryKey: boolean;
|
|
350
|
+
notNull: boolean;
|
|
337
351
|
}>;
|
|
338
352
|
indexes: Record<string, {
|
|
339
353
|
name: string;
|
|
@@ -341,25 +355,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
341
355
|
isUnique: boolean;
|
|
342
356
|
}>;
|
|
343
357
|
foreignKeys: Record<string, {
|
|
358
|
+
onUpdate?: string | undefined;
|
|
359
|
+
onDelete?: string | undefined;
|
|
360
|
+
schemaTo?: string | undefined;
|
|
344
361
|
name: string;
|
|
345
362
|
tableFrom: string;
|
|
346
363
|
columnsFrom: string[];
|
|
347
364
|
tableTo: string;
|
|
348
365
|
columnsTo: string[];
|
|
349
|
-
onUpdate?: string | undefined;
|
|
350
|
-
onDelete?: string | undefined;
|
|
351
|
-
schemaTo?: string | undefined;
|
|
352
366
|
}>;
|
|
353
367
|
schema: string;
|
|
354
368
|
compositePrimaryKeys: Record<string, {
|
|
355
369
|
name: string;
|
|
356
370
|
columns: string[];
|
|
357
371
|
}>;
|
|
358
|
-
uniqueConstraints?: Record<string, {
|
|
359
|
-
name: string;
|
|
360
|
-
columns: string[];
|
|
361
|
-
nullsNotDistinct: boolean;
|
|
362
|
-
}> | undefined;
|
|
363
372
|
}>;
|
|
364
373
|
id: string;
|
|
365
374
|
prevId: string;
|
|
@@ -376,19 +385,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
376
385
|
name: string;
|
|
377
386
|
schema: string;
|
|
378
387
|
}>;
|
|
379
|
-
internal?: {
|
|
380
|
-
tables: Record<string, {
|
|
381
|
-
columns: Record<string, {
|
|
382
|
-
isArray?: boolean | undefined;
|
|
383
|
-
dimensions?: number | undefined;
|
|
384
|
-
rawType?: string | undefined;
|
|
385
|
-
} | undefined>;
|
|
386
|
-
} | undefined>;
|
|
387
|
-
} | undefined;
|
|
388
388
|
}>;
|
|
389
389
|
type PgSchema = TypeOf<typeof pgSchema>;
|
|
390
390
|
|
|
391
|
-
declare const schema$1: zod.ZodObject<zod.
|
|
391
|
+
declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
392
392
|
version: zod.ZodLiteral<"6">;
|
|
393
393
|
dialect: zod.ZodEnum<["sqlite"]>;
|
|
394
394
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -401,19 +401,19 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
401
401
|
autoincrement: zod.ZodOptional<zod.ZodBoolean>;
|
|
402
402
|
default: zod.ZodOptional<zod.ZodAny>;
|
|
403
403
|
}, "strict", zod.ZodTypeAny, {
|
|
404
|
+
default?: any;
|
|
405
|
+
autoincrement?: boolean | undefined;
|
|
404
406
|
type: string;
|
|
405
407
|
name: string;
|
|
406
408
|
primaryKey: boolean;
|
|
407
409
|
notNull: boolean;
|
|
410
|
+
}, {
|
|
408
411
|
default?: any;
|
|
409
412
|
autoincrement?: boolean | undefined;
|
|
410
|
-
}, {
|
|
411
413
|
type: string;
|
|
412
414
|
name: string;
|
|
413
415
|
primaryKey: boolean;
|
|
414
416
|
notNull: boolean;
|
|
415
|
-
default?: any;
|
|
416
|
-
autoincrement?: boolean | undefined;
|
|
417
417
|
}>>;
|
|
418
418
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
419
419
|
name: zod.ZodString;
|
|
@@ -421,15 +421,15 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
421
421
|
where: zod.ZodOptional<zod.ZodString>;
|
|
422
422
|
isUnique: zod.ZodBoolean;
|
|
423
423
|
}, "strict", zod.ZodTypeAny, {
|
|
424
|
+
where?: string | undefined;
|
|
424
425
|
name: string;
|
|
425
426
|
columns: string[];
|
|
426
427
|
isUnique: boolean;
|
|
427
|
-
where?: string | undefined;
|
|
428
428
|
}, {
|
|
429
|
+
where?: string | undefined;
|
|
429
430
|
name: string;
|
|
430
431
|
columns: string[];
|
|
431
432
|
isUnique: boolean;
|
|
432
|
-
where?: string | undefined;
|
|
433
433
|
}>>;
|
|
434
434
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
435
435
|
name: zod.ZodString;
|
|
@@ -440,31 +440,31 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
440
440
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
441
441
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
442
442
|
}, "strict", zod.ZodTypeAny, {
|
|
443
|
+
onUpdate?: string | undefined;
|
|
444
|
+
onDelete?: string | undefined;
|
|
443
445
|
name: string;
|
|
444
446
|
tableFrom: string;
|
|
445
447
|
columnsFrom: string[];
|
|
446
448
|
tableTo: string;
|
|
447
449
|
columnsTo: string[];
|
|
450
|
+
}, {
|
|
448
451
|
onUpdate?: string | undefined;
|
|
449
452
|
onDelete?: string | undefined;
|
|
450
|
-
}, {
|
|
451
453
|
name: string;
|
|
452
454
|
tableFrom: string;
|
|
453
455
|
columnsFrom: string[];
|
|
454
456
|
tableTo: string;
|
|
455
457
|
columnsTo: string[];
|
|
456
|
-
onUpdate?: string | undefined;
|
|
457
|
-
onDelete?: string | undefined;
|
|
458
458
|
}>>;
|
|
459
459
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
460
460
|
columns: zod.ZodArray<zod.ZodString, "many">;
|
|
461
461
|
name: zod.ZodOptional<zod.ZodString>;
|
|
462
462
|
}, "strict", zod.ZodTypeAny, {
|
|
463
|
-
columns: string[];
|
|
464
463
|
name?: string | undefined;
|
|
465
|
-
}, {
|
|
466
464
|
columns: string[];
|
|
465
|
+
}, {
|
|
467
466
|
name?: string | undefined;
|
|
467
|
+
columns: string[];
|
|
468
468
|
}>>;
|
|
469
469
|
uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
470
470
|
name: zod.ZodString;
|
|
@@ -479,69 +479,69 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
479
479
|
}, "strict", zod.ZodTypeAny, {
|
|
480
480
|
name: string;
|
|
481
481
|
columns: Record<string, {
|
|
482
|
+
default?: any;
|
|
483
|
+
autoincrement?: boolean | undefined;
|
|
482
484
|
type: string;
|
|
483
485
|
name: string;
|
|
484
486
|
primaryKey: boolean;
|
|
485
487
|
notNull: boolean;
|
|
486
|
-
default?: any;
|
|
487
|
-
autoincrement?: boolean | undefined;
|
|
488
488
|
}>;
|
|
489
489
|
indexes: Record<string, {
|
|
490
|
+
where?: string | undefined;
|
|
490
491
|
name: string;
|
|
491
492
|
columns: string[];
|
|
492
493
|
isUnique: boolean;
|
|
493
|
-
where?: string | undefined;
|
|
494
494
|
}>;
|
|
495
495
|
foreignKeys: Record<string, {
|
|
496
|
+
onUpdate?: string | undefined;
|
|
497
|
+
onDelete?: string | undefined;
|
|
496
498
|
name: string;
|
|
497
499
|
tableFrom: string;
|
|
498
500
|
columnsFrom: string[];
|
|
499
501
|
tableTo: string;
|
|
500
502
|
columnsTo: string[];
|
|
501
|
-
onUpdate?: string | undefined;
|
|
502
|
-
onDelete?: string | undefined;
|
|
503
503
|
}>;
|
|
504
504
|
compositePrimaryKeys: Record<string, {
|
|
505
|
-
columns: string[];
|
|
506
505
|
name?: string | undefined;
|
|
506
|
+
columns: string[];
|
|
507
507
|
}>;
|
|
508
508
|
uniqueConstraints: Record<string, {
|
|
509
509
|
name: string;
|
|
510
510
|
columns: string[];
|
|
511
511
|
}>;
|
|
512
512
|
}, {
|
|
513
|
+
uniqueConstraints?: Record<string, {
|
|
514
|
+
name: string;
|
|
515
|
+
columns: string[];
|
|
516
|
+
}> | undefined;
|
|
513
517
|
name: string;
|
|
514
518
|
columns: Record<string, {
|
|
519
|
+
default?: any;
|
|
520
|
+
autoincrement?: boolean | undefined;
|
|
515
521
|
type: string;
|
|
516
522
|
name: string;
|
|
517
523
|
primaryKey: boolean;
|
|
518
524
|
notNull: boolean;
|
|
519
|
-
default?: any;
|
|
520
|
-
autoincrement?: boolean | undefined;
|
|
521
525
|
}>;
|
|
522
526
|
indexes: Record<string, {
|
|
527
|
+
where?: string | undefined;
|
|
523
528
|
name: string;
|
|
524
529
|
columns: string[];
|
|
525
530
|
isUnique: boolean;
|
|
526
|
-
where?: string | undefined;
|
|
527
531
|
}>;
|
|
528
532
|
foreignKeys: Record<string, {
|
|
533
|
+
onUpdate?: string | undefined;
|
|
534
|
+
onDelete?: string | undefined;
|
|
529
535
|
name: string;
|
|
530
536
|
tableFrom: string;
|
|
531
537
|
columnsFrom: string[];
|
|
532
538
|
tableTo: string;
|
|
533
539
|
columnsTo: string[];
|
|
534
|
-
onUpdate?: string | undefined;
|
|
535
|
-
onDelete?: string | undefined;
|
|
536
540
|
}>;
|
|
537
541
|
compositePrimaryKeys: Record<string, {
|
|
538
|
-
columns: string[];
|
|
539
542
|
name?: string | undefined;
|
|
540
|
-
}>;
|
|
541
|
-
uniqueConstraints?: Record<string, {
|
|
542
|
-
name: string;
|
|
543
543
|
columns: string[];
|
|
544
|
-
}
|
|
544
|
+
}>;
|
|
545
545
|
}>>;
|
|
546
546
|
enums: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
|
|
547
547
|
_meta: zod.ZodObject<{
|
|
@@ -561,31 +561,31 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
561
561
|
tables: Record<string, {
|
|
562
562
|
name: string;
|
|
563
563
|
columns: Record<string, {
|
|
564
|
+
default?: any;
|
|
565
|
+
autoincrement?: boolean | undefined;
|
|
564
566
|
type: string;
|
|
565
567
|
name: string;
|
|
566
568
|
primaryKey: boolean;
|
|
567
569
|
notNull: boolean;
|
|
568
|
-
default?: any;
|
|
569
|
-
autoincrement?: boolean | undefined;
|
|
570
570
|
}>;
|
|
571
571
|
indexes: Record<string, {
|
|
572
|
+
where?: string | undefined;
|
|
572
573
|
name: string;
|
|
573
574
|
columns: string[];
|
|
574
575
|
isUnique: boolean;
|
|
575
|
-
where?: string | undefined;
|
|
576
576
|
}>;
|
|
577
577
|
foreignKeys: Record<string, {
|
|
578
|
+
onUpdate?: string | undefined;
|
|
579
|
+
onDelete?: string | undefined;
|
|
578
580
|
name: string;
|
|
579
581
|
tableFrom: string;
|
|
580
582
|
columnsFrom: string[];
|
|
581
583
|
tableTo: string;
|
|
582
584
|
columnsTo: string[];
|
|
583
|
-
onUpdate?: string | undefined;
|
|
584
|
-
onDelete?: string | undefined;
|
|
585
585
|
}>;
|
|
586
586
|
compositePrimaryKeys: Record<string, {
|
|
587
|
-
columns: string[];
|
|
588
587
|
name?: string | undefined;
|
|
588
|
+
columns: string[];
|
|
589
589
|
}>;
|
|
590
590
|
uniqueConstraints: Record<string, {
|
|
591
591
|
name: string;
|
|
@@ -603,38 +603,38 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
603
603
|
enums: {};
|
|
604
604
|
}, {
|
|
605
605
|
tables: Record<string, {
|
|
606
|
+
uniqueConstraints?: Record<string, {
|
|
607
|
+
name: string;
|
|
608
|
+
columns: string[];
|
|
609
|
+
}> | undefined;
|
|
606
610
|
name: string;
|
|
607
611
|
columns: Record<string, {
|
|
612
|
+
default?: any;
|
|
613
|
+
autoincrement?: boolean | undefined;
|
|
608
614
|
type: string;
|
|
609
615
|
name: string;
|
|
610
616
|
primaryKey: boolean;
|
|
611
617
|
notNull: boolean;
|
|
612
|
-
default?: any;
|
|
613
|
-
autoincrement?: boolean | undefined;
|
|
614
618
|
}>;
|
|
615
619
|
indexes: Record<string, {
|
|
620
|
+
where?: string | undefined;
|
|
616
621
|
name: string;
|
|
617
622
|
columns: string[];
|
|
618
623
|
isUnique: boolean;
|
|
619
|
-
where?: string | undefined;
|
|
620
624
|
}>;
|
|
621
625
|
foreignKeys: Record<string, {
|
|
626
|
+
onUpdate?: string | undefined;
|
|
627
|
+
onDelete?: string | undefined;
|
|
622
628
|
name: string;
|
|
623
629
|
tableFrom: string;
|
|
624
630
|
columnsFrom: string[];
|
|
625
631
|
tableTo: string;
|
|
626
632
|
columnsTo: string[];
|
|
627
|
-
onUpdate?: string | undefined;
|
|
628
|
-
onDelete?: string | undefined;
|
|
629
633
|
}>;
|
|
630
634
|
compositePrimaryKeys: Record<string, {
|
|
631
|
-
columns: string[];
|
|
632
635
|
name?: string | undefined;
|
|
633
|
-
}>;
|
|
634
|
-
uniqueConstraints?: Record<string, {
|
|
635
|
-
name: string;
|
|
636
636
|
columns: string[];
|
|
637
|
-
}
|
|
637
|
+
}>;
|
|
638
638
|
}>;
|
|
639
639
|
id: string;
|
|
640
640
|
prevId: string;
|
|
@@ -648,7 +648,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
648
648
|
}>;
|
|
649
649
|
type SQLiteSchema = TypeOf<typeof schema$1>;
|
|
650
650
|
|
|
651
|
-
declare const schema: zod.ZodObject<zod.
|
|
651
|
+
declare const schema: zod.ZodObject<zod.extendShape<{
|
|
652
652
|
version: zod.ZodLiteral<"5">;
|
|
653
653
|
dialect: zod.ZodLiteral<"mysql">;
|
|
654
654
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -662,21 +662,21 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
662
662
|
default: zod.ZodOptional<zod.ZodAny>;
|
|
663
663
|
onUpdate: zod.ZodOptional<zod.ZodAny>;
|
|
664
664
|
}, "strict", zod.ZodTypeAny, {
|
|
665
|
+
default?: any;
|
|
666
|
+
onUpdate?: any;
|
|
667
|
+
autoincrement?: boolean | undefined;
|
|
665
668
|
type: string;
|
|
666
669
|
name: string;
|
|
667
670
|
primaryKey: boolean;
|
|
668
671
|
notNull: boolean;
|
|
672
|
+
}, {
|
|
669
673
|
default?: any;
|
|
670
674
|
onUpdate?: any;
|
|
671
675
|
autoincrement?: boolean | undefined;
|
|
672
|
-
}, {
|
|
673
676
|
type: string;
|
|
674
677
|
name: string;
|
|
675
678
|
primaryKey: boolean;
|
|
676
679
|
notNull: boolean;
|
|
677
|
-
default?: any;
|
|
678
|
-
onUpdate?: any;
|
|
679
|
-
autoincrement?: boolean | undefined;
|
|
680
680
|
}>>;
|
|
681
681
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
682
682
|
name: zod.ZodString;
|
|
@@ -686,19 +686,19 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
686
686
|
algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
|
|
687
687
|
lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
688
688
|
}, "strict", zod.ZodTypeAny, {
|
|
689
|
-
name: string;
|
|
690
|
-
columns: string[];
|
|
691
|
-
isUnique: boolean;
|
|
692
689
|
using?: "btree" | "hash" | undefined;
|
|
693
690
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
694
691
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
695
|
-
}, {
|
|
696
692
|
name: string;
|
|
697
693
|
columns: string[];
|
|
698
694
|
isUnique: boolean;
|
|
695
|
+
}, {
|
|
699
696
|
using?: "btree" | "hash" | undefined;
|
|
700
697
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
701
698
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
699
|
+
name: string;
|
|
700
|
+
columns: string[];
|
|
701
|
+
isUnique: boolean;
|
|
702
702
|
}>>;
|
|
703
703
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
704
704
|
name: zod.ZodString;
|
|
@@ -709,21 +709,21 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
709
709
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
710
710
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
711
711
|
}, "strict", zod.ZodTypeAny, {
|
|
712
|
+
onUpdate?: string | undefined;
|
|
713
|
+
onDelete?: string | undefined;
|
|
712
714
|
name: string;
|
|
713
715
|
tableFrom: string;
|
|
714
716
|
columnsFrom: string[];
|
|
715
717
|
tableTo: string;
|
|
716
718
|
columnsTo: string[];
|
|
719
|
+
}, {
|
|
717
720
|
onUpdate?: string | undefined;
|
|
718
721
|
onDelete?: string | undefined;
|
|
719
|
-
}, {
|
|
720
722
|
name: string;
|
|
721
723
|
tableFrom: string;
|
|
722
724
|
columnsFrom: string[];
|
|
723
725
|
tableTo: string;
|
|
724
726
|
columnsTo: string[];
|
|
725
|
-
onUpdate?: string | undefined;
|
|
726
|
-
onDelete?: string | undefined;
|
|
727
727
|
}>>;
|
|
728
728
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
729
729
|
name: zod.ZodString;
|
|
@@ -748,30 +748,30 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
748
748
|
}, "strict", zod.ZodTypeAny, {
|
|
749
749
|
name: string;
|
|
750
750
|
columns: Record<string, {
|
|
751
|
+
default?: any;
|
|
752
|
+
onUpdate?: any;
|
|
753
|
+
autoincrement?: boolean | undefined;
|
|
751
754
|
type: string;
|
|
752
755
|
name: string;
|
|
753
756
|
primaryKey: boolean;
|
|
754
757
|
notNull: boolean;
|
|
755
|
-
default?: any;
|
|
756
|
-
onUpdate?: any;
|
|
757
|
-
autoincrement?: boolean | undefined;
|
|
758
758
|
}>;
|
|
759
759
|
indexes: Record<string, {
|
|
760
|
-
name: string;
|
|
761
|
-
columns: string[];
|
|
762
|
-
isUnique: boolean;
|
|
763
760
|
using?: "btree" | "hash" | undefined;
|
|
764
761
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
765
762
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
763
|
+
name: string;
|
|
764
|
+
columns: string[];
|
|
765
|
+
isUnique: boolean;
|
|
766
766
|
}>;
|
|
767
767
|
foreignKeys: Record<string, {
|
|
768
|
+
onUpdate?: string | undefined;
|
|
769
|
+
onDelete?: string | undefined;
|
|
768
770
|
name: string;
|
|
769
771
|
tableFrom: string;
|
|
770
772
|
columnsFrom: string[];
|
|
771
773
|
tableTo: string;
|
|
772
774
|
columnsTo: string[];
|
|
773
|
-
onUpdate?: string | undefined;
|
|
774
|
-
onDelete?: string | undefined;
|
|
775
775
|
}>;
|
|
776
776
|
compositePrimaryKeys: Record<string, {
|
|
777
777
|
name: string;
|
|
@@ -782,41 +782,41 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
782
782
|
columns: string[];
|
|
783
783
|
}>;
|
|
784
784
|
}, {
|
|
785
|
+
uniqueConstraints?: Record<string, {
|
|
786
|
+
name: string;
|
|
787
|
+
columns: string[];
|
|
788
|
+
}> | undefined;
|
|
785
789
|
name: string;
|
|
786
790
|
columns: Record<string, {
|
|
791
|
+
default?: any;
|
|
792
|
+
onUpdate?: any;
|
|
793
|
+
autoincrement?: boolean | undefined;
|
|
787
794
|
type: string;
|
|
788
795
|
name: string;
|
|
789
796
|
primaryKey: boolean;
|
|
790
797
|
notNull: boolean;
|
|
791
|
-
default?: any;
|
|
792
|
-
onUpdate?: any;
|
|
793
|
-
autoincrement?: boolean | undefined;
|
|
794
798
|
}>;
|
|
795
799
|
indexes: Record<string, {
|
|
796
|
-
name: string;
|
|
797
|
-
columns: string[];
|
|
798
|
-
isUnique: boolean;
|
|
799
800
|
using?: "btree" | "hash" | undefined;
|
|
800
801
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
801
802
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
803
|
+
name: string;
|
|
804
|
+
columns: string[];
|
|
805
|
+
isUnique: boolean;
|
|
802
806
|
}>;
|
|
803
807
|
foreignKeys: Record<string, {
|
|
808
|
+
onUpdate?: string | undefined;
|
|
809
|
+
onDelete?: string | undefined;
|
|
804
810
|
name: string;
|
|
805
811
|
tableFrom: string;
|
|
806
812
|
columnsFrom: string[];
|
|
807
813
|
tableTo: string;
|
|
808
814
|
columnsTo: string[];
|
|
809
|
-
onUpdate?: string | undefined;
|
|
810
|
-
onDelete?: string | undefined;
|
|
811
815
|
}>;
|
|
812
816
|
compositePrimaryKeys: Record<string, {
|
|
813
817
|
name: string;
|
|
814
818
|
columns: string[];
|
|
815
819
|
}>;
|
|
816
|
-
uniqueConstraints?: Record<string, {
|
|
817
|
-
name: string;
|
|
818
|
-
columns: string[];
|
|
819
|
-
}> | undefined;
|
|
820
820
|
}>>;
|
|
821
821
|
_meta: zod.ZodObject<{
|
|
822
822
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
@@ -863,33 +863,40 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
863
863
|
id: zod.ZodString;
|
|
864
864
|
prevId: zod.ZodString;
|
|
865
865
|
}>, "strip", zod.ZodTypeAny, {
|
|
866
|
+
internal?: {
|
|
867
|
+
tables: Record<string, {
|
|
868
|
+
columns: Record<string, {
|
|
869
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
870
|
+
} | undefined>;
|
|
871
|
+
} | undefined>;
|
|
872
|
+
} | undefined;
|
|
866
873
|
tables: Record<string, {
|
|
867
874
|
name: string;
|
|
868
875
|
columns: Record<string, {
|
|
876
|
+
default?: any;
|
|
877
|
+
onUpdate?: any;
|
|
878
|
+
autoincrement?: boolean | undefined;
|
|
869
879
|
type: string;
|
|
870
880
|
name: string;
|
|
871
881
|
primaryKey: boolean;
|
|
872
882
|
notNull: boolean;
|
|
873
|
-
default?: any;
|
|
874
|
-
onUpdate?: any;
|
|
875
|
-
autoincrement?: boolean | undefined;
|
|
876
883
|
}>;
|
|
877
884
|
indexes: Record<string, {
|
|
878
|
-
name: string;
|
|
879
|
-
columns: string[];
|
|
880
|
-
isUnique: boolean;
|
|
881
885
|
using?: "btree" | "hash" | undefined;
|
|
882
886
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
883
887
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
888
|
+
name: string;
|
|
889
|
+
columns: string[];
|
|
890
|
+
isUnique: boolean;
|
|
884
891
|
}>;
|
|
885
892
|
foreignKeys: Record<string, {
|
|
893
|
+
onUpdate?: string | undefined;
|
|
894
|
+
onDelete?: string | undefined;
|
|
886
895
|
name: string;
|
|
887
896
|
tableFrom: string;
|
|
888
897
|
columnsFrom: string[];
|
|
889
898
|
tableTo: string;
|
|
890
899
|
columnsTo: string[];
|
|
891
|
-
onUpdate?: string | undefined;
|
|
892
|
-
onDelete?: string | undefined;
|
|
893
900
|
}>;
|
|
894
901
|
compositePrimaryKeys: Record<string, {
|
|
895
902
|
name: string;
|
|
@@ -908,6 +915,7 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
908
915
|
columns: Record<string, string>;
|
|
909
916
|
tables: Record<string, string>;
|
|
910
917
|
};
|
|
918
|
+
}, {
|
|
911
919
|
internal?: {
|
|
912
920
|
tables: Record<string, {
|
|
913
921
|
columns: Record<string, {
|
|
@@ -915,43 +923,42 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
915
923
|
} | undefined>;
|
|
916
924
|
} | undefined>;
|
|
917
925
|
} | undefined;
|
|
918
|
-
}, {
|
|
919
926
|
tables: Record<string, {
|
|
927
|
+
uniqueConstraints?: Record<string, {
|
|
928
|
+
name: string;
|
|
929
|
+
columns: string[];
|
|
930
|
+
}> | undefined;
|
|
920
931
|
name: string;
|
|
921
932
|
columns: Record<string, {
|
|
933
|
+
default?: any;
|
|
934
|
+
onUpdate?: any;
|
|
935
|
+
autoincrement?: boolean | undefined;
|
|
922
936
|
type: string;
|
|
923
937
|
name: string;
|
|
924
938
|
primaryKey: boolean;
|
|
925
939
|
notNull: boolean;
|
|
926
|
-
default?: any;
|
|
927
|
-
onUpdate?: any;
|
|
928
|
-
autoincrement?: boolean | undefined;
|
|
929
940
|
}>;
|
|
930
941
|
indexes: Record<string, {
|
|
931
|
-
name: string;
|
|
932
|
-
columns: string[];
|
|
933
|
-
isUnique: boolean;
|
|
934
942
|
using?: "btree" | "hash" | undefined;
|
|
935
943
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
936
944
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
945
|
+
name: string;
|
|
946
|
+
columns: string[];
|
|
947
|
+
isUnique: boolean;
|
|
937
948
|
}>;
|
|
938
949
|
foreignKeys: Record<string, {
|
|
950
|
+
onUpdate?: string | undefined;
|
|
951
|
+
onDelete?: string | undefined;
|
|
939
952
|
name: string;
|
|
940
953
|
tableFrom: string;
|
|
941
954
|
columnsFrom: string[];
|
|
942
955
|
tableTo: string;
|
|
943
956
|
columnsTo: string[];
|
|
944
|
-
onUpdate?: string | undefined;
|
|
945
|
-
onDelete?: string | undefined;
|
|
946
957
|
}>;
|
|
947
958
|
compositePrimaryKeys: Record<string, {
|
|
948
959
|
name: string;
|
|
949
960
|
columns: string[];
|
|
950
961
|
}>;
|
|
951
|
-
uniqueConstraints?: Record<string, {
|
|
952
|
-
name: string;
|
|
953
|
-
columns: string[];
|
|
954
|
-
}> | undefined;
|
|
955
962
|
}>;
|
|
956
963
|
id: string;
|
|
957
964
|
prevId: string;
|
|
@@ -961,13 +968,6 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
961
968
|
columns: Record<string, string>;
|
|
962
969
|
tables: Record<string, string>;
|
|
963
970
|
};
|
|
964
|
-
internal?: {
|
|
965
|
-
tables: Record<string, {
|
|
966
|
-
columns: Record<string, {
|
|
967
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
968
|
-
} | undefined>;
|
|
969
|
-
} | undefined>;
|
|
970
|
-
} | undefined;
|
|
971
971
|
}>;
|
|
972
972
|
type MySqlSchema = TypeOf<typeof schema>;
|
|
973
973
|
|
|
@@ -999,21 +999,30 @@ declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstanc
|
|
|
999
999
|
apply: () => Promise<void>;
|
|
1000
1000
|
}>;
|
|
1001
1001
|
declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
1002
|
+
internal?: {
|
|
1003
|
+
tables: Record<string, {
|
|
1004
|
+
columns: Record<string, {
|
|
1005
|
+
isArray?: boolean | undefined;
|
|
1006
|
+
dimensions?: number | undefined;
|
|
1007
|
+
rawType?: string | undefined;
|
|
1008
|
+
} | undefined>;
|
|
1009
|
+
} | undefined>;
|
|
1010
|
+
} | undefined;
|
|
1002
1011
|
version: "6";
|
|
1003
1012
|
dialect: "postgresql";
|
|
1004
1013
|
tables: Record<string, {
|
|
1005
1014
|
name: string;
|
|
1006
1015
|
schema: string;
|
|
1007
1016
|
columns: Record<string, {
|
|
1008
|
-
type: string;
|
|
1009
|
-
name: string;
|
|
1010
|
-
primaryKey: boolean;
|
|
1011
|
-
notNull: boolean;
|
|
1012
1017
|
typeSchema?: string | undefined;
|
|
1013
1018
|
default?: any;
|
|
1014
1019
|
isUnique?: any;
|
|
1015
1020
|
uniqueName?: string | undefined;
|
|
1016
1021
|
nullsNotDistinct?: boolean | undefined;
|
|
1022
|
+
type: string;
|
|
1023
|
+
name: string;
|
|
1024
|
+
primaryKey: boolean;
|
|
1025
|
+
notNull: boolean;
|
|
1017
1026
|
}>;
|
|
1018
1027
|
indexes: Record<string, {
|
|
1019
1028
|
name: string;
|
|
@@ -1021,14 +1030,14 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
1021
1030
|
isUnique: boolean;
|
|
1022
1031
|
}>;
|
|
1023
1032
|
foreignKeys: Record<string, {
|
|
1033
|
+
schemaTo?: string | undefined;
|
|
1034
|
+
onUpdate?: string | undefined;
|
|
1035
|
+
onDelete?: string | undefined;
|
|
1024
1036
|
name: string;
|
|
1025
1037
|
tableFrom: string;
|
|
1026
1038
|
columnsFrom: string[];
|
|
1027
1039
|
tableTo: string;
|
|
1028
1040
|
columnsTo: string[];
|
|
1029
|
-
schemaTo?: string | undefined;
|
|
1030
|
-
onUpdate?: string | undefined;
|
|
1031
|
-
onDelete?: string | undefined;
|
|
1032
1041
|
}>;
|
|
1033
1042
|
compositePrimaryKeys: Record<string, {
|
|
1034
1043
|
name: string;
|
|
@@ -1053,15 +1062,6 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
1053
1062
|
};
|
|
1054
1063
|
id: string;
|
|
1055
1064
|
prevId: string;
|
|
1056
|
-
internal?: {
|
|
1057
|
-
tables: Record<string, {
|
|
1058
|
-
columns: Record<string, {
|
|
1059
|
-
isArray?: boolean | undefined;
|
|
1060
|
-
dimensions?: number | undefined;
|
|
1061
|
-
rawType?: string | undefined;
|
|
1062
|
-
} | undefined>;
|
|
1063
|
-
} | undefined>;
|
|
1064
|
-
} | undefined;
|
|
1065
1065
|
};
|
|
1066
1066
|
|
|
1067
1067
|
export { type DrizzleMySQLSnapshotJSON, type DrizzleSQLiteSnapshotJSON, type DrizzleSnapshotJSON, generateDrizzleJson, generateMigration, generateMySQLDrizzleJson, generateMySQLMigration, generateSQLiteDrizzleJson, generateSQLiteMigration, pushMySQLSchema, pushSQLiteSchema, pushSchema, upPgSnapshot };
|