drizzle-kit 0.21.2-ef624aa → 0.21.2-f3756f2
Sign up to get free protection for your applications and to get access to all the features.
- package/bin.cjs +15369 -13682
- package/package.json +3 -3
- package/payload.d.mts +273 -187
- package/payload.d.ts +273 -187
- package/payload.js +1671 -1167
- package/payload.mjs +1663 -1159
- package/utils-studio.js +1074 -813
- package/utils-studio.mjs +1047 -786
- package/utils.js +999 -290
- package/utils.mjs +974 -265
package/payload.d.mts
CHANGED
|
@@ -4,8 +4,8 @@ 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.extendShape<{
|
|
8
|
-
version: zod.ZodLiteral<"
|
|
7
|
+
declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
8
|
+
version: zod.ZodLiteral<"7">;
|
|
9
9
|
dialect: zod.ZodLiteral<"postgresql">;
|
|
10
10
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
11
11
|
name: zod.ZodString;
|
|
@@ -21,38 +21,80 @@ declare const pgSchema: zod.ZodObject<zod.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;
|
|
24
28
|
isUnique?: any;
|
|
25
29
|
default?: any;
|
|
26
30
|
typeSchema?: string | undefined;
|
|
27
31
|
uniqueName?: string | undefined;
|
|
28
32
|
nullsNotDistinct?: boolean | undefined;
|
|
33
|
+
}, {
|
|
29
34
|
type: string;
|
|
30
35
|
name: string;
|
|
31
36
|
primaryKey: boolean;
|
|
32
37
|
notNull: boolean;
|
|
33
|
-
}, {
|
|
34
38
|
isUnique?: any;
|
|
35
39
|
default?: any;
|
|
36
40
|
typeSchema?: string | undefined;
|
|
37
41
|
uniqueName?: string | undefined;
|
|
38
42
|
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;
|
|
46
|
-
columns: zod.ZodArray<zod.
|
|
46
|
+
columns: zod.ZodArray<zod.ZodObject<{
|
|
47
|
+
expression: zod.ZodString;
|
|
48
|
+
isExpression: zod.ZodBoolean;
|
|
49
|
+
asc: zod.ZodBoolean;
|
|
50
|
+
nulls: zod.ZodOptional<zod.ZodString>;
|
|
51
|
+
opclass: zod.ZodOptional<zod.ZodString>;
|
|
52
|
+
}, "strip", zod.ZodTypeAny, {
|
|
53
|
+
expression: string;
|
|
54
|
+
isExpression: boolean;
|
|
55
|
+
asc: boolean;
|
|
56
|
+
nulls?: string | undefined;
|
|
57
|
+
opclass?: string | undefined;
|
|
58
|
+
}, {
|
|
59
|
+
expression: string;
|
|
60
|
+
isExpression: boolean;
|
|
61
|
+
asc: boolean;
|
|
62
|
+
nulls?: string | undefined;
|
|
63
|
+
opclass?: string | undefined;
|
|
64
|
+
}>, "many">;
|
|
47
65
|
isUnique: zod.ZodBoolean;
|
|
66
|
+
with: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
|
|
67
|
+
method: zod.ZodDefault<zod.ZodString>;
|
|
68
|
+
where: zod.ZodOptional<zod.ZodString>;
|
|
69
|
+
concurrently: zod.ZodDefault<zod.ZodBoolean>;
|
|
48
70
|
}, "strict", zod.ZodTypeAny, {
|
|
49
71
|
name: string;
|
|
50
|
-
columns:
|
|
72
|
+
columns: {
|
|
73
|
+
expression: string;
|
|
74
|
+
isExpression: boolean;
|
|
75
|
+
asc: boolean;
|
|
76
|
+
nulls?: string | undefined;
|
|
77
|
+
opclass?: string | undefined;
|
|
78
|
+
}[];
|
|
51
79
|
isUnique: boolean;
|
|
80
|
+
method: string;
|
|
81
|
+
concurrently: boolean;
|
|
82
|
+
with?: Record<string, any> | undefined;
|
|
83
|
+
where?: string | undefined;
|
|
52
84
|
}, {
|
|
53
85
|
name: string;
|
|
54
|
-
columns:
|
|
86
|
+
columns: {
|
|
87
|
+
expression: string;
|
|
88
|
+
isExpression: boolean;
|
|
89
|
+
asc: boolean;
|
|
90
|
+
nulls?: string | undefined;
|
|
91
|
+
opclass?: string | undefined;
|
|
92
|
+
}[];
|
|
55
93
|
isUnique: boolean;
|
|
94
|
+
with?: Record<string, any> | undefined;
|
|
95
|
+
method?: string | undefined;
|
|
96
|
+
where?: string | undefined;
|
|
97
|
+
concurrently?: boolean | undefined;
|
|
56
98
|
}>>;
|
|
57
99
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
58
100
|
name: zod.ZodString;
|
|
@@ -64,23 +106,23 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
64
106
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
65
107
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
66
108
|
}, "strict", zod.ZodTypeAny, {
|
|
67
|
-
onUpdate?: string | undefined;
|
|
68
|
-
onDelete?: string | undefined;
|
|
69
|
-
schemaTo?: string | undefined;
|
|
70
109
|
name: string;
|
|
71
110
|
tableFrom: string;
|
|
72
111
|
columnsFrom: string[];
|
|
73
112
|
tableTo: string;
|
|
74
113
|
columnsTo: string[];
|
|
75
|
-
}, {
|
|
76
114
|
onUpdate?: string | undefined;
|
|
77
115
|
onDelete?: string | undefined;
|
|
78
116
|
schemaTo?: string | undefined;
|
|
117
|
+
}, {
|
|
79
118
|
name: string;
|
|
80
119
|
tableFrom: string;
|
|
81
120
|
columnsFrom: string[];
|
|
82
121
|
tableTo: string;
|
|
83
122
|
columnsTo: string[];
|
|
123
|
+
onUpdate?: string | undefined;
|
|
124
|
+
onDelete?: string | undefined;
|
|
125
|
+
schemaTo?: string | undefined;
|
|
84
126
|
}>>;
|
|
85
127
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
86
128
|
name: zod.ZodString;
|
|
@@ -108,30 +150,40 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
108
150
|
}, "strict", zod.ZodTypeAny, {
|
|
109
151
|
name: string;
|
|
110
152
|
columns: Record<string, {
|
|
153
|
+
type: string;
|
|
154
|
+
name: string;
|
|
155
|
+
primaryKey: boolean;
|
|
156
|
+
notNull: boolean;
|
|
111
157
|
isUnique?: any;
|
|
112
158
|
default?: any;
|
|
113
159
|
typeSchema?: string | undefined;
|
|
114
160
|
uniqueName?: string | undefined;
|
|
115
161
|
nullsNotDistinct?: boolean | undefined;
|
|
116
|
-
type: string;
|
|
117
|
-
name: string;
|
|
118
|
-
primaryKey: boolean;
|
|
119
|
-
notNull: boolean;
|
|
120
162
|
}>;
|
|
121
163
|
indexes: Record<string, {
|
|
122
164
|
name: string;
|
|
123
|
-
columns:
|
|
165
|
+
columns: {
|
|
166
|
+
expression: string;
|
|
167
|
+
isExpression: boolean;
|
|
168
|
+
asc: boolean;
|
|
169
|
+
nulls?: string | undefined;
|
|
170
|
+
opclass?: string | undefined;
|
|
171
|
+
}[];
|
|
124
172
|
isUnique: boolean;
|
|
173
|
+
method: string;
|
|
174
|
+
concurrently: boolean;
|
|
175
|
+
with?: Record<string, any> | undefined;
|
|
176
|
+
where?: string | undefined;
|
|
125
177
|
}>;
|
|
126
178
|
foreignKeys: Record<string, {
|
|
127
|
-
onUpdate?: string | undefined;
|
|
128
|
-
onDelete?: string | undefined;
|
|
129
|
-
schemaTo?: string | undefined;
|
|
130
179
|
name: string;
|
|
131
180
|
tableFrom: string;
|
|
132
181
|
columnsFrom: string[];
|
|
133
182
|
tableTo: string;
|
|
134
183
|
columnsTo: string[];
|
|
184
|
+
onUpdate?: string | undefined;
|
|
185
|
+
onDelete?: string | undefined;
|
|
186
|
+
schemaTo?: string | undefined;
|
|
135
187
|
}>;
|
|
136
188
|
schema: string;
|
|
137
189
|
compositePrimaryKeys: Record<string, {
|
|
@@ -144,43 +196,53 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
144
196
|
nullsNotDistinct: boolean;
|
|
145
197
|
}>;
|
|
146
198
|
}, {
|
|
147
|
-
uniqueConstraints?: Record<string, {
|
|
148
|
-
name: string;
|
|
149
|
-
columns: string[];
|
|
150
|
-
nullsNotDistinct: boolean;
|
|
151
|
-
}> | undefined;
|
|
152
199
|
name: string;
|
|
153
200
|
columns: Record<string, {
|
|
201
|
+
type: string;
|
|
202
|
+
name: string;
|
|
203
|
+
primaryKey: boolean;
|
|
204
|
+
notNull: boolean;
|
|
154
205
|
isUnique?: any;
|
|
155
206
|
default?: any;
|
|
156
207
|
typeSchema?: string | undefined;
|
|
157
208
|
uniqueName?: string | undefined;
|
|
158
209
|
nullsNotDistinct?: boolean | undefined;
|
|
159
|
-
type: string;
|
|
160
|
-
name: string;
|
|
161
|
-
primaryKey: boolean;
|
|
162
|
-
notNull: boolean;
|
|
163
210
|
}>;
|
|
164
211
|
indexes: Record<string, {
|
|
165
212
|
name: string;
|
|
166
|
-
columns:
|
|
213
|
+
columns: {
|
|
214
|
+
expression: string;
|
|
215
|
+
isExpression: boolean;
|
|
216
|
+
asc: boolean;
|
|
217
|
+
nulls?: string | undefined;
|
|
218
|
+
opclass?: string | undefined;
|
|
219
|
+
}[];
|
|
167
220
|
isUnique: boolean;
|
|
221
|
+
with?: Record<string, any> | undefined;
|
|
222
|
+
method?: string | undefined;
|
|
223
|
+
where?: string | undefined;
|
|
224
|
+
concurrently?: boolean | undefined;
|
|
168
225
|
}>;
|
|
169
226
|
foreignKeys: Record<string, {
|
|
170
|
-
onUpdate?: string | undefined;
|
|
171
|
-
onDelete?: string | undefined;
|
|
172
|
-
schemaTo?: string | undefined;
|
|
173
227
|
name: string;
|
|
174
228
|
tableFrom: string;
|
|
175
229
|
columnsFrom: string[];
|
|
176
230
|
tableTo: string;
|
|
177
231
|
columnsTo: string[];
|
|
232
|
+
onUpdate?: string | undefined;
|
|
233
|
+
onDelete?: string | undefined;
|
|
234
|
+
schemaTo?: string | undefined;
|
|
178
235
|
}>;
|
|
179
236
|
schema: string;
|
|
180
237
|
compositePrimaryKeys: Record<string, {
|
|
181
238
|
name: string;
|
|
182
239
|
columns: string[];
|
|
183
240
|
}>;
|
|
241
|
+
uniqueConstraints?: Record<string, {
|
|
242
|
+
name: string;
|
|
243
|
+
columns: string[];
|
|
244
|
+
nullsNotDistinct: boolean;
|
|
245
|
+
}> | undefined;
|
|
184
246
|
}>>;
|
|
185
247
|
enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
186
248
|
name: zod.ZodString;
|
|
@@ -258,42 +320,43 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
258
320
|
id: zod.ZodString;
|
|
259
321
|
prevId: zod.ZodString;
|
|
260
322
|
}>, "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;
|
|
270
323
|
tables: Record<string, {
|
|
271
324
|
name: string;
|
|
272
325
|
columns: Record<string, {
|
|
326
|
+
type: string;
|
|
327
|
+
name: string;
|
|
328
|
+
primaryKey: boolean;
|
|
329
|
+
notNull: boolean;
|
|
273
330
|
isUnique?: any;
|
|
274
331
|
default?: any;
|
|
275
332
|
typeSchema?: string | undefined;
|
|
276
333
|
uniqueName?: string | undefined;
|
|
277
334
|
nullsNotDistinct?: boolean | undefined;
|
|
278
|
-
type: string;
|
|
279
|
-
name: string;
|
|
280
|
-
primaryKey: boolean;
|
|
281
|
-
notNull: boolean;
|
|
282
335
|
}>;
|
|
283
336
|
indexes: Record<string, {
|
|
284
337
|
name: string;
|
|
285
|
-
columns:
|
|
338
|
+
columns: {
|
|
339
|
+
expression: string;
|
|
340
|
+
isExpression: boolean;
|
|
341
|
+
asc: boolean;
|
|
342
|
+
nulls?: string | undefined;
|
|
343
|
+
opclass?: string | undefined;
|
|
344
|
+
}[];
|
|
286
345
|
isUnique: boolean;
|
|
346
|
+
method: string;
|
|
347
|
+
concurrently: boolean;
|
|
348
|
+
with?: Record<string, any> | undefined;
|
|
349
|
+
where?: string | undefined;
|
|
287
350
|
}>;
|
|
288
351
|
foreignKeys: Record<string, {
|
|
289
|
-
onUpdate?: string | undefined;
|
|
290
|
-
onDelete?: string | undefined;
|
|
291
|
-
schemaTo?: string | undefined;
|
|
292
352
|
name: string;
|
|
293
353
|
tableFrom: string;
|
|
294
354
|
columnsFrom: string[];
|
|
295
355
|
tableTo: string;
|
|
296
356
|
columnsTo: string[];
|
|
357
|
+
onUpdate?: string | undefined;
|
|
358
|
+
onDelete?: string | undefined;
|
|
359
|
+
schemaTo?: string | undefined;
|
|
297
360
|
}>;
|
|
298
361
|
schema: string;
|
|
299
362
|
compositePrimaryKeys: Record<string, {
|
|
@@ -308,7 +371,7 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
308
371
|
}>;
|
|
309
372
|
id: string;
|
|
310
373
|
prevId: string;
|
|
311
|
-
version: "
|
|
374
|
+
version: "7";
|
|
312
375
|
dialect: "postgresql";
|
|
313
376
|
schemas: Record<string, string>;
|
|
314
377
|
_meta: {
|
|
@@ -321,7 +384,6 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
321
384
|
name: string;
|
|
322
385
|
schema: string;
|
|
323
386
|
}>;
|
|
324
|
-
}, {
|
|
325
387
|
internal?: {
|
|
326
388
|
tables: Record<string, {
|
|
327
389
|
columns: Record<string, {
|
|
@@ -331,48 +393,59 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
331
393
|
} | undefined>;
|
|
332
394
|
} | undefined>;
|
|
333
395
|
} | undefined;
|
|
396
|
+
}, {
|
|
334
397
|
tables: Record<string, {
|
|
335
|
-
uniqueConstraints?: Record<string, {
|
|
336
|
-
name: string;
|
|
337
|
-
columns: string[];
|
|
338
|
-
nullsNotDistinct: boolean;
|
|
339
|
-
}> | undefined;
|
|
340
398
|
name: string;
|
|
341
399
|
columns: Record<string, {
|
|
400
|
+
type: string;
|
|
401
|
+
name: string;
|
|
402
|
+
primaryKey: boolean;
|
|
403
|
+
notNull: boolean;
|
|
342
404
|
isUnique?: any;
|
|
343
405
|
default?: any;
|
|
344
406
|
typeSchema?: string | undefined;
|
|
345
407
|
uniqueName?: string | undefined;
|
|
346
408
|
nullsNotDistinct?: boolean | undefined;
|
|
347
|
-
type: string;
|
|
348
|
-
name: string;
|
|
349
|
-
primaryKey: boolean;
|
|
350
|
-
notNull: boolean;
|
|
351
409
|
}>;
|
|
352
410
|
indexes: Record<string, {
|
|
353
411
|
name: string;
|
|
354
|
-
columns:
|
|
412
|
+
columns: {
|
|
413
|
+
expression: string;
|
|
414
|
+
isExpression: boolean;
|
|
415
|
+
asc: boolean;
|
|
416
|
+
nulls?: string | undefined;
|
|
417
|
+
opclass?: string | undefined;
|
|
418
|
+
}[];
|
|
355
419
|
isUnique: boolean;
|
|
420
|
+
with?: Record<string, any> | undefined;
|
|
421
|
+
method?: string | undefined;
|
|
422
|
+
where?: string | undefined;
|
|
423
|
+
concurrently?: boolean | undefined;
|
|
356
424
|
}>;
|
|
357
425
|
foreignKeys: Record<string, {
|
|
358
|
-
onUpdate?: string | undefined;
|
|
359
|
-
onDelete?: string | undefined;
|
|
360
|
-
schemaTo?: string | undefined;
|
|
361
426
|
name: string;
|
|
362
427
|
tableFrom: string;
|
|
363
428
|
columnsFrom: string[];
|
|
364
429
|
tableTo: string;
|
|
365
430
|
columnsTo: string[];
|
|
431
|
+
onUpdate?: string | undefined;
|
|
432
|
+
onDelete?: string | undefined;
|
|
433
|
+
schemaTo?: string | undefined;
|
|
366
434
|
}>;
|
|
367
435
|
schema: string;
|
|
368
436
|
compositePrimaryKeys: Record<string, {
|
|
369
437
|
name: string;
|
|
370
438
|
columns: string[];
|
|
371
439
|
}>;
|
|
440
|
+
uniqueConstraints?: Record<string, {
|
|
441
|
+
name: string;
|
|
442
|
+
columns: string[];
|
|
443
|
+
nullsNotDistinct: boolean;
|
|
444
|
+
}> | undefined;
|
|
372
445
|
}>;
|
|
373
446
|
id: string;
|
|
374
447
|
prevId: string;
|
|
375
|
-
version: "
|
|
448
|
+
version: "7";
|
|
376
449
|
dialect: "postgresql";
|
|
377
450
|
schemas: Record<string, string>;
|
|
378
451
|
_meta: {
|
|
@@ -385,10 +458,19 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
385
458
|
name: string;
|
|
386
459
|
schema: string;
|
|
387
460
|
}>;
|
|
461
|
+
internal?: {
|
|
462
|
+
tables: Record<string, {
|
|
463
|
+
columns: Record<string, {
|
|
464
|
+
isArray?: boolean | undefined;
|
|
465
|
+
dimensions?: number | undefined;
|
|
466
|
+
rawType?: string | undefined;
|
|
467
|
+
} | undefined>;
|
|
468
|
+
} | undefined>;
|
|
469
|
+
} | undefined;
|
|
388
470
|
}>;
|
|
389
471
|
type PgSchema = TypeOf<typeof pgSchema>;
|
|
390
472
|
|
|
391
|
-
declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
473
|
+
declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
392
474
|
version: zod.ZodLiteral<"6">;
|
|
393
475
|
dialect: zod.ZodEnum<["sqlite"]>;
|
|
394
476
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -401,19 +483,19 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
401
483
|
autoincrement: zod.ZodOptional<zod.ZodBoolean>;
|
|
402
484
|
default: zod.ZodOptional<zod.ZodAny>;
|
|
403
485
|
}, "strict", zod.ZodTypeAny, {
|
|
404
|
-
default?: any;
|
|
405
|
-
autoincrement?: boolean | undefined;
|
|
406
486
|
type: string;
|
|
407
487
|
name: string;
|
|
408
488
|
primaryKey: boolean;
|
|
409
489
|
notNull: boolean;
|
|
410
|
-
}, {
|
|
411
490
|
default?: any;
|
|
412
491
|
autoincrement?: boolean | undefined;
|
|
492
|
+
}, {
|
|
413
493
|
type: string;
|
|
414
494
|
name: string;
|
|
415
495
|
primaryKey: boolean;
|
|
416
496
|
notNull: boolean;
|
|
497
|
+
default?: any;
|
|
498
|
+
autoincrement?: boolean | undefined;
|
|
417
499
|
}>>;
|
|
418
500
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
419
501
|
name: zod.ZodString;
|
|
@@ -421,15 +503,15 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
421
503
|
where: zod.ZodOptional<zod.ZodString>;
|
|
422
504
|
isUnique: zod.ZodBoolean;
|
|
423
505
|
}, "strict", zod.ZodTypeAny, {
|
|
424
|
-
where?: string | undefined;
|
|
425
506
|
name: string;
|
|
426
507
|
columns: string[];
|
|
427
508
|
isUnique: boolean;
|
|
428
|
-
}, {
|
|
429
509
|
where?: string | undefined;
|
|
510
|
+
}, {
|
|
430
511
|
name: string;
|
|
431
512
|
columns: string[];
|
|
432
513
|
isUnique: boolean;
|
|
514
|
+
where?: string | undefined;
|
|
433
515
|
}>>;
|
|
434
516
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
435
517
|
name: zod.ZodString;
|
|
@@ -440,31 +522,31 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
440
522
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
441
523
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
442
524
|
}, "strict", zod.ZodTypeAny, {
|
|
443
|
-
onUpdate?: string | undefined;
|
|
444
|
-
onDelete?: string | undefined;
|
|
445
525
|
name: string;
|
|
446
526
|
tableFrom: string;
|
|
447
527
|
columnsFrom: string[];
|
|
448
528
|
tableTo: string;
|
|
449
529
|
columnsTo: string[];
|
|
450
|
-
}, {
|
|
451
530
|
onUpdate?: string | undefined;
|
|
452
531
|
onDelete?: string | undefined;
|
|
532
|
+
}, {
|
|
453
533
|
name: string;
|
|
454
534
|
tableFrom: string;
|
|
455
535
|
columnsFrom: string[];
|
|
456
536
|
tableTo: string;
|
|
457
537
|
columnsTo: string[];
|
|
538
|
+
onUpdate?: string | undefined;
|
|
539
|
+
onDelete?: string | undefined;
|
|
458
540
|
}>>;
|
|
459
541
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
460
542
|
columns: zod.ZodArray<zod.ZodString, "many">;
|
|
461
543
|
name: zod.ZodOptional<zod.ZodString>;
|
|
462
544
|
}, "strict", zod.ZodTypeAny, {
|
|
463
|
-
name?: string | undefined;
|
|
464
545
|
columns: string[];
|
|
465
|
-
}, {
|
|
466
546
|
name?: string | undefined;
|
|
547
|
+
}, {
|
|
467
548
|
columns: string[];
|
|
549
|
+
name?: string | undefined;
|
|
468
550
|
}>>;
|
|
469
551
|
uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
470
552
|
name: zod.ZodString;
|
|
@@ -479,69 +561,69 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
479
561
|
}, "strict", zod.ZodTypeAny, {
|
|
480
562
|
name: string;
|
|
481
563
|
columns: Record<string, {
|
|
482
|
-
default?: any;
|
|
483
|
-
autoincrement?: boolean | undefined;
|
|
484
564
|
type: string;
|
|
485
565
|
name: string;
|
|
486
566
|
primaryKey: boolean;
|
|
487
567
|
notNull: boolean;
|
|
568
|
+
default?: any;
|
|
569
|
+
autoincrement?: boolean | undefined;
|
|
488
570
|
}>;
|
|
489
571
|
indexes: Record<string, {
|
|
490
|
-
where?: string | undefined;
|
|
491
572
|
name: string;
|
|
492
573
|
columns: string[];
|
|
493
574
|
isUnique: boolean;
|
|
575
|
+
where?: string | undefined;
|
|
494
576
|
}>;
|
|
495
577
|
foreignKeys: Record<string, {
|
|
496
|
-
onUpdate?: string | undefined;
|
|
497
|
-
onDelete?: string | undefined;
|
|
498
578
|
name: string;
|
|
499
579
|
tableFrom: string;
|
|
500
580
|
columnsFrom: string[];
|
|
501
581
|
tableTo: string;
|
|
502
582
|
columnsTo: string[];
|
|
583
|
+
onUpdate?: string | undefined;
|
|
584
|
+
onDelete?: string | undefined;
|
|
503
585
|
}>;
|
|
504
586
|
compositePrimaryKeys: Record<string, {
|
|
505
|
-
name?: string | undefined;
|
|
506
587
|
columns: string[];
|
|
588
|
+
name?: string | undefined;
|
|
507
589
|
}>;
|
|
508
590
|
uniqueConstraints: Record<string, {
|
|
509
591
|
name: string;
|
|
510
592
|
columns: string[];
|
|
511
593
|
}>;
|
|
512
594
|
}, {
|
|
513
|
-
uniqueConstraints?: Record<string, {
|
|
514
|
-
name: string;
|
|
515
|
-
columns: string[];
|
|
516
|
-
}> | undefined;
|
|
517
595
|
name: string;
|
|
518
596
|
columns: Record<string, {
|
|
519
|
-
default?: any;
|
|
520
|
-
autoincrement?: boolean | undefined;
|
|
521
597
|
type: string;
|
|
522
598
|
name: string;
|
|
523
599
|
primaryKey: boolean;
|
|
524
600
|
notNull: boolean;
|
|
601
|
+
default?: any;
|
|
602
|
+
autoincrement?: boolean | undefined;
|
|
525
603
|
}>;
|
|
526
604
|
indexes: Record<string, {
|
|
527
|
-
where?: string | undefined;
|
|
528
605
|
name: string;
|
|
529
606
|
columns: string[];
|
|
530
607
|
isUnique: boolean;
|
|
608
|
+
where?: string | undefined;
|
|
531
609
|
}>;
|
|
532
610
|
foreignKeys: Record<string, {
|
|
533
|
-
onUpdate?: string | undefined;
|
|
534
|
-
onDelete?: string | undefined;
|
|
535
611
|
name: string;
|
|
536
612
|
tableFrom: string;
|
|
537
613
|
columnsFrom: string[];
|
|
538
614
|
tableTo: string;
|
|
539
615
|
columnsTo: string[];
|
|
616
|
+
onUpdate?: string | undefined;
|
|
617
|
+
onDelete?: string | undefined;
|
|
540
618
|
}>;
|
|
541
619
|
compositePrimaryKeys: Record<string, {
|
|
542
|
-
name?: string | undefined;
|
|
543
620
|
columns: string[];
|
|
621
|
+
name?: string | undefined;
|
|
544
622
|
}>;
|
|
623
|
+
uniqueConstraints?: Record<string, {
|
|
624
|
+
name: string;
|
|
625
|
+
columns: string[];
|
|
626
|
+
}> | undefined;
|
|
545
627
|
}>>;
|
|
546
628
|
enums: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
|
|
547
629
|
_meta: zod.ZodObject<{
|
|
@@ -561,31 +643,31 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
561
643
|
tables: Record<string, {
|
|
562
644
|
name: string;
|
|
563
645
|
columns: Record<string, {
|
|
564
|
-
default?: any;
|
|
565
|
-
autoincrement?: boolean | undefined;
|
|
566
646
|
type: string;
|
|
567
647
|
name: string;
|
|
568
648
|
primaryKey: boolean;
|
|
569
649
|
notNull: boolean;
|
|
650
|
+
default?: any;
|
|
651
|
+
autoincrement?: boolean | undefined;
|
|
570
652
|
}>;
|
|
571
653
|
indexes: Record<string, {
|
|
572
|
-
where?: string | undefined;
|
|
573
654
|
name: string;
|
|
574
655
|
columns: string[];
|
|
575
656
|
isUnique: boolean;
|
|
657
|
+
where?: string | undefined;
|
|
576
658
|
}>;
|
|
577
659
|
foreignKeys: Record<string, {
|
|
578
|
-
onUpdate?: string | undefined;
|
|
579
|
-
onDelete?: string | undefined;
|
|
580
660
|
name: string;
|
|
581
661
|
tableFrom: string;
|
|
582
662
|
columnsFrom: string[];
|
|
583
663
|
tableTo: string;
|
|
584
664
|
columnsTo: string[];
|
|
665
|
+
onUpdate?: string | undefined;
|
|
666
|
+
onDelete?: string | undefined;
|
|
585
667
|
}>;
|
|
586
668
|
compositePrimaryKeys: Record<string, {
|
|
587
|
-
name?: string | undefined;
|
|
588
669
|
columns: string[];
|
|
670
|
+
name?: string | undefined;
|
|
589
671
|
}>;
|
|
590
672
|
uniqueConstraints: Record<string, {
|
|
591
673
|
name: string;
|
|
@@ -603,38 +685,38 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
603
685
|
enums: {};
|
|
604
686
|
}, {
|
|
605
687
|
tables: Record<string, {
|
|
606
|
-
uniqueConstraints?: Record<string, {
|
|
607
|
-
name: string;
|
|
608
|
-
columns: string[];
|
|
609
|
-
}> | undefined;
|
|
610
688
|
name: string;
|
|
611
689
|
columns: Record<string, {
|
|
612
|
-
default?: any;
|
|
613
|
-
autoincrement?: boolean | undefined;
|
|
614
690
|
type: string;
|
|
615
691
|
name: string;
|
|
616
692
|
primaryKey: boolean;
|
|
617
693
|
notNull: boolean;
|
|
694
|
+
default?: any;
|
|
695
|
+
autoincrement?: boolean | undefined;
|
|
618
696
|
}>;
|
|
619
697
|
indexes: Record<string, {
|
|
620
|
-
where?: string | undefined;
|
|
621
698
|
name: string;
|
|
622
699
|
columns: string[];
|
|
623
700
|
isUnique: boolean;
|
|
701
|
+
where?: string | undefined;
|
|
624
702
|
}>;
|
|
625
703
|
foreignKeys: Record<string, {
|
|
626
|
-
onUpdate?: string | undefined;
|
|
627
|
-
onDelete?: string | undefined;
|
|
628
704
|
name: string;
|
|
629
705
|
tableFrom: string;
|
|
630
706
|
columnsFrom: string[];
|
|
631
707
|
tableTo: string;
|
|
632
708
|
columnsTo: string[];
|
|
709
|
+
onUpdate?: string | undefined;
|
|
710
|
+
onDelete?: string | undefined;
|
|
633
711
|
}>;
|
|
634
712
|
compositePrimaryKeys: Record<string, {
|
|
635
|
-
name?: string | undefined;
|
|
636
713
|
columns: string[];
|
|
714
|
+
name?: string | undefined;
|
|
637
715
|
}>;
|
|
716
|
+
uniqueConstraints?: Record<string, {
|
|
717
|
+
name: string;
|
|
718
|
+
columns: string[];
|
|
719
|
+
}> | undefined;
|
|
638
720
|
}>;
|
|
639
721
|
id: string;
|
|
640
722
|
prevId: string;
|
|
@@ -648,7 +730,7 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
648
730
|
}>;
|
|
649
731
|
type SQLiteSchema = TypeOf<typeof schema$1>;
|
|
650
732
|
|
|
651
|
-
declare const schema: zod.ZodObject<zod.extendShape<{
|
|
733
|
+
declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
652
734
|
version: zod.ZodLiteral<"5">;
|
|
653
735
|
dialect: zod.ZodLiteral<"mysql">;
|
|
654
736
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -662,21 +744,21 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
662
744
|
default: zod.ZodOptional<zod.ZodAny>;
|
|
663
745
|
onUpdate: zod.ZodOptional<zod.ZodAny>;
|
|
664
746
|
}, "strict", zod.ZodTypeAny, {
|
|
665
|
-
default?: any;
|
|
666
|
-
onUpdate?: any;
|
|
667
|
-
autoincrement?: boolean | undefined;
|
|
668
747
|
type: string;
|
|
669
748
|
name: string;
|
|
670
749
|
primaryKey: boolean;
|
|
671
750
|
notNull: boolean;
|
|
672
|
-
}, {
|
|
673
751
|
default?: any;
|
|
674
752
|
onUpdate?: any;
|
|
675
753
|
autoincrement?: boolean | undefined;
|
|
754
|
+
}, {
|
|
676
755
|
type: string;
|
|
677
756
|
name: string;
|
|
678
757
|
primaryKey: boolean;
|
|
679
758
|
notNull: boolean;
|
|
759
|
+
default?: any;
|
|
760
|
+
onUpdate?: any;
|
|
761
|
+
autoincrement?: boolean | undefined;
|
|
680
762
|
}>>;
|
|
681
763
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
682
764
|
name: zod.ZodString;
|
|
@@ -686,19 +768,19 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
686
768
|
algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
|
|
687
769
|
lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
688
770
|
}, "strict", zod.ZodTypeAny, {
|
|
689
|
-
using?: "btree" | "hash" | undefined;
|
|
690
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
691
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
692
771
|
name: string;
|
|
693
772
|
columns: string[];
|
|
694
773
|
isUnique: boolean;
|
|
695
|
-
}, {
|
|
696
774
|
using?: "btree" | "hash" | undefined;
|
|
697
775
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
698
776
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
777
|
+
}, {
|
|
699
778
|
name: string;
|
|
700
779
|
columns: string[];
|
|
701
780
|
isUnique: boolean;
|
|
781
|
+
using?: "btree" | "hash" | undefined;
|
|
782
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
783
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
702
784
|
}>>;
|
|
703
785
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
704
786
|
name: zod.ZodString;
|
|
@@ -709,21 +791,21 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
709
791
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
710
792
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
711
793
|
}, "strict", zod.ZodTypeAny, {
|
|
712
|
-
onUpdate?: string | undefined;
|
|
713
|
-
onDelete?: string | undefined;
|
|
714
794
|
name: string;
|
|
715
795
|
tableFrom: string;
|
|
716
796
|
columnsFrom: string[];
|
|
717
797
|
tableTo: string;
|
|
718
798
|
columnsTo: string[];
|
|
719
|
-
}, {
|
|
720
799
|
onUpdate?: string | undefined;
|
|
721
800
|
onDelete?: string | undefined;
|
|
801
|
+
}, {
|
|
722
802
|
name: string;
|
|
723
803
|
tableFrom: string;
|
|
724
804
|
columnsFrom: string[];
|
|
725
805
|
tableTo: string;
|
|
726
806
|
columnsTo: string[];
|
|
807
|
+
onUpdate?: string | undefined;
|
|
808
|
+
onDelete?: string | undefined;
|
|
727
809
|
}>>;
|
|
728
810
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
729
811
|
name: zod.ZodString;
|
|
@@ -748,30 +830,30 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
748
830
|
}, "strict", zod.ZodTypeAny, {
|
|
749
831
|
name: string;
|
|
750
832
|
columns: Record<string, {
|
|
751
|
-
default?: any;
|
|
752
|
-
onUpdate?: any;
|
|
753
|
-
autoincrement?: boolean | undefined;
|
|
754
833
|
type: string;
|
|
755
834
|
name: string;
|
|
756
835
|
primaryKey: boolean;
|
|
757
836
|
notNull: boolean;
|
|
837
|
+
default?: any;
|
|
838
|
+
onUpdate?: any;
|
|
839
|
+
autoincrement?: boolean | undefined;
|
|
758
840
|
}>;
|
|
759
841
|
indexes: Record<string, {
|
|
760
|
-
using?: "btree" | "hash" | undefined;
|
|
761
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
762
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
763
842
|
name: string;
|
|
764
843
|
columns: string[];
|
|
765
844
|
isUnique: boolean;
|
|
845
|
+
using?: "btree" | "hash" | undefined;
|
|
846
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
847
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
766
848
|
}>;
|
|
767
849
|
foreignKeys: Record<string, {
|
|
768
|
-
onUpdate?: string | undefined;
|
|
769
|
-
onDelete?: string | undefined;
|
|
770
850
|
name: string;
|
|
771
851
|
tableFrom: string;
|
|
772
852
|
columnsFrom: string[];
|
|
773
853
|
tableTo: string;
|
|
774
854
|
columnsTo: string[];
|
|
855
|
+
onUpdate?: string | undefined;
|
|
856
|
+
onDelete?: string | undefined;
|
|
775
857
|
}>;
|
|
776
858
|
compositePrimaryKeys: Record<string, {
|
|
777
859
|
name: string;
|
|
@@ -782,41 +864,41 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
782
864
|
columns: string[];
|
|
783
865
|
}>;
|
|
784
866
|
}, {
|
|
785
|
-
uniqueConstraints?: Record<string, {
|
|
786
|
-
name: string;
|
|
787
|
-
columns: string[];
|
|
788
|
-
}> | undefined;
|
|
789
867
|
name: string;
|
|
790
868
|
columns: Record<string, {
|
|
791
|
-
default?: any;
|
|
792
|
-
onUpdate?: any;
|
|
793
|
-
autoincrement?: boolean | undefined;
|
|
794
869
|
type: string;
|
|
795
870
|
name: string;
|
|
796
871
|
primaryKey: boolean;
|
|
797
872
|
notNull: boolean;
|
|
873
|
+
default?: any;
|
|
874
|
+
onUpdate?: any;
|
|
875
|
+
autoincrement?: boolean | undefined;
|
|
798
876
|
}>;
|
|
799
877
|
indexes: Record<string, {
|
|
800
|
-
using?: "btree" | "hash" | undefined;
|
|
801
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
802
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
803
878
|
name: string;
|
|
804
879
|
columns: string[];
|
|
805
880
|
isUnique: boolean;
|
|
881
|
+
using?: "btree" | "hash" | undefined;
|
|
882
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
883
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
806
884
|
}>;
|
|
807
885
|
foreignKeys: Record<string, {
|
|
808
|
-
onUpdate?: string | undefined;
|
|
809
|
-
onDelete?: string | undefined;
|
|
810
886
|
name: string;
|
|
811
887
|
tableFrom: string;
|
|
812
888
|
columnsFrom: string[];
|
|
813
889
|
tableTo: string;
|
|
814
890
|
columnsTo: string[];
|
|
891
|
+
onUpdate?: string | undefined;
|
|
892
|
+
onDelete?: string | undefined;
|
|
815
893
|
}>;
|
|
816
894
|
compositePrimaryKeys: Record<string, {
|
|
817
895
|
name: string;
|
|
818
896
|
columns: string[];
|
|
819
897
|
}>;
|
|
898
|
+
uniqueConstraints?: Record<string, {
|
|
899
|
+
name: string;
|
|
900
|
+
columns: string[];
|
|
901
|
+
}> | undefined;
|
|
820
902
|
}>>;
|
|
821
903
|
_meta: zod.ZodObject<{
|
|
822
904
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
@@ -863,40 +945,33 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
863
945
|
id: zod.ZodString;
|
|
864
946
|
prevId: zod.ZodString;
|
|
865
947
|
}>, "strip", zod.ZodTypeAny, {
|
|
866
|
-
internal?: {
|
|
867
|
-
tables: Record<string, {
|
|
868
|
-
columns: Record<string, {
|
|
869
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
870
|
-
} | undefined>;
|
|
871
|
-
} | undefined>;
|
|
872
|
-
} | undefined;
|
|
873
948
|
tables: Record<string, {
|
|
874
949
|
name: string;
|
|
875
950
|
columns: Record<string, {
|
|
876
|
-
default?: any;
|
|
877
|
-
onUpdate?: any;
|
|
878
|
-
autoincrement?: boolean | undefined;
|
|
879
951
|
type: string;
|
|
880
952
|
name: string;
|
|
881
953
|
primaryKey: boolean;
|
|
882
954
|
notNull: boolean;
|
|
955
|
+
default?: any;
|
|
956
|
+
onUpdate?: any;
|
|
957
|
+
autoincrement?: boolean | undefined;
|
|
883
958
|
}>;
|
|
884
959
|
indexes: Record<string, {
|
|
885
|
-
using?: "btree" | "hash" | undefined;
|
|
886
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
887
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
888
960
|
name: string;
|
|
889
961
|
columns: string[];
|
|
890
962
|
isUnique: boolean;
|
|
963
|
+
using?: "btree" | "hash" | undefined;
|
|
964
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
965
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
891
966
|
}>;
|
|
892
967
|
foreignKeys: Record<string, {
|
|
893
|
-
onUpdate?: string | undefined;
|
|
894
|
-
onDelete?: string | undefined;
|
|
895
968
|
name: string;
|
|
896
969
|
tableFrom: string;
|
|
897
970
|
columnsFrom: string[];
|
|
898
971
|
tableTo: string;
|
|
899
972
|
columnsTo: string[];
|
|
973
|
+
onUpdate?: string | undefined;
|
|
974
|
+
onDelete?: string | undefined;
|
|
900
975
|
}>;
|
|
901
976
|
compositePrimaryKeys: Record<string, {
|
|
902
977
|
name: string;
|
|
@@ -915,7 +990,6 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
915
990
|
columns: Record<string, string>;
|
|
916
991
|
tables: Record<string, string>;
|
|
917
992
|
};
|
|
918
|
-
}, {
|
|
919
993
|
internal?: {
|
|
920
994
|
tables: Record<string, {
|
|
921
995
|
columns: Record<string, {
|
|
@@ -923,42 +997,43 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
923
997
|
} | undefined>;
|
|
924
998
|
} | undefined>;
|
|
925
999
|
} | undefined;
|
|
1000
|
+
}, {
|
|
926
1001
|
tables: Record<string, {
|
|
927
|
-
uniqueConstraints?: Record<string, {
|
|
928
|
-
name: string;
|
|
929
|
-
columns: string[];
|
|
930
|
-
}> | undefined;
|
|
931
1002
|
name: string;
|
|
932
1003
|
columns: Record<string, {
|
|
933
|
-
default?: any;
|
|
934
|
-
onUpdate?: any;
|
|
935
|
-
autoincrement?: boolean | undefined;
|
|
936
1004
|
type: string;
|
|
937
1005
|
name: string;
|
|
938
1006
|
primaryKey: boolean;
|
|
939
1007
|
notNull: boolean;
|
|
1008
|
+
default?: any;
|
|
1009
|
+
onUpdate?: any;
|
|
1010
|
+
autoincrement?: boolean | undefined;
|
|
940
1011
|
}>;
|
|
941
1012
|
indexes: Record<string, {
|
|
942
|
-
using?: "btree" | "hash" | undefined;
|
|
943
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
944
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
945
1013
|
name: string;
|
|
946
1014
|
columns: string[];
|
|
947
1015
|
isUnique: boolean;
|
|
1016
|
+
using?: "btree" | "hash" | undefined;
|
|
1017
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1018
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
948
1019
|
}>;
|
|
949
1020
|
foreignKeys: Record<string, {
|
|
950
|
-
onUpdate?: string | undefined;
|
|
951
|
-
onDelete?: string | undefined;
|
|
952
1021
|
name: string;
|
|
953
1022
|
tableFrom: string;
|
|
954
1023
|
columnsFrom: string[];
|
|
955
1024
|
tableTo: string;
|
|
956
1025
|
columnsTo: string[];
|
|
1026
|
+
onUpdate?: string | undefined;
|
|
1027
|
+
onDelete?: string | undefined;
|
|
957
1028
|
}>;
|
|
958
1029
|
compositePrimaryKeys: Record<string, {
|
|
959
1030
|
name: string;
|
|
960
1031
|
columns: string[];
|
|
961
1032
|
}>;
|
|
1033
|
+
uniqueConstraints?: Record<string, {
|
|
1034
|
+
name: string;
|
|
1035
|
+
columns: string[];
|
|
1036
|
+
}> | undefined;
|
|
962
1037
|
}>;
|
|
963
1038
|
id: string;
|
|
964
1039
|
prevId: string;
|
|
@@ -968,6 +1043,13 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
968
1043
|
columns: Record<string, string>;
|
|
969
1044
|
tables: Record<string, string>;
|
|
970
1045
|
};
|
|
1046
|
+
internal?: {
|
|
1047
|
+
tables: Record<string, {
|
|
1048
|
+
columns: Record<string, {
|
|
1049
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1050
|
+
} | undefined>;
|
|
1051
|
+
} | undefined>;
|
|
1052
|
+
} | undefined;
|
|
971
1053
|
}>;
|
|
972
1054
|
type MySqlSchema = TypeOf<typeof schema>;
|
|
973
1055
|
|
|
@@ -999,45 +1081,40 @@ declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstanc
|
|
|
999
1081
|
apply: () => Promise<void>;
|
|
1000
1082
|
}>;
|
|
1001
1083
|
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;
|
|
1011
1084
|
version: "6";
|
|
1012
1085
|
dialect: "postgresql";
|
|
1013
1086
|
tables: Record<string, {
|
|
1014
1087
|
name: string;
|
|
1015
1088
|
schema: string;
|
|
1016
1089
|
columns: Record<string, {
|
|
1090
|
+
type: string;
|
|
1091
|
+
name: string;
|
|
1092
|
+
primaryKey: boolean;
|
|
1093
|
+
notNull: boolean;
|
|
1017
1094
|
typeSchema?: string | undefined;
|
|
1018
1095
|
default?: any;
|
|
1019
1096
|
isUnique?: any;
|
|
1020
1097
|
uniqueName?: string | undefined;
|
|
1021
1098
|
nullsNotDistinct?: boolean | undefined;
|
|
1022
|
-
type: string;
|
|
1023
|
-
name: string;
|
|
1024
|
-
primaryKey: boolean;
|
|
1025
|
-
notNull: boolean;
|
|
1026
1099
|
}>;
|
|
1027
1100
|
indexes: Record<string, {
|
|
1028
1101
|
name: string;
|
|
1029
1102
|
columns: string[];
|
|
1030
1103
|
isUnique: boolean;
|
|
1104
|
+
method: string;
|
|
1105
|
+
concurrently: boolean;
|
|
1106
|
+
with?: Record<string, string> | undefined;
|
|
1107
|
+
where?: string | undefined;
|
|
1031
1108
|
}>;
|
|
1032
1109
|
foreignKeys: Record<string, {
|
|
1033
|
-
schemaTo?: string | undefined;
|
|
1034
|
-
onUpdate?: string | undefined;
|
|
1035
|
-
onDelete?: string | undefined;
|
|
1036
1110
|
name: string;
|
|
1037
1111
|
tableFrom: string;
|
|
1038
1112
|
columnsFrom: string[];
|
|
1039
1113
|
tableTo: string;
|
|
1040
1114
|
columnsTo: string[];
|
|
1115
|
+
schemaTo?: string | undefined;
|
|
1116
|
+
onUpdate?: string | undefined;
|
|
1117
|
+
onDelete?: string | undefined;
|
|
1041
1118
|
}>;
|
|
1042
1119
|
compositePrimaryKeys: Record<string, {
|
|
1043
1120
|
name: string;
|
|
@@ -1062,6 +1139,15 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
1062
1139
|
};
|
|
1063
1140
|
id: string;
|
|
1064
1141
|
prevId: string;
|
|
1142
|
+
internal?: {
|
|
1143
|
+
tables: Record<string, {
|
|
1144
|
+
columns: Record<string, {
|
|
1145
|
+
isArray?: boolean | undefined;
|
|
1146
|
+
dimensions?: number | undefined;
|
|
1147
|
+
rawType?: string | undefined;
|
|
1148
|
+
} | undefined>;
|
|
1149
|
+
} | undefined>;
|
|
1150
|
+
} | undefined;
|
|
1065
1151
|
};
|
|
1066
1152
|
|
|
1067
1153
|
export { type DrizzleMySQLSnapshotJSON, type DrizzleSQLiteSnapshotJSON, type DrizzleSnapshotJSON, generateDrizzleJson, generateMigration, generateMySQLDrizzleJson, generateMySQLMigration, generateSQLiteDrizzleJson, generateSQLiteMigration, pushMySQLSchema, pushSQLiteSchema, pushSchema, upPgSnapshot };
|