@devbro/neko-sql 0.1.31 → 0.1.34

package/dist/index.js

@@ -37,13 +37,19 @@ __export(index_exports, {
   ForeignKeyConstraint: () => ForeignKeyConstraint,
   IndexConstraint: () => IndexConstraint,
   Migration: () => Migration,
+  MysqlConnection: () => MysqlConnection,
+  MysqlQueryGrammar: () => MysqlQueryGrammar,
+  MysqlSchemaGrammar: () => MysqlSchemaGrammar,
   PostgresqlConnection: () => PostgresqlConnection,
   PostgresqlQueryGrammar: () => PostgresqlQueryGrammar,
   PostgresqlSchemaGrammar: () => PostgresqlSchemaGrammar,
   Query: () => Query,
   QueryGrammar: () => QueryGrammar,
   Schema: () => Schema,
-  SchemaGrammar: () => SchemaGrammar
+  SchemaGrammar: () => SchemaGrammar,
+  SqliteConnection: () => SqliteConnection,
+  SqliteQueryGrammar: () => SqliteQueryGrammar,
+  SqliteSchemaGrammar: () => SqliteSchemaGrammar
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -198,7 +204,9 @@ var Query = class _Query {
   }
   async insertGetId(data, options = { primaryKey: ["id"] }) {
     const csql = this.grammar.compileInsertGetId(this, data, options);
-    return await this.connection?.runQuery(csql);
+    let rc = await this.connection?.runQuery(csql);
+    rc = this.grammar.postProcessGetInsertId(rc);
+    return rc;
   }
   async update(data) {
     const csql = this.grammar.compileUpdate(this, data);
@@ -584,6 +592,14 @@ var QueryGrammar = class {
       bindings: w.bindings
     };
   }
+  /**
+   * post process result from database
+   * @param result result from database
+   * @returns post processed result
+   */
+  postProcessGetInsertId(result) {
+    return result;
+  }
 };
 
 // src/databases/postgresql/PostgresqlQueryGrammar.mts
@@ -1221,7 +1237,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 +1251,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 +1268,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 +1293,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;
@@ -1311,9 +1329,11 @@ var PostgresqlConnection = class _PostgresqlConnection extends Connection {
   }
   async createDatabase(name) {
     if (this.isConnected()) {
-      throw new Error("Cannot create database while connected.");
+      const safeName2 = this.validateAndEscapeIdentifier(name);
+      await this.runQuery(`CREATE DATABASE ${safeName2}`);
+      return;
     }
-    let conn = new import_pg.Client({
+    const conn = new import_pg.Client({
       ..._PostgresqlConnection.pool.options,
       database: "postgres"
     });
@@ -1324,9 +1344,11 @@ var PostgresqlConnection = class _PostgresqlConnection extends Connection {
   }
   async dropDatabase(name) {
     if (this.isConnected()) {
-      throw new Error("Cannot drop database while connected.");
+      const safeName2 = this.validateAndEscapeIdentifier(name);
+      await this.runQuery(`DROP DATABASE ${safeName2}`);
+      return;
     }
-    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
@@ -1347,7 +1369,17 @@ var PostgresqlConnection = class _PostgresqlConnection extends Connection {
   }
   async existsDatabase(name) {
     if (!this.isConnected()) {
-      await this.connect();
+      const conn = new import_pg.Client({
+        ..._PostgresqlConnection.pool.options,
+        database: "postgres"
+      });
+      await conn.connect();
+      const safeName = this.validateAndEscapeIdentifier(name);
+      const result2 = await conn.query("SELECT 1 FROM pg_database WHERE datname = $1", [
+        safeName
+      ]);
+      await conn.end();
+      return result2.rows.length > 0;
     }
     const result = await this.connection.query("SELECT 1 FROM pg_database WHERE datname = $1", [
       name
@@ -1356,6 +1388,596 @@ 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");
+  }
+  compileColumn(column) {
+    const rc = [`${column.columnName}`];
+    if (column.properties.type === "string") {
+      rc.push("varchar(" + column.properties.length + ")");
+    } else if (column.properties.type === "char") {
+      rc.push("char");
+    } else if (column.properties.type === "boolean") {
+      rc.push("boolean");
+    } else if (column.properties.type === "integer") {
+      rc.push("integer");
+    } else if (column.properties.type === "text") {
+      rc.push("text");
+    } else if (column.properties.type === "timestamp") {
+      rc.push("timestamp");
+    } else if (column.properties.type === "timestampz") {
+      rc.push("timestamp with time zone");
+    } else if (column.properties.type === "serial") {
+      rc.push("INTEGER");
+    } else if (column.properties.type === "float") {
+      rc.push("float");
+    } else if (column.properties.type === "double") {
+      rc.push("double precision");
+    } else if (column.properties.type === "date") {
+      rc.push("date");
+    } else if (column.properties.type === "json") {
+      rc.push("json");
+    } else if (column.properties.type === "jsonb") {
+      rc.push("jsonb");
+    } else if (column.properties.type === "raw") {
+      return column.columnName;
+    } else {
+      throw new Error("Unknown column type: " + column.properties.type);
+    }
+    if (column.properties.nullable) {
+      rc.push("null");
+    } else {
+      rc.push("not null");
+    }
+    if (column.properties.unique) {
+      rc.push("unique");
+    }
+    if (column.properties.default !== null) {
+      rc.push("default " + this.escape(column.properties.default));
+    }
+    return rc.join(" ");
+  }
+};
+
+// 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/databases/mysql/MysqlConnection.mts
+var import_promise = __toESM(require("mysql2/promise"), 1);
+
+// src/databases/mysql/MysqlQueryGrammar.mts
+var MysqlQueryGrammar = class extends QueryGrammar {
+  static {
+    __name(this, "MysqlQueryGrammar");
+  }
+  compileInsertGetId(query, data, options = { primaryKey: ["id"] }) {
+    return super.compileInsert(query, data);
+  }
+  postProcessGetInsertId(result) {
+    return [{ id: result.insertId }];
+  }
+};
+
+// src/databases/mysql/MysqlSchemaGrammar.mts
+var MysqlSchemaGrammar = class extends SchemaGrammar {
+  static {
+    __name(this, "MysqlSchemaGrammar");
+  }
+  compileColumn(column) {
+    const rc = [`${column.columnName}`];
+    if (column.properties.type === "string") {
+      rc.push("varchar(" + column.properties.length + ")");
+    } else if (column.properties.type === "char") {
+      rc.push("char");
+    } else if (column.properties.type === "boolean") {
+      rc.push("boolean");
+    } else if (column.properties.type === "integer") {
+      rc.push("integer");
+    } else if (column.properties.type === "text") {
+      rc.push("text");
+    } else if (column.properties.type === "timestamp") {
+      rc.push("TIMESTAMP");
+    } else if (column.properties.type === "timestampz") {
+      rc.push("TIMESTAMP");
+    } else if (column.properties.type === "serial") {
+      rc.push("INT AUTO_INCREMENT");
+    } else if (column.properties.type === "float") {
+      rc.push("float");
+    } else if (column.properties.type === "double") {
+      rc.push("double precision");
+    } else if (column.properties.type === "date") {
+      rc.push("date");
+    } else if (column.properties.type === "json") {
+      rc.push("json");
+    } else if (column.properties.type === "jsonb") {
+      rc.push("jsonb");
+    } else if (column.properties.type === "raw") {
+      return column.columnName;
+    } else {
+      throw new Error("Unknown column type: " + column.properties.type);
+    }
+    if (column.properties.nullable) {
+      rc.push("null");
+    } else {
+      rc.push("NOT NULL");
+    }
+    if (column.properties.unique) {
+      rc.push("unique");
+    }
+    if (column.properties.default !== null) {
+      rc.push("default " + this.escape(column.properties.default));
+    }
+    return rc.join(" ");
+  }
+};
+
+// src/databases/mysql/MysqlConnection.mts
+var import_neko_helper6 = require("@devbro/neko-helper");
+var MysqlConnection = class _MysqlConnection extends Connection {
+  static {
+    __name(this, "MysqlConnection");
+  }
+  eventManager = new import_neko_helper6.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;
+  static pool;
+  static poolConfig;
+  static defaults = {
+    port: 3306,
+    connectionLimit: 20,
+    waitForConnections: true,
+    queueLimit: 0,
+    enableKeepAlive: true,
+    keepAliveInitialDelay: 0
+  };
+  constructor(params) {
+    super();
+    if (!_MysqlConnection.pool) {
+      _MysqlConnection.poolConfig = { ..._MysqlConnection.defaults, ...params };
+      _MysqlConnection.pool = import_promise.default.createPool(_MysqlConnection.poolConfig);
+    }
+  }
+  async connect() {
+    this.eventManager.emit("connect").catch(() => {
+    });
+    this.connection = await _MysqlConnection.pool.getConnection();
+    return true;
+  }
+  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();
+    }
+    const result = await this.connection.query(sql.sql, sql.bindings);
+    return result[0];
+  }
+  async runCursor(sql) {
+    return this.runQuery(sql);
+  }
+  async disconnect() {
+    if (this.connection === void 0) {
+      return true;
+    }
+    this.connection.release();
+    this.connection = void 0;
+    this.eventManager.emit("disconnect").catch(() => {
+    });
+    return true;
+  }
+  getQuery() {
+    return new Query(this, new MysqlQueryGrammar());
+  }
+  getSchema() {
+    return new Schema(this, new MysqlSchemaGrammar());
+  }
+  getQueryGrammar() {
+    return new MysqlQueryGrammar();
+  }
+  getSchemaGrammar() {
+    return new MysqlSchemaGrammar();
+  }
+  async beginTransaction() {
+    await this.runQuery({
+      sql: "BEGIN",
+      bindings: [],
+      parts: ["BEGIN"]
+    });
+  }
+  async commit() {
+    await this.runQuery({ sql: "COMMIT", bindings: [], parts: ["COMMIT"] });
+  }
+  async rollback() {
+    await this.runQuery({ sql: "ROLLBACK", bindings: [], parts: ["ROLLBACK"] });
+  }
+  static destroy() {
+    return _MysqlConnection.pool.end();
+  }
+  isConnected() {
+    return this.connection !== void 0;
+  }
+  /**
+   * Validates and escapes a MySQL identifier (database name, table name, etc.)
+   * Uses a whitelist approach to ensure only safe characters are allowed
+   */
+  validateAndEscapeIdentifier(name) {
+    const validIdentifierPattern = /^[a-zA-Z0-9_$]+$/;
+    if (!validIdentifierPattern.test(name)) {
+      throw new Error(
+        `Invalid identifier: "${name}". Identifiers must contain only letters, digits, underscores, and dollar signs.`
+      );
+    }
+    const reservedKeywords = /* @__PURE__ */ new Set([
+      "database",
+      "table",
+      "user",
+      "order",
+      "group",
+      "select",
+      "insert",
+      "update",
+      "delete",
+      "from",
+      "where",
+      "index",
+      "key"
+    ]);
+    if (reservedKeywords.has(name.toLowerCase())) {
+      const escapedName = name.replace(/`/g, "``");
+      return `\`${escapedName}\``;
+    }
+    return name;
+  }
+  async createDatabase(name) {
+    if (!this.isConnected()) {
+      const tempConn2 = await import_promise.default.createConnection({
+        host: _MysqlConnection.poolConfig.host,
+        user: _MysqlConnection.poolConfig.user,
+        password: _MysqlConnection.poolConfig.password,
+        port: _MysqlConnection.poolConfig.port
+      });
+      const safeName2 = this.validateAndEscapeIdentifier(name);
+      console.log(safeName2);
+      let [rows] = await tempConn2.query(`CREATE DATABASE ${safeName2}`);
+      await tempConn2.end();
+      return;
+    }
+    const tempConn = await import_promise.default.createConnection({
+      host: _MysqlConnection.poolConfig.host,
+      user: _MysqlConnection.poolConfig.user,
+      password: _MysqlConnection.poolConfig.password,
+      port: _MysqlConnection.poolConfig.port
+    });
+    const safeName = this.validateAndEscapeIdentifier(name);
+    await tempConn.query(`CREATE DATABASE ${safeName}`);
+    await tempConn.end();
+  }
+  async dropDatabase(name) {
+    if (this.isConnected()) {
+      throw new Error("Cannot drop database while connected.");
+    }
+    const tempConn = await import_promise.default.createConnection({
+      host: _MysqlConnection.poolConfig.host,
+      user: _MysqlConnection.poolConfig.user,
+      password: _MysqlConnection.poolConfig.password,
+      port: _MysqlConnection.poolConfig.port
+    });
+    const safeName = this.validateAndEscapeIdentifier(name);
+    await tempConn.query(`DROP DATABASE ${safeName}`);
+    await tempConn.end();
+  }
+  async listDatabases() {
+    if (!this.isConnected()) {
+      await this.connect();
+    }
+    const [rows] = await this.connection.query("SHOW DATABASES");
+    return rows.map((row) => row.Database);
+  }
+  async existsDatabase(name) {
+    if (!this.isConnected()) {
+      const tempConn = await import_promise.default.createConnection({
+        host: _MysqlConnection.poolConfig.host,
+        user: _MysqlConnection.poolConfig.user,
+        password: _MysqlConnection.poolConfig.password,
+        port: _MysqlConnection.poolConfig.port
+      });
+      let [rows2] = await tempConn.query(
+        "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = ?",
+        [name]
+      );
+      await tempConn.end();
+      return rows2.length > 0;
+    }
+    const [rows] = await this.connection.query(
+      "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = ?",
+      [name]
+    );
+    return rows.length > 0;
+  }
+};
+
 // src/Migration.mts
 var Migration = class {
   static {
@@ -1370,12 +1992,18 @@ var Migration = class {
   ForeignKeyConstraint,
   IndexConstraint,
   Migration,
+  MysqlConnection,
+  MysqlQueryGrammar,
+  MysqlSchemaGrammar,
   PostgresqlConnection,
   PostgresqlQueryGrammar,
   PostgresqlSchemaGrammar,
   Query,
   QueryGrammar,
   Schema,
-  SchemaGrammar
+  SchemaGrammar,
+  SqliteConnection,
+  SqliteQueryGrammar,
+  SqliteSchemaGrammar
 });
 //# sourceMappingURL=index.js.map