@20baht/definitions 0.0.0-stage → 0.1.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/LICENSE +21 -0
- package/README.md +97 -2
- package/dist/elysia.d.ts +363 -0
- package/dist/elysia.js +101 -0
- package/dist/files.d.ts +4 -0
- package/dist/files.js +9 -0
- package/dist/hash.d.ts +2 -0
- package/dist/hash.js +17 -0
- package/dist/index.d.ts +6 -0
- package/dist/index.js +5 -0
- package/dist/memory.d.ts +3 -0
- package/dist/memory.js +79 -0
- package/dist/pg.d.ts +334 -0
- package/dist/pg.js +170 -0
- package/dist/seed.d.ts +23 -0
- package/dist/seed.js +15 -0
- package/dist/service.d.ts +2 -0
- package/dist/service.js +109 -0
- package/dist/types.d.ts +155 -0
- package/dist/types.js +1 -0
- package/dist/upgrade.d.ts +2 -0
- package/dist/upgrade.js +43 -0
- package/package.json +91 -4
package/dist/memory.js
ADDED
|
@@ -0,0 +1,79 @@
|
|
|
1
|
+
const info = (version, active) => {
|
|
2
|
+
const { definition: _definition, ...rest } = version;
|
|
3
|
+
return { ...rest, active: version.version === active };
|
|
4
|
+
};
|
|
5
|
+
export function memoryStorage() {
|
|
6
|
+
const heads = new Map();
|
|
7
|
+
const head = (name) => {
|
|
8
|
+
let found = heads.get(name);
|
|
9
|
+
if (!found) {
|
|
10
|
+
found = { versions: [], active: null, draft: undefined, updated_at: '' };
|
|
11
|
+
heads.set(name, found);
|
|
12
|
+
}
|
|
13
|
+
return found;
|
|
14
|
+
};
|
|
15
|
+
const at = (name, version) => heads.get(name)?.versions.find((v) => v.version === version);
|
|
16
|
+
return {
|
|
17
|
+
list: () => Promise.resolve([...heads.entries()]
|
|
18
|
+
.sort(([a], [b]) => a.localeCompare(b))
|
|
19
|
+
.map(([name, h]) => ({
|
|
20
|
+
name,
|
|
21
|
+
kind: h.versions.at(-1)?.kind ?? h.draft?.kind ?? null,
|
|
22
|
+
active: h.active,
|
|
23
|
+
latest: h.versions.at(-1)?.version ?? null,
|
|
24
|
+
draft: h.draft !== undefined,
|
|
25
|
+
updated_at: h.updated_at,
|
|
26
|
+
}))),
|
|
27
|
+
draft: (name) => Promise.resolve(heads.get(name)?.draft),
|
|
28
|
+
saveDraft(draft) {
|
|
29
|
+
const h = head(draft.name);
|
|
30
|
+
h.draft = draft;
|
|
31
|
+
h.updated_at = draft.saved_at;
|
|
32
|
+
return Promise.resolve();
|
|
33
|
+
},
|
|
34
|
+
dropDraft(name) {
|
|
35
|
+
const h = heads.get(name);
|
|
36
|
+
const had = h?.draft !== undefined;
|
|
37
|
+
if (h)
|
|
38
|
+
h.draft = undefined;
|
|
39
|
+
return Promise.resolve(had);
|
|
40
|
+
},
|
|
41
|
+
version: (name, version) => Promise.resolve(at(name, version)),
|
|
42
|
+
active(name) {
|
|
43
|
+
const active = heads.get(name)?.active;
|
|
44
|
+
return Promise.resolve(active == null ? undefined : at(name, active));
|
|
45
|
+
},
|
|
46
|
+
latest: (name) => Promise.resolve(heads.get(name)?.versions.at(-1)),
|
|
47
|
+
versions(name) {
|
|
48
|
+
const h = heads.get(name);
|
|
49
|
+
return Promise.resolve(h ? h.versions.map((v) => info(v, h.active)).reverse() : []);
|
|
50
|
+
},
|
|
51
|
+
append(entry) {
|
|
52
|
+
const h = head(entry.name);
|
|
53
|
+
const version = {
|
|
54
|
+
name: entry.name,
|
|
55
|
+
kind: entry.kind,
|
|
56
|
+
version: (h.versions.at(-1)?.version ?? 0) + 1,
|
|
57
|
+
definition: entry.definition,
|
|
58
|
+
hash: entry.hash,
|
|
59
|
+
published_by: entry.by,
|
|
60
|
+
published_at: entry.at,
|
|
61
|
+
};
|
|
62
|
+
h.versions.push(version);
|
|
63
|
+
if (entry.activate)
|
|
64
|
+
h.active = version.version;
|
|
65
|
+
if (entry.dropDraft)
|
|
66
|
+
h.draft = undefined;
|
|
67
|
+
h.updated_at = entry.at;
|
|
68
|
+
return Promise.resolve(version);
|
|
69
|
+
},
|
|
70
|
+
activate(name, version, when) {
|
|
71
|
+
const h = heads.get(name);
|
|
72
|
+
if (!h || !at(name, version))
|
|
73
|
+
return Promise.resolve(false);
|
|
74
|
+
h.active = version;
|
|
75
|
+
h.updated_at = when;
|
|
76
|
+
return Promise.resolve(true);
|
|
77
|
+
},
|
|
78
|
+
};
|
|
79
|
+
}
|
package/dist/pg.d.ts
ADDED
|
@@ -0,0 +1,334 @@
|
|
|
1
|
+
import { type PgDatabase, type PgQueryResultHKT } from 'drizzle-orm/pg-core';
|
|
2
|
+
import type { Definition, DefinitionKind, DefinitionStorage } from './types.js';
|
|
3
|
+
/**
|
|
4
|
+
* The two tables, for the host's drizzle schema: `export const { heads, versions } =
|
|
5
|
+
* definitionTables()`. `prefix` names them (`baht_definitions`, `baht_definition_versions`).
|
|
6
|
+
* Column keys are the column names, so a row reads the same in SQL and in TypeScript.
|
|
7
|
+
*/
|
|
8
|
+
export declare function definitionTables(options?: {
|
|
9
|
+
prefix?: string;
|
|
10
|
+
}): {
|
|
11
|
+
heads: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
12
|
+
name: `${string}definitions`;
|
|
13
|
+
schema: undefined;
|
|
14
|
+
columns: {
|
|
15
|
+
name: import("drizzle-orm/pg-core").PgColumn<{
|
|
16
|
+
name: "name";
|
|
17
|
+
tableName: `${string}definitions`;
|
|
18
|
+
dataType: "string";
|
|
19
|
+
columnType: "PgText";
|
|
20
|
+
data: string;
|
|
21
|
+
driverParam: string;
|
|
22
|
+
notNull: true;
|
|
23
|
+
hasDefault: false;
|
|
24
|
+
isPrimaryKey: true;
|
|
25
|
+
isAutoincrement: false;
|
|
26
|
+
hasRuntimeDefault: false;
|
|
27
|
+
enumValues: [string, ...string[]];
|
|
28
|
+
baseColumn: never;
|
|
29
|
+
identity: undefined;
|
|
30
|
+
generated: undefined;
|
|
31
|
+
}, {}, {}>;
|
|
32
|
+
kind: import("drizzle-orm/pg-core").PgColumn<{
|
|
33
|
+
name: "kind";
|
|
34
|
+
tableName: `${string}definitions`;
|
|
35
|
+
dataType: "string";
|
|
36
|
+
columnType: "PgText";
|
|
37
|
+
data: DefinitionKind;
|
|
38
|
+
driverParam: string;
|
|
39
|
+
notNull: false;
|
|
40
|
+
hasDefault: false;
|
|
41
|
+
isPrimaryKey: false;
|
|
42
|
+
isAutoincrement: false;
|
|
43
|
+
hasRuntimeDefault: false;
|
|
44
|
+
enumValues: [string, ...string[]];
|
|
45
|
+
baseColumn: never;
|
|
46
|
+
identity: undefined;
|
|
47
|
+
generated: undefined;
|
|
48
|
+
}, {}, {
|
|
49
|
+
$type: DefinitionKind;
|
|
50
|
+
}>;
|
|
51
|
+
active_version: import("drizzle-orm/pg-core").PgColumn<{
|
|
52
|
+
name: "active_version";
|
|
53
|
+
tableName: `${string}definitions`;
|
|
54
|
+
dataType: "number";
|
|
55
|
+
columnType: "PgInteger";
|
|
56
|
+
data: number;
|
|
57
|
+
driverParam: string | number;
|
|
58
|
+
notNull: false;
|
|
59
|
+
hasDefault: false;
|
|
60
|
+
isPrimaryKey: false;
|
|
61
|
+
isAutoincrement: false;
|
|
62
|
+
hasRuntimeDefault: false;
|
|
63
|
+
enumValues: undefined;
|
|
64
|
+
baseColumn: never;
|
|
65
|
+
identity: undefined;
|
|
66
|
+
generated: undefined;
|
|
67
|
+
}, {}, {}>;
|
|
68
|
+
latest_version: import("drizzle-orm/pg-core").PgColumn<{
|
|
69
|
+
name: "latest_version";
|
|
70
|
+
tableName: `${string}definitions`;
|
|
71
|
+
dataType: "number";
|
|
72
|
+
columnType: "PgInteger";
|
|
73
|
+
data: number;
|
|
74
|
+
driverParam: string | number;
|
|
75
|
+
notNull: false;
|
|
76
|
+
hasDefault: false;
|
|
77
|
+
isPrimaryKey: false;
|
|
78
|
+
isAutoincrement: false;
|
|
79
|
+
hasRuntimeDefault: false;
|
|
80
|
+
enumValues: undefined;
|
|
81
|
+
baseColumn: never;
|
|
82
|
+
identity: undefined;
|
|
83
|
+
generated: undefined;
|
|
84
|
+
}, {}, {}>;
|
|
85
|
+
draft: import("drizzle-orm/pg-core").PgColumn<{
|
|
86
|
+
name: "draft";
|
|
87
|
+
tableName: `${string}definitions`;
|
|
88
|
+
dataType: "json";
|
|
89
|
+
columnType: "PgJsonb";
|
|
90
|
+
data: unknown;
|
|
91
|
+
driverParam: unknown;
|
|
92
|
+
notNull: false;
|
|
93
|
+
hasDefault: false;
|
|
94
|
+
isPrimaryKey: false;
|
|
95
|
+
isAutoincrement: false;
|
|
96
|
+
hasRuntimeDefault: false;
|
|
97
|
+
enumValues: undefined;
|
|
98
|
+
baseColumn: never;
|
|
99
|
+
identity: undefined;
|
|
100
|
+
generated: undefined;
|
|
101
|
+
}, {}, {
|
|
102
|
+
$type: unknown;
|
|
103
|
+
}>;
|
|
104
|
+
draft_kind: import("drizzle-orm/pg-core").PgColumn<{
|
|
105
|
+
name: "draft_kind";
|
|
106
|
+
tableName: `${string}definitions`;
|
|
107
|
+
dataType: "string";
|
|
108
|
+
columnType: "PgText";
|
|
109
|
+
data: DefinitionKind;
|
|
110
|
+
driverParam: string;
|
|
111
|
+
notNull: false;
|
|
112
|
+
hasDefault: false;
|
|
113
|
+
isPrimaryKey: false;
|
|
114
|
+
isAutoincrement: false;
|
|
115
|
+
hasRuntimeDefault: false;
|
|
116
|
+
enumValues: [string, ...string[]];
|
|
117
|
+
baseColumn: never;
|
|
118
|
+
identity: undefined;
|
|
119
|
+
generated: undefined;
|
|
120
|
+
}, {}, {
|
|
121
|
+
$type: DefinitionKind;
|
|
122
|
+
}>;
|
|
123
|
+
draft_base: import("drizzle-orm/pg-core").PgColumn<{
|
|
124
|
+
name: "draft_base";
|
|
125
|
+
tableName: `${string}definitions`;
|
|
126
|
+
dataType: "number";
|
|
127
|
+
columnType: "PgInteger";
|
|
128
|
+
data: number;
|
|
129
|
+
driverParam: string | number;
|
|
130
|
+
notNull: false;
|
|
131
|
+
hasDefault: false;
|
|
132
|
+
isPrimaryKey: false;
|
|
133
|
+
isAutoincrement: false;
|
|
134
|
+
hasRuntimeDefault: false;
|
|
135
|
+
enumValues: undefined;
|
|
136
|
+
baseColumn: never;
|
|
137
|
+
identity: undefined;
|
|
138
|
+
generated: undefined;
|
|
139
|
+
}, {}, {}>;
|
|
140
|
+
draft_by: import("drizzle-orm/pg-core").PgColumn<{
|
|
141
|
+
name: "draft_by";
|
|
142
|
+
tableName: `${string}definitions`;
|
|
143
|
+
dataType: "string";
|
|
144
|
+
columnType: "PgText";
|
|
145
|
+
data: string;
|
|
146
|
+
driverParam: string;
|
|
147
|
+
notNull: false;
|
|
148
|
+
hasDefault: false;
|
|
149
|
+
isPrimaryKey: false;
|
|
150
|
+
isAutoincrement: false;
|
|
151
|
+
hasRuntimeDefault: false;
|
|
152
|
+
enumValues: [string, ...string[]];
|
|
153
|
+
baseColumn: never;
|
|
154
|
+
identity: undefined;
|
|
155
|
+
generated: undefined;
|
|
156
|
+
}, {}, {}>;
|
|
157
|
+
draft_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
158
|
+
name: "draft_at";
|
|
159
|
+
tableName: `${string}definitions`;
|
|
160
|
+
dataType: "date";
|
|
161
|
+
columnType: "PgTimestamp";
|
|
162
|
+
data: Date;
|
|
163
|
+
driverParam: string;
|
|
164
|
+
notNull: false;
|
|
165
|
+
hasDefault: false;
|
|
166
|
+
isPrimaryKey: false;
|
|
167
|
+
isAutoincrement: false;
|
|
168
|
+
hasRuntimeDefault: false;
|
|
169
|
+
enumValues: undefined;
|
|
170
|
+
baseColumn: never;
|
|
171
|
+
identity: undefined;
|
|
172
|
+
generated: undefined;
|
|
173
|
+
}, {}, {}>;
|
|
174
|
+
updated_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
175
|
+
name: "updated_at";
|
|
176
|
+
tableName: `${string}definitions`;
|
|
177
|
+
dataType: "date";
|
|
178
|
+
columnType: "PgTimestamp";
|
|
179
|
+
data: Date;
|
|
180
|
+
driverParam: string;
|
|
181
|
+
notNull: true;
|
|
182
|
+
hasDefault: false;
|
|
183
|
+
isPrimaryKey: false;
|
|
184
|
+
isAutoincrement: false;
|
|
185
|
+
hasRuntimeDefault: false;
|
|
186
|
+
enumValues: undefined;
|
|
187
|
+
baseColumn: never;
|
|
188
|
+
identity: undefined;
|
|
189
|
+
generated: undefined;
|
|
190
|
+
}, {}, {}>;
|
|
191
|
+
};
|
|
192
|
+
dialect: "pg";
|
|
193
|
+
}>;
|
|
194
|
+
versions: import("drizzle-orm/pg-core").PgTableWithColumns<{
|
|
195
|
+
name: `${string}definition_versions`;
|
|
196
|
+
schema: undefined;
|
|
197
|
+
columns: {
|
|
198
|
+
name: import("drizzle-orm/pg-core").PgColumn<{
|
|
199
|
+
name: "name";
|
|
200
|
+
tableName: `${string}definition_versions`;
|
|
201
|
+
dataType: "string";
|
|
202
|
+
columnType: "PgText";
|
|
203
|
+
data: string;
|
|
204
|
+
driverParam: string;
|
|
205
|
+
notNull: true;
|
|
206
|
+
hasDefault: false;
|
|
207
|
+
isPrimaryKey: false;
|
|
208
|
+
isAutoincrement: false;
|
|
209
|
+
hasRuntimeDefault: false;
|
|
210
|
+
enumValues: [string, ...string[]];
|
|
211
|
+
baseColumn: never;
|
|
212
|
+
identity: undefined;
|
|
213
|
+
generated: undefined;
|
|
214
|
+
}, {}, {}>;
|
|
215
|
+
version: import("drizzle-orm/pg-core").PgColumn<{
|
|
216
|
+
name: "version";
|
|
217
|
+
tableName: `${string}definition_versions`;
|
|
218
|
+
dataType: "number";
|
|
219
|
+
columnType: "PgInteger";
|
|
220
|
+
data: number;
|
|
221
|
+
driverParam: string | number;
|
|
222
|
+
notNull: true;
|
|
223
|
+
hasDefault: false;
|
|
224
|
+
isPrimaryKey: false;
|
|
225
|
+
isAutoincrement: false;
|
|
226
|
+
hasRuntimeDefault: false;
|
|
227
|
+
enumValues: undefined;
|
|
228
|
+
baseColumn: never;
|
|
229
|
+
identity: undefined;
|
|
230
|
+
generated: undefined;
|
|
231
|
+
}, {}, {}>;
|
|
232
|
+
kind: import("drizzle-orm/pg-core").PgColumn<{
|
|
233
|
+
name: "kind";
|
|
234
|
+
tableName: `${string}definition_versions`;
|
|
235
|
+
dataType: "string";
|
|
236
|
+
columnType: "PgText";
|
|
237
|
+
data: DefinitionKind;
|
|
238
|
+
driverParam: string;
|
|
239
|
+
notNull: true;
|
|
240
|
+
hasDefault: false;
|
|
241
|
+
isPrimaryKey: false;
|
|
242
|
+
isAutoincrement: false;
|
|
243
|
+
hasRuntimeDefault: false;
|
|
244
|
+
enumValues: [string, ...string[]];
|
|
245
|
+
baseColumn: never;
|
|
246
|
+
identity: undefined;
|
|
247
|
+
generated: undefined;
|
|
248
|
+
}, {}, {
|
|
249
|
+
$type: DefinitionKind;
|
|
250
|
+
}>;
|
|
251
|
+
definition: import("drizzle-orm/pg-core").PgColumn<{
|
|
252
|
+
name: "definition";
|
|
253
|
+
tableName: `${string}definition_versions`;
|
|
254
|
+
dataType: "json";
|
|
255
|
+
columnType: "PgJsonb";
|
|
256
|
+
data: Definition;
|
|
257
|
+
driverParam: unknown;
|
|
258
|
+
notNull: true;
|
|
259
|
+
hasDefault: false;
|
|
260
|
+
isPrimaryKey: false;
|
|
261
|
+
isAutoincrement: false;
|
|
262
|
+
hasRuntimeDefault: false;
|
|
263
|
+
enumValues: undefined;
|
|
264
|
+
baseColumn: never;
|
|
265
|
+
identity: undefined;
|
|
266
|
+
generated: undefined;
|
|
267
|
+
}, {}, {
|
|
268
|
+
$type: Definition;
|
|
269
|
+
}>;
|
|
270
|
+
hash: import("drizzle-orm/pg-core").PgColumn<{
|
|
271
|
+
name: "hash";
|
|
272
|
+
tableName: `${string}definition_versions`;
|
|
273
|
+
dataType: "string";
|
|
274
|
+
columnType: "PgText";
|
|
275
|
+
data: string;
|
|
276
|
+
driverParam: string;
|
|
277
|
+
notNull: true;
|
|
278
|
+
hasDefault: false;
|
|
279
|
+
isPrimaryKey: false;
|
|
280
|
+
isAutoincrement: false;
|
|
281
|
+
hasRuntimeDefault: false;
|
|
282
|
+
enumValues: [string, ...string[]];
|
|
283
|
+
baseColumn: never;
|
|
284
|
+
identity: undefined;
|
|
285
|
+
generated: undefined;
|
|
286
|
+
}, {}, {}>;
|
|
287
|
+
published_by: import("drizzle-orm/pg-core").PgColumn<{
|
|
288
|
+
name: "published_by";
|
|
289
|
+
tableName: `${string}definition_versions`;
|
|
290
|
+
dataType: "string";
|
|
291
|
+
columnType: "PgText";
|
|
292
|
+
data: string;
|
|
293
|
+
driverParam: string;
|
|
294
|
+
notNull: true;
|
|
295
|
+
hasDefault: false;
|
|
296
|
+
isPrimaryKey: false;
|
|
297
|
+
isAutoincrement: false;
|
|
298
|
+
hasRuntimeDefault: false;
|
|
299
|
+
enumValues: [string, ...string[]];
|
|
300
|
+
baseColumn: never;
|
|
301
|
+
identity: undefined;
|
|
302
|
+
generated: undefined;
|
|
303
|
+
}, {}, {}>;
|
|
304
|
+
published_at: import("drizzle-orm/pg-core").PgColumn<{
|
|
305
|
+
name: "published_at";
|
|
306
|
+
tableName: `${string}definition_versions`;
|
|
307
|
+
dataType: "date";
|
|
308
|
+
columnType: "PgTimestamp";
|
|
309
|
+
data: Date;
|
|
310
|
+
driverParam: string;
|
|
311
|
+
notNull: true;
|
|
312
|
+
hasDefault: false;
|
|
313
|
+
isPrimaryKey: false;
|
|
314
|
+
isAutoincrement: false;
|
|
315
|
+
hasRuntimeDefault: false;
|
|
316
|
+
enumValues: undefined;
|
|
317
|
+
baseColumn: never;
|
|
318
|
+
identity: undefined;
|
|
319
|
+
generated: undefined;
|
|
320
|
+
}, {}, {}>;
|
|
321
|
+
};
|
|
322
|
+
dialect: "pg";
|
|
323
|
+
}>;
|
|
324
|
+
};
|
|
325
|
+
export type DefinitionTables = ReturnType<typeof definitionTables>;
|
|
326
|
+
/** Any drizzle Postgres database (node-postgres, postgres.js, PGlite, Neon, …), whatever its schema. */
|
|
327
|
+
export type DefinitionsDatabase = PgDatabase<PgQueryResultHKT, any>;
|
|
328
|
+
export interface PgStorageOptions {
|
|
329
|
+
db: DefinitionsDatabase;
|
|
330
|
+
tables: DefinitionTables;
|
|
331
|
+
}
|
|
332
|
+
/** The storage port on the host's Postgres. */
|
|
333
|
+
export declare function pgStorage({ db, tables }: PgStorageOptions): DefinitionStorage;
|
|
334
|
+
export * from './index.js';
|
package/dist/pg.js
ADDED
|
@@ -0,0 +1,170 @@
|
|
|
1
|
+
import { and, asc, desc, eq, sql } from 'drizzle-orm';
|
|
2
|
+
import { integer, jsonb, pgTable, primaryKey, text, timestamp, } from 'drizzle-orm/pg-core';
|
|
3
|
+
export function definitionTables(options = {}) {
|
|
4
|
+
const prefix = options.prefix ?? 'baht_';
|
|
5
|
+
const at = () => timestamp({ withTimezone: true });
|
|
6
|
+
const heads = pgTable(`${prefix}definitions`, {
|
|
7
|
+
name: text().primaryKey(),
|
|
8
|
+
kind: text().$type(),
|
|
9
|
+
active_version: integer(),
|
|
10
|
+
latest_version: integer(),
|
|
11
|
+
draft: jsonb().$type(),
|
|
12
|
+
draft_kind: text().$type(),
|
|
13
|
+
draft_base: integer(),
|
|
14
|
+
draft_by: text(),
|
|
15
|
+
draft_at: at(),
|
|
16
|
+
updated_at: at().notNull(),
|
|
17
|
+
});
|
|
18
|
+
const versions = pgTable(`${prefix}definition_versions`, {
|
|
19
|
+
name: text()
|
|
20
|
+
.notNull()
|
|
21
|
+
.references(() => heads.name),
|
|
22
|
+
version: integer().notNull(),
|
|
23
|
+
kind: text().$type().notNull(),
|
|
24
|
+
definition: jsonb().$type().notNull(),
|
|
25
|
+
hash: text().notNull(),
|
|
26
|
+
published_by: text().notNull(),
|
|
27
|
+
published_at: at().notNull(),
|
|
28
|
+
}, (table) => [primaryKey({ columns: [table.name, table.version] })]);
|
|
29
|
+
return { heads, versions };
|
|
30
|
+
}
|
|
31
|
+
export function pgStorage({ db, tables }) {
|
|
32
|
+
const { heads, versions } = tables;
|
|
33
|
+
const toVersion = (row) => ({
|
|
34
|
+
...row,
|
|
35
|
+
published_at: row.published_at.toISOString(),
|
|
36
|
+
});
|
|
37
|
+
const one = async (where) => {
|
|
38
|
+
const [row] = await db.select().from(versions).where(where).limit(1);
|
|
39
|
+
return row && toVersion(row);
|
|
40
|
+
};
|
|
41
|
+
const pointer = async (name, column) => {
|
|
42
|
+
const [head] = await db.select().from(heads).where(eq(heads.name, name));
|
|
43
|
+
const version = head?.[column];
|
|
44
|
+
return version == null
|
|
45
|
+
? undefined
|
|
46
|
+
: one(and(eq(versions.name, name), eq(versions.version, version)));
|
|
47
|
+
};
|
|
48
|
+
return {
|
|
49
|
+
async list() {
|
|
50
|
+
const rows = await db.select().from(heads).orderBy(asc(heads.name));
|
|
51
|
+
return rows.map((head) => ({
|
|
52
|
+
name: head.name,
|
|
53
|
+
kind: head.kind ?? head.draft_kind,
|
|
54
|
+
active: head.active_version,
|
|
55
|
+
latest: head.latest_version,
|
|
56
|
+
draft: head.draft_at !== null,
|
|
57
|
+
updated_at: head.updated_at.toISOString(),
|
|
58
|
+
}));
|
|
59
|
+
},
|
|
60
|
+
async draft(name) {
|
|
61
|
+
const [head] = await db.select().from(heads).where(eq(heads.name, name));
|
|
62
|
+
if (!head?.draft_at)
|
|
63
|
+
return undefined;
|
|
64
|
+
return {
|
|
65
|
+
name,
|
|
66
|
+
kind: head.draft_kind,
|
|
67
|
+
definition: head.draft,
|
|
68
|
+
base: head.draft_base,
|
|
69
|
+
saved_by: head.draft_by ?? '',
|
|
70
|
+
saved_at: head.draft_at.toISOString(),
|
|
71
|
+
};
|
|
72
|
+
},
|
|
73
|
+
async saveDraft(draft) {
|
|
74
|
+
const at = new Date(draft.saved_at);
|
|
75
|
+
const values = {
|
|
76
|
+
draft: draft.definition,
|
|
77
|
+
draft_kind: draft.kind,
|
|
78
|
+
draft_base: draft.base,
|
|
79
|
+
draft_by: draft.saved_by,
|
|
80
|
+
draft_at: at,
|
|
81
|
+
updated_at: at,
|
|
82
|
+
};
|
|
83
|
+
await db
|
|
84
|
+
.insert(heads)
|
|
85
|
+
.values({ name: draft.name, ...values })
|
|
86
|
+
.onConflictDoUpdate({ target: heads.name, set: values });
|
|
87
|
+
},
|
|
88
|
+
async dropDraft(name) {
|
|
89
|
+
const cleared = await db
|
|
90
|
+
.update(heads)
|
|
91
|
+
.set({ draft: null, draft_kind: null, draft_base: null, draft_by: null, draft_at: null })
|
|
92
|
+
.where(and(eq(heads.name, name), sql `${heads.draft_at} is not null`))
|
|
93
|
+
.returning({ name: heads.name });
|
|
94
|
+
return cleared.length > 0;
|
|
95
|
+
},
|
|
96
|
+
version: (name, version) => one(and(eq(versions.name, name), eq(versions.version, version))),
|
|
97
|
+
active: (name) => pointer(name, 'active_version'),
|
|
98
|
+
latest: (name) => pointer(name, 'latest_version'),
|
|
99
|
+
async versions(name) {
|
|
100
|
+
const [head] = await db.select().from(heads).where(eq(heads.name, name));
|
|
101
|
+
const rows = await db
|
|
102
|
+
.select({
|
|
103
|
+
name: versions.name,
|
|
104
|
+
version: versions.version,
|
|
105
|
+
kind: versions.kind,
|
|
106
|
+
hash: versions.hash,
|
|
107
|
+
published_by: versions.published_by,
|
|
108
|
+
published_at: versions.published_at,
|
|
109
|
+
})
|
|
110
|
+
.from(versions)
|
|
111
|
+
.where(eq(versions.name, name))
|
|
112
|
+
.orderBy(desc(versions.version));
|
|
113
|
+
return rows.map((row) => ({
|
|
114
|
+
...row,
|
|
115
|
+
published_at: row.published_at.toISOString(),
|
|
116
|
+
active: row.version === head?.active_version,
|
|
117
|
+
}));
|
|
118
|
+
},
|
|
119
|
+
append(entry) {
|
|
120
|
+
const at = new Date(entry.at);
|
|
121
|
+
return db.transaction(async (tx) => {
|
|
122
|
+
await tx
|
|
123
|
+
.insert(heads)
|
|
124
|
+
.values({ name: entry.name, updated_at: at })
|
|
125
|
+
.onConflictDoNothing({ target: heads.name });
|
|
126
|
+
const [head] = await tx
|
|
127
|
+
.select({ latest: heads.latest_version })
|
|
128
|
+
.from(heads)
|
|
129
|
+
.where(eq(heads.name, entry.name))
|
|
130
|
+
.for('update');
|
|
131
|
+
const version = (head?.latest ?? 0) + 1;
|
|
132
|
+
const [row] = await tx
|
|
133
|
+
.insert(versions)
|
|
134
|
+
.values({
|
|
135
|
+
name: entry.name,
|
|
136
|
+
version,
|
|
137
|
+
kind: entry.kind,
|
|
138
|
+
definition: entry.definition,
|
|
139
|
+
hash: entry.hash,
|
|
140
|
+
published_by: entry.by,
|
|
141
|
+
published_at: at,
|
|
142
|
+
})
|
|
143
|
+
.returning();
|
|
144
|
+
const draft = entry.dropDraft
|
|
145
|
+
? { draft: null, draft_kind: null, draft_base: null, draft_by: null, draft_at: null }
|
|
146
|
+
: {};
|
|
147
|
+
await tx
|
|
148
|
+
.update(heads)
|
|
149
|
+
.set({
|
|
150
|
+
kind: entry.kind,
|
|
151
|
+
latest_version: version,
|
|
152
|
+
updated_at: at,
|
|
153
|
+
...(entry.activate ? { active_version: version } : {}),
|
|
154
|
+
...draft,
|
|
155
|
+
})
|
|
156
|
+
.where(eq(heads.name, entry.name));
|
|
157
|
+
return toVersion(row);
|
|
158
|
+
});
|
|
159
|
+
},
|
|
160
|
+
async activate(name, version, at) {
|
|
161
|
+
const moved = await db
|
|
162
|
+
.update(heads)
|
|
163
|
+
.set({ active_version: version, updated_at: new Date(at) })
|
|
164
|
+
.where(and(eq(heads.name, name), sql `exists (select 1 from ${versions} where ${versions.name} = ${name} and ${versions.version} = ${version})`))
|
|
165
|
+
.returning({ name: heads.name });
|
|
166
|
+
return moved.length > 0;
|
|
167
|
+
},
|
|
168
|
+
};
|
|
169
|
+
}
|
|
170
|
+
export * from './index.js';
|
package/dist/seed.d.ts
ADDED
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
import type { Definitions } from './types.js';
|
|
2
|
+
/** One definition to seed: the name it is kept under, and its JSON. */
|
|
3
|
+
export interface SeedEntry {
|
|
4
|
+
name: string;
|
|
5
|
+
definition: unknown;
|
|
6
|
+
}
|
|
7
|
+
export interface SeedReport {
|
|
8
|
+
/** Published as version 1 and activated. */
|
|
9
|
+
seeded: string[];
|
|
10
|
+
/** Already in storage: left as they are (storage is the source of truth once seeded). */
|
|
11
|
+
kept: string[];
|
|
12
|
+
refused: {
|
|
13
|
+
name: string;
|
|
14
|
+
message: string;
|
|
15
|
+
}[];
|
|
16
|
+
}
|
|
17
|
+
/**
|
|
18
|
+
* Puts the copies kept in code into storage, once: a name that has any version is left alone,
|
|
19
|
+
* so an edit published from the builder is never overwritten by the seed on the next start.
|
|
20
|
+
*/
|
|
21
|
+
export declare function seed(definitions: Definitions, entries: readonly SeedEntry[], { by }?: {
|
|
22
|
+
by?: string;
|
|
23
|
+
}): Promise<SeedReport>;
|
package/dist/seed.js
ADDED
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
export async function seed(definitions, entries, { by = 'seed' } = {}) {
|
|
2
|
+
const report = { seeded: [], kept: [], refused: [] };
|
|
3
|
+
for (const { name, definition } of entries) {
|
|
4
|
+
if ((await definitions.versions(name)).length > 0) {
|
|
5
|
+
report.kept.push(name);
|
|
6
|
+
continue;
|
|
7
|
+
}
|
|
8
|
+
const published = await definitions.publish(name, { by, activate: true, definition });
|
|
9
|
+
if (published.ok)
|
|
10
|
+
report.seeded.push(name);
|
|
11
|
+
else
|
|
12
|
+
report.refused.push({ name, message: published.message });
|
|
13
|
+
}
|
|
14
|
+
return report;
|
|
15
|
+
}
|