@devbro/neko-sql 0.1.31 → 0.1.32

package/dist/databases/sqlite/SqliteQueryGrammar.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/databases/sqlite/SqliteQueryGrammar.mts"],"sourcesContent":["import { Query } from '../../Query.mjs';\nimport { QueryGrammar } from '../../QueryGrammar.mjs';\nimport { CompiledSql, Parameter } from '../../types.mjs';\nimport { Arr } from '@devbro/neko-helper';\n\nexport class SqliteQueryGrammar extends QueryGrammar {\n  constructor() {\n    super();\n  }\n\n  toSql(query: Query): CompiledSql {\n    return super.toSql(query);\n  }\n\n  compileInsert(query: Query, data: Record<string, any>): CompiledSql {\n    return super.compileInsert(query, data);\n  }\n\n  compileInsertGetId(\n    query: Query,\n    data: Record<string, any>,\n    options: { primaryKey: string[] } = { primaryKey: ['id'] }\n  ): CompiledSql {\n    const rc = super.compileInsert(query, data);\n    rc.sql += ` RETURNING ${options.primaryKey.join(', ')}`;\n    rc.parts = rc.parts.concat(['RETURNING', ...Arr.intersperse(options.primaryKey, ',')]);\n    return rc;\n  }\n\n  compileUpdate(query: Query, data: Record<string, any>): CompiledSql {\n    return super.compileUpdate(query, data);\n  }\n\n  compileDelete(query: Query): CompiledSql {\n    return super.compileDelete(query);\n  }\n\n  compileUpsert(\n    query: Query,\n    data: Record<string, Parameter>,\n    conflictFields: string[],\n    updateFields: string[]\n  ): CompiledSql {\n    return super.compileUpsert(query, data, conflictFields, updateFields);\n  }\n\n  compileCount(query: Query): CompiledSql {\n    return super.compileCount(query);\n  }\n}\n"],"mappings":";;AACA,SAAS,oBAAoB;AAE7B,SAAS,WAAW;AAEb,MAAM,2BAA2B,aAAa;AAAA,EALrD,OAKqD;AAAA;AAAA;AAAA,EACnD,cAAc;AACZ,UAAM;AAAA,EACR;AAAA,EAEA,MAAM,OAA2B;AAC/B,WAAO,MAAM,MAAM,KAAK;AAAA,EAC1B;AAAA,EAEA,cAAc,OAAc,MAAwC;AAClE,WAAO,MAAM,cAAc,OAAO,IAAI;AAAA,EACxC;AAAA,EAEA,mBACE,OACA,MACA,UAAoC,EAAE,YAAY,CAAC,IAAI,EAAE,GAC5C;AACb,UAAM,KAAK,MAAM,cAAc,OAAO,IAAI;AAC1C,OAAG,OAAO,cAAc,QAAQ,WAAW,KAAK,IAAI,CAAC;AACrD,OAAG,QAAQ,GAAG,MAAM,OAAO,CAAC,aAAa,GAAG,IAAI,YAAY,QAAQ,YAAY,GAAG,CAAC,CAAC;AACrF,WAAO;AAAA,EACT;AAAA,EAEA,cAAc,OAAc,MAAwC;AAClE,WAAO,MAAM,cAAc,OAAO,IAAI;AAAA,EACxC;AAAA,EAEA,cAAc,OAA2B;AACvC,WAAO,MAAM,cAAc,KAAK;AAAA,EAClC;AAAA,EAEA,cACE,OACA,MACA,gBACA,cACa;AACb,WAAO,MAAM,cAAc,OAAO,MAAM,gBAAgB,YAAY;AAAA,EACtE;AAAA,EAEA,aAAa,OAA2B;AACtC,WAAO,MAAM,aAAa,KAAK;AAAA,EACjC;AACF;","names":[]}

package/dist/databases/sqlite/SqliteSchemaGrammar.d.mts

@@ -0,0 +1,7 @@
+import { f as SchemaGrammar } from '../../Blueprint-D3WHeqRS.mjs';
+import '@devbro/neko-helper';
+
+declare class SqliteSchemaGrammar extends SchemaGrammar {
+}
+
+export { SqliteSchemaGrammar };

package/dist/databases/sqlite/SqliteSchemaGrammar.mjs

@@ -0,0 +1,12 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { SchemaGrammar } from "../../SchemaGrammar.mjs";
+class SqliteSchemaGrammar extends SchemaGrammar {
+  static {
+    __name(this, "SqliteSchemaGrammar");
+  }
+}
+export {
+  SqliteSchemaGrammar
+};
+//# sourceMappingURL=SqliteSchemaGrammar.mjs.map

package/dist/databases/sqlite/SqliteSchemaGrammar.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/databases/sqlite/SqliteSchemaGrammar.mts"],"sourcesContent":["import { SchemaGrammar } from '../../SchemaGrammar.mjs';\n\nexport class SqliteSchemaGrammar extends SchemaGrammar {}\n"],"mappings":";;AAAA,SAAS,qBAAqB;AAEvB,MAAM,4BAA4B,cAAc;AAAA,EAFvD,OAEuD;AAAA;AAAA;AAAC;","names":[]}

package/dist/databases/sqlite/index.d.mts

@@ -0,0 +1,6 @@
+export { SqliteConfig, SqliteConnection } from './SqliteConnection.mjs';
+export { SqliteQueryGrammar } from './SqliteQueryGrammar.mjs';
+export { SqliteSchemaGrammar } from './SqliteSchemaGrammar.mjs';
+import '../../Blueprint-D3WHeqRS.mjs';
+import '@devbro/neko-helper';
+import 'better-sqlite3';

package/dist/databases/sqlite/index.mjs

@@ -0,0 +1,4 @@
+export * from "./SqliteConnection.mjs";
+export * from "./SqliteQueryGrammar.mjs";
+export * from "./SqliteSchemaGrammar.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/databases/sqlite/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/databases/sqlite/index.mts"],"sourcesContent":["export * from './SqliteConnection.mjs';\nexport * from './SqliteQueryGrammar.mjs';\nexport * from './SqliteSchemaGrammar.mjs';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,cAAc;","names":[]}

package/dist/index.d.mts

@@ -1,7 +1,11 @@
 export { PostgresqlConnection } from './databases/postgresql/PostgresqlConnection.mjs';
 export { PostgresqlQueryGrammar } from './databases/postgresql/PostgresqlQueryGrammar.mjs';
 export { PostgresqlSchemaGrammar } from './databases/postgresql/PostgresqlSchemaGrammar.mjs';
+export { SqliteConfig, SqliteConnection } from './databases/sqlite/SqliteConnection.mjs';
+export { SqliteQueryGrammar } from './databases/sqlite/SqliteQueryGrammar.mjs';
+export { SqliteSchemaGrammar } from './databases/sqlite/SqliteSchemaGrammar.mjs';
 export { B as Blueprint, a as Column, C as ColumnPropertiesType, m as CompiledSql, b as Connection, F as ForeignKeyConstraint, I as IndexConstraint, J as JoinCondition, P as Parameter, d as Query, e as QueryGrammar, Q as QueryParts, S as Schema, f as SchemaGrammar, c as connection_events, n as havingType, o as joinType, s as selectType, w as whereBasic, i as whereNested, k as whereNull, g as whereOp, h as whereOpColumn, j as whereRaw, l as whereType } from './Blueprint-D3WHeqRS.mjs';
 export { Migration } from './Migration.mjs';
 import 'pg';
+import 'better-sqlite3';
 import '@devbro/neko-helper';

package/dist/index.js

@@ -43,7 +43,10 @@ __export(index_exports, {
   Query: () => Query,
   QueryGrammar: () => QueryGrammar,
   Schema: () => Schema,
-  SchemaGrammar: () => SchemaGrammar
+  SchemaGrammar: () => SchemaGrammar,
+  SqliteConnection: () => SqliteConnection,
+  SqliteQueryGrammar: () => SqliteQueryGrammar,
+  SqliteSchemaGrammar: () => SqliteSchemaGrammar
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1221,7 +1224,8 @@ var PostgresqlConnection = class _PostgresqlConnection extends Connection {
     }
   }
   async connect() {
-    this.eventManager.emit("connect");
+    this.eventManager.emit("connect").catch(() => {
+    });
     this.connection = await _PostgresqlConnection.pool.connect();
     return true;
   }
@@ -1234,7 +1238,8 @@ var PostgresqlConnection = class _PostgresqlConnection extends Connection {
     if (sql.parts && sql.parts.length > 0) {
       sql2 = sql.parts.map((v) => v === "?" ? "$" + counter++ : v).join(" ");
     }
-    this.eventManager.emit("query", { sql: sql2, bindings: sql.bindings });
+    this.eventManager.emit("query", { sql: sql2, bindings: sql.bindings }).catch(() => {
+    });
     if (!this.isConnected()) {
       await this.connect();
     }
@@ -1250,7 +1255,8 @@ var PostgresqlConnection = class _PostgresqlConnection extends Connection {
     }
     await this.connection?.release();
     this.connection = void 0;
-    this.eventManager.emit("disconnect");
+    this.eventManager.emit("disconnect").catch(() => {
+    });
     return true;
   }
   getQuery() {
@@ -1274,9 +1280,8 @@ var PostgresqlConnection = class _PostgresqlConnection extends Connection {
   async rollback() {
     await this.runQuery({ sql: "ROLLBACK", bindings: [], parts: ["ROLLBACK"] });
   }
-  static async destroy() {
-    _PostgresqlConnection.pool.end();
-    return;
+  static destroy() {
+    return _PostgresqlConnection.pool.end();
   }
   isConnected() {
     return this.connection !== void 0;
@@ -1313,7 +1318,7 @@ var PostgresqlConnection = class _PostgresqlConnection extends Connection {
     if (this.isConnected()) {
       throw new Error("Cannot create database while connected.");
     }
-    let conn = new import_pg.Client({
+    const conn = new import_pg.Client({
       ..._PostgresqlConnection.pool.options,
       database: "postgres"
     });
@@ -1326,7 +1331,7 @@ var PostgresqlConnection = class _PostgresqlConnection extends Connection {
     if (this.isConnected()) {
       throw new Error("Cannot drop database while connected.");
     }
-    let conn = new import_pg.Client({
+    const conn = new import_pg.Client({
       ..._PostgresqlConnection.pool.options,
       database: "postgres"
       // connect to default 'postgres' database to drop others
@@ -1356,6 +1361,283 @@ var PostgresqlConnection = class _PostgresqlConnection extends Connection {
   }
 };
 
+// src/databases/sqlite/SqliteConnection.mts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+
+// src/databases/sqlite/SqliteQueryGrammar.mts
+var import_neko_helper4 = require("@devbro/neko-helper");
+var SqliteQueryGrammar = class extends QueryGrammar {
+  static {
+    __name(this, "SqliteQueryGrammar");
+  }
+  constructor() {
+    super();
+  }
+  toSql(query) {
+    return super.toSql(query);
+  }
+  compileInsert(query, data) {
+    return super.compileInsert(query, data);
+  }
+  compileInsertGetId(query, data, options = { primaryKey: ["id"] }) {
+    const rc = super.compileInsert(query, data);
+    rc.sql += ` RETURNING ${options.primaryKey.join(", ")}`;
+    rc.parts = rc.parts.concat(["RETURNING", ...import_neko_helper4.Arr.intersperse(options.primaryKey, ",")]);
+    return rc;
+  }
+  compileUpdate(query, data) {
+    return super.compileUpdate(query, data);
+  }
+  compileDelete(query) {
+    return super.compileDelete(query);
+  }
+  compileUpsert(query, data, conflictFields, updateFields) {
+    return super.compileUpsert(query, data, conflictFields, updateFields);
+  }
+  compileCount(query) {
+    return super.compileCount(query);
+  }
+};
+
+// src/databases/sqlite/SqliteSchemaGrammar.mts
+var SqliteSchemaGrammar = class extends SchemaGrammar {
+  static {
+    __name(this, "SqliteSchemaGrammar");
+  }
+};
+
+// src/databases/sqlite/SqliteConnection.mts
+var import_neko_helper5 = require("@devbro/neko-helper");
+var fs = __toESM(require("fs"), 1);
+var SqliteConnection = class _SqliteConnection extends Connection {
+  static {
+    __name(this, "SqliteConnection");
+  }
+  eventManager = new import_neko_helper5.EventManager();
+  on(event, listener) {
+    this.eventManager.on(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.eventManager.off(event, listener);
+    return this;
+  }
+  emit(event, ...args) {
+    return this.eventManager.emit(event, ...args);
+  }
+  connection;
+  config;
+  /** Default configuration values for SQLite connections */
+  static defaults = {
+    readonly: false,
+    fileMustExist: false,
+    timeout: 5e3
+  };
+  constructor(params) {
+    super();
+    this.config = { ..._SqliteConnection.defaults, ...params };
+  }
+  /**
+   * Establishes a connection to the SQLite database
+   * Creates or opens the database file specified in the configuration
+   */
+  async connect() {
+    this.eventManager.emit("connect").catch(() => {
+    });
+    this.connection = new import_better_sqlite3.default(this.config.filename, {
+      readonly: this.config.readonly,
+      fileMustExist: this.config.fileMustExist,
+      timeout: this.config.timeout,
+      verbose: this.config.verbose
+    });
+    return true;
+  }
+  /**
+   * Executes a SQL query against the database
+   * Automatically detects SELECT queries and queries with RETURNING clauses
+   *
+   * @param sql - Compiled SQL or raw SQL string to execute
+   * @returns Query results (rows for SELECT, run info for INSERT/UPDATE/DELETE)
+   */
+  async runQuery(sql) {
+    if (typeof sql === "string") {
+      sql = { sql, bindings: [], parts: [sql] };
+    }
+    this.eventManager.emit("query", { sql: sql.sql, bindings: sql.bindings }).catch(() => {
+    });
+    if (!this.isConnected()) {
+      await this.connect();
+    }
+    try {
+      const stmt = this.connection.prepare(sql.sql);
+      const sqlUpper = sql.sql.trim().toUpperCase();
+      if (sqlUpper.startsWith("SELECT") || sqlUpper.includes("RETURNING")) {
+        return stmt.all(...sql.bindings);
+      } else {
+        const result = stmt.run(...sql.bindings);
+        return result;
+      }
+    } catch (error) {
+      this.eventManager.emit("error", error).catch(() => {
+      });
+      throw error;
+    }
+  }
+  /**
+   * Executes a query and returns an iterator for streaming results
+   * Useful for large result sets to avoid loading all rows into memory
+   *
+   * @param sql - Compiled SQL to execute
+   * @returns Iterator over query results
+   */
+  async runCursor(sql) {
+    if (!this.isConnected()) {
+      await this.connect();
+    }
+    const stmt = this.connection.prepare(sql.sql);
+    return stmt.iterate(...sql.bindings);
+  }
+  /**
+   * Closes the database connection
+   */
+  async disconnect() {
+    if (this.connection === void 0) {
+      return true;
+    }
+    this.connection.close();
+    this.connection = void 0;
+    this.eventManager.emit("disconnect").catch(() => {
+    });
+    return true;
+  }
+  /**
+   * Creates a new query builder instance for this connection
+   */
+  getQuery() {
+    return new Query(this, new SqliteQueryGrammar());
+  }
+  /**
+   * Creates a new schema builder instance for this connection
+   */
+  getSchema() {
+    return new Schema(this, new SqliteSchemaGrammar());
+  }
+  /**
+   * Gets the query grammar for building SQL statements
+   */
+  getQueryGrammar() {
+    return new SqliteQueryGrammar();
+  }
+  /**
+   * Gets the schema grammar for building DDL statements
+   */
+  getSchemaGrammar() {
+    return new SqliteSchemaGrammar();
+  }
+  /**
+   * Starts a new database transaction
+   */
+  async beginTransaction() {
+    await this.runQuery({
+      sql: "BEGIN TRANSACTION",
+      bindings: [],
+      parts: ["BEGIN", "TRANSACTION"]
+    });
+  }
+  /**
+   * Commits the current transaction
+   */
+  async commit() {
+    await this.runQuery({ sql: "COMMIT", bindings: [], parts: ["COMMIT"] });
+  }
+  /**
+   * Rolls back the current transaction
+   */
+  async rollback() {
+    await this.runQuery({ sql: "ROLLBACK", bindings: [], parts: ["ROLLBACK"] });
+  }
+  /**
+   * Checks if the database connection is active
+   */
+  isConnected() {
+    return this.connection !== void 0 && this.connection.open;
+  }
+  /**
+   * Validates and escapes a SQLite identifier (database name, table name, etc.)
+   * Uses a whitelist approach to ensure only safe characters are allowed
+   *
+   * @param name - The identifier to validate and escape
+   * @returns The escaped identifier, quoted if it's a reserved keyword
+   * @throws Error if the identifier contains invalid characters
+   */
+  validateAndEscapeIdentifier(name) {
+    const validIdentifierPattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    if (!validIdentifierPattern.test(name)) {
+      throw new Error(
+        `Invalid identifier: "${name}". Identifiers must start with a letter or underscore and contain only letters, digits, and underscores.`
+      );
+    }
+    const reservedKeywords = /* @__PURE__ */ new Set([
+      "table",
+      "database",
+      "order",
+      "group",
+      "select",
+      "insert",
+      "update",
+      "delete",
+      "index",
+      "from",
+      "where"
+    ]);
+    if (reservedKeywords.has(name.toLowerCase())) {
+      const escapedName = name.replace(/"/g, '""');
+      return `"${escapedName}"`;
+    }
+    return name;
+  }
+  /**
+   * Creates a new SQLite database file
+   *
+   * @param name - Name or path of the database file to create
+   */
+  async createDatabase(name) {
+    const dbPath = name.endsWith(".db") ? name : `${name}.db`;
+    const tempDb = new import_better_sqlite3.default(dbPath);
+    tempDb.close();
+  }
+  /**
+   * Deletes a SQLite database file
+   *
+   * @param name - Name or path of the database file to delete
+   */
+  async dropDatabase(name) {
+    const dbPath = name.endsWith(".db") ? name : `${name}.db`;
+    if (fs.existsSync(dbPath)) {
+      fs.unlinkSync(dbPath);
+    }
+  }
+  /**
+   * Lists available databases
+   * For SQLite, this returns the current database filename
+   *
+   * @returns Array containing the current database filename
+   */
+  async listDatabases() {
+    return [this.config.filename];
+  }
+  /**
+   * Checks if a database file exists
+   *
+   * @param name - Name or path of the database file to check
+   * @returns True if the database file exists, false otherwise
+   */
+  async existsDatabase(name) {
+    const dbPath = name.endsWith(".db") ? name : `${name}.db`;
+    return fs.existsSync(dbPath);
+  }
+};
+
 // src/Migration.mts
 var Migration = class {
   static {
@@ -1376,6 +1658,9 @@ var Migration = class {
   Query,
   QueryGrammar,
   Schema,
-  SchemaGrammar
+  SchemaGrammar,
+  SqliteConnection,
+  SqliteQueryGrammar,
+  SqliteSchemaGrammar
 });
 //# sourceMappingURL=index.js.map