db-model-router 1.0.3 → 1.0.5

package/src/cli/init/prompt.js

@@ -5,6 +5,7 @@ const inquirer = require("inquirer");
 const VALID_FRAMEWORKS = ["ultimate-express", "express"];
 const VALID_DATABASES = [
   "mysql",
+  "mariadb",
   "postgres",
   "sqlite3",
   "mongodb",
@@ -56,12 +57,17 @@ function parseInitArgs(argv) {
   }
 
   // Boolean flags
-  for (const flag of ["rateLimiting", "helmet", "logger"]) {
+  for (const flag of ["rateLimiting", "helmet", "logger", "loki"]) {
     if (args[flag] !== undefined) {
       partial[flag] = parseBool(args[flag]);
     }
   }
 
+  // Output directory
+  if (args.output !== undefined && args.output !== "true") {
+    partial.output = args.output;
+  }
+
   return partial;
 }
 
@@ -114,12 +120,22 @@ async function promptUser(prefilledAnswers) {
     });
   }
 
+  if (prefilled.output === undefined) {
+    questions.push({
+      type: "input",
+      name: "output",
+      message:
+        "Output directory for backend source files (leave empty for root):",
+      default: "",
+    });
+  }
+
   if (prefilled.rateLimiting === undefined) {
     questions.push({
       type: "confirm",
       name: "rateLimiting",
       message: "Enable rate limiting?",
-      default: false,
+      default: true,
     });
   }
 
@@ -128,7 +144,7 @@ async function promptUser(prefilledAnswers) {
       type: "confirm",
       name: "helmet",
       message: "Enable Helmet security headers?",
-      default: false,
+      default: true,
     });
   }
 
@@ -136,8 +152,8 @@ async function promptUser(prefilledAnswers) {
     questions.push({
       type: "confirm",
       name: "logger",
-      message: "Enable request/response logger?",
-      default: false,
+      message: "Enable request/response logger (Winston)?",
+      default: true,
     });
   }
 
@@ -147,6 +163,22 @@ async function promptUser(prefilledAnswers) {
   }
 
   const prompted = await inquirer.prompt(questions);
+
+  // Follow-up: if logger is enabled, ask about Loki
+  if (prompted.logger && prefilled.loki === undefined) {
+    const lokiAnswer = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "loki",
+        message: "Send logs to Grafana Loki?",
+        default: false,
+      },
+    ]);
+    prompted.loki = lokiAnswer.loki;
+  } else if (!prompted.logger && prefilled.logger === undefined) {
+    prompted.loki = false;
+  }
+
   return Object.assign({}, prefilled, prompted);
 }
 

package/src/cli/init.js

@@ -7,14 +7,26 @@ const { execSync } = require("child_process");
 
 const {
   generateAppJs,
+  generateAppJsV2,
   generateEnvFile,
   generateEnvExample,
   generateLoggerMiddleware,
-  generateMigrateScript,
-  generateAddMigrationScript,
   generateInitialMigration,
   generateSessionMigration,
   generateGitignore,
+  generateDockerfile,
+  generateDockerignore,
+  generateGrafanaDatasources,
+  generateDockerCompose,
+  generateCloudBeaverDataSources,
+  generateSessionJs,
+  generateMigrateModule,
+  generateAddMigrationModule,
+  generateSecurityJs,
+  generateHealthRoute,
+  generateRouteIndexFile,
+  generateDbModule,
+  randomPassword,
 } = require("./init/generators");
 
 const { collectDependencies, getScripts } = require("./init/dependencies");
@@ -61,40 +73,139 @@ function safeWriteFile(filePath, content) {
  * Creates directories and writes files. Skips files that already exist.
  * Returns the list of generated filenames for the summary.
  * @param {import('./init/types').InitAnswers} answers
+ * @param {string} [outputDir] - relative directory for source files (e.g. "backend")
  * @returns {{ files: string[], migrationFiles: string[] }}
  */
-function generateFiles(answers) {
+function generateFiles(answers, outputDir) {
   const files = [];
   const migrationFiles = [];
 
+  // Resolve source directory (outputDir-relative or cwd)
+  const srcBase = outputDir || ".";
+
+  // Generate random secrets (shared between .env and docker-compose)
+  const secrets = {
+    dbPass: randomPassword(),
+    redisPass: answers.session === "redis" ? randomPassword() : "",
+    sessionSecret: randomPassword(32),
+  };
+
   // Create directories
-  if (!fs.existsSync("middleware")) {
-    fs.mkdirSync("middleware", { recursive: true });
+  const dirs = [
+    path.join(srcBase, "middleware"),
+    path.join(srcBase, "migrations"),
+    path.join(srcBase, "commons"),
+    path.join(srcBase, "routes"),
+  ];
+  // SQLite3 needs a data/ folder for the database file
+  if (answers.database === "sqlite3") {
+    dirs.push("data");
   }
-  if (!fs.existsSync("migrations")) {
-    fs.mkdirSync("migrations", { recursive: true });
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
   }
 
-  // Write files (skip if they already exist)
-  if (safeWriteFile("app.js", generateAppJs(answers))) files.push("app.js");
-  if (safeWriteFile(".env", generateEnvFile(answers))) files.push(".env");
+  // Root-level files (always in cwd, not in outputDir)
+  // app.js uses the v2 generator that links commons/route modules
+  if (safeWriteFile("app.js", generateAppJsV2(answers, outputDir || "")))
+    files.push("app.js");
+  if (safeWriteFile(".env", generateEnvFile(answers, secrets)))
+    files.push(".env");
   if (safeWriteFile(".env.example", generateEnvExample(answers)))
     files.push(".env.example");
-
-  const loggerPath = path.join("middleware", "logger.js");
-  if (safeWriteFile(loggerPath, generateLoggerMiddleware(answers)))
-    files.push("middleware/logger.js");
-
-  if (safeWriteFile("migrate.js", generateMigrateScript(answers)))
-    files.push("migrate.js");
-  if (safeWriteFile("add_migration.js", generateAddMigrationScript(answers)))
-    files.push("add_migration.js");
   if (safeWriteFile(".gitignore", generateGitignore()))
     files.push(".gitignore");
 
-  // Initial migration
+  // docker-compose.yml (if the database needs Docker)
+  const dockerCompose = generateDockerCompose(answers, secrets);
+  if (dockerCompose !== null) {
+    if (safeWriteFile("docker-compose.yml", dockerCompose))
+      files.push("docker-compose.yml");
+  }
+
+  // CloudBeaver data-sources.json (auto-connect config)
+  const cbDataSources = generateCloudBeaverDataSources(answers, secrets);
+  if (cbDataSources !== null) {
+    const cbDir = ".cloudbeaver";
+    if (!fs.existsSync(cbDir)) {
+      fs.mkdirSync(cbDir, { recursive: true });
+    }
+    const cbPath = path.join(cbDir, "data-sources.json");
+    if (safeWriteFile(cbPath, cbDataSources))
+      files.push(".cloudbeaver/data-sources.json");
+  }
+
+  // Grafana datasource provisioning (when loki is enabled)
+  if (answers.loki) {
+    const grafanaDir = ".grafana";
+    if (!fs.existsSync(grafanaDir)) {
+      fs.mkdirSync(grafanaDir, { recursive: true });
+    }
+    const grafanaPath = path.join(grafanaDir, "datasources.yml");
+    if (safeWriteFile(grafanaPath, generateGrafanaDatasources()))
+      files.push(".grafana/datasources.yml");
+  }
+
+  // Dockerfile and .dockerignore
+  if (safeWriteFile("Dockerfile", generateDockerfile(answers, outputDir)))
+    files.push("Dockerfile");
+  if (safeWriteFile(".dockerignore", generateDockerignore()))
+    files.push(".dockerignore");
+
+  // Source files inside outputDir (or cwd if no outputDir)
+  const loggerPath = path.join(srcBase, "middleware", "logger.js");
+  if (safeWriteFile(loggerPath, generateLoggerMiddleware(answers)))
+    files.push(path.join(srcBase, "middleware/logger.js"));
+
+  // commons/session.js
+  const sessionPath = path.join(srcBase, "commons", "session.js");
+  if (safeWriteFile(sessionPath, generateSessionJs(answers)))
+    files.push(path.join(srcBase, "commons/session.js"));
+
+  // commons/migrate.js
+  const migratePath = path.join(srcBase, "commons", "migrate.js");
+  if (safeWriteFile(migratePath, generateMigrateModule(answers, outputDir)))
+    files.push(path.join(srcBase, "commons/migrate.js"));
+
+  // commons/add_migration.js
+  const addMigrationPath = path.join(srcBase, "commons", "add_migration.js");
+  if (
+    safeWriteFile(
+      addMigrationPath,
+      generateAddMigrationModule(answers, outputDir),
+    )
+  )
+    files.push(path.join(srcBase, "commons/add_migration.js"));
+
+  // commons/security.js
+  const securityPath = path.join(srcBase, "commons", "security.js");
+  if (safeWriteFile(securityPath, generateSecurityJs(answers)))
+    files.push(path.join(srcBase, "commons/security.js"));
+
+  // commons/db.js
+  const dbPath = path.join(srcBase, "commons", "db.js");
+  if (safeWriteFile(dbPath, generateDbModule(answers)))
+    files.push(path.join(srcBase, "commons/db.js"));
+
+  // routes/health.js
+  const healthPath = path.join(srcBase, "routes", "health.js");
+  if (safeWriteFile(healthPath, generateHealthRoute()))
+    files.push(path.join(srcBase, "routes/health.js"));
+
+  // routes/index.js
+  const routeIndexPath = path.join(srcBase, "routes", "index.js");
+  if (safeWriteFile(routeIndexPath, generateRouteIndexFile()))
+    files.push(path.join(srcBase, "routes/index.js"));
+
+  // Initial migration (inside outputDir/migrations)
   const initialMigration = generateInitialMigration(answers);
-  const initialPath = path.join("migrations", initialMigration.filename);
+  const initialPath = path.join(
+    srcBase,
+    "migrations",
+    initialMigration.filename,
+  );
   if (safeWriteFile(initialPath, initialMigration.content)) {
     migrationFiles.push(initialMigration.filename);
   }
@@ -102,8 +213,12 @@ function generateFiles(answers) {
   // Conditional session migration
   const sessionMigration = generateSessionMigration(answers);
   if (sessionMigration !== null) {
-    const sessionPath = path.join("migrations", sessionMigration.filename);
-    if (safeWriteFile(sessionPath, sessionMigration.content)) {
+    const sessionMigPath = path.join(
+      srcBase,
+      "migrations",
+      sessionMigration.filename,
+    );
+    if (safeWriteFile(sessionMigPath, sessionMigration.content)) {
       migrationFiles.push(sessionMigration.filename);
     }
   }
@@ -114,8 +229,9 @@ function generateFiles(answers) {
 /**
  * Update package.json with scripts and dependencies from the answers.
  * @param {import('./init/types').InitAnswers} answers
+ * @param {string} [outputDir] - relative output directory for source files
  */
-function updatePackageJson(answers) {
+function updatePackageJson(answers, outputDir) {
   let raw;
   try {
     raw = fs.readFileSync("package.json", "utf8");
@@ -135,8 +251,9 @@ function updatePackageJson(answers) {
   }
 
   const { dependencies, devDependencies } = collectDependencies(answers);
-  const scripts = getScripts();
+  const scripts = getScripts(outputDir);
 
+  pkg.type = "module";
   pkg.scripts = Object.assign({}, pkg.scripts || {}, scripts);
   pkg.dependencies = Object.assign({}, pkg.dependencies || {}, dependencies);
   pkg.devDependencies = Object.assign(
@@ -247,6 +364,9 @@ Options:
                         cockroachdb, oracle, redis, dynamodb
   --db <name>           Alias for --database
   --session <type>      Session store: memory, redis, database
+  --output <dir>        Directory for backend source files (e.g. --output backend).
+                        package.json stays in root; index.js, commons/, routes/,
+                        middleware/, and migrations/ go inside the output folder.
   --rateLimiting        Enable rate limiting (express-rate-limit)
   --helmet              Enable Helmet security headers
   --logger              Enable request/response logger (express-mung)
@@ -256,6 +376,9 @@ Examples:
   # Fully non-interactive (LLM-friendly)
   db-model-router-init --framework express --database postgres --session redis --rateLimiting --helmet --logger
 
+  # With output directory
+  db-model-router-init --framework express --database postgres --output backend --yes
+
   # Partial — only prompts for missing values
   db-model-router-init --database mysql --session memory
 

package/src/cli/main.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 "use strict";
 
 const { parseFlags, OutputContext } = require("./flags");
@@ -8,6 +8,7 @@ const inspectCmd = require("./commands/inspect");
 const generateCmd = require("./commands/generate");
 const doctorCmd = require("./commands/doctor");
 const diffCmd = require("./commands/diff");
+const helpCmd = require("./commands/help");
 
 /**
  * Map of subcommand names to their handler functions.
@@ -18,6 +19,7 @@ const COMMANDS = {
   generate: generateCmd,
   doctor: doctorCmd,
   diff: diffCmd,
+  help: helpCmd,
 };
 
 /**
@@ -29,23 +31,74 @@ const COMMAND_DESCRIPTIONS = {
   generate: "Generate models, routes, tests, and OpenAPI spec from a schema",
   doctor: "Validate schema, check dependencies, and verify file sync",
   diff: "Preview changes between current files and what the schema would produce",
+  help: "Show help for a command",
 };
 
 /**
- * Print help message listing all available subcommands.
+ * Per-command flag summaries shown in the general help overview.
+ */
+const COMMAND_FLAGS = {
+  init: [
+    ["--from <path>", "Read config from a schema file"],
+    ["--framework <name>", "express, ultimate-express"],
+    [
+      "--database <name>",
+      "mysql, mariadb, postgres, sqlite3, mongodb, mssql, cockroachdb, oracle, redis, dynamodb",
+    ],
+    ["--db <name>", "Alias for --database"],
+    ["--session <type>", "memory, redis, database"],
+    ["--output <dir>", "Directory for backend source files"],
+    ["--rateLimiting", "Enable rate limiting (default: yes)"],
+    ["--helmet", "Enable Helmet security headers (default: yes)"],
+    ["--logger", "Enable Winston + Loki logger (default: yes)"],
+  ],
+  inspect: [
+    ["--type <adapter>", "Database adapter (required)"],
+    ["--env <path>", "Path to .env file"],
+    ["--out <path>", "Output file (default: dbmr.schema.json)"],
+    ["--tables <list>", "Comma-separated table filter"],
+  ],
+  generate: [
+    ["--from <path>", "Schema file (default: dbmr.schema.json)"],
+    ["--models", "Generate only model files"],
+    ["--routes", "Generate only route files"],
+    ["--openapi", "Generate only OpenAPI spec"],
+    ["--tests", "Generate only test files"],
+    ["--llm-docs", "Generate only LLM documentation"],
+  ],
+  doctor: [["--from <path>", "Schema file (default: dbmr.schema.json)"]],
+  diff: [["--from <path>", "Schema file (default: dbmr.schema.json)"]],
+};
+
+/**
+ * Print help message listing all available subcommands with their flags.
  */
 function printHelp() {
   console.log("Usage: db-model-router <command> [options]\n");
-  console.log("Commands:");
+
+  console.log("Commands:\n");
   for (const [name, desc] of Object.entries(COMMAND_DESCRIPTIONS)) {
+    if (name === "help") {
+      console.log(`  ${name.padEnd(12)} ${desc}`);
+      continue;
+    }
     console.log(`  ${name.padEnd(12)} ${desc}`);
+    const flags = COMMAND_FLAGS[name];
+    if (flags) {
+      for (const [flag, info] of flags) {
+        console.log(`    ${flag.padEnd(22)} ${info}`);
+      }
+      console.log("");
+    }
   }
-  console.log("\nGlobal flags:");
-  console.log("  --yes          Accept all defaults without prompting");
-  console.log("  --json         Output machine-readable JSON");
-  console.log("  --dry-run      Preview actions without side effects");
-  console.log("  --no-install   Skip npm install step");
-  console.log("  --help         Show help for a command");
+
+  console.log("Global flags (all commands):");
+  console.log("  --yes            Accept all defaults without prompting");
+  console.log("  --json           Output machine-readable JSON");
+  console.log("  --dry-run        Preview actions without side effects");
+  console.log("  --no-install     Skip npm install step");
+  console.log("  --help           Show help for a command");
+  console.log('\nRun "db-model-router help <command>" for detailed usage.');
 }
 
 /**
@@ -65,11 +118,38 @@ function printUnknown(cmd) {
 async function main(argv) {
   const { subcommand, flags, args } = parseFlags(argv);
 
-  if (!subcommand || flags.help) {
+  if (!subcommand) {
     printHelp();
     return;
   }
 
+  // `help <command>` — extract the topic from the second positional arg
+  if (subcommand === "help") {
+    // Re-parse to grab the second positional word as the help topic.
+    // parseFlags puts the first positional into subcommand; the second
+    // positional ends up as a key in args (if it looks like a flag value)
+    // or is lost. So we grab it directly from argv.
+    const topic =
+      argv.find((a, i) => i > 0 && !a.startsWith("-") && argv[0] === "help") ||
+      argv.find(
+        (a, i) => i > 0 && !a.startsWith("-") && argv.indexOf("help") < i,
+      );
+    args._command = topic || null;
+    const ctx = new OutputContext(flags);
+    await helpCmd(args, flags, ctx, { printHelp });
+    ctx.flush();
+    return;
+  }
+
+  // `<command> --help` — show detailed help for that command
+  if (flags.help) {
+    args._command = subcommand;
+    const ctx = new OutputContext(flags);
+    await helpCmd(args, flags, ctx, { printHelp });
+    ctx.flush();
+    return;
+  }
+
   if (!COMMANDS[subcommand]) {
     printUnknown(subcommand);
     process.exitCode = 1;

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,