db-model-router 1.0.4 → 1.0.5

package/src/cockroachdb/db.js

@@ -371,22 +371,30 @@ async function insert(table, data, uniqueKeys = []) {
     }
   }
 
-  // Bulk insert via multi-row VALUES
+  // Bulk insert via multi-row VALUES in batches of 1000
+  const BATCH_SIZE = 1000;
+  const colList = columns.join(",");
   const client = await pool.connect();
   try {
-    let paramIdx = 0;
-    const allParams = [];
-    const valuesClauses = array.map((row) => {
-      const placeholders = columns.map((c) => {
-        paramIdx++;
-        allParams.push(sanitizeValue(row[c]));
-        return "$" + paramIdx;
+    await client.query("BEGIN");
+    for (let offset = 0; offset < total; offset += BATCH_SIZE) {
+      const batch = array.slice(offset, offset + BATCH_SIZE);
+      let paramIdx = 0;
+      const allParams = [];
+      const valuesClauses = batch.map((row) => {
+        const placeholders = columns.map((c) => {
+          paramIdx++;
+          allParams.push(sanitizeValue(row[c]));
+          return "$" + paramIdx;
+        });
+        return "(" + placeholders.join(",") + ")";
       });
-      return "(" + placeholders.join(",") + ")";
-    });
-    const sql = `INSERT INTO ${table} (${columns.join(",")}) VALUES ${valuesClauses.join(",")}`;
-    await client.query(sql, allParams);
+      const sql = `INSERT INTO ${table} (${colList}) VALUES ${valuesClauses.join(",")}`;
+      await client.query(sql, allParams);
+    }
+    await client.query("COMMIT");
   } catch (e) {
+    await client.query("ROLLBACK").catch(() => {});
     throw mapPgError(e);
   } finally {
     client.release();
@@ -407,35 +415,40 @@ async function _insertOnConflict(table, array, columns, uniqueKeys, total) {
   let lastId = 0;
   const pk = await getPkColumn(table);
   const conflictCols = uniqueKeys.join(",");
+  const colList = columns.join(",");
+  const BATCH_SIZE = 1000;
 
-  for (const row of array) {
-    const vals = columns.map((c) => sanitizeValue(row[c]));
-    const placeholders = columns.map((_, i) => "$" + (i + 1)).join(",");
-    let sql = `INSERT INTO ${table} (${columns.join(",")}) VALUES (${placeholders}) ON CONFLICT (${conflictCols}) DO NOTHING`;
-    if (pk) sql += ` RETURNING ${pk}`;
+  const client = await pool.connect();
+  try {
+    await client.query("BEGIN");
+
+    for (let offset = 0; offset < total; offset += BATCH_SIZE) {
+      const batch = array.slice(offset, offset + BATCH_SIZE);
+      let paramIdx = 0;
+      const allParams = [];
+      const valuesClauses = batch.map((row) => {
+        const placeholders = columns.map((c) => {
+          paramIdx++;
+          allParams.push(sanitizeValue(row[c]));
+          return "$" + paramIdx;
+        });
+        return "(" + placeholders.join(",") + ")";
+      });
+      let sql = `INSERT INTO ${table} (${colList}) VALUES ${valuesClauses.join(",")} ON CONFLICT (${conflictCols}) DO NOTHING`;
+      if (pk) sql += ` RETURNING ${pk}`;
 
-    const client = await pool.connect();
-    try {
-      const result = await client.query(sql, vals);
-      if (result.rows && result.rows.length > 0 && pk) {
-        lastId = result.rows[0][pk] || 0;
-      } else if (total === 1 && pk) {
-        // Row already existed, fetch its PK
-        const whereClauses = uniqueKeys
-          .map((k, i) => `${k} = $${i + 1}`)
-          .join(" AND ");
-        const whereVals = uniqueKeys.map((k) => row[k]);
-        const fetched = await client.query(
-          `SELECT ${pk} FROM ${table} WHERE ${whereClauses}`,
-          whereVals,
-        );
-        if (fetched.rows.length > 0) lastId = fetched.rows[0][pk] || 0;
+      const result = await client.query(sql, allParams);
+      if (pk && result.rows && result.rows.length > 0) {
+        lastId = result.rows[result.rows.length - 1][pk] || lastId;
       }
-    } catch (e) {
-      throw mapPgError(e);
-    } finally {
-      client.release();
     }
+
+    await client.query("COMMIT");
+  } catch (e) {
+    await client.query("ROLLBACK").catch(() => {});
+    throw mapPgError(e);
+  } finally {
+    client.release();
   }
 
   return {
@@ -471,13 +484,13 @@ async function upsert(table, data, uniqueKeys = []) {
         const updateCols = columns.filter((c) => c !== keyCol);
         if (updateCols.length === 0) continue;
         const setClause = updateCols
-          .map((c, i) => `${c} = $${i + 1}`)
+          .map((c, i) => `${c} = ${i + 1}`)
           .join(", ");
         const vals = [
           ...updateCols.map((c) => sanitizeValue(row[c])),
           row[keyCol],
         ];
-        const sql = `UPDATE ${table} SET ${setClause} WHERE ${keyCol} = $${updateCols.length + 1}`;
+        const sql = `UPDATE ${table} SET ${setClause} WHERE ${keyCol} = ${updateCols.length + 1}`;
         await query(sql, vals);
         if (row[keyCol]) lastId = row[keyCol];
       }
@@ -497,34 +510,51 @@ async function upsert(table, data, uniqueKeys = []) {
   const nonUniqueColumns = columns.filter((c) => !uniqueKeys.includes(c));
   const pk = await getPkColumn(table);
   let lastId = 0;
+  const BATCH_SIZE = 1000;
+
+  const client = await pool.connect();
+  try {
+    await client.query("BEGIN");
 
-  for (const row of array) {
-    const vals = columns.map((c) => sanitizeValue(row[c]));
-    const placeholders = columns.map((_, i) => "$" + (i + 1)).join(",");
-    const conflictCols = uniqueKeys.join(",");
     const updateSetSql = nonUniqueColumns
       .map((c) => `${c} = EXCLUDED.${c}`)
       .join(", ");
+    const conflictCols = uniqueKeys.join(",");
+    const colList = columns.join(",");
+
+    for (let offset = 0; offset < total; offset += BATCH_SIZE) {
+      const batch = array.slice(offset, offset + BATCH_SIZE);
+      let paramIdx = 0;
+      const allParams = [];
+      const valuesClauses = batch.map((row) => {
+        const placeholders = columns.map((c) => {
+          paramIdx++;
+          allParams.push(sanitizeValue(row[c]));
+          return "$" + paramIdx;
+        });
+        return "(" + placeholders.join(",") + ")";
+      });
 
-    let sql = `INSERT INTO ${table} (${columns.join(",")}) VALUES (${placeholders}) ON CONFLICT (${conflictCols})`;
-    if (updateSetSql) {
-      sql += ` DO UPDATE SET ${updateSetSql}`;
-    } else {
-      sql += ` DO NOTHING`;
-    }
-    if (pk) sql += ` RETURNING ${pk}`;
+      let sql = `INSERT INTO ${table} (${colList}) VALUES ${valuesClauses.join(",")} ON CONFLICT (${conflictCols})`;
+      if (updateSetSql) {
+        sql += ` DO UPDATE SET ${updateSetSql}`;
+      } else {
+        sql += ` DO NOTHING`;
+      }
+      if (pk) sql += ` RETURNING ${pk}`;
 
-    const client = await pool.connect();
-    try {
-      const result = await client.query(sql, vals);
-      if (result.rows && result.rows.length > 0 && pk) {
-        lastId = result.rows[0][pk] || 0;
+      const result = await client.query(sql, allParams);
+      if (pk && result.rows && result.rows.length > 0) {
+        lastId = result.rows[result.rows.length - 1][pk] || lastId;
       }
-    } catch (e) {
-      throw mapPgError(e);
-    } finally {
-      client.release();
     }
+
+    await client.query("COMMIT");
+  } catch (e) {
+    await client.query("ROLLBACK").catch(() => {});
+    throw mapPgError(e);
+  } finally {
+    client.release();
   }
 
   const response = {
@@ -554,6 +584,7 @@ module.exports = {
   query,
   qcount,
   remove,
+  delete: remove,
   upsert,
   change: upsert,
   insert,

package/src/commons/route.js

@@ -157,12 +157,10 @@ module.exports = function route(model, override = {}) {
     })
     .post("/", (req, res) => {
       if (!req.body || !Array.isArray(req.body.data)) {
-        return res
-          .status(400)
-          .send({
-            type: "danger",
-            message: "Request body must contain a 'data' array",
-          });
+        return res.status(400).send({
+          type: "danger",
+          message: "Request body must contain a 'data' array",
+        });
       }
       let payload = payloadOverride(req.body.data, req, override);
       model
@@ -176,12 +174,10 @@ module.exports = function route(model, override = {}) {
     })
     .put("/", (req, res) => {
       if (!req.body || !Array.isArray(req.body.data)) {
-        return res
-          .status(400)
-          .send({
-            type: "danger",
-            message: "Request body must contain a 'data' array",
-          });
+        return res.status(400).send({
+          type: "danger",
+          message: "Request body must contain a 'data' array",
+        });
       }
       let payload = payloadOverride(req.body.data, req, override);
       model
@@ -194,15 +190,19 @@ module.exports = function route(model, override = {}) {
         });
     })
     .delete("/", (req, res) => {
-      if (!req.body || !Array.isArray(req.body.data)) {
-        return res
-          .status(400)
-          .send({
-            type: "danger",
-            message: "Request body must contain a 'data' array",
-          });
+      if (!req.body || Object.keys(req.body).length === 0) {
+        return res.status(400).send({
+          type: "danger",
+          message: "Request body must contain filter criteria",
+        });
+      }
+      // Accept { data: [...] } (legacy array) or plain filter object in body
+      let payload;
+      if (req.body.data && Array.isArray(req.body.data)) {
+        payload = payloadOverride(req.body.data, req, override);
+      } else {
+        payload = payloadOverride(req.body, req, override);
       }
-      let payload = payloadOverride(req.body.data, req, override);
       model
         .remove(payload)
         .then((response) => {

package/src/commons/validator.js

@@ -107,10 +107,66 @@ function getErrorMessage(errors) {
   }
   return message;
 }
+function parseFilterValue(value) {
+  if (typeof value !== "string") {
+    return ["=", value];
+  }
+
+  // !in(john,snow,ram) -> not in
+  if (/^!in\((.+)\)$/i.test(value)) {
+    const items = value.match(/^!in\((.+)\)$/i)[1].split(",");
+    return ["not in", items];
+  }
+
+  // in(john,snow,ram) -> in
+  if (/^in\((.+)\)$/i.test(value)) {
+    const items = value.match(/^in\((.+)\)$/i)[1].split(",");
+    return ["in", items];
+  }
+
+  // !%john% -> not like
+  if (value.startsWith("!") && value.slice(1).includes("%")) {
+    return ["not like", value.slice(1)];
+  }
+
+  // %john% -> like
+  if (value.includes("%")) {
+    return ["like", value];
+  }
+
+  // >= (value arrives as >=xxx after URL decoding of >%3Dxxx)
+  if (value.startsWith(">=")) {
+    return [">=", value.slice(2)];
+  }
+
+  // <= (value arrives as <=xxx after URL decoding of <%3Dxxx)
+  if (value.startsWith("<=")) {
+    return ["<=", value.slice(2)];
+  }
+
+  // > greater than
+  if (value.startsWith(">")) {
+    return [">", value.slice(1)];
+  }
+
+  // < less than
+  if (value.startsWith("<")) {
+    return ["<", value.slice(1)];
+  }
+
+  // !value -> not equal
+  if (value.startsWith("!")) {
+    return ["!=", value.slice(1)];
+  }
+
+  return ["=", value];
+}
+
 function objectToFilter(obj) {
   let filterArray = [];
   for (let key in obj) {
-    filterArray.push([key, "=", obj[key]]);
+    let [operator, value] = parseFilterValue(obj[key]);
+    filterArray.push([key, operator, value]);
   }
   return [filterArray];
 }
@@ -150,6 +206,7 @@ module.exports = {
   errorResponse,
   validateInput,
   getErrorMessage,
+  parseFilterValue,
   objectToFilter,
   dataToFilter,
 };

package/src/dynamodb/db.js

@@ -295,27 +295,43 @@ async function remove(table, filter, safeDelete = null) {
   const items = await getAllMatchingItems(table, whereData);
 
   if (safeDelete != null) {
-    // Soft delete: update each item
-    for (const item of items) {
-      const key = extractKey(item);
-      await docClient.send(
-        new UpdateCommand({
-          TableName: tableName(table),
-          Key: key,
-          UpdateExpression: `SET #sd = :sdVal`,
-          ExpressionAttributeNames: { "#sd": safeDelete },
-          ExpressionAttributeValues: { ":sdVal": 1 },
-        }),
+    // Soft delete: update each item in parallel batches
+    const CONCURRENCY = 25;
+    for (let i = 0; i < items.length; i += CONCURRENCY) {
+      const batch = items.slice(i, i + CONCURRENCY);
+      await Promise.all(
+        batch.map((item) =>
+          docClient.send(
+            new UpdateCommand({
+              TableName: tableName(table),
+              Key: extractKey(item),
+              UpdateExpression: `SET #sd = :sdVal`,
+              ExpressionAttributeNames: { "#sd": safeDelete },
+              ExpressionAttributeValues: { ":sdVal": 1 },
+            }),
+          ),
+        ),
       );
     }
   } else {
-    // Hard delete
-    for (const item of items) {
-      const key = extractKey(item);
-      await docClient.send(
-        new DeleteCommand({
-          TableName: tableName(table),
-          Key: key,
+    // Hard delete in batches of 25, run in parallel groups
+    const PARALLEL = 40;
+    const deleteBatches = [];
+    for (let i = 0; i < items.length; i += 25) {
+      deleteBatches.push(items.slice(i, i + 25));
+    }
+    for (let i = 0; i < deleteBatches.length; i += PARALLEL) {
+      const group = deleteBatches.slice(i, i + PARALLEL);
+      await Promise.all(
+        group.map((batch) => {
+          const requestItems = {
+            [tableName(table)]: batch.map((item) => ({
+              DeleteRequest: { Key: extractKey(item) },
+            })),
+          };
+          return docClient.send(
+            new BatchWriteCommand({ RequestItems: requestItems }),
+          );
         }),
       );
     }
@@ -437,20 +453,26 @@ async function insert(table, data, uniqueKeys = []) {
       }
       return response;
     } else {
-      // Batch write (max 25 items per batch)
+      // Batch write (max 25 items per batch), run in parallel groups
       const batches = [];
       for (let i = 0; i < array.length; i += 25) {
         batches.push(array.slice(i, i + 25));
       }
 
-      for (const batch of batches) {
-        const requestItems = {
-          [tableName(table)]: batch.map((item) => ({
-            PutRequest: { Item: item },
-          })),
-        };
-        await docClient.send(
-          new BatchWriteCommand({ RequestItems: requestItems }),
+      const PARALLEL = 40;
+      for (let i = 0; i < batches.length; i += PARALLEL) {
+        const group = batches.slice(i, i + PARALLEL);
+        await Promise.all(
+          group.map((batch) => {
+            const requestItems = {
+              [tableName(table)]: batch.map((item) => ({
+                PutRequest: { Item: item },
+              })),
+            };
+            return docClient.send(
+              new BatchWriteCommand({ RequestItems: requestItems }),
+            );
+          }),
         );
       }
 
@@ -544,6 +566,7 @@ module.exports = {
   where,
   qcount,
   remove,
+  delete: remove,
   upsert,
   change: upsert,
   insert,

package/src/mongodb/db.js

@@ -373,6 +373,7 @@ module.exports = {
   query,
   qcount,
   remove,
+  delete: remove,
   upsert,
   change: upsert,
   insert,

package/src/mssql/db.js

@@ -280,51 +280,61 @@ async function upsert(table, data, uniqueKeys = []) {
   const columns = Object.keys(array[0]);
   const nonUniqueColumns = columns.filter((c) => !uniqueKeys.includes(c));
   let lastId = 0;
+  // MSSQL has a 2100 parameter limit per request
+  const MAX_PARAMS = 2000;
+  const BATCH_SIZE = Math.max(1, Math.floor(MAX_PARAMS / columns.length));
 
-  for (const row of array) {
-    const request = pool.request();
-    let paramIdx = 0;
-
-    // Build source VALUES
-    const valuePlaceholders = columns.map((c) => {
-      const p = "@param" + paramIdx;
-      request.input("param" + paramIdx, row[c]);
-      paramIdx++;
-      return p;
-    });
+  const transaction = new sql.Transaction(pool);
+  await transaction.begin();
+  try {
+    for (let offset = 0; offset < total; offset += BATCH_SIZE) {
+      const batch = array.slice(offset, offset + BATCH_SIZE);
+      const request = new sql.Request(transaction);
+      let paramIdx = 0;
+
+      const valueRows = batch.map((row) => {
+        const placeholders = columns.map((c) => {
+          const p = "@p" + paramIdx;
+          request.input("p" + paramIdx, row[c]);
+          paramIdx++;
+          return p;
+        });
+        return "(" + placeholders.join(",") + ")";
+      });
+
+      const colList = columns.map(escapeId).join(",");
+      const onClause = uniqueKeys
+        .map((k) => `target.${escapeId(k)} = source.${escapeId(k)}`)
+        .join(" AND ");
 
-    const colList = columns.map(escapeId).join(",");
-    const onClause = uniqueKeys
-      .map((k) => `target.${escapeId(k)} = source.${escapeId(k)}`)
-      .join(" AND ");
+      let mergeSql = `MERGE INTO ${escapeId(table)} AS target`;
+      mergeSql += ` USING (VALUES ${valueRows.join(",")}) AS source (${colList})`;
+      mergeSql += ` ON ${onClause}`;
 
-    let mergeSql = `MERGE INTO ${escapeId(table)} AS target`;
-    mergeSql += ` USING (VALUES (${valuePlaceholders.join(",")})) AS source (${colList})`;
-    mergeSql += ` ON ${onClause}`;
+      if (nonUniqueColumns.length > 0) {
+        const updateSet = nonUniqueColumns
+          .map((c) => `target.${escapeId(c)} = source.${escapeId(c)}`)
+          .join(",");
+        mergeSql += ` WHEN MATCHED THEN UPDATE SET ${updateSet}`;
+      }
 
-    if (nonUniqueColumns.length > 0) {
-      const updateSet = nonUniqueColumns
-        .map((c) => `target.${escapeId(c)} = source.${escapeId(c)}`)
+      const insertCols = nonUniqueColumns.map((c) => escapeId(c)).join(",");
+      const insertVals = nonUniqueColumns
+        .map((c) => `source.${escapeId(c)}`)
         .join(",");
-      mergeSql += ` WHEN MATCHED THEN UPDATE SET ${updateSet}`;
-    }
+      mergeSql += ` WHEN NOT MATCHED THEN INSERT (${insertCols}) VALUES (${insertVals})`;
+      mergeSql += ` OUTPUT INSERTED.*;`;
 
-    const insertCols = nonUniqueColumns.map((c) => escapeId(c)).join(",");
-    const insertVals = nonUniqueColumns
-      .map((c) => `source.${escapeId(c)}`)
-      .join(",");
-    mergeSql += ` WHEN NOT MATCHED THEN INSERT (${insertCols}) VALUES (${insertVals})`;
-    mergeSql += ` OUTPUT INSERTED.*;`;
-
-    try {
       const result = await request.query(mergeSql);
       if (result.recordset && result.recordset.length > 0) {
-        const firstRow = result.recordset[0];
-        lastId = firstRow.id || firstRow[Object.keys(firstRow)[0]] || 0;
+        const lastRow = result.recordset[result.recordset.length - 1];
+        lastId = lastRow.id || lastRow[Object.keys(lastRow)[0]] || lastId;
       }
-    } catch (e) {
-      throw mapMssqlError(e);
     }
+    await transaction.commit();
+  } catch (e) {
+    await transaction.rollback().catch(() => {});
+    throw mapMssqlError(e);
   }
 
   const response = {
@@ -395,36 +405,53 @@ async function insert(table, data, uniqueKeys = []) {
     }
   }
 
-  // Bulk insert
-  for (const row of array) {
-    const request = pool.request();
-    const colList = columns.map(escapeId).join(",");
-    const valuePlaceholders = columns.map((c, i) => {
-      request.input("param" + i, row[c]);
-      return "@param" + i;
-    });
-
-    let sqlStr;
-    if (hasAllUniqueKeys) {
-      const onClause = uniqueKeys
-        .map((k) => `target.${escapeId(k)} = source.${escapeId(k)}`)
-        .join(" AND ");
-      const insertCols = columns.map(escapeId).join(",");
-      const insertVals = columns.map((c) => `source.${escapeId(c)}`).join(",");
+  // Bulk insert in batches within a transaction
+  // MSSQL has a 2100 parameter limit per request
+  const MAX_PARAMS = 2000;
+  const BATCH_SIZE = Math.max(1, Math.floor(MAX_PARAMS / columns.length));
+  const transaction = new sql.Transaction(pool);
+  await transaction.begin();
+  try {
+    for (let offset = 0; offset < total; offset += BATCH_SIZE) {
+      const batch = array.slice(offset, offset + BATCH_SIZE);
+      const request = new sql.Request(transaction);
+      let paramIdx = 0;
+
+      const valueRows = batch.map((row) => {
+        const placeholders = columns.map((c) => {
+          const p = "@p" + paramIdx;
+          request.input("p" + paramIdx, row[c]);
+          paramIdx++;
+          return p;
+        });
+        return "(" + placeholders.join(",") + ")";
+      });
+
+      const colList = columns.map(escapeId).join(",");
+      let sqlStr;
+      if (hasAllUniqueKeys) {
+        const onClause = uniqueKeys
+          .map((k) => `target.${escapeId(k)} = source.${escapeId(k)}`)
+          .join(" AND ");
+        const insertCols = columns.map(escapeId).join(",");
+        const insertVals = columns
+          .map((c) => `source.${escapeId(c)}`)
+          .join(",");
 
-      sqlStr = `MERGE INTO ${escapeId(table)} AS target`;
-      sqlStr += ` USING (VALUES (${valuePlaceholders.join(",")})) AS source (${colList})`;
-      sqlStr += ` ON ${onClause}`;
-      sqlStr += ` WHEN NOT MATCHED THEN INSERT (${insertCols}) VALUES (${insertVals});`;
-    } else {
-      sqlStr = `INSERT INTO ${escapeId(table)} (${colList}) VALUES (${valuePlaceholders.join(",")})`;
-    }
+        sqlStr = `MERGE INTO ${escapeId(table)} AS target`;
+        sqlStr += ` USING (VALUES ${valueRows.join(",")}) AS source (${colList})`;
+        sqlStr += ` ON ${onClause}`;
+        sqlStr += ` WHEN NOT MATCHED THEN INSERT (${insertCols}) VALUES (${insertVals});`;
+      } else {
+        sqlStr = `INSERT INTO ${escapeId(table)} (${colList}) VALUES ${valueRows.join(",")}`;
+      }
 
-    try {
       await request.query(sqlStr);
-    } catch (e) {
-      throw mapMssqlError(e);
     }
+    await transaction.commit();
+  } catch (e) {
+    await transaction.rollback().catch(() => {});
+    throw mapMssqlError(e);
   }
 
   return {
@@ -453,6 +480,7 @@ module.exports = {
   query,
   qcount,
   remove,
+  delete: remove,
   upsert,
   change: upsert,
   insert,

package/src/mysql/db.js

@@ -375,6 +375,7 @@ module.exports = {
   query,
   qcount,
   remove,
+  delete: remove,
   upsert,
   change: upsert,
   pool,

package/src/oracle/db.js

@@ -846,6 +846,7 @@ module.exports = {
   query,
   qcount,
   remove,
+  delete: remove,
   upsert,
   change: upsert,
   insert,