@devbro/neko-sql 0.1.32 → 0.1.34

package/dist/index.js

@@ -37,6 +37,9 @@ __export(index_exports, {
   ForeignKeyConstraint: () => ForeignKeyConstraint,
   IndexConstraint: () => IndexConstraint,
   Migration: () => Migration,
+  MysqlConnection: () => MysqlConnection,
+  MysqlQueryGrammar: () => MysqlQueryGrammar,
+  MysqlSchemaGrammar: () => MysqlSchemaGrammar,
   PostgresqlConnection: () => PostgresqlConnection,
   PostgresqlQueryGrammar: () => PostgresqlQueryGrammar,
   PostgresqlSchemaGrammar: () => PostgresqlSchemaGrammar,
@@ -201,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);
@@ -587,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
@@ -1316,7 +1329,9 @@ 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;
     }
     const conn = new import_pg.Client({
       ..._PostgresqlConnection.pool.options,
@@ -1329,7 +1344,9 @@ 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;
     }
     const conn = new import_pg.Client({
       ..._PostgresqlConnection.pool.options,
@@ -1352,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
@@ -1404,6 +1431,52 @@ 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
@@ -1638,6 +1711,273 @@ var SqliteConnection = class _SqliteConnection extends Connection {
   }
 };
 
+// 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 {
@@ -1652,6 +1992,9 @@ var Migration = class {
   ForeignKeyConstraint,
   IndexConstraint,
   Migration,
+  MysqlConnection,
+  MysqlQueryGrammar,
+  MysqlSchemaGrammar,
   PostgresqlConnection,
   PostgresqlQueryGrammar,
   PostgresqlSchemaGrammar,