@pikku/cli 0.12.128 → 0.12.133

package/dist/src/functions/db/db-migrator.d.ts

@@ -1,63 +0,0 @@
-/**
- * The migrator's own bookkeeping table, which belongs to no dialect and to no
- * project's schema.
- *
- * Every introspector hides it for that reason. Leaving it visible on one
- * dialect and not the other is not cosmetic: a schema source exported from a
- * database that has been migrated would publish `sql_migrations` as one of its
- * own tables, and the consumer — which also has it — would then read the source
- * as partially covered and emit column deltas instead of the source's own SQL,
- * silently dropping its primary keys, indexes and constraints.
- */
-export declare const MIGRATION_TRACKING_TABLE = "sql_migrations";
-export declare class MigrationDriftError extends Error {
-    readonly file: string;
-    readonly recordedHash: string;
-    readonly currentHash: string | null;
-    readonly appliedAt: string;
-    constructor(file: string, recordedHash: string, currentHash: string | null, appliedAt: string, migrationsDir: string);
-}
-export interface MigrateResult {
-    applied: string[];
-    skipped: string[];
-}
-export interface AppliedMigration {
-    name: string;
-    hash: string;
-    applied_at: string;
-}
-/**
- * Provider-agnostic migration executor. Implement this for each DB dialect.
- * Each method maps to a single DB operation; all file I/O and hashing lives
- * in the shared `migrate()` function above.
- */
-export interface MigrationExecutor {
-    ensureTrackingTable(): Promise<void>;
-    getApplied(): Promise<AppliedMigration[]>;
-    runMigration(sql: string, name: string, hash: string): Promise<void>;
-    /**
-     * Record a migration as applied without running its SQL.
-     *
-     * For a database that already contains what the migration describes, because
-     * something created those tables before anyone wrote them down. Only ever
-     * called once the caller has confirmed that is actually true — recording a
-     * migration whose tables are absent leaves a database permanently behind with
-     * no pending migration to reveal it.
-     */
-    recordMigration(name: string, hash: string): Promise<void>;
-}
-export declare function migrate(executor: MigrationExecutor, migrationsDir: string): Promise<MigrateResult>;
-/**
- * Record every pending migration as applied, without running any of it.
- *
- * The escape hatch for a database that already has the tables a migration
- * creates — the shape you get when a runtime bootstrapped its own schema at
- * boot and the migration writing it down was authored afterwards. Running that
- * migration would fail on every existing deployment; skipping it forever would
- * leave the history lying. Recording it says what is true.
- *
- * Deliberately unconditional here. Whether the database really does match is a
- * question about schemas, not migration files, so the caller answers it first
- * and this only runs once it has.
- */
-export declare function baselineMigrations(executor: MigrationExecutor, migrationsDir: string): Promise<string[]>;

package/dist/src/functions/db/db-migrator.js

@@ -1,136 +0,0 @@
-import { createHash } from 'node:crypto';
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { assertSnakeCaseIdentifiers } from './migration-identifiers.js';
-/**
- * The migrator's own bookkeeping table, which belongs to no dialect and to no
- * project's schema.
- *
- * Every introspector hides it for that reason. Leaving it visible on one
- * dialect and not the other is not cosmetic: a schema source exported from a
- * database that has been migrated would publish `sql_migrations` as one of its
- * own tables, and the consumer — which also has it — would then read the source
- * as partially covered and emit column deltas instead of the source's own SQL,
- * silently dropping its primary keys, indexes and constraints.
- */
-export const MIGRATION_TRACKING_TABLE = 'sql_migrations';
-export class MigrationDriftError extends Error {
-    file;
-    recordedHash;
-    currentHash;
-    appliedAt;
-    constructor(file, recordedHash, currentHash, appliedAt, migrationsDir) {
-        const onDisk = currentHash === null
-            ? 'file missing on disk'
-            : `sha256:${currentHash.slice(0, 8)}…`;
-        super(`[PKU-DB-DRIFT] ${migrationsDir}/${file}\n\n` +
-            `Migration content has changed since it was applied.\n` +
-            `  recorded:  sha256:${recordedHash.slice(0, 8)}…  applied ${appliedAt}\n` +
-            `  on disk:   ${onDisk}\n\n` +
-            `If this edit was intentional, write a new forward migration to revert the change.\n` +
-            `Production migrations are immutable.`);
-        this.file = file;
-        this.recordedHash = recordedHash;
-        this.currentHash = currentHash;
-        this.appliedAt = appliedAt;
-        this.name = 'MigrationDriftError';
-    }
-}
-function sha256(bytes) {
-    return createHash('sha256').update(bytes).digest('hex');
-}
-/**
- * Apply pending migrations from `migrationsDir/*.sql` using the supplied
- * executor. Hashes raw file bytes on apply; subsequent runs re-hash and bail
- * with `MigrationDriftError` if any applied file has changed on disk.
- */
-/**
- * The migrations on disk, or none.
- *
- * A project that has never generated a migration has no directory to read, and
- * that is the ordinary first-run state rather than a failure — it is precisely
- * the project `db generate` exists to serve.
- */
-const migrationFiles = (migrationsDir) => existsSync(migrationsDir)
-    ? readdirSync(migrationsDir)
-        .filter((f) => f.endsWith('.sql'))
-        .sort()
-    : [];
-/**
- * Re-hash every applied migration and bail if one has changed on disk.
- *
- * Applies to baselining as much as to migrating: recording a file as applied
- * only means anything if the file is still the one that was applied.
- */
-function assertNoDrift(applied, migrationsDir) {
-    for (const row of applied) {
-        let currentHash = null;
-        try {
-            currentHash = sha256(readFileSync(join(migrationsDir, row.name)));
-        }
-        catch {
-            currentHash = null;
-        }
-        if (currentHash !== row.hash) {
-            throw new MigrationDriftError(row.name, row.hash, currentHash, row.applied_at, migrationsDir);
-        }
-    }
-}
-/**
- * Every migration on disk, read once.
- *
- * The identifier check reads all of them and not just the pending ones, so that
- * whether a migration is rejected depends on the files alone. A camelCase
- * column that had already been applied somewhere would otherwise pass on that
- * machine and fail on a fresh checkout, which is the opposite of deterministic.
- */
-const readMigrations = (migrationsDir) => migrationFiles(migrationsDir).map((name) => ({
-    name,
-    sql: readFileSync(join(migrationsDir, name), 'utf8'),
-}));
-export async function migrate(executor, migrationsDir) {
-    assertSnakeCaseIdentifiers(readMigrations(migrationsDir));
-    await executor.ensureTrackingTable();
-    const applied = await executor.getApplied();
-    assertNoDrift(applied, migrationsDir);
-    const appliedNames = new Set(applied.map((r) => r.name));
-    const result = { applied: [], skipped: [] };
-    for (const name of migrationFiles(migrationsDir)) {
-        if (appliedNames.has(name)) {
-            result.skipped.push(name);
-            continue;
-        }
-        const raw = readFileSync(join(migrationsDir, name));
-        const hash = sha256(raw);
-        await executor.runMigration(raw.toString('utf8'), name, hash);
-        result.applied.push(name);
-    }
-    return result;
-}
-/**
- * Record every pending migration as applied, without running any of it.
- *
- * The escape hatch for a database that already has the tables a migration
- * creates — the shape you get when a runtime bootstrapped its own schema at
- * boot and the migration writing it down was authored afterwards. Running that
- * migration would fail on every existing deployment; skipping it forever would
- * leave the history lying. Recording it says what is true.
- *
- * Deliberately unconditional here. Whether the database really does match is a
- * question about schemas, not migration files, so the caller answers it first
- * and this only runs once it has.
- */
-export async function baselineMigrations(executor, migrationsDir) {
-    await executor.ensureTrackingTable();
-    const applied = await executor.getApplied();
-    assertNoDrift(applied, migrationsDir);
-    const appliedNames = new Set(applied.map((r) => r.name));
-    const recorded = [];
-    for (const name of migrationFiles(migrationsDir)) {
-        if (appliedNames.has(name))
-            continue;
-        await executor.recordMigration(name, sha256(readFileSync(join(migrationsDir, name))));
-        recorded.push(name);
-    }
-    return recorded;
-}

package/dist/src/functions/db/migration-identifiers.d.ts

@@ -1,58 +0,0 @@
-/**
- * Catching camelCase columns at migrate time, before they can half-work.
- *
- * Pikku's Kysely runs with `CamelCasePlugin`, so `priceCents` in TypeScript is
- * `price_cents` in SQL and nothing else. A migration that declares the column
- * *as* `priceCents` is not merely unconventional — it is broken in the one way
- * that hides itself: `.selectAll()` compiles to `SELECT *` and never names an
- * identifier, so the table reads back perfectly, while the first query that
- * names the column (`.select(['animal.priceCents'])`) asks for `price_cents`
- * and gets `no such column`. The usual conclusion is that the plugin is broken,
- * and the usual response is a raw `sql` template or a retreat to `.selectAll()`
- * — both of which keep the real cause alive.
- *
- * There is no exception to escape. Even the Better Auth schema `db generate`
- * writes is snake_case (`email_verified`, `user_id`), because Better Auth is
- * handed the app's own Kysely and its camelCase field names compile the same
- * way everyone else's do.
- */
-/** A camelCase identifier a migration declares, and what it should have said. */
-export interface CamelCaseIdentifier {
-    file: string;
-    table: string;
-    /** `null` when the table name itself is the offender. */
-    column: string | null;
-    suggestion: string;
-}
-export declare class CamelCaseIdentifierError extends Error {
-    readonly offenders: CamelCaseIdentifier[];
-    constructor(offenders: CamelCaseIdentifier[]);
-}
-/**
- * Strip comments so a word in prose can never be read as an identifier.
- *
- * `splitStatements` already skips over comments when it looks for a boundary,
- * but it hands back the statement with them still in it, and `-- the userId
- * column` would otherwise be flagged. Quoting rules are honoured for the same
- * reason they are there: `'a -- b'` is a string, not a comment.
- */
-export declare function stripSqlComments(sql: string): string;
-/**
- * Every camelCase identifier one migration file declares.
- *
- * Only declarations are read — a `CREATE TABLE` column list and an `ALTER TABLE
- * … ADD COLUMN`. Everywhere else an identifier merely refers to something that
- * was declared somewhere, and reporting those would name the same mistake once
- * per reference while adding nothing to the fix.
- */
-export declare function findCamelCaseIdentifiers(file: string, sql: string): CamelCaseIdentifier[];
-/**
- * Bail unless every migration on disk is snake_case throughout.
- *
- * Reports all of them at once: a camelCase column is rarely alone, and a
- * one-at-a-time failure turns a single edit into one migrate run per column.
- */
-export declare function assertSnakeCaseIdentifiers(migrations: Array<{
-    name: string;
-    sql: string;
-}>): void;

package/dist/src/functions/db/migration-identifiers.js

@@ -1,262 +0,0 @@
-/**
- * Catching camelCase columns at migrate time, before they can half-work.
- *
- * Pikku's Kysely runs with `CamelCasePlugin`, so `priceCents` in TypeScript is
- * `price_cents` in SQL and nothing else. A migration that declares the column
- * *as* `priceCents` is not merely unconventional — it is broken in the one way
- * that hides itself: `.selectAll()` compiles to `SELECT *` and never names an
- * identifier, so the table reads back perfectly, while the first query that
- * names the column (`.select(['animal.priceCents'])`) asks for `price_cents`
- * and gets `no such column`. The usual conclusion is that the plugin is broken,
- * and the usual response is a raw `sql` template or a retreat to `.selectAll()`
- * — both of which keep the real cause alive.
- *
- * There is no exception to escape. Even the Better Auth schema `db generate`
- * writes is snake_case (`email_verified`, `user_id`), because Better Auth is
- * handed the app's own Kysely and its camelCase field names compile the same
- * way everyone else's do.
- */
-import { splitStatements } from './schema-sql.js';
-export class CamelCaseIdentifierError extends Error {
-    offenders;
-    constructor(offenders) {
-        const lines = offenders.map((o) => `  ${o.file}  ${o.column === null ? o.table : `${o.table}.${o.column}`}  →  ${o.suggestion}`);
-        super(`[PKU-DB-CAMEL] Migrations declare camelCase identifiers.\n\n` +
-            `Pikku's Kysely runs with CamelCasePlugin, which maps camelCase in TypeScript\n` +
-            `to snake_case in SQL. A camelCase column half-works: \`.selectAll()\` emits\n` +
-            `\`SELECT *\` so the table reads fine, but naming the column compiles it to\n` +
-            `snake_case and the database answers \`no such column\`.\n\n` +
-            `${lines.join('\n')}\n\n` +
-            `Fix the column definition in the migration file itself and replay your dev\n` +
-            `database from scratch. Do not write a RENAME COLUMN migration — that leaves\n` +
-            `the banned identifier in a SQL file forever.`);
-        this.offenders = offenders;
-        this.name = 'CamelCaseIdentifierError';
-    }
-}
-/**
- * Strip comments so a word in prose can never be read as an identifier.
- *
- * `splitStatements` already skips over comments when it looks for a boundary,
- * but it hands back the statement with them still in it, and `-- the userId
- * column` would otherwise be flagged. Quoting rules are honoured for the same
- * reason they are there: `'a -- b'` is a string, not a comment.
- */
-export function stripSqlComments(sql) {
-    let out = '';
-    let i = 0;
-    while (i < sql.length) {
-        const ch = sql[i];
-        if (ch === "'" || ch === '"' || ch === '`') {
-            const start = i;
-            i++;
-            while (i < sql.length) {
-                if (sql[i] === '\\' && ch === "'") {
-                    i += 2;
-                    continue;
-                }
-                if (sql[i] === ch) {
-                    if (sql[i + 1] === ch) {
-                        i += 2;
-                        continue;
-                    }
-                    i++;
-                    break;
-                }
-                i++;
-            }
-            out += sql.slice(start, i);
-            continue;
-        }
-        if (ch === '-' && sql[i + 1] === '-') {
-            const end = sql.indexOf('\n', i);
-            i = end === -1 ? sql.length : end;
-            continue;
-        }
-        if (ch === '/' && sql[i + 1] === '*') {
-            const end = sql.indexOf('*/', i + 2);
-            i = end === -1 ? sql.length : end + 2;
-            // A block comment can span lines, and removing it outright would join two
-            // statements onto one line. A space keeps the tokens either side apart.
-            out += ' ';
-            continue;
-        }
-        out += ch;
-        i++;
-    }
-    return out;
-}
-const IDENTIFIER = String.raw `"[^"]*"|\`[^\`]*\`|\[[^\]]*\]|[A-Za-z_][A-Za-z_0-9$]*`;
-const CREATE_TABLE = new RegExp(String.raw `^CREATE\s+(?:TEMP(?:ORARY)?\s+|UNLOGGED\s+)*TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\S+?)\s*\(`, 'i');
-const ALTER_TABLE = new RegExp(String.raw `^ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:ONLY\s+)?(\S+)`, 'i');
-const ADD_COLUMN = new RegExp(String.raw `^\s*ADD\s+(?:COLUMN\s+)?(?:IF\s+NOT\s+EXISTS\s+)?(${IDENTIFIER})`, 'i');
-const COLUMN_NAME = new RegExp(String.raw `^\s*(${IDENTIFIER})`);
-/**
- * The words that open a table-level constraint rather than a column.
- *
- * Only consulted for an unquoted first token: `"check"` in quotes is a column
- * named check, however unwise, and skipping it would let `"checkedAt"`'s
- * neighbours hide behind it.
- */
-const CONSTRAINT_KEYWORDS = new Set([
-    'constraint',
-    'primary',
-    'foreign',
-    'unique',
-    'check',
-    'exclude',
-    'index',
-    'key',
-    'like',
-    'period',
-    'fulltext',
-    'spatial',
-]);
-/** Drop the quoting a dialect happens to use, leaving the identifier itself. */
-const unquote = (name) => /^["`[]/.test(name) ? name.slice(1, -1) : name;
-const isCamelCase = (name) => /[a-z][A-Z]/.test(name);
-const toSnakeCase = (name) => name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
-/**
- * Walk `sql` from `from` and return the offsets just inside and just outside
- * the parenthesised group that starts there, or `null` if it never closes.
- *
- * Quote-aware, because a `)` inside `DEFAULT ')'` closes nothing.
- */
-function parenSpan(sql, from) {
-    let depth = 0;
-    let i = from;
-    while (i < sql.length) {
-        const ch = sql[i];
-        if (ch === "'" || ch === '"' || ch === '`') {
-            i++;
-            while (i < sql.length && sql[i] !== ch)
-                i++;
-            i++;
-            continue;
-        }
-        if (ch === '(') {
-            depth++;
-            if (depth === 1)
-                from = i + 1;
-        }
-        else if (ch === ')') {
-            depth--;
-            if (depth === 0)
-                return { start: from, end: i };
-        }
-        i++;
-    }
-    return null;
-}
-/**
- * Split a definition list on the commas that separate its items.
- *
- * The commas inside `NUMERIC(10,2)`, a `CHECK (x IN ('a','b'))` or a compound
- * `PRIMARY KEY (a, b)` belong to those and not to the list, so only depth zero
- * counts.
- */
-function splitTopLevel(list) {
-    const items = [];
-    let depth = 0;
-    let start = 0;
-    let i = 0;
-    while (i < list.length) {
-        const ch = list[i];
-        if (ch === "'" || ch === '"' || ch === '`') {
-            i++;
-            while (i < list.length && list[i] !== ch)
-                i++;
-            i++;
-            continue;
-        }
-        if (ch === '(')
-            depth++;
-        else if (ch === ')')
-            depth--;
-        else if (ch === ',' && depth === 0) {
-            items.push(list.slice(start, i));
-            start = i + 1;
-        }
-        i++;
-    }
-    items.push(list.slice(start));
-    return items.filter((item) => item.trim().length > 0);
-}
-/**
- * Every camelCase identifier one migration file declares.
- *
- * Only declarations are read — a `CREATE TABLE` column list and an `ALTER TABLE
- * … ADD COLUMN`. Everywhere else an identifier merely refers to something that
- * was declared somewhere, and reporting those would name the same mistake once
- * per reference while adding nothing to the fix.
- */
-export function findCamelCaseIdentifiers(file, sql) {
-    const offenders = [];
-    for (const statement of splitStatements(stripSqlComments(sql))) {
-        const create = CREATE_TABLE.exec(statement);
-        if (create) {
-            const table = unquote(create[1].split('.').pop());
-            if (isCamelCase(table)) {
-                offenders.push({
-                    file,
-                    table,
-                    column: null,
-                    suggestion: toSnakeCase(table),
-                });
-            }
-            const span = parenSpan(statement, create.index + create[0].length - 1);
-            if (!span)
-                continue;
-            for (const item of splitTopLevel(statement.slice(span.start, span.end))) {
-                const name = COLUMN_NAME.exec(item)?.[1];
-                if (!name)
-                    continue;
-                if (CONSTRAINT_KEYWORDS.has(name.toLowerCase()))
-                    continue;
-                const column = unquote(name);
-                if (isCamelCase(column)) {
-                    offenders.push({
-                        file,
-                        table,
-                        column,
-                        suggestion: toSnakeCase(column),
-                    });
-                }
-            }
-            continue;
-        }
-        const alter = ALTER_TABLE.exec(statement);
-        if (!alter)
-            continue;
-        const table = unquote(alter[1].split('.').pop());
-        // Postgres lets one ALTER carry several actions, and only the ADDs declare.
-        for (const action of splitTopLevel(statement.slice(alter[0].length).replace(/;\s*$/, ''))) {
-            const name = ADD_COLUMN.exec(action)?.[1];
-            if (!name)
-                continue;
-            if (CONSTRAINT_KEYWORDS.has(name.toLowerCase()))
-                continue;
-            const column = unquote(name);
-            if (isCamelCase(column)) {
-                offenders.push({
-                    file,
-                    table,
-                    column,
-                    suggestion: toSnakeCase(column),
-                });
-            }
-        }
-    }
-    return offenders;
-}
-/**
- * Bail unless every migration on disk is snake_case throughout.
- *
- * Reports all of them at once: a camelCase column is rarely alone, and a
- * one-at-a-time failure turns a single edit into one migrate run per column.
- */
-export function assertSnakeCaseIdentifiers(migrations) {
-    const offenders = migrations.flatMap(({ name, sql }) => findCamelCaseIdentifiers(name, sql));
-    if (offenders.length > 0)
-        throw new CamelCaseIdentifierError(offenders);
-}

package/dist/src/functions/db/postgres/postgres-migrator.d.ts

@@ -1,15 +0,0 @@
-import type { MigrationExecutor, AppliedMigration } from '../db-migrator.js';
-export interface PostgresMigrationClient {
-    query<T = unknown>(sql: string, params?: unknown[]): Promise<{
-        rows: T[];
-    }>;
-    exec?(sql: string): Promise<unknown>;
-}
-export declare class PostgresMigrationExecutor implements MigrationExecutor {
-    private readonly client;
-    constructor(client: PostgresMigrationClient);
-    ensureTrackingTable(): Promise<void>;
-    getApplied(): Promise<AppliedMigration[]>;
-    recordMigration(name: string, hash: string): Promise<void>;
-    runMigration(sql: string, name: string, hash: string): Promise<void>;
-}

package/dist/src/functions/db/postgres/postgres-migrator.js

@@ -1,40 +0,0 @@
-import { MIGRATION_TRACKING_TABLE as TRACKING_TABLE } from '../db-migrator.js';
-export class PostgresMigrationExecutor {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    async ensureTrackingTable() {
-        await this.client.query(`
-      CREATE TABLE IF NOT EXISTS ${TRACKING_TABLE} (
-        name       TEXT PRIMARY KEY,
-        hash       TEXT NOT NULL,
-        applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-      )
-    `);
-    }
-    async getApplied() {
-        const { rows } = await this.client.query(`SELECT name, hash, applied_at FROM ${TRACKING_TABLE} ORDER BY name`);
-        return rows;
-    }
-    async recordMigration(name, hash) {
-        await this.client.query(`INSERT INTO ${TRACKING_TABLE} (name, hash) VALUES ($1, $2)`, [name, hash]);
-    }
-    async runMigration(sql, name, hash) {
-        await this.client.query('BEGIN');
-        try {
-            if (typeof this.client.exec === 'function') {
-                await this.client.exec(sql);
-            }
-            else {
-                await this.client.query(sql);
-            }
-            await this.client.query(`INSERT INTO ${TRACKING_TABLE} (name, hash) VALUES ($1, $2)`, [name, hash]);
-            await this.client.query('COMMIT');
-        }
-        catch (err) {
-            await this.client.query('ROLLBACK');
-            throw err;
-        }
-    }
-}

package/dist/src/functions/db/schema-sql.d.ts

@@ -1,43 +0,0 @@
-/**
- * Reading a schema source's own SQL back out, one table at a time.
- *
- * A source hands `db generate` both what must exist (`tables`) and what creates
- * it (`sql`). The column map is a comparison surface — it answers "is this
- * table there, and does it have these columns" — and it is deliberately lossy:
- * primary keys, foreign keys, uniqueness, check constraints and indexes are all
- * absent from it. So the moment the generator has to *create* something, the
- * only honest source is the SQL, and this is what pulls the relevant part of it
- * out.
- */
-/**
- * Split a SQL script into its top-level statements, semicolons included.
- *
- * A naive `split(';')` is wrong in a way that only shows up later: a semicolon
- * inside a string literal, a quoted identifier or a comment is not a statement
- * boundary, and cutting there yields two fragments that are each valid-looking
- * and neither of which does what the original did.
- */
-export declare function splitStatements(sql: string): string[];
-/**
- * Reduce a written table name to the form two sources can be compared on.
- *
- * The same table is `two_factor` to one writer, `"two_factor"` to Kysely and
- * `public.two_factor` to Postgres introspection. Dropping the schema qualifier,
- * the quoting and the case is the only shape all three agree on.
- */
-export declare function bareTableName(name: string): string;
-/**
- * Every statement in `sql` that builds `table`, in the order the source wrote
- * them.
- *
- * The `CREATE TABLE` and its indexes, plus any `ALTER TABLE` the source uses to
- * hang a constraint on it afterwards — which together are what the column list
- * cannot express. Source order is preserved because it is load-bearing: an
- * index cannot precede its table, and a table cannot precede one it references.
- *
- * An empty result means the source's SQL does not visibly create the table.
- * That is a real answer rather than a failure — a source may create a table
- * from something other than a literal `CREATE TABLE` — and the caller is
- * expected to fall back rather than emit nothing.
- */
-export declare function tableCreationSql(sql: string, table: string): string[];