@mountsqli/sqlite 0.1.0

package/dist/chunk-O5OK22LQ.js

@@ -0,0 +1,250 @@
+// src/sqlite-core/dialect.ts
+import { Dialect, SQL } from "@mountsqli/core";
+var SqliteDialect = class extends Dialect {
+  dialect = "sqlite";
+  escapeName(name) {
+    return `"${name}"`;
+  }
+  escapeParam(index) {
+    return `?`;
+  }
+  buildSelectQuery(config) {
+    const parts = ["SELECT"];
+    if (config.distinct) parts.push("DISTINCT");
+    if (config.columns.length > 0) {
+      const colSqls = config.columns.map((col) => {
+        const tableName2 = col._.tableName || config.table?.[/* @__PURE__ */ Symbol.for("name")];
+        if (tableName2) {
+          return `${this.escapeName(tableName2)}.${this.escapeName(col.name)}`;
+        }
+        return this.escapeName(col.name);
+      });
+      parts.push(colSqls.join(", "));
+    } else {
+      parts.push("*");
+    }
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    parts.push(`FROM ${this.escapeName(tableName)}`);
+    if (config.joins) {
+      for (const join of config.joins) {
+        const joinTableName = join.table?.[/* @__PURE__ */ Symbol.for("name")];
+        const joinType = join.type.toUpperCase();
+        const onSql = join.on.toQuery(this.getBuildQueryConfig()).sql;
+        parts.push(`${joinType} JOIN ${this.escapeName(joinTableName)} ON ${onSql}`);
+      }
+    }
+    if (config.where) {
+      parts.push(`WHERE ${config.where.toQuery(this.getBuildQueryConfig()).sql}`);
+    }
+    if (config.groupBy && config.groupBy.length > 0) {
+      parts.push(`GROUP BY ${config.groupBy.map((g) => g.toQuery(this.getBuildQueryConfig()).sql).join(", ")}`);
+    }
+    if (config.having) {
+      parts.push(`HAVING ${config.having.toQuery(this.getBuildQueryConfig()).sql}`);
+    }
+    if (config.orderBy && config.orderBy.length > 0) {
+      parts.push(`ORDER BY ${config.orderBy.map((o) => o.toQuery(this.getBuildQueryConfig()).sql).join(", ")}`);
+    }
+    if (config.limit !== void 0) parts.push(`LIMIT ${config.limit}`);
+    if (config.offset !== void 0) parts.push(`OFFSET ${config.offset}`);
+    return new SQL([parts.join(" ")]);
+  }
+  buildInsertQuery(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const columns = Object.keys(config.values[0] ?? {});
+    const escapedCols = columns.map((c) => this.escapeName(c));
+    const placeholders = columns.map(() => "?");
+    let sql = `INSERT INTO ${this.escapeName(tableName)} (${escapedCols.join(", ")}) VALUES (${placeholders.join(", ")})`;
+    if (config.onConflict) {
+      sql += ` ${config.onConflict.toQuery(this.getBuildQueryConfig()).sql}`;
+    }
+    if (config.returning && config.returning.length > 0) {
+      const retCols = config.returning.map((c) => this.escapeName(c.name)).join(", ");
+      sql += ` RETURNING ${retCols}`;
+    }
+    return new SQL([sql]);
+  }
+  buildUpdateQuery(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const setClauses = Object.keys(config.set).map((k) => `${this.escapeName(k)} = ?`);
+    let sql = `UPDATE ${this.escapeName(tableName)} SET ${setClauses.join(", ")}`;
+    if (config.where) {
+      sql += ` WHERE ${config.where.toQuery(this.getBuildQueryConfig()).sql}`;
+    }
+    if (config.returning && config.returning.length > 0) {
+      const retCols = config.returning.map((c) => this.escapeName(c.name)).join(", ");
+      sql += ` RETURNING ${retCols}`;
+    }
+    return new SQL([sql]);
+  }
+  buildDeleteQuery(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    let sql = `DELETE FROM ${this.escapeName(tableName)}`;
+    if (config.where) {
+      sql += ` WHERE ${config.where.toQuery(this.getBuildQueryConfig()).sql}`;
+    }
+    if (config.returning && config.returning.length > 0) {
+      const retCols = config.returning.map((c) => this.escapeName(c.name)).join(", ");
+      sql += ` RETURNING ${retCols}`;
+    }
+    return new SQL([sql]);
+  }
+  buildCreateTable(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const ifNotExists = config.ifNotExists ? " IF NOT EXISTS" : "";
+    const columns = config.table.getSQLColumns();
+    const colDefs = Object.values(columns).map(
+      (col) => `  ${this.escapeName(col.name)} ${col.sqlType}`
+    );
+    const pkCols = [];
+    for (const [, col] of Object.entries(config.table.columns)) {
+      if (col.isPrimaryKey) pkCols.push(this.escapeName(col.name));
+    }
+    if (pkCols.length > 0) colDefs.push(`  PRIMARY KEY (${pkCols.join(", ")})`);
+    return new SQL([`CREATE TABLE${ifNotExists} ${this.escapeName(tableName)} (
+${colDefs.join(",\n")}
+)`]);
+  }
+  buildDropTable(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const ifExists = config.ifExists ? " IF EXISTS" : "";
+    return new SQL([`DROP TABLE${ifExists} ${this.escapeName(tableName)}`]);
+  }
+  buildCreateIndex(config) {
+    const tableName = config.table?.[/* @__PURE__ */ Symbol.for("name")];
+    const unique = config.unique ? "UNIQUE " : "";
+    const colNames = config.columns.map((c) => this.escapeName(c.name)).join(", ");
+    return new SQL([`CREATE ${unique}INDEX ${this.escapeName(config.name)} ON ${this.escapeName(tableName)} (${colNames})`]);
+  }
+};
+
+// src/sqlite-core/session.ts
+import { Session } from "@mountsqli/core";
+var SqlitePreparedQuery = class {
+  _stmt;
+  _query;
+  constructor(stmt, query) {
+    this._stmt = stmt;
+    this._query = query;
+  }
+  async execute() {
+    return this._stmt.run(...this._query.params);
+  }
+  async all() {
+    return this._stmt.all(...this._query.params);
+  }
+  async values() {
+    const rows = this._stmt.all(...this._query.params);
+    return rows.map((row) => Object.values(row));
+  }
+  getQuery() {
+    return this._query;
+  }
+};
+var SqliteSession = class extends Session {
+  _db;
+  constructor(db, logger) {
+    super(logger);
+    this._db = db;
+  }
+  async execute(query) {
+    const stmt = this._db.prepare(query.sql);
+    const result = stmt.all(...query.params);
+    return result;
+  }
+  prepare(query) {
+    const stmt = this._db.prepare(query.sql);
+    return new SqlitePreparedQuery(stmt, query);
+  }
+  async transaction(fn) {
+    return this._db.transaction(() => {
+      const tx = new SqliteTransaction(this._db, this.logger);
+      return fn(tx);
+    });
+  }
+  async dispose() {
+    this._db.close();
+  }
+};
+var SqliteTransaction = class _SqliteTransaction extends Session {
+  _db;
+  constructor(db, logger) {
+    super(logger);
+    this._db = db;
+    this.inTransaction = true;
+  }
+  async execute(query) {
+    const stmt = this._db.prepare(query.sql);
+    return stmt.all(...query.params);
+  }
+  prepare(query) {
+    const stmt = this._db.prepare(query.sql);
+    return new SqlitePreparedQuery(stmt, query);
+  }
+  async transaction(fn) {
+    const tx = new _SqliteTransaction(this._db, this.logger);
+    this._db.exec(`SAVEPOINT sp_${Date.now()}`);
+    try {
+      const result = await fn(tx);
+      this._db.exec(`RELEASE SAVEPOINT sp_${Date.now()}`);
+      return result;
+    } catch (err) {
+      this._db.exec(`ROLLBACK TO SAVEPOINT sp_${Date.now()}`);
+      throw err;
+    }
+  }
+  async rollback() {
+    this._db.exec("ROLLBACK");
+    throw new Error("Transaction rolled back");
+  }
+  async commit() {
+    this._db.exec("COMMIT");
+  }
+  async setTransactionIsolation(_level) {
+  }
+  async dispose() {
+  }
+};
+
+// src/drivers/better-sqlite3/driver.ts
+import { createLogger } from "@mountsqli/core";
+var BetterSqlite3Driver = class {
+  dialect = "sqlite";
+  _config;
+  _db = null;
+  _logger;
+  constructor(config) {
+    this._config = config;
+    this._logger = typeof config.logger === "boolean" ? createLogger({ enabled: config.logger }) : config.logger ?? createLogger({ enabled: false });
+  }
+  createSession() {
+    if (!this._db) throw new Error("Not connected");
+    return new SqliteSession(this._db, this._logger);
+  }
+  async connect() {
+    const mod = await import("better-sqlite3");
+    const Database = mod.default ?? mod;
+    this._db = new Database(this._config.filename);
+  }
+  async disconnect() {
+    if (this._db) {
+      this._db.close();
+      this._db = null;
+    }
+  }
+  async ping() {
+    try {
+      this._db?.prepare("SELECT 1").get();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+export {
+  SqliteDialect,
+  SqliteSession,
+  SqliteTransaction,
+  BetterSqlite3Driver
+};

package/dist/driver-BfnsrAUr.d.ts

@@ -0,0 +1,59 @@
+import { Session, Logger, QueryWithTypings, PreparedQuery, Driver } from '@mountsqli/core';
+
+/**
+ * SQLite session — wraps better-sqlite3.
+ */
+
+interface SqliteDatabase {
+    prepare(sql: string): SqliteStatement;
+    exec(sql: string): this;
+    close(): void;
+    transaction<T>(fn: () => T): T;
+}
+interface SqliteStatement {
+    run(...params: any[]): any;
+    get(...params: any[]): any;
+    all(...params: any[]): any[];
+}
+declare class SqliteSession extends Session {
+    private _db;
+    constructor(db: SqliteDatabase, logger: Logger);
+    execute<T>(query: QueryWithTypings): Promise<T>;
+    prepare<T>(query: QueryWithTypings): PreparedQuery<T>;
+    transaction<T>(fn: (tx: any) => Promise<T>): Promise<T>;
+    dispose(): Promise<void>;
+}
+declare class SqliteTransaction extends Session {
+    private _db;
+    constructor(db: SqliteDatabase, logger: Logger);
+    execute<T>(query: QueryWithTypings): Promise<T>;
+    prepare<T>(query: QueryWithTypings): PreparedQuery<T>;
+    transaction<T>(fn: (tx: any) => Promise<T>): Promise<T>;
+    rollback(): Promise<never>;
+    commit(): Promise<void>;
+    setTransactionIsolation(_level: string): Promise<void>;
+    dispose(): Promise<void>;
+}
+
+/**
+ * better-sqlite3 driver.
+ */
+
+interface BetterSqlite3DriverConfig {
+    /** Database file path or ':memory:' */
+    filename: string;
+    logger?: Logger | boolean;
+}
+declare class BetterSqlite3Driver implements Driver {
+    readonly dialect: "sqlite";
+    private _config;
+    private _db;
+    private _logger;
+    constructor(config: BetterSqlite3DriverConfig);
+    createSession(): SqliteSession;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    ping(): Promise<boolean>;
+}
+
+export { type BetterSqlite3DriverConfig as B, SqliteSession as S, BetterSqlite3Driver as a, SqliteTransaction as b };

package/dist/drivers/better-sqlite3/index.d.ts

@@ -0,0 +1,11 @@
+import { DatabaseConfig, Database } from '@mountsqli/core';
+import { B as BetterSqlite3DriverConfig } from '../../driver-BfnsrAUr.js';
+export { a as BetterSqlite3Driver } from '../../driver-BfnsrAUr.js';
+
+/**
+ * better-sqlite3 driver entry point.
+ */
+
+declare function mountsqli(connectionOrConfig: string | BetterSqlite3DriverConfig, options?: DatabaseConfig): Database;
+
+export { BetterSqlite3DriverConfig, mountsqli };

package/dist/drivers/better-sqlite3/index.js

@@ -0,0 +1,19 @@
+import {
+  BetterSqlite3Driver,
+  SqliteDialect
+} from "../../chunk-O5OK22LQ.js";
+
+// src/drivers/better-sqlite3/index.ts
+import { Database, createLogger } from "@mountsqli/core";
+function mountsqli(connectionOrConfig, options) {
+  const logger = typeof options?.logger === "boolean" ? createLogger({ enabled: options.logger }) : options?.logger ?? createLogger({ enabled: false });
+  const driverConfig = typeof connectionOrConfig === "string" ? { filename: connectionOrConfig, logger } : { ...connectionOrConfig, logger };
+  const driver = new BetterSqlite3Driver(driverConfig);
+  const dialect = new SqliteDialect();
+  const session = driver.createSession();
+  return new Database(session, dialect, { ...options, logger });
+}
+export {
+  BetterSqlite3Driver,
+  mountsqli
+};

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import { Table, TableConfig, Column, Dialect, AnyColumn, SQL } from '@mountsqli/core';
+export { a as BetterSqlite3Driver, S as SqliteSession, b as SqliteTransaction } from './driver-BfnsrAUr.js';
+
+/**
+ * SQLite table factory.
+ */
+
+declare class SqliteTable extends Table<TableConfig & {
+    dialect: 'sqlite';
+}> {
+}
+type SqliteTableColumns = Record<string, Column>;
+declare function sqliteTable<TColumns extends SqliteTableColumns>(name: string, columns: TColumns, config?: {
+    schema?: string;
+}): SqliteTable & {
+    columns: TColumns;
+};
+
+/**
+ * SQLite dialect — SQL generation for SQLite.
+ */
+
+declare class SqliteDialect extends Dialect {
+    readonly dialect: "sqlite";
+    escapeName(name: string): string;
+    escapeParam(index: number): string;
+    buildSelectQuery(config: {
+        table: Table;
+        columns: AnyColumn[];
+        where?: SQL;
+        orderBy?: SQL[];
+        groupBy?: SQL[];
+        having?: SQL;
+        limit?: number;
+        offset?: number;
+        joins?: Array<{
+            table: Table;
+            on: SQL;
+            type: 'inner' | 'left' | 'right' | 'full';
+        }>;
+        distinct?: boolean;
+    }): SQL;
+    buildInsertQuery(config: {
+        table: Table;
+        values: Record<string, unknown>[];
+        onConflict?: SQL;
+        returning?: AnyColumn[];
+    }): SQL;
+    buildUpdateQuery(config: {
+        table: Table;
+        set: Record<string, unknown>;
+        where?: SQL;
+        returning?: AnyColumn[];
+    }): SQL;
+    buildDeleteQuery(config: {
+        table: Table;
+        where?: SQL;
+        returning?: AnyColumn[];
+    }): SQL;
+    buildCreateTable(config: {
+        table: Table;
+        ifNotExists?: boolean;
+    }): SQL;
+    buildDropTable(config: {
+        table: Table;
+        ifExists?: boolean;
+    }): SQL;
+    buildCreateIndex(config: {
+        name: string;
+        table: Table;
+        columns: AnyColumn[];
+        unique?: boolean;
+        concurrently?: boolean;
+    }): SQL;
+}
+
+export { SqliteDialect, SqliteTable, type SqliteTableColumns, sqliteTable };

package/dist/index.js

@@ -0,0 +1,28 @@
+import {
+  BetterSqlite3Driver,
+  SqliteDialect,
+  SqliteSession,
+  SqliteTransaction
+} from "./chunk-O5OK22LQ.js";
+
+// src/sqlite-core/table.ts
+import { Table } from "@mountsqli/core";
+var SqliteTable = class extends Table {
+};
+function sqliteTable(name, columns, config) {
+  const table = new SqliteTable(name, config?.schema, name);
+  for (const [key, col] of Object.entries(columns)) {
+    table.columns[key] = col;
+    col.tableName = name;
+  }
+  const result = table;
+  result.columns = columns;
+  return result;
+}
+export {
+  BetterSqlite3Driver,
+  SqliteDialect,
+  SqliteSession,
+  SqliteTransaction,
+  sqliteTable
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@mountsqli/sqlite",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./better-sqlite3": {
+      "import": "./dist/drivers/better-sqlite3/index.js",
+      "types": "./dist/drivers/better-sqlite3/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist", "LICENSE", "README.md"],
+  "scripts": {
+    "build": "tsup src/index.ts src/drivers/better-sqlite3/index.ts --format esm --dts --clean",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@mountsqli/core": "workspace:*",
+    "@mountsqli/shared": "workspace:*"
+  },
+  "peerDependencies": {
+    "better-sqlite3": "^11.0.0"
+  },
+  "peerDependenciesMeta": {
+    "better-sqlite3": { "optional": true }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "tsup": "^8.0.0",
+    "vitest": "^3.0.0"
+  }
+}