@snolla/data 0.0.0-stage → 1.0.7

package/dist/schema/generated/kysely-types.js

@@ -0,0 +1,5 @@
+// GENERATED from the canonical schema — do not edit; run schema/generate.mjs
+//
+// Row types for Kysely plus the `Database` interface. Decimals and datetimes
+// are strings (exactness first, plan:49 Q4); optional columns admit null.
+export {};

package/dist/schema/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dsl.ts';
+export { canonicalSchema } from './tables.ts';

package/dist/schema/index.js

@@ -0,0 +1,7 @@
+// Public entry point of the canonical schema (task:3812).
+//
+// Consumers: the code generators (task:3820 — Kysely types, per-dialect DDL,
+// Prisma bridge), the access-layer guard (task:3813) and the site transfer tool
+// (task:3825). Import from here, never reach into `tables.ts` directly.
+export * from "./dsl.js";
+export { canonicalSchema } from "./tables.js";

package/dist/schema/provision.d.mts

@@ -0,0 +1,11 @@
+export const CANON_TABLES: string[];
+export function canonTablesIn(db: any, dialect: any): Promise<string[]>;
+export function applyCanonDdl({ db, dialect, force }: {
+    db: import("kysely").Kysely<any>;
+    dialect: "postgres" | "mariadb" | "sqlite" | "mssql";
+    force?: boolean;
+}): Promise<{
+    dialect: "postgres" | "mariadb" | "sqlite" | "mssql";
+    created: string[];
+    existing: string[];
+}>;

package/dist/schema/provision.mjs

@@ -0,0 +1,111 @@
+// Canon DDL into an empty cell (task:4001, the tail of the cutover rehearsal
+// [[concepts/cutover-rehearsal-live]]).
+//
+// Provisioning a cell is two commands: this one lays the schema, `site import
+// --provision` adds the control rows a bundle cannot carry. Step one used to be a
+// script somebody ran by hand (`renderDdlSql` + `psql -f`); when they forgot, the
+// import died on `relation "Accounts" does not exist`.
+//
+// The DDL is the *generated* one — the same text the stands and the tests execute —
+// so there is no second generator, and the catalog is asked what it already holds
+// instead of assuming. Three outcomes, no fourth:
+//
+//   empty database    → every canon table is created;
+//   fully provisioned → nothing is executed and the report says so (idempotent);
+//   anything else     → refused before the first statement, unless `force` says
+//                       "top up": then only the missing tables are created and the
+//                       tables that were already there are left exactly as they are.
+//
+// Statements are grouped by the table they belong to (`create table T`, `create
+// index … on T`, `alter table T …`), which is how a top-up skips a table without
+// the generator having to emit per-table pieces.
+import { sql } from 'kysely';
+import { renderDdlSql } from './generate.mjs';
+import { canonicalSchema } from "./index.js";
+export const CANON_TABLES = canonicalSchema.tables.map((table) => table.name);
+/** Each dialect's own catalog — one query, one column, no driver-specific API. */
+const CATALOG = {
+    postgres: 'select table_name as name from information_schema.tables where table_schema = current_schema()',
+    mariadb: 'select table_name as name from information_schema.tables where table_schema = database()',
+    mssql: "select table_name as name from information_schema.tables where table_type = 'BASE TABLE'",
+    sqlite: "select name from sqlite_master where type = 'table'",
+};
+/** Every table the database holds, canon or not, compared by lowercase name. */
+const tableNames = async (db, dialect) => {
+    const query = CATALOG[dialect];
+    if (!query)
+        throw new Error(`canon-provision: unsupported dialect "${dialect}" (${Object.keys(CATALOG).join(', ')})`);
+    const { rows } = await sql.raw(query).execute(db);
+    return rows.map((row) => String(row.name ?? row.NAME ?? row.Name).toLowerCase());
+};
+/** The canon tables this database already holds, in canon order. */
+export const canonTablesIn = async (db, dialect) => {
+    const present = new Set(await tableNames(db, dialect));
+    return CANON_TABLES.filter((name) => present.has(name.toLowerCase()));
+};
+/** The generated DDL as statements; the header comments are not statements. */
+const statementsOf = (dialect) => renderDdlSql(dialect)
+    .split('\n')
+    .filter((line) => !line.trim().startsWith('--'))
+    .join('\n')
+    .split(/;\s*\n/)
+    .map((part) => part.trim())
+    .filter(Boolean);
+/** The table a statement belongs to — null for anything that names no table. */
+const ownerOf = (statement) => {
+    const match = /^create\s+table\s+(?:if\s+not\s+exists\s+)?([^\s(]+)/im.exec(statement) ??
+        /^create\s+(?:unique\s+)?index\s+\S+\s+on\s+([^\s(]+)/im.exec(statement) ??
+        /^alter\s+table\s+(\S+)/im.exec(statement);
+    // quoted identifiers ("T", `T`, [T]) and a schema prefix are not part of the name
+    return match ? match[1].replace(/["`[\]]/g, '').replace(/^.*\./, '').toLowerCase() : null;
+};
+/**
+ * Applies the canon DDL to an open database. Reports what it created and what was
+ * already there; touches nothing outside the canon tables it had to create.
+ *
+ * @param {object} options
+ * @param {import('kysely').Kysely<any>} options.db  an open Kysely handle on the target
+ * @param {'postgres'|'mariadb'|'sqlite'|'mssql'} options.dialect  which generated DDL to run
+ * @param {boolean} [options.force]  top up a database that already holds tables
+ */
+export const applyCanonDdl = async ({ db, dialect, force = false }) => {
+    const present = await tableNames(db, dialect);
+    const there = new Set(present);
+    const existing = CANON_TABLES.filter((name) => there.has(name.toLowerCase()));
+    if (existing.length === CANON_TABLES.length)
+        return { dialect, created: [], existing };
+    if (present.length > 0 && !force) {
+        const named = existing.length
+            ? ` — ${existing.length} of the canon tables are already among them: ${existing.slice(0, 3).join(', ')}${existing.length > 3 ? ', …' : ''}`
+            : '';
+        throw new Error(`canon-provision: the target is not empty — it holds ${present.length} table(s)${named}; ` +
+            'the canon DDL goes into an empty database only (--force creates just the missing tables)');
+    }
+    const statements = statementsOf(dialect).filter((statement) => {
+        const owner = ownerOf(statement);
+        return !owner || !there.has(owner);
+    });
+    // SQLite commits every statement on its own (an fsync per commit: measured ~78ms) —
+    // one transaction turns the whole canon from ~20s into ~0.1s. Postgres and MariaDB
+    // run without one: a pooled handle does not promise the same connection for a raw
+    // `begin`, and their round trips are cheap.
+    const transactional = dialect === 'sqlite';
+    if (transactional)
+        await sql.raw('begin').execute(db);
+    try {
+        for (const statement of statements)
+            await sql.raw(statement).execute(db);
+        if (transactional)
+            await sql.raw('commit').execute(db);
+    }
+    catch (error) {
+        if (transactional)
+            await sql.raw('rollback').execute(db).catch(() => { });
+        throw error;
+    }
+    // the catalog is the answer, not the statement count: the run also creates
+    // indexes and constraints, and only tables that were missing are "created"
+    const after = new Set(await tableNames(db, dialect));
+    const created = CANON_TABLES.filter((name) => !there.has(name.toLowerCase()) && after.has(name.toLowerCase()));
+    return { dialect, created, existing };
+};

package/dist/schema/tables.d.ts

@@ -0,0 +1,2 @@
+import type { CanonSchema } from './dsl.ts';
+export declare const canonicalSchema: CanonSchema;