duron 0.1.0 → 0.2.0
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/README.md +4 -4
- package/dist/adapters/postgres/base.d.ts +52 -0
- package/dist/adapters/postgres/base.d.ts.map +1 -0
- package/dist/adapters/postgres/base.js +832 -0
- package/dist/adapters/postgres/pglite.d.ts +10 -5
- package/dist/adapters/postgres/pglite.d.ts.map +1 -1
- package/dist/adapters/postgres/pglite.js +19 -7
- package/dist/adapters/postgres/postgres.d.ts +6 -39
- package/dist/adapters/postgres/postgres.d.ts.map +1 -1
- package/dist/adapters/postgres/postgres.js +9 -822
- package/dist/adapters/postgres/schema.d.ts +89 -135
- package/dist/adapters/postgres/schema.d.ts.map +1 -1
- package/dist/adapters/postgres/schema.default.d.ts +89 -135
- package/dist/adapters/postgres/schema.default.d.ts.map +1 -1
- package/dist/step-manager.js +1 -0
- package/migrations/postgres/20251203223656_conscious_johnny_blaze/migration.sql +64 -0
- package/migrations/postgres/20251203223656_conscious_johnny_blaze/snapshot.json +954 -0
- package/package.json +3 -3
- package/src/adapters/postgres/base.ts +1297 -0
- package/src/adapters/postgres/pglite.ts +36 -18
- package/src/adapters/postgres/postgres.ts +19 -1244
- package/src/step-manager.ts +1 -0
- package/migrations/postgres/0000_lethal_speed_demon.sql +0 -64
- package/migrations/postgres/meta/0000_snapshot.json +0 -606
- package/migrations/postgres/meta/_journal.json +0 -13
|
@@ -3,10 +3,9 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
3
3
|
schema: string;
|
|
4
4
|
columns: {
|
|
5
5
|
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
6
|
-
name:
|
|
6
|
+
name: string;
|
|
7
7
|
tableName: "jobs";
|
|
8
|
-
dataType: "string";
|
|
9
|
-
columnType: "PgUUID";
|
|
8
|
+
dataType: "string uuid";
|
|
10
9
|
data: string;
|
|
11
10
|
driverParam: string;
|
|
12
11
|
notNull: true;
|
|
@@ -18,12 +17,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
18
17
|
baseColumn: never;
|
|
19
18
|
identity: undefined;
|
|
20
19
|
generated: undefined;
|
|
21
|
-
}, {}
|
|
20
|
+
}, {}>;
|
|
22
21
|
action_name: import("drizzle-orm/pg-core").PgColumn<{
|
|
23
|
-
name:
|
|
22
|
+
name: string;
|
|
24
23
|
tableName: "jobs";
|
|
25
24
|
dataType: "string";
|
|
26
|
-
columnType: "PgText";
|
|
27
25
|
data: string;
|
|
28
26
|
driverParam: string;
|
|
29
27
|
notNull: true;
|
|
@@ -35,12 +33,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
35
33
|
baseColumn: never;
|
|
36
34
|
identity: undefined;
|
|
37
35
|
generated: undefined;
|
|
38
|
-
}, {}
|
|
36
|
+
}, {}>;
|
|
39
37
|
group_key: import("drizzle-orm/pg-core").PgColumn<{
|
|
40
|
-
name:
|
|
38
|
+
name: string;
|
|
41
39
|
tableName: "jobs";
|
|
42
40
|
dataType: "string";
|
|
43
|
-
columnType: "PgText";
|
|
44
41
|
data: string;
|
|
45
42
|
driverParam: string;
|
|
46
43
|
notNull: true;
|
|
@@ -52,12 +49,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
52
49
|
baseColumn: never;
|
|
53
50
|
identity: undefined;
|
|
54
51
|
generated: undefined;
|
|
55
|
-
}, {}
|
|
52
|
+
}, {}>;
|
|
56
53
|
status: import("drizzle-orm/pg-core").PgColumn<{
|
|
57
|
-
name:
|
|
54
|
+
name: string;
|
|
58
55
|
tableName: "jobs";
|
|
59
56
|
dataType: "string";
|
|
60
|
-
columnType: "PgText";
|
|
61
57
|
data: "created" | "active" | "completed" | "failed" | "cancelled";
|
|
62
58
|
driverParam: string;
|
|
63
59
|
notNull: true;
|
|
@@ -69,14 +65,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
69
65
|
baseColumn: never;
|
|
70
66
|
identity: undefined;
|
|
71
67
|
generated: undefined;
|
|
72
|
-
}, {}
|
|
73
|
-
$type: "created" | "active" | "completed" | "failed" | "cancelled";
|
|
74
|
-
}>;
|
|
68
|
+
}, {}>;
|
|
75
69
|
checksum: import("drizzle-orm/pg-core").PgColumn<{
|
|
76
|
-
name:
|
|
70
|
+
name: string;
|
|
77
71
|
tableName: "jobs";
|
|
78
72
|
dataType: "string";
|
|
79
|
-
columnType: "PgText";
|
|
80
73
|
data: string;
|
|
81
74
|
driverParam: string;
|
|
82
75
|
notNull: true;
|
|
@@ -88,12 +81,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
88
81
|
baseColumn: never;
|
|
89
82
|
identity: undefined;
|
|
90
83
|
generated: undefined;
|
|
91
|
-
}, {}
|
|
84
|
+
}, {}>;
|
|
92
85
|
input: import("drizzle-orm/pg-core").PgColumn<{
|
|
93
|
-
name:
|
|
86
|
+
name: string;
|
|
94
87
|
tableName: "jobs";
|
|
95
|
-
dataType: "json";
|
|
96
|
-
columnType: "PgJsonb";
|
|
88
|
+
dataType: "object json";
|
|
97
89
|
data: unknown;
|
|
98
90
|
driverParam: unknown;
|
|
99
91
|
notNull: true;
|
|
@@ -105,12 +97,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
105
97
|
baseColumn: never;
|
|
106
98
|
identity: undefined;
|
|
107
99
|
generated: undefined;
|
|
108
|
-
}, {}
|
|
100
|
+
}, {}>;
|
|
109
101
|
output: import("drizzle-orm/pg-core").PgColumn<{
|
|
110
|
-
name:
|
|
102
|
+
name: string;
|
|
111
103
|
tableName: "jobs";
|
|
112
|
-
dataType: "json";
|
|
113
|
-
columnType: "PgJsonb";
|
|
104
|
+
dataType: "object json";
|
|
114
105
|
data: unknown;
|
|
115
106
|
driverParam: unknown;
|
|
116
107
|
notNull: false;
|
|
@@ -122,12 +113,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
122
113
|
baseColumn: never;
|
|
123
114
|
identity: undefined;
|
|
124
115
|
generated: undefined;
|
|
125
|
-
}, {}
|
|
116
|
+
}, {}>;
|
|
126
117
|
error: import("drizzle-orm/pg-core").PgColumn<{
|
|
127
|
-
name:
|
|
118
|
+
name: string;
|
|
128
119
|
tableName: "jobs";
|
|
129
|
-
dataType: "json";
|
|
130
|
-
columnType: "PgJsonb";
|
|
120
|
+
dataType: "object json";
|
|
131
121
|
data: import("../../errors.js").SerializableError;
|
|
132
122
|
driverParam: unknown;
|
|
133
123
|
notNull: false;
|
|
@@ -139,14 +129,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
139
129
|
baseColumn: never;
|
|
140
130
|
identity: undefined;
|
|
141
131
|
generated: undefined;
|
|
142
|
-
}, {}
|
|
143
|
-
$type: import("../../errors.js").SerializableError;
|
|
144
|
-
}>;
|
|
132
|
+
}, {}>;
|
|
145
133
|
timeout_ms: import("drizzle-orm/pg-core").PgColumn<{
|
|
146
|
-
name:
|
|
134
|
+
name: string;
|
|
147
135
|
tableName: "jobs";
|
|
148
|
-
dataType: "number";
|
|
149
|
-
columnType: "PgInteger";
|
|
136
|
+
dataType: "number int32";
|
|
150
137
|
data: number;
|
|
151
138
|
driverParam: string | number;
|
|
152
139
|
notNull: true;
|
|
@@ -158,12 +145,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
158
145
|
baseColumn: never;
|
|
159
146
|
identity: undefined;
|
|
160
147
|
generated: undefined;
|
|
161
|
-
}, {}
|
|
148
|
+
}, {}>;
|
|
162
149
|
expires_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
163
|
-
name:
|
|
150
|
+
name: string;
|
|
164
151
|
tableName: "jobs";
|
|
165
|
-
dataType: "date";
|
|
166
|
-
columnType: "PgTimestamp";
|
|
152
|
+
dataType: "object date";
|
|
167
153
|
data: Date;
|
|
168
154
|
driverParam: string;
|
|
169
155
|
notNull: false;
|
|
@@ -175,12 +161,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
175
161
|
baseColumn: never;
|
|
176
162
|
identity: undefined;
|
|
177
163
|
generated: undefined;
|
|
178
|
-
}, {}
|
|
164
|
+
}, {}>;
|
|
179
165
|
started_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
180
|
-
name:
|
|
166
|
+
name: string;
|
|
181
167
|
tableName: "jobs";
|
|
182
|
-
dataType: "date";
|
|
183
|
-
columnType: "PgTimestamp";
|
|
168
|
+
dataType: "object date";
|
|
184
169
|
data: Date;
|
|
185
170
|
driverParam: string;
|
|
186
171
|
notNull: false;
|
|
@@ -192,12 +177,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
192
177
|
baseColumn: never;
|
|
193
178
|
identity: undefined;
|
|
194
179
|
generated: undefined;
|
|
195
|
-
}, {}
|
|
180
|
+
}, {}>;
|
|
196
181
|
finished_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
197
|
-
name:
|
|
182
|
+
name: string;
|
|
198
183
|
tableName: "jobs";
|
|
199
|
-
dataType: "date";
|
|
200
|
-
columnType: "PgTimestamp";
|
|
184
|
+
dataType: "object date";
|
|
201
185
|
data: Date;
|
|
202
186
|
driverParam: string;
|
|
203
187
|
notNull: false;
|
|
@@ -209,12 +193,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
209
193
|
baseColumn: never;
|
|
210
194
|
identity: undefined;
|
|
211
195
|
generated: undefined;
|
|
212
|
-
}, {}
|
|
196
|
+
}, {}>;
|
|
213
197
|
owner_id: import("drizzle-orm/pg-core").PgColumn<{
|
|
214
|
-
name:
|
|
198
|
+
name: string;
|
|
215
199
|
tableName: "jobs";
|
|
216
200
|
dataType: "string";
|
|
217
|
-
columnType: "PgText";
|
|
218
201
|
data: string;
|
|
219
202
|
driverParam: string;
|
|
220
203
|
notNull: false;
|
|
@@ -226,12 +209,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
226
209
|
baseColumn: never;
|
|
227
210
|
identity: undefined;
|
|
228
211
|
generated: undefined;
|
|
229
|
-
}, {}
|
|
212
|
+
}, {}>;
|
|
230
213
|
concurrency_limit: import("drizzle-orm/pg-core").PgColumn<{
|
|
231
|
-
name:
|
|
214
|
+
name: string;
|
|
232
215
|
tableName: "jobs";
|
|
233
|
-
dataType: "number";
|
|
234
|
-
columnType: "PgInteger";
|
|
216
|
+
dataType: "number int32";
|
|
235
217
|
data: number;
|
|
236
218
|
driverParam: string | number;
|
|
237
219
|
notNull: true;
|
|
@@ -243,12 +225,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
243
225
|
baseColumn: never;
|
|
244
226
|
identity: undefined;
|
|
245
227
|
generated: undefined;
|
|
246
|
-
}, {}
|
|
228
|
+
}, {}>;
|
|
247
229
|
created_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
248
|
-
name:
|
|
230
|
+
name: string;
|
|
249
231
|
tableName: "jobs";
|
|
250
|
-
dataType: "date";
|
|
251
|
-
columnType: "PgTimestamp";
|
|
232
|
+
dataType: "object date";
|
|
252
233
|
data: Date;
|
|
253
234
|
driverParam: string;
|
|
254
235
|
notNull: true;
|
|
@@ -260,12 +241,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
260
241
|
baseColumn: never;
|
|
261
242
|
identity: undefined;
|
|
262
243
|
generated: undefined;
|
|
263
|
-
}, {}
|
|
244
|
+
}, {}>;
|
|
264
245
|
updated_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
265
|
-
name:
|
|
246
|
+
name: string;
|
|
266
247
|
tableName: "jobs";
|
|
267
|
-
dataType: "date";
|
|
268
|
-
columnType: "PgTimestamp";
|
|
248
|
+
dataType: "object date";
|
|
269
249
|
data: Date;
|
|
270
250
|
driverParam: string;
|
|
271
251
|
notNull: true;
|
|
@@ -277,7 +257,7 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
277
257
|
baseColumn: never;
|
|
278
258
|
identity: undefined;
|
|
279
259
|
generated: undefined;
|
|
280
|
-
}, {}
|
|
260
|
+
}, {}>;
|
|
281
261
|
};
|
|
282
262
|
dialect: "pg";
|
|
283
263
|
}>, jobStepsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
@@ -285,10 +265,9 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
285
265
|
schema: string;
|
|
286
266
|
columns: {
|
|
287
267
|
id: import("drizzle-orm/pg-core").PgColumn<{
|
|
288
|
-
name:
|
|
268
|
+
name: string;
|
|
289
269
|
tableName: "job_steps";
|
|
290
|
-
dataType: "string";
|
|
291
|
-
columnType: "PgUUID";
|
|
270
|
+
dataType: "string uuid";
|
|
292
271
|
data: string;
|
|
293
272
|
driverParam: string;
|
|
294
273
|
notNull: true;
|
|
@@ -300,12 +279,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
300
279
|
baseColumn: never;
|
|
301
280
|
identity: undefined;
|
|
302
281
|
generated: undefined;
|
|
303
|
-
}, {}
|
|
282
|
+
}, {}>;
|
|
304
283
|
job_id: import("drizzle-orm/pg-core").PgColumn<{
|
|
305
|
-
name:
|
|
284
|
+
name: string;
|
|
306
285
|
tableName: "job_steps";
|
|
307
|
-
dataType: "string";
|
|
308
|
-
columnType: "PgUUID";
|
|
286
|
+
dataType: "string uuid";
|
|
309
287
|
data: string;
|
|
310
288
|
driverParam: string;
|
|
311
289
|
notNull: true;
|
|
@@ -317,12 +295,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
317
295
|
baseColumn: never;
|
|
318
296
|
identity: undefined;
|
|
319
297
|
generated: undefined;
|
|
320
|
-
}, {}
|
|
298
|
+
}, {}>;
|
|
321
299
|
name: import("drizzle-orm/pg-core").PgColumn<{
|
|
322
|
-
name:
|
|
300
|
+
name: string;
|
|
323
301
|
tableName: "job_steps";
|
|
324
302
|
dataType: "string";
|
|
325
|
-
columnType: "PgText";
|
|
326
303
|
data: string;
|
|
327
304
|
driverParam: string;
|
|
328
305
|
notNull: true;
|
|
@@ -334,12 +311,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
334
311
|
baseColumn: never;
|
|
335
312
|
identity: undefined;
|
|
336
313
|
generated: undefined;
|
|
337
|
-
}, {}
|
|
314
|
+
}, {}>;
|
|
338
315
|
status: import("drizzle-orm/pg-core").PgColumn<{
|
|
339
|
-
name:
|
|
316
|
+
name: string;
|
|
340
317
|
tableName: "job_steps";
|
|
341
318
|
dataType: "string";
|
|
342
|
-
columnType: "PgText";
|
|
343
319
|
data: "active" | "completed" | "failed" | "cancelled";
|
|
344
320
|
driverParam: string;
|
|
345
321
|
notNull: true;
|
|
@@ -351,14 +327,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
351
327
|
baseColumn: never;
|
|
352
328
|
identity: undefined;
|
|
353
329
|
generated: undefined;
|
|
354
|
-
}, {}
|
|
355
|
-
$type: "active" | "completed" | "failed" | "cancelled";
|
|
356
|
-
}>;
|
|
330
|
+
}, {}>;
|
|
357
331
|
output: import("drizzle-orm/pg-core").PgColumn<{
|
|
358
|
-
name:
|
|
332
|
+
name: string;
|
|
359
333
|
tableName: "job_steps";
|
|
360
|
-
dataType: "json";
|
|
361
|
-
columnType: "PgJsonb";
|
|
334
|
+
dataType: "object json";
|
|
362
335
|
data: unknown;
|
|
363
336
|
driverParam: unknown;
|
|
364
337
|
notNull: false;
|
|
@@ -370,12 +343,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
370
343
|
baseColumn: never;
|
|
371
344
|
identity: undefined;
|
|
372
345
|
generated: undefined;
|
|
373
|
-
}, {}
|
|
346
|
+
}, {}>;
|
|
374
347
|
error: import("drizzle-orm/pg-core").PgColumn<{
|
|
375
|
-
name:
|
|
348
|
+
name: string;
|
|
376
349
|
tableName: "job_steps";
|
|
377
|
-
dataType: "json";
|
|
378
|
-
columnType: "PgJsonb";
|
|
350
|
+
dataType: "object json";
|
|
379
351
|
data: import("../../errors.js").SerializableError;
|
|
380
352
|
driverParam: unknown;
|
|
381
353
|
notNull: false;
|
|
@@ -387,14 +359,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
387
359
|
baseColumn: never;
|
|
388
360
|
identity: undefined;
|
|
389
361
|
generated: undefined;
|
|
390
|
-
}, {}
|
|
391
|
-
$type: import("../../errors.js").SerializableError;
|
|
392
|
-
}>;
|
|
362
|
+
}, {}>;
|
|
393
363
|
started_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
394
|
-
name:
|
|
364
|
+
name: string;
|
|
395
365
|
tableName: "job_steps";
|
|
396
|
-
dataType: "date";
|
|
397
|
-
columnType: "PgTimestamp";
|
|
366
|
+
dataType: "object date";
|
|
398
367
|
data: Date;
|
|
399
368
|
driverParam: string;
|
|
400
369
|
notNull: true;
|
|
@@ -406,12 +375,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
406
375
|
baseColumn: never;
|
|
407
376
|
identity: undefined;
|
|
408
377
|
generated: undefined;
|
|
409
|
-
}, {}
|
|
378
|
+
}, {}>;
|
|
410
379
|
finished_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
411
|
-
name:
|
|
380
|
+
name: string;
|
|
412
381
|
tableName: "job_steps";
|
|
413
|
-
dataType: "date";
|
|
414
|
-
columnType: "PgTimestamp";
|
|
382
|
+
dataType: "object date";
|
|
415
383
|
data: Date;
|
|
416
384
|
driverParam: string;
|
|
417
385
|
notNull: false;
|
|
@@ -423,12 +391,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
423
391
|
baseColumn: never;
|
|
424
392
|
identity: undefined;
|
|
425
393
|
generated: undefined;
|
|
426
|
-
}, {}
|
|
394
|
+
}, {}>;
|
|
427
395
|
timeout_ms: import("drizzle-orm/pg-core").PgColumn<{
|
|
428
|
-
name:
|
|
396
|
+
name: string;
|
|
429
397
|
tableName: "job_steps";
|
|
430
|
-
dataType: "number";
|
|
431
|
-
columnType: "PgInteger";
|
|
398
|
+
dataType: "number int32";
|
|
432
399
|
data: number;
|
|
433
400
|
driverParam: string | number;
|
|
434
401
|
notNull: true;
|
|
@@ -440,12 +407,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
440
407
|
baseColumn: never;
|
|
441
408
|
identity: undefined;
|
|
442
409
|
generated: undefined;
|
|
443
|
-
}, {}
|
|
410
|
+
}, {}>;
|
|
444
411
|
expires_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
445
|
-
name:
|
|
412
|
+
name: string;
|
|
446
413
|
tableName: "job_steps";
|
|
447
|
-
dataType: "date";
|
|
448
|
-
columnType: "PgTimestamp";
|
|
414
|
+
dataType: "object date";
|
|
449
415
|
data: Date;
|
|
450
416
|
driverParam: string;
|
|
451
417
|
notNull: false;
|
|
@@ -457,12 +423,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
457
423
|
baseColumn: never;
|
|
458
424
|
identity: undefined;
|
|
459
425
|
generated: undefined;
|
|
460
|
-
}, {}
|
|
426
|
+
}, {}>;
|
|
461
427
|
retries_limit: import("drizzle-orm/pg-core").PgColumn<{
|
|
462
|
-
name:
|
|
428
|
+
name: string;
|
|
463
429
|
tableName: "job_steps";
|
|
464
|
-
dataType: "number";
|
|
465
|
-
columnType: "PgInteger";
|
|
430
|
+
dataType: "number int32";
|
|
466
431
|
data: number;
|
|
467
432
|
driverParam: string | number;
|
|
468
433
|
notNull: true;
|
|
@@ -474,12 +439,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
474
439
|
baseColumn: never;
|
|
475
440
|
identity: undefined;
|
|
476
441
|
generated: undefined;
|
|
477
|
-
}, {}
|
|
442
|
+
}, {}>;
|
|
478
443
|
retries_count: import("drizzle-orm/pg-core").PgColumn<{
|
|
479
|
-
name:
|
|
444
|
+
name: string;
|
|
480
445
|
tableName: "job_steps";
|
|
481
|
-
dataType: "number";
|
|
482
|
-
columnType: "PgInteger";
|
|
446
|
+
dataType: "number int32";
|
|
483
447
|
data: number;
|
|
484
448
|
driverParam: string | number;
|
|
485
449
|
notNull: true;
|
|
@@ -491,12 +455,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
491
455
|
baseColumn: never;
|
|
492
456
|
identity: undefined;
|
|
493
457
|
generated: undefined;
|
|
494
|
-
}, {}
|
|
458
|
+
}, {}>;
|
|
495
459
|
delayed_ms: import("drizzle-orm/pg-core").PgColumn<{
|
|
496
|
-
name:
|
|
460
|
+
name: string;
|
|
497
461
|
tableName: "job_steps";
|
|
498
|
-
dataType: "number";
|
|
499
|
-
columnType: "PgInteger";
|
|
462
|
+
dataType: "number int32";
|
|
500
463
|
data: number;
|
|
501
464
|
driverParam: string | number;
|
|
502
465
|
notNull: false;
|
|
@@ -508,12 +471,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
508
471
|
baseColumn: never;
|
|
509
472
|
identity: undefined;
|
|
510
473
|
generated: undefined;
|
|
511
|
-
}, {}
|
|
474
|
+
}, {}>;
|
|
512
475
|
history_failed_attempts: import("drizzle-orm/pg-core").PgColumn<{
|
|
513
|
-
name:
|
|
476
|
+
name: string;
|
|
514
477
|
tableName: "job_steps";
|
|
515
|
-
dataType: "json";
|
|
516
|
-
columnType: "PgJsonb";
|
|
478
|
+
dataType: "object json";
|
|
517
479
|
data: Record<string, {
|
|
518
480
|
failedAt: Date;
|
|
519
481
|
error: import("../../errors.js").SerializableError;
|
|
@@ -529,18 +491,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
529
491
|
baseColumn: never;
|
|
530
492
|
identity: undefined;
|
|
531
493
|
generated: undefined;
|
|
532
|
-
}, {}
|
|
533
|
-
$type: Record<string, {
|
|
534
|
-
failedAt: Date;
|
|
535
|
-
error: import("../../errors.js").SerializableError;
|
|
536
|
-
delayedMs: number;
|
|
537
|
-
}>;
|
|
538
|
-
}>;
|
|
494
|
+
}, {}>;
|
|
539
495
|
created_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
540
|
-
name:
|
|
496
|
+
name: string;
|
|
541
497
|
tableName: "job_steps";
|
|
542
|
-
dataType: "date";
|
|
543
|
-
columnType: "PgTimestamp";
|
|
498
|
+
dataType: "object date";
|
|
544
499
|
data: Date;
|
|
545
500
|
driverParam: string;
|
|
546
501
|
notNull: true;
|
|
@@ -552,12 +507,11 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
552
507
|
baseColumn: never;
|
|
553
508
|
identity: undefined;
|
|
554
509
|
generated: undefined;
|
|
555
|
-
}, {}
|
|
510
|
+
}, {}>;
|
|
556
511
|
updated_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
557
|
-
name:
|
|
512
|
+
name: string;
|
|
558
513
|
tableName: "job_steps";
|
|
559
|
-
dataType: "date";
|
|
560
|
-
columnType: "PgTimestamp";
|
|
514
|
+
dataType: "object date";
|
|
561
515
|
data: Date;
|
|
562
516
|
driverParam: string;
|
|
563
517
|
notNull: true;
|
|
@@ -569,7 +523,7 @@ declare const schema: import("drizzle-orm/pg-core").PgSchema<string>, jobsTable:
|
|
|
569
523
|
baseColumn: never;
|
|
570
524
|
identity: undefined;
|
|
571
525
|
generated: undefined;
|
|
572
|
-
}, {}
|
|
526
|
+
}, {}>;
|
|
573
527
|
};
|
|
574
528
|
dialect: "pg";
|
|
575
529
|
}>;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"schema.default.d.ts","sourceRoot":"","sources":["../../../src/adapters/postgres/schema.default.ts"],"names":[],"mappings":"AAEA,QAAA,MAAQ,MAAM,kDAAE,SAAS
|
|
1
|
+
{"version":3,"file":"schema.default.d.ts","sourceRoot":"","sources":["../../../src/adapters/postgres/schema.default.ts"],"names":[],"mappings":"AAEA,QAAA,MAAQ,MAAM,kDAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0B,CAAA;AAElE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,EAAE,CAAA"}
|
package/dist/step-manager.js
CHANGED
|
@@ -0,0 +1,64 @@
|
|
|
1
|
+
CREATE SCHEMA IF NOT EXISTS "duron";
|
|
2
|
+
--> statement-breakpoint
|
|
3
|
+
CREATE TABLE "duron"."job_steps" (
|
|
4
|
+
"id" uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
|
5
|
+
"job_id" uuid NOT NULL,
|
|
6
|
+
"name" text NOT NULL,
|
|
7
|
+
"status" text DEFAULT 'active' NOT NULL,
|
|
8
|
+
"output" jsonb,
|
|
9
|
+
"error" jsonb,
|
|
10
|
+
"started_at" timestamp with time zone DEFAULT now() NOT NULL,
|
|
11
|
+
"finished_at" timestamp with time zone,
|
|
12
|
+
"timeout_ms" integer NOT NULL,
|
|
13
|
+
"expires_at" timestamp with time zone,
|
|
14
|
+
"retries_limit" integer DEFAULT 0 NOT NULL,
|
|
15
|
+
"retries_count" integer DEFAULT 0 NOT NULL,
|
|
16
|
+
"delayed_ms" integer,
|
|
17
|
+
"history_failed_attempts" jsonb DEFAULT '{}' NOT NULL,
|
|
18
|
+
"created_at" timestamp with time zone DEFAULT now() NOT NULL,
|
|
19
|
+
"updated_at" timestamp with time zone DEFAULT now() NOT NULL,
|
|
20
|
+
CONSTRAINT "unique_job_step_name" UNIQUE("job_id","name"),
|
|
21
|
+
CONSTRAINT "job_steps_status_check" CHECK ("status" IN ('active','completed','failed','cancelled'))
|
|
22
|
+
);
|
|
23
|
+
--> statement-breakpoint
|
|
24
|
+
CREATE TABLE "duron"."jobs" (
|
|
25
|
+
"id" uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
|
26
|
+
"action_name" text NOT NULL,
|
|
27
|
+
"group_key" text NOT NULL,
|
|
28
|
+
"status" text DEFAULT 'created' NOT NULL,
|
|
29
|
+
"checksum" text NOT NULL,
|
|
30
|
+
"input" jsonb DEFAULT '{}' NOT NULL,
|
|
31
|
+
"output" jsonb,
|
|
32
|
+
"error" jsonb,
|
|
33
|
+
"timeout_ms" integer NOT NULL,
|
|
34
|
+
"expires_at" timestamp with time zone,
|
|
35
|
+
"started_at" timestamp with time zone,
|
|
36
|
+
"finished_at" timestamp with time zone,
|
|
37
|
+
"owner_id" text,
|
|
38
|
+
"concurrency_limit" integer DEFAULT 10 NOT NULL,
|
|
39
|
+
"created_at" timestamp with time zone DEFAULT now() NOT NULL,
|
|
40
|
+
"updated_at" timestamp with time zone DEFAULT now() NOT NULL,
|
|
41
|
+
CONSTRAINT "jobs_status_check" CHECK ("status" IN ('created','active','completed','failed','cancelled'))
|
|
42
|
+
);
|
|
43
|
+
--> statement-breakpoint
|
|
44
|
+
CREATE INDEX "idx_job_steps_job_id" ON "duron"."job_steps" ("job_id");--> statement-breakpoint
|
|
45
|
+
CREATE INDEX "idx_job_steps_status" ON "duron"."job_steps" ("status");--> statement-breakpoint
|
|
46
|
+
CREATE INDEX "idx_job_steps_name" ON "duron"."job_steps" ("name");--> statement-breakpoint
|
|
47
|
+
CREATE INDEX "idx_job_steps_expires_at" ON "duron"."job_steps" ("expires_at");--> statement-breakpoint
|
|
48
|
+
CREATE INDEX "idx_job_steps_job_status" ON "duron"."job_steps" ("job_id","status");--> statement-breakpoint
|
|
49
|
+
CREATE INDEX "idx_job_steps_job_name" ON "duron"."job_steps" ("job_id","name");--> statement-breakpoint
|
|
50
|
+
CREATE INDEX "idx_job_steps_output_fts" ON "duron"."job_steps" USING gin (to_tsvector('english', "output"::text));--> statement-breakpoint
|
|
51
|
+
CREATE INDEX "idx_jobs_action_name" ON "duron"."jobs" ("action_name");--> statement-breakpoint
|
|
52
|
+
CREATE INDEX "idx_jobs_status" ON "duron"."jobs" ("status");--> statement-breakpoint
|
|
53
|
+
CREATE INDEX "idx_jobs_group_key" ON "duron"."jobs" ("group_key");--> statement-breakpoint
|
|
54
|
+
CREATE INDEX "idx_jobs_started_at" ON "duron"."jobs" ("started_at");--> statement-breakpoint
|
|
55
|
+
CREATE INDEX "idx_jobs_finished_at" ON "duron"."jobs" ("finished_at");--> statement-breakpoint
|
|
56
|
+
CREATE INDEX "idx_jobs_expires_at" ON "duron"."jobs" ("expires_at");--> statement-breakpoint
|
|
57
|
+
CREATE INDEX "idx_jobs_owner_id" ON "duron"."jobs" ("owner_id");--> statement-breakpoint
|
|
58
|
+
CREATE INDEX "idx_jobs_checksum" ON "duron"."jobs" ("checksum");--> statement-breakpoint
|
|
59
|
+
CREATE INDEX "idx_jobs_concurrency_limit" ON "duron"."jobs" ("concurrency_limit");--> statement-breakpoint
|
|
60
|
+
CREATE INDEX "idx_jobs_action_status" ON "duron"."jobs" ("action_name","status");--> statement-breakpoint
|
|
61
|
+
CREATE INDEX "idx_jobs_action_group" ON "duron"."jobs" ("action_name","group_key");--> statement-breakpoint
|
|
62
|
+
CREATE INDEX "idx_jobs_input_fts" ON "duron"."jobs" USING gin (to_tsvector('english', "input"::text));--> statement-breakpoint
|
|
63
|
+
CREATE INDEX "idx_jobs_output_fts" ON "duron"."jobs" USING gin (to_tsvector('english', "output"::text));--> statement-breakpoint
|
|
64
|
+
ALTER TABLE "duron"."job_steps" ADD CONSTRAINT "job_steps_job_id_jobs_id_fkey" FOREIGN KEY ("job_id") REFERENCES "duron"."jobs"("id") ON DELETE CASCADE;
|