@axiosleo/orm-mysql 0.15.1 → 0.15.2

package/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+## 0.15.2 (2026-06-12)
+
+### Fixed
+
+- **Data correctness: `IN` conditions silently matched zero rows on the transaction path.**
+
+  In 0.15.0 / 0.15.1, `whereIn()` / `whereNotIn()` / `where(field, 'IN', array)` executed
+  through `TransactionHandler` silently returned an empty result set (SELECT) or affected
+  0 rows (UPDATE / DELETE), without any error. The same query worked fine through
+  `QueryHandler`.
+
+  Root cause: the SQL builder bound the whole array as a single value, producing
+  `WHERE \`id\` IN (?)` with values `[[1, 2]]`. The non-transaction path uses
+  `conn.query()` (client-side interpolation), which happens to expand array parameters
+  into `IN (1, 2)`. The transaction path uses `conn.execute()` (server-side prepared
+  statement), which never expands arrays, so the condition matched nothing.
+
+  Fix: `Builder` now emits one placeholder per array element (`IN (?,?)`) and binds flat
+  scalar values, so `query` and `execute` behave identically. The transaction path keeps
+  using prepared statements (`conn.execute`).
+
+- The same array-as-single-bind pattern was fixed in the JSON branches: `key->'$.path'`
+  with `IN` / `NOT IN`, `CONTAIN` / `NOT CONTAIN` and `OVERLAPS` / `NOT OVERLAPS` now
+  expand arrays into `JSON_ARRAY(?,?,...)` with scalar bindings.
+
+- Comma-separated string values for `IN` (e.g. `whereIn('id', '1,2,3')`, documented in
+  `index.d.ts`) previously threw `Value must be an array or sub-query for "IN" condition`;
+  they are now split, trimmed and expanded like arrays.
+
+### Unchanged behavior
+
+- Empty arrays (and now empty strings) for `IN` still throw
+  `Value must not be empty for "IN" condition`.
+- `Query` sub-queries for `IN` still render the sub-select SQL.

package/bin/orm-mysql.js

@@ -9,7 +9,7 @@ const app = new App({
   name: 'MySQL ORM CLI',
   desc: 'migrate, model, seed, etc.',
   bin: 'orm-mysql',
-  version: '0.15.1',
+  version: '0.15.2',
   commands_dir: path.join(__dirname, '../commands'),
 });
 

package/commands/skills.js

@@ -118,7 +118,7 @@ class SkillsCommand extends Command {
       printer.info(`Found ${PKG_NAME}@${source.version} in node_modules`);
     } else if (source.outdated) {
       printer.warning(`${PKG_NAME}@${source.localVersion} is installed locally but does not include skills files.`);
-      printer.warning('Skills files are available since v0.15.1. Please update:');
+      printer.warning('Skills files are available since v0.15.2. Please update:');
       printer.warning(`  npm install ${PKG_NAME}@latest`);
       printer.println();
       printer.info(`Using skills from npx ${PKG_NAME}@${source.version} instead.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiosleo/orm-mysql",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "description": "MySQL ORM tool",
   "keywords": [
     "mysql",

package/src/builder.js

@@ -334,6 +334,20 @@ class Builder {
     return null;
   }
 
+  /**
+   * Bind each array element as a single scalar value and return the matching
+   * placeholder list (e.g. "?,?,?"). Binding the whole array as one value only
+   * works with conn.query (client-side interpolation); conn.execute (prepared
+   * statement, used on the transaction path) does not expand arrays and would
+   * silently match nothing.
+   * @param {Array} values
+   * @returns {string}
+   */
+  _buildArrayPlaceholders(values) {
+    values.forEach((item) => this.values.push(item));
+    return values.map(() => '?').join(',');
+  }
+
   _buildConditionBetween(condition, isNot = false) {
     if (!Array.isArray(condition.value) || condition.value.length !== 2) {
       throw new Error('Value must be an array with two elements for "BETWEEN" condition');
@@ -353,22 +367,33 @@ class Builder {
   }
 
   _buildConditionIn(condition, isNot = false) {
-    if (Array.isArray(condition.value) && !condition.value.length) {
+    // "1,2,3" is split into an array, then goes through the same expansion path as arrays
+    let v = is.string(condition.value)
+      ? condition.value.split(',').map(s => s.trim()).filter(s => s.length)
+      : condition.value;
+    if (Array.isArray(v) && !v.length) {
       throw new Error('Value must not be empty for "IN" condition');
-    } else if (!Array.isArray(condition.value) && !(condition.value instanceof Query)) {
+    } else if (!Array.isArray(v) && !(v instanceof Query)) {
       throw new Error('Value must be an array or sub-query for "IN" condition');
     }
     if (condition.key.indexOf('->') !== -1) {
       let keys = condition.key.split('->');
       let k = `${this._buildFieldKey(keys[0])}`;
-      let res = this._buildConditionValues(condition.value);
-      let sql = res ? `JSON_CONTAINS(JSON_ARRAY(${res}), JSON_EXTRACT(${k}, '${keys[1]}'))` :
-        `JSON_CONTAINS(JSON_ARRAY(?), JSON_EXTRACT(${k}, '${keys[1]}'))`;
+      let sql;
+      if (Array.isArray(v)) {
+        sql = `JSON_CONTAINS(JSON_ARRAY(${this._buildArrayPlaceholders(v)}), JSON_EXTRACT(${k}, '${keys[1]}'))`;
+      } else {
+        let res = this._buildConditionValues(v);
+        sql = res ? `JSON_CONTAINS(JSON_ARRAY(${res}), JSON_EXTRACT(${k}, '${keys[1]}'))` :
+          `JSON_CONTAINS(JSON_ARRAY(?), JSON_EXTRACT(${k}, '${keys[1]}'))`;
+      }
       return isNot ? `${sql}=0` : sql;
     }
-    let v = is.string(condition.value) ? condition.value.split(',').map(v => v.trim()) : condition.value;
-    let res = this._buildConditionValues(v);
     const opt = isNot ? 'NOT IN' : 'IN';
+    if (Array.isArray(v)) {
+      return `${this._buildFieldKey(condition.key)} ${opt} (${this._buildArrayPlaceholders(v)})`;
+    }
+    let res = this._buildConditionValues(v);
     return res ? `${this._buildFieldKey(condition.key)} ${opt} (${res})` : `${this._buildFieldKey(condition.key)} ${opt} (?)`;
   }
 
@@ -376,9 +401,14 @@ class Builder {
     if (condition.key.indexOf('->') !== -1) {
       let keys = condition.key.split('->');
       let k = `${this._buildFieldKey(keys[0])}`;
-      let res = this._buildConditionValues(condition.value);
-      let sql = res ? `JSON_CONTAINS(${k}, JSON_ARRAY(${res}), '${keys[1]}')` :
-        `JSON_CONTAINS(${k}, JSON_ARRAY(?), '${keys[1]}')`;
+      let sql;
+      if (Array.isArray(condition.value)) {
+        sql = `JSON_CONTAINS(${k}, JSON_ARRAY(${this._buildArrayPlaceholders(condition.value)}), '${keys[1]}')`;
+      } else {
+        let res = this._buildConditionValues(condition.value);
+        sql = res ? `JSON_CONTAINS(${k}, JSON_ARRAY(${res}), '${keys[1]}')` :
+          `JSON_CONTAINS(${k}, JSON_ARRAY(?), '${keys[1]}')`;
+      }
       return isNot ? `${sql}=0` : sql;
     }
     let res = this._buildConditionValues(condition.value);
@@ -390,9 +420,14 @@ class Builder {
     if (condition.key.indexOf('->') !== -1) {
       let keys = condition.key.split('->');
       let k = `${this._buildFieldKey(keys[0])}`;
-      let res = this._buildConditionValues(condition.value);
-      let sql = res ? `JSON_OVERLAPS(JSON_EXTRACT(${k}, '${keys[1]}'), JSON_ARRAY(${res}))` :
-        `JSON_OVERLAPS(JSON_EXTRACT(${k}, '${keys[1]}'), JSON_ARRAY(?))`;
+      let sql;
+      if (Array.isArray(condition.value)) {
+        sql = `JSON_OVERLAPS(JSON_EXTRACT(${k}, '${keys[1]}'), JSON_ARRAY(${this._buildArrayPlaceholders(condition.value)}))`;
+      } else {
+        let res = this._buildConditionValues(condition.value);
+        sql = res ? `JSON_OVERLAPS(JSON_EXTRACT(${k}, '${keys[1]}'), JSON_ARRAY(${res}))` :
+          `JSON_OVERLAPS(JSON_EXTRACT(${k}, '${keys[1]}'), JSON_ARRAY(?))`;
+      }
       return isNot ? `${sql}=0` : sql;
     }
     let res = this._buildConditionValues(condition.value);