noormme 1.0.0

package/dist/esm/dialect/sqlite/sqlite-driver.js

@@ -0,0 +1,149 @@
+/// <reference types="./sqlite-driver.d.ts" />
+import { SelectQueryNode } from '../../operation-node/select-query-node.js';
+import { parseSavepointCommand } from '../../parser/savepoint-parser.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { freeze, isFunction } from '../../util/object-utils.js';
+import { createQueryId } from '../../util/query-id.js';
+export class SqliteDriver {
+    #config;
+    #connectionMutex = new ConnectionMutex();
+    #db;
+    #connection;
+    constructor(config) {
+        this.#config = freeze({ ...config });
+    }
+    async init() {
+        this.#db = isFunction(this.#config.database)
+            ? await this.#config.database()
+            : this.#config.database;
+        this.#connection = new SqliteConnection(this.#db);
+        if (this.#config.onCreateConnection) {
+            await this.#config.onCreateConnection(this.#connection);
+        }
+    }
+    async acquireConnection() {
+        if (!this.#connection) {
+            throw new Error('driver has already been destroyed');
+        }
+        // SQLite only has one single connection. We use a mutex here to wait
+        // until the single connection has been released.
+        await this.#connectionMutex.lock();
+        return this.#connection;
+    }
+    async beginTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('begin'));
+    }
+    async commitTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('commit'));
+    }
+    async rollbackTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('rollback'));
+    }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('rollback to', savepointName), createQueryId()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('release', savepointName), createQueryId()));
+    }
+    async releaseConnection() {
+        this.#connectionMutex.unlock();
+    }
+    async destroy() {
+        if (this.#db) {
+            this.#db.close();
+            this.#db = undefined;
+            this.#connection = undefined;
+        }
+    }
+}
+class SqliteConnection {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    executeQuery(compiledQuery) {
+        const { sql, parameters } = compiledQuery;
+        // Convert parameters to SQLite-compatible types
+        const sqliteParameters = parameters.map(param => {
+            if (param === undefined) {
+                return null;
+            }
+            if (typeof param === 'boolean') {
+                return param ? 1 : 0;
+            }
+            if (param instanceof Date) {
+                return param.toISOString();
+            }
+            if (typeof param === 'object' && param !== null) {
+                return JSON.stringify(param);
+            }
+            return param;
+        });
+        const stmt = this.#db.prepare(sql);
+        if (stmt.reader) {
+            return Promise.resolve({
+                rows: stmt.all(sqliteParameters),
+            });
+        }
+        const { changes, lastInsertRowid } = stmt.run(sqliteParameters);
+        return Promise.resolve({
+            numAffectedRows: changes !== undefined && changes !== null ? BigInt(changes) : undefined,
+            insertId: lastInsertRowid !== undefined && lastInsertRowid !== null
+                ? BigInt(lastInsertRowid)
+                : undefined,
+            rows: [],
+        });
+    }
+    async *streamQuery(compiledQuery, _chunkSize) {
+        const { sql, parameters, query } = compiledQuery;
+        // Convert parameters to SQLite-compatible types
+        const sqliteParameters = parameters.map(param => {
+            if (param === undefined) {
+                return null;
+            }
+            if (typeof param === 'boolean') {
+                return param ? 1 : 0;
+            }
+            if (param instanceof Date) {
+                return param.toISOString();
+            }
+            if (typeof param === 'object' && param !== null) {
+                return JSON.stringify(param);
+            }
+            return param;
+        });
+        const stmt = this.#db.prepare(sql);
+        if (SelectQueryNode.is(query)) {
+            const iter = stmt.iterate(sqliteParameters);
+            for (const row of iter) {
+                yield {
+                    rows: [row],
+                };
+            }
+        }
+        else {
+            throw new Error('Sqlite driver only supports streaming of select queries');
+        }
+    }
+}
+class ConnectionMutex {
+    #promise;
+    #resolve;
+    async lock() {
+        while (this.#promise) {
+            await this.#promise;
+        }
+        this.#promise = new Promise((resolve) => {
+            this.#resolve = resolve;
+        });
+    }
+    unlock() {
+        const resolve = this.#resolve;
+        this.#promise = undefined;
+        this.#resolve = undefined;
+        resolve?.();
+    }
+}

package/dist/esm/dialect/sqlite/sqlite-introspector.d.ts

@@ -0,0 +1,36 @@
+import { DatabaseIntrospector, DatabaseMetadata, DatabaseMetadataOptions, SchemaMetadata, TableMetadata, ColumnMetadata, IndexMetadata, ForeignKeyMetadata } from '../database-introspector.js';
+import { Kysely } from '../../kysely.js';
+export declare class SqliteIntrospector extends DatabaseIntrospector {
+    #private;
+    constructor(db: Kysely<any>);
+    getSchemas(): Promise<SchemaMetadata[]>;
+    /**
+     * Get all tables in the database
+     */
+    getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
+    getMetadata(options?: DatabaseMetadataOptions): Promise<DatabaseMetadata>;
+    /**
+     * Enhanced auto-increment detection for SQLite
+     */
+    private detectAutoIncrement;
+    /**
+     * Extract unique constraints from SQL
+     */
+    private extractUniqueConstraints;
+    /**
+     * Extract check constraints from SQL
+     */
+    private extractCheckConstraints;
+    /**
+     * Get columns for a specific table
+     */
+    getColumns(tableName: string): Promise<ColumnMetadata[]>;
+    /**
+     * Get indexes for a specific table
+     */
+    getIndexes(tableName: string): Promise<IndexMetadata[]>;
+    /**
+     * Get foreign keys for a specific table
+     */
+    getForeignKeys(tableName: string): Promise<ForeignKeyMetadata[]>;
+}

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -0,0 +1,233 @@
+/// <reference types="./sqlite-introspector.d.ts" />
+import { DatabaseIntrospector, } from '../database-introspector.js';
+// Migration constants - moved from old migration system
+const DEFAULT_MIGRATION_TABLE = 'kysely_migration';
+const DEFAULT_MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
+import { sql } from '../../raw-builder/sql.js';
+export class SqliteIntrospector extends DatabaseIntrospector {
+    #db;
+    constructor(db) {
+        super(db);
+        this.#db = db;
+    }
+    async getSchemas() {
+        // Sqlite doesn't support schemas.
+        return [];
+    }
+    async getTables(options = { withInternalKyselyTables: false }) {
+        return await this.#getTableMetadata(options);
+    }
+    async getMetadata(options) {
+        return {
+            tables: await this.getTables(options),
+        };
+    }
+    #tablesQuery(qb, options) {
+        let tablesQuery = qb
+            .selectFrom('sqlite_master')
+            .where('type', 'in', ['table', 'view'])
+            .where('name', 'not like', 'sqlite_%')
+            .select(['name', 'sql', 'type'])
+            .orderBy('name');
+        if (!options.withInternalKyselyTables) {
+            tablesQuery = tablesQuery
+                .where('name', '!=', DEFAULT_MIGRATION_TABLE)
+                .where('name', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
+        }
+        return tablesQuery;
+    }
+    async #getTableMetadata(options) {
+        const tablesResult = await this.#tablesQuery(this.#db, options).execute();
+        const tableMetadata = await this.#db
+            .with('table_list', (qb) => this.#tablesQuery(qb, options))
+            .selectFrom([
+            'table_list as tl',
+            sql `pragma_table_info(tl.name)`.as('p'),
+        ])
+            .select([
+            'tl.name as table',
+            'p.cid',
+            'p.name',
+            'p.type',
+            'p.notnull',
+            'p.dflt_value',
+            'p.pk',
+        ])
+            .orderBy('tl.name')
+            .orderBy('p.cid')
+            .execute();
+        const columnsByTable = {};
+        for (const row of tableMetadata) {
+            columnsByTable[row.table] ??= [];
+            columnsByTable[row.table].push(row);
+        }
+        return tablesResult.map(({ name, sql, type }) => {
+            // Enhanced auto-increment detection
+            const autoIncrementInfo = this.detectAutoIncrement(sql, columnsByTable[name] ?? []);
+            const columns = columnsByTable[name] ?? [];
+            return {
+                name: name,
+                isView: type === 'view',
+                columns: columns.map((col) => ({
+                    name: col.name,
+                    dataType: col.type,
+                    isNullable: !col.notnull,
+                    isAutoIncrementing: autoIncrementInfo.isAutoIncrement && col.name === autoIncrementInfo.columnName,
+                    hasDefaultValue: col.dflt_value != null,
+                    comment: undefined,
+                    // Enhanced SQLite-specific metadata
+                    isPrimaryKey: col.pk > 0,
+                    columnIndex: col.cid,
+                    defaultValue: col.dflt_value,
+                    autoIncrementType: autoIncrementInfo.type,
+                })),
+                // Additional table-level metadata
+                autoIncrementColumn: autoIncrementInfo.columnName,
+                hasAutoIncrement: autoIncrementInfo.isAutoIncrement,
+                autoIncrementType: autoIncrementInfo.type,
+                primaryKeyColumns: columns.filter(col => col.pk > 0).map(col => col.name),
+                uniqueConstraints: this.extractUniqueConstraints(sql),
+                checkConstraints: this.extractCheckConstraints(sql),
+            };
+        });
+    }
+    /**
+     * Enhanced auto-increment detection for SQLite
+     */
+    detectAutoIncrement(sql, columns) {
+        if (!sql) {
+            return { isAutoIncrement: false, columnName: null, type: 'none' };
+        }
+        // Method 1: Check for explicit AUTOINCREMENT keyword
+        const autoIncrementMatch = sql.match(/(\w+)\s+INTEGER\s+PRIMARY\s+KEY\s+AUTOINCREMENT/i);
+        if (autoIncrementMatch) {
+            return {
+                isAutoIncrement: true,
+                columnName: autoIncrementMatch[1].replace(/["`]/g, ''),
+                type: 'autoincrement'
+            };
+        }
+        // Method 2: Check for INTEGER PRIMARY KEY (implicit auto-increment)
+        const integerPkMatch = sql.match(/(\w+)\s+INTEGER\s+PRIMARY\s+KEY/i);
+        if (integerPkMatch) {
+            return {
+                isAutoIncrement: true,
+                columnName: integerPkMatch[1].replace(/["`]/g, ''),
+                type: 'rowid'
+            };
+        }
+        // Method 3: Check columns for INTEGER PRIMARY KEY
+        const pkColumns = columns.filter((col) => col.pk > 0);
+        if (pkColumns.length === 1) {
+            const pkCol = pkColumns[0];
+            if (pkCol.type.toLowerCase() === 'integer') {
+                return {
+                    isAutoIncrement: true,
+                    columnName: pkCol.name,
+                    type: 'rowid'
+                };
+            }
+        }
+        // Method 4: Check for rowid usage (SQLite's implicit primary key)
+        const hasExplicitPk = columns.some((col) => col.pk > 0);
+        if (!hasExplicitPk) {
+            return {
+                isAutoIncrement: true,
+                columnName: 'rowid',
+                type: 'rowid'
+            };
+        }
+        return { isAutoIncrement: false, columnName: null, type: 'none' };
+    }
+    /**
+     * Extract unique constraints from SQL
+     */
+    extractUniqueConstraints(sql) {
+        if (!sql)
+            return [];
+        const constraints = [];
+        const uniqueMatches = sql.match(/UNIQUE\s*\(([^)]+)\)/gi);
+        if (uniqueMatches) {
+            for (const match of uniqueMatches) {
+                const columnsMatch = match.match(/\(([^)]+)\)/);
+                if (columnsMatch) {
+                    const columns = columnsMatch[1]
+                        .split(',')
+                        .map(col => col.trim().replace(/["`]/g, ''));
+                    constraints.push(...columns);
+                }
+            }
+        }
+        return constraints;
+    }
+    /**
+     * Extract check constraints from SQL
+     */
+    extractCheckConstraints(sql) {
+        if (!sql)
+            return [];
+        const constraints = [];
+        const checkMatches = sql.match(/CHECK\s*\(([^)]+)\)/gi);
+        if (checkMatches) {
+            for (const match of checkMatches) {
+                const conditionMatch = match.match(/\(([^)]+)\)/);
+                if (conditionMatch) {
+                    constraints.push(conditionMatch[1]);
+                }
+            }
+        }
+        return constraints;
+    }
+    async getColumns(tableName) {
+        try {
+            // SQLite - use raw SQL for pragma_table_info
+            const result = await sql `PRAGMA table_info(${sql.lit(tableName)})`.execute(this.#db);
+            const sqliteColumns = result.rows;
+            return sqliteColumns.map((col) => ({
+                name: col.name,
+                type: col.type,
+                nullable: !col.notnull,
+                defaultValue: col.dflt_value,
+                isPrimaryKey: !!col.pk,
+                isAutoIncrement: col.type.toLowerCase().includes('integer') && col.pk
+            }));
+        }
+        catch (error) {
+            console.warn('SQLite column discovery failed:', error);
+            return [];
+        }
+    }
+    async getIndexes(tableName) {
+        try {
+            // SQLite - use raw SQL for pragma_index_list
+            const result = await sql `PRAGMA index_list(${sql.lit(tableName)})`.execute(this.#db);
+            const sqliteIndexes = result.rows;
+            return sqliteIndexes.map((idx) => ({
+                name: idx.name,
+                columns: [], // Would need additional query to get column names
+                unique: !!idx.unique
+            }));
+        }
+        catch (error) {
+            console.warn('SQLite index discovery failed:', error);
+            return [];
+        }
+    }
+    async getForeignKeys(tableName) {
+        try {
+            // SQLite - use raw SQL for pragma_foreign_key_list
+            const result = await sql `PRAGMA foreign_key_list(${sql.lit(tableName)})`.execute(this.#db);
+            const sqliteFks = result.rows;
+            return sqliteFks.map((fk) => ({
+                name: `fk_${tableName}_${fk.from}`,
+                column: fk.from,
+                referencedTable: fk.table,
+                referencedColumn: fk.to
+            }));
+        }
+        catch (error) {
+            console.warn('SQLite foreign key discovery failed:', error);
+            return [];
+        }
+    }
+}

package/dist/esm/dialect/sqlite/sqlite-query-compiler.d.ts

@@ -0,0 +1,16 @@
+import { DefaultInsertValueNode } from '../../operation-node/default-insert-value-node.js';
+import { OrActionNode } from '../../operation-node/or-action-node.js';
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+import { ForeignKeyConstraintNode } from '../../operation-node/foreign-key-constraint-node.js';
+export declare class SqliteQueryCompiler extends DefaultQueryCompiler {
+    protected visitOrAction(node: OrActionNode): void;
+    protected getCurrentParameterPlaceholder(): string;
+    protected getLeftExplainOptionsWrapper(): string;
+    protected getRightExplainOptionsWrapper(): string;
+    protected getLeftIdentifierWrapper(): string;
+    protected getRightIdentifierWrapper(): string;
+    protected getAutoIncrement(): string;
+    protected sanitizeIdentifier(identifier: string): string;
+    protected visitDefaultInsertValue(_: DefaultInsertValueNode): void;
+    protected visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
+}

package/dist/esm/dialect/sqlite/sqlite-query-compiler.js

@@ -0,0 +1,40 @@
+/// <reference types="./sqlite-query-compiler.d.ts" />
+import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+const ID_WRAP_REGEX = /"/g;
+export class SqliteQueryCompiler extends DefaultQueryCompiler {
+    visitOrAction(node) {
+        this.append('or ');
+        this.append(node.action);
+    }
+    getCurrentParameterPlaceholder() {
+        return '?';
+    }
+    getLeftExplainOptionsWrapper() {
+        return '';
+    }
+    getRightExplainOptionsWrapper() {
+        return '';
+    }
+    getLeftIdentifierWrapper() {
+        return '"';
+    }
+    getRightIdentifierWrapper() {
+        return '"';
+    }
+    getAutoIncrement() {
+        return 'autoincrement';
+    }
+    sanitizeIdentifier(identifier) {
+        return identifier.replace(ID_WRAP_REGEX, '""');
+    }
+    visitDefaultInsertValue(_) {
+        // sqlite doesn't support the `default` keyword in inserts.
+        this.append('null');
+    }
+    visitForeignKeyConstraint(node) {
+        // SQLite doesn't support ALTER TABLE ADD CONSTRAINT for foreign keys
+        // Foreign keys must be defined during table creation
+        // For now, we'll skip foreign key constraints in ALTER TABLE statements
+        throw new Error('SQLite does not support adding foreign key constraints via ALTER TABLE. Foreign keys must be defined during table creation.');
+    }
+}

package/dist/esm/driver/connection-provider.d.ts

@@ -0,0 +1,8 @@
+import { DatabaseConnection } from './database-connection.js';
+export interface ConnectionProvider {
+    /**
+     * Provides a connection for the callback and takes care of disposing
+     * the connection after the callback has been run.
+     */
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+}

package/dist/esm/driver/connection-provider.js

@@ -0,0 +1,2 @@
+/// <reference types="./connection-provider.d.ts" />
+export {};

package/dist/esm/driver/database-connection.d.ts

@@ -0,0 +1,35 @@
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+/**
+ * A single connection to the database engine.
+ *
+ * These are created by an instance of {@link Driver}.
+ */
+export interface DatabaseConnection {
+    executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    streamQuery<R>(compiledQuery: CompiledQuery, chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
+}
+export interface QueryResult<O> {
+    /**
+     * This is defined for insert, update, delete and merge queries and contains
+     * the number of rows the query inserted/updated/deleted.
+     */
+    readonly numAffectedRows?: bigint;
+    /**
+     * This is defined for update queries and contains the number of rows
+     * the query changed.
+     *
+     * This is **optional** and only provided in dialects such as MySQL.
+     * You would probably use {@link numAffectedRows} in most cases.
+     */
+    readonly numChangedRows?: bigint;
+    /**
+     * This is defined for insert queries on dialects that return
+     * the auto incrementing primary key from an insert.
+     */
+    readonly insertId?: bigint;
+    /**
+     * The rows returned by the query. This is always defined and is
+     * empty if the query returned no rows.
+     */
+    readonly rows: O[];
+}

package/dist/esm/driver/database-connection.js

@@ -0,0 +1,2 @@
+/// <reference types="./database-connection.d.ts" />
+export {};

package/dist/esm/driver/default-connection-provider.d.ts

@@ -0,0 +1,12 @@
+import { DatabaseConnection } from './database-connection.js';
+import { ConnectionProvider } from './connection-provider.js';
+import { Driver } from './driver.js';
+export declare class DefaultConnectionProvider implements ConnectionProvider {
+    #private;
+    constructor(driver: Driver);
+    /**
+     * Provides a connection for the callback and takes care of disposing
+     * the connection after the callback has been run.
+     */
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+}

package/dist/esm/driver/default-connection-provider.js

@@ -0,0 +1,16 @@
+/// <reference types="./default-connection-provider.d.ts" />
+export class DefaultConnectionProvider {
+    #driver;
+    constructor(driver) {
+        this.#driver = driver;
+    }
+    async provideConnection(consumer) {
+        const connection = await this.#driver.acquireConnection();
+        try {
+            return await consumer(connection);
+        }
+        finally {
+            await this.#driver.releaseConnection(connection);
+        }
+    }
+}

package/dist/esm/driver/driver.d.ts

@@ -0,0 +1,61 @@
+import { QueryCompiler } from '../query-compiler/query-compiler.js';
+import { ArrayItemType } from '../util/type-utils.js';
+import { DatabaseConnection } from './database-connection.js';
+/**
+ * A Driver creates and releases {@link DatabaseConnection | database connections}
+ * and is also responsible for connection pooling (if the dialect supports pooling).
+ */
+export interface Driver {
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     */
+    init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
+    acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
+    beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
+    commitTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
+    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Establishses a new savepoint within a transaction.
+     */
+    savepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Rolls back to a savepoint within a transaction.
+     */
+    rollbackToSavepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Releases a savepoint within a transaction.
+     */
+    releaseSavepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
+    releaseConnection(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
+    destroy(): Promise<void>;
+}
+export interface TransactionSettings {
+    readonly accessMode?: AccessMode;
+    readonly isolationLevel?: IsolationLevel;
+}
+export declare const TRANSACTION_ACCESS_MODES: readonly ["read only", "read write"];
+export type AccessMode = ArrayItemType<typeof TRANSACTION_ACCESS_MODES>;
+export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable", "snapshot"];
+export type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;
+export declare function validateTransactionSettings(settings: TransactionSettings): void;

package/dist/esm/driver/driver.js

@@ -0,0 +1,19 @@
+/// <reference types="./driver.d.ts" />
+export const TRANSACTION_ACCESS_MODES = ['read only', 'read write'];
+export const TRANSACTION_ISOLATION_LEVELS = [
+    'read uncommitted',
+    'read committed',
+    'repeatable read',
+    'serializable',
+    'snapshot',
+];
+export function validateTransactionSettings(settings) {
+    if (settings.accessMode &&
+        !TRANSACTION_ACCESS_MODES.includes(settings.accessMode)) {
+        throw new Error(`invalid transaction access mode ${settings.accessMode}`);
+    }
+    if (settings.isolationLevel &&
+        !TRANSACTION_ISOLATION_LEVELS.includes(settings.isolationLevel)) {
+        throw new Error(`invalid transaction isolation level ${settings.isolationLevel}`);
+    }
+}