@pikku/cli 0.12.127 → 0.12.133

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[];

package/dist/src/functions/db/schema-sql.js

@@ -1,135 +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 function splitStatements(sql) {
-    const statements = [];
-    let start = 0;
-    let i = 0;
-    const closeQuote = (quote) => {
-        i++;
-        while (i < sql.length) {
-            if (sql[i] === '\\' && quote === "'") {
-                i += 2;
-                continue;
-            }
-            if (sql[i] === quote) {
-                // A doubled quote is an escaped one, not the end of the literal.
-                if (sql[i + 1] === quote) {
-                    i += 2;
-                    continue;
-                }
-                i++;
-                return;
-            }
-            i++;
-        }
-    };
-    while (i < sql.length) {
-        const ch = sql[i];
-        if (ch === "'" || ch === '"' || ch === '`') {
-            closeQuote(ch);
-            continue;
-        }
-        if (ch === '-' && sql[i + 1] === '-') {
-            const end = sql.indexOf('\n', i);
-            i = end === -1 ? sql.length : end + 1;
-            continue;
-        }
-        if (ch === '/' && sql[i + 1] === '*') {
-            const end = sql.indexOf('*/', i + 2);
-            i = end === -1 ? sql.length : end + 2;
-            continue;
-        }
-        // Postgres dollar quoting: everything between `$tag$` and its twin is a
-        // literal, and a function body written that way is full of semicolons.
-        if (ch === '$') {
-            const tag = /^\$[A-Za-z_0-9]*\$/.exec(sql.slice(i));
-            if (tag) {
-                const end = sql.indexOf(tag[0], i + tag[0].length);
-                i = end === -1 ? sql.length : end + tag[0].length;
-                continue;
-            }
-        }
-        if (ch === ';') {
-            const statement = sql.slice(start, i + 1).trim();
-            if (statement.length > 1)
-                statements.push(statement);
-            start = i + 1;
-        }
-        i++;
-    }
-    // A script whose last statement has no trailing semicolon still ran it.
-    const tail = sql.slice(start).trim();
-    if (tail.length > 0)
-        statements.push(tail);
-    return statements;
-}
-/**
- * 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 function bareTableName(name) {
-    const last = name.split('.').pop() ?? name;
-    return last.replace(/^["'`[]|["'`\]]$/g, '').toLowerCase();
-}
-const CREATE_TABLE = /^CREATE\s+(?:TEMP(?:ORARY)?\s+|UNLOGGED\s+)*TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([^\s(]+)/i;
-const CREATE_INDEX = /^CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?\S+\s+ON\s+(?:ONLY\s+)?([^\s(]+)/i;
-const ALTER_TABLE = /^ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:ONLY\s+)?([^\s(]+)/i;
-/**
- * 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 function tableCreationSql(sql, table) {
-    const wanted = bareTableName(table);
-    const statements = [];
-    let creates = false;
-    for (const statement of splitStatements(sql)) {
-        const create = CREATE_TABLE.exec(statement);
-        if (create && bareTableName(create[1]) === wanted) {
-            creates = true;
-            statements.push(statement);
-            continue;
-        }
-        const index = CREATE_INDEX.exec(statement);
-        if (index && bareTableName(index[1]) === wanted) {
-            statements.push(statement);
-            continue;
-        }
-        const alter = ALTER_TABLE.exec(statement);
-        if (alter && bareTableName(alter[1]) === wanted) {
-            statements.push(statement);
-        }
-    }
-    // Indexes and alters without the table they belong to would fail on their own,
-    // and their presence says the table came from somewhere this cannot read.
-    return creates ? statements : [];
-}

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

@@ -1,11 +0,0 @@
-import type { MigrationExecutor, AppliedMigration } from '../db-migrator.js';
-import type { SyncSqliteDatabase } from './sqlite-runtime.js';
-export declare class SqliteMigrationExecutor implements MigrationExecutor {
-    private readonly db;
-    constructor(db: SyncSqliteDatabase);
-    ensureTrackingTable(): Promise<void>;
-    getApplied(): Promise<AppliedMigration[]>;
-    recordMigration(name: string, hash: string): Promise<void>;
-    runMigration(sql: string, name: string, hash: string): Promise<void>;
-}
-export declare function dropTrackingTable(db: SyncSqliteDatabase): void;

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

@@ -1,41 +0,0 @@
-import { MIGRATION_TRACKING_TABLE as TRACKING_TABLE } from '../db-migrator.js';
-export class SqliteMigrationExecutor {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    async ensureTrackingTable() {
-        this.db.exec(`CREATE TABLE IF NOT EXISTS ${TRACKING_TABLE} (
-         name       TEXT PRIMARY KEY,
-         hash       TEXT NOT NULL,
-         applied_at TEXT NOT NULL DEFAULT (datetime('now'))
-       )`);
-    }
-    async getApplied() {
-        return this.db
-            .prepare(`SELECT name, hash, applied_at FROM ${TRACKING_TABLE} ORDER BY name`)
-            .all();
-    }
-    async recordMigration(name, hash) {
-        this.db
-            .prepare(`INSERT INTO ${TRACKING_TABLE} (name, hash) VALUES (?, ?)`)
-            .run(name, hash);
-    }
-    async runMigration(sql, name, hash) {
-        this.db.exec('BEGIN');
-        try {
-            this.db.exec(sql);
-            this.db
-                .prepare(`INSERT INTO ${TRACKING_TABLE} (name, hash) VALUES (?, ?)`)
-                .run(name, hash);
-            this.db.exec('COMMIT');
-        }
-        catch (err) {
-            this.db.exec('ROLLBACK');
-            throw err;
-        }
-    }
-}
-export function dropTrackingTable(db) {
-    db.exec(`DROP TABLE IF EXISTS ${TRACKING_TABLE}`);
-}

package/dist/src/functions/db/sqlite/sqlite-runtime-bun.d.ts

@@ -1,2 +0,0 @@
-import type { SqliteRuntime } from './sqlite-runtime.js';
-export declare const bunSqliteRuntime: SqliteRuntime;

package/dist/src/functions/db/sqlite/sqlite-runtime-bun.js

@@ -1,62 +0,0 @@
-import { Database } from 'bun:sqlite';
-class BunSqliteStatement {
-    stmt;
-    reader;
-    constructor(stmt, reader) {
-        this.stmt = stmt;
-        this.reader = reader;
-    }
-    all(...parameters) {
-        return this.stmt.all(...parameters);
-    }
-    get(...parameters) {
-        return (this.stmt.get(...parameters) ?? null);
-    }
-    iterate(...parameters) {
-        return this.stmt.iterate(...parameters);
-    }
-    run(...parameters) {
-        const result = this.stmt.run(...parameters);
-        return {
-            changes: result.changes,
-            lastInsertRowid: result.lastInsertRowid,
-        };
-    }
-}
-class BunSqliteDatabase {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    exec(sql) {
-        // bun:sqlite throws "no valid SQL statement" on comment-only/empty input
-        // (e.g. a placeholder dev-seed.sql); node:sqlite silently no-ops. Match node's
-        // tolerance by skipping when nothing executable remains after stripping
-        // comments. The original `sql` is still exec'd verbatim when non-empty.
-        const executable = sql
-            .replace(/--[^\n]*/g, '')
-            .replace(/\/\*[\s\S]*?\*\//g, '')
-            .trim();
-        if (executable.length === 0)
-            return;
-        this.db.exec(sql);
-    }
-    prepare(sql) {
-        return new BunSqliteStatement(this.db.prepare(sql), isReaderSql(sql));
-    }
-    close() {
-        this.db.close();
-    }
-}
-function isReaderSql(sql) {
-    const normalized = sql.trimStart().toUpperCase();
-    return (normalized.startsWith('SELECT') ||
-        normalized.startsWith('WITH') ||
-        normalized.startsWith('PRAGMA') ||
-        normalized.startsWith('EXPLAIN'));
-}
-export const bunSqliteRuntime = {
-    open(filename) {
-        return new BunSqliteDatabase(new Database(filename));
-    },
-};

package/dist/src/functions/db/sqlite/sqlite-runtime-node.d.ts

@@ -1,2 +0,0 @@
-import type { SqliteRuntime } from './sqlite-runtime.js';
-export declare function createNodeSqliteRuntime(): Promise<SqliteRuntime>;

package/dist/src/functions/db/sqlite/sqlite-runtime-node.js

@@ -1,78 +0,0 @@
-class NodeSqliteStatement {
-    stmt;
-    reader;
-    constructor(stmt, sql) {
-        this.stmt = stmt;
-        // node:sqlite StatementSync does not have a .reader property
-        // (that's a better-sqlite3 API). Fall back to SQL inspection when absent.
-        if (stmt.reader !== undefined) {
-            this.reader = Boolean(stmt.reader);
-        }
-        else {
-            const upper = sql.trimStart().toUpperCase();
-            this.reader =
-                upper.startsWith('SELECT') ||
-                    upper.startsWith('WITH') ||
-                    upper.startsWith('PRAGMA') ||
-                    upper.startsWith('EXPLAIN') ||
-                    upper.startsWith('VALUES') ||
-                    /\bRETURNING\b/.test(upper);
-        }
-    }
-    all(...parameters) {
-        return this.stmt.all(...parameters);
-    }
-    get(...parameters) {
-        return this.stmt.get(...parameters) ?? null;
-    }
-    iterate(...parameters) {
-        return this.stmt.iterate(...parameters);
-    }
-    run(...parameters) {
-        const result = this.stmt.run(...parameters);
-        return {
-            changes: result.changes,
-            lastInsertRowid: result.lastInsertRowid,
-        };
-    }
-}
-class NodeSqliteDatabase {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    exec(sql) {
-        this.db.exec(sql);
-    }
-    prepare(sql) {
-        return new NodeSqliteStatement(this.db.prepare(sql), sql);
-    }
-    close() {
-        this.db.close();
-    }
-}
-async function importNodeSqlite() {
-    const dynamicImport = new Function('return import("node:sqlite")');
-    try {
-        return await dynamicImport();
-    }
-    catch (error) {
-        // node ships node:sqlite unflagged only from 24. The raw failure is
-        // ERR_UNKNOWN_BUILTIN_MODULE, which reads like a broken install rather than
-        // a runtime that is simply too old — so say which it is and how to get past it.
-        if (error?.code === 'ERR_UNKNOWN_BUILTIN_MODULE') {
-            throw new Error(`This needs node:sqlite, which Node ${process.versions.node} does not provide ` +
-                `(it is unflagged from Node 24). Either upgrade Node, or run the CLI on bun, ` +
-                `which has it: \`bunx --bun pikku <command>\`.`, { cause: error });
-        }
-        throw error;
-    }
-}
-export async function createNodeSqliteRuntime() {
-    const { DatabaseSync } = await importNodeSqlite();
-    return {
-        open(filename) {
-            return new NodeSqliteDatabase(new DatabaseSync(filename));
-        },
-    };
-}

package/dist/src/functions/db/sqlite/sqlite-runtime.d.ts

@@ -1,20 +0,0 @@
-export interface SyncSqliteChanges {
-    changes: number | bigint;
-    lastInsertRowid: number | bigint;
-}
-export interface SyncSqliteStatement {
-    reader: boolean;
-    all(...parameters: unknown[]): unknown[];
-    get(...parameters: unknown[]): unknown | null;
-    iterate(...parameters: unknown[]): IterableIterator<unknown>;
-    run(...parameters: unknown[]): SyncSqliteChanges;
-}
-export interface SyncSqliteDatabase {
-    exec(sql: string): void;
-    prepare(sql: string): SyncSqliteStatement;
-    close(): void;
-}
-export interface SqliteRuntime {
-    open(filename: string): SyncSqliteDatabase;
-}
-export declare function loadSqliteRuntime(): Promise<SqliteRuntime>;

package/dist/src/functions/db/sqlite/sqlite-runtime.js

@@ -1,13 +0,0 @@
-let runtimePromise;
-export async function loadSqliteRuntime() {
-    runtimePromise ??= (async () => {
-        const isBunRuntime = typeof globalThis.Bun !== 'undefined';
-        if (isBunRuntime) {
-            const { bunSqliteRuntime } = await import('./sqlite-runtime-bun.js');
-            return bunSqliteRuntime;
-        }
-        const { createNodeSqliteRuntime } = await import('./sqlite-runtime-node.js');
-        return createNodeSqliteRuntime();
-    })();
-    return runtimePromise;
-}