@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/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
+ }
@@ -0,0 +1,2 @@
1
+ import type { Definitions, DefinitionsOptions } from './types.js';
2
+ export declare function createDefinitions(options: DefinitionsOptions): Definitions;