db-model-router 1.0.3 → 1.0.5

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/index.js

@@ -2,6 +2,7 @@ const model = require("./commons/model.js");
 const route = require("./commons/route.js");
 const routers = {
   mysql: "./mysql/db.js",
+  mariadb: "./mysql/db.js",
   postgresql: "./postgres/db.js",
   postgres: "./postgres/db.js",
   oracle: "./oracle/db.js",
@@ -29,6 +30,7 @@ function init(DB_TYPE) {
     if (err.code === "MODULE_NOT_FOUND") {
       const driverMap = {
         mysql: "mysql2",
+        mariadb: "mysql2",
         postgresql: "pg",
         postgres: "pg",
         oracle: "oracledb",

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,

package/src/postgres/db.js

@@ -462,22 +462,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.map(escapeId).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 ${escapeId(table)} (${columns.map(escapeId).join(",")}) VALUES ${valuesClauses.join(",")}`;
-    await client.query(sql, allParams);
+      const sql = `INSERT INTO ${escapeId(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();
@@ -499,31 +507,30 @@ async function _insertOnConflict(table, array, columns, uniqueKeys, total) {
   const pk = await getPkColumn(table);
   const conflictCols = uniqueKeys.map(escapeId).join(",");
   const colList = columns.map(escapeId).join(",");
+  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(",");
-      let sql = `INSERT INTO ${escapeId(table)} (${colList}) VALUES (${placeholders}) ON CONFLICT (${conflictCols}) DO NOTHING`;
+    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 ${escapeId(table)} (${colList}) VALUES ${valuesClauses.join(",")} ON CONFLICT (${conflictCols}) DO NOTHING`;
       if (pk) sql += ` RETURNING ${escapeId(pk)}`;
 
-      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) => `${escapeId(k)} = ${i + 1}`)
-          .join(" AND ");
-        const whereVals = uniqueKeys.map((k) => row[k]);
-        const fetched = await client.query(
-          `SELECT ${escapeId(pk)} FROM ${escapeId(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;
       }
     }
 
@@ -594,20 +601,32 @@ 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.map(escapeId).join(",");
-      const updateSetSql = nonUniqueColumns
-        .map((c) => `${escapeId(c)} = EXCLUDED.${escapeId(c)}`)
-        .join(", ");
+    const updateSetSql = nonUniqueColumns
+      .map((c) => `${escapeId(c)} = EXCLUDED.${escapeId(c)}`)
+      .join(", ");
+    const conflictCols = uniqueKeys.map(escapeId).join(",");
+    const colList = columns.map(escapeId).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 ${escapeId(table)} (${columns.map(escapeId).join(",")}) VALUES (${placeholders}) ON CONFLICT (${conflictCols})`;
+      let sql = `INSERT INTO ${escapeId(table)} (${colList}) VALUES ${valuesClauses.join(",")} ON CONFLICT (${conflictCols})`;
       if (updateSetSql) {
         sql += ` DO UPDATE SET ${updateSetSql}`;
       } else {
@@ -615,9 +634,9 @@ async function upsert(table, data, uniqueKeys = []) {
       }
       if (pk) sql += ` RETURNING ${escapeId(pk)}`;
 
-      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;
       }
     }
 
@@ -656,6 +675,7 @@ module.exports = {
   query,
   qcount,
   remove,
+  delete: remove,
   upsert,
   change: upsert,
   insert,

package/src/redis/db.js

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