cynx-lib 1.3.41 → 1.3.43

package/utils/utils/db.cjs

@@ -0,0 +1,779 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var db_exports = {};
+__export(db_exports, {
+  default: () => db_default,
+  dropAllTables: () => dropAllTables,
+  dropDb: () => dropDb,
+  drop_db: () => drop_db,
+  initDb: () => initDb,
+  init_db: () => init_db,
+  parseSchema: () => parseSchema,
+  parseSchemaAlterColumns: () => parseSchemaAlterColumns,
+  parseSchemaDoBlocks: () => parseSchemaDoBlocks,
+  parseSchemaDropConstraints: () => parseSchemaDropConstraints,
+  parseSchemaDropIndexes: () => parseSchemaDropIndexes,
+  parseSchemaIndexes: () => parseSchemaIndexes,
+  parseSchemaTables: () => parseSchemaTables,
+  resetDb: () => resetDb,
+  resetTable: () => resetTable,
+  reset_db: () => reset_db,
+  reset_table: () => reset_table,
+  runSafeDdl: () => runSafeDdl,
+  syncDatabaseSchema: () => syncDatabaseSchema,
+  syncDb: () => syncDb,
+  sync_db: () => sync_db,
+  truncateTable: () => truncateTable,
+  truncate_table: () => truncate_table
+});
+module.exports = __toCommonJS(db_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+async function runSafeDdl(queryFn, sql, label = "DDL", { maxRetries = 3, retryDelayMs = 300, logger = console } = {}) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      await queryFn(sql);
+      return true;
+    } catch (err) {
+      const msg = err && err.message ? err.message : String(err);
+      const isLockTimeout = msg.includes("lock timeout") || msg.includes("deadlock") || msg.includes("canceling statement due to lock timeout");
+      if (isLockTimeout && attempt < maxRetries) {
+        if (logger && logger.warn) {
+          logger.warn(`[DB Sync] Lock timeout on ${label} (attempt ${attempt}/${maxRetries}), retrying in ${retryDelayMs * attempt}ms...`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs * attempt));
+        continue;
+      }
+      if (logger && logger.warn) {
+        logger.warn(`[DB Sync] Notice on ${label}: ${msg}`);
+      }
+      return false;
+    }
+  }
+  return false;
+}
+function parseSchemaTables(schemaSql) {
+  if (!schemaSql || typeof schemaSql !== "string") return [];
+  const tableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([a-zA-Z0-9_]+)\s*\(([\s\S]*?)\);/gi;
+  let match;
+  const tables = [];
+  while ((match = tableRegex.exec(schemaSql)) !== null) {
+    const tableName = match[1].toLowerCase();
+    const body = match[2];
+    const columns = [];
+    const lines = body.split("\n");
+    for (const rawLine of lines) {
+      const line = rawLine.trim().replace(/,$/, "");
+      if (!line || line.startsWith("--") || line.startsWith("/*")) continue;
+      if (/^(PRIMARY\s+KEY|FOREIGN\s+KEY|UNIQUE|CONSTRAINT|CHECK)\b/i.test(line)) continue;
+      const colMatch = line.match(/^([a-zA-Z0-9_]+)\s+([\s\S]+)$/i);
+      if (colMatch) {
+        const colName = colMatch[1].toLowerCase();
+        let colDef = colMatch[2].trim();
+        colDef = colDef.replace(/\bPRIMARY\s+KEY\b/gi, "").trim();
+        columns.push({ name: colName, def: colDef, raw: line });
+      }
+    }
+    tables.push({
+      name: tableName,
+      columns,
+      fullCreateSql: match[0]
+    });
+  }
+  return tables;
+}
+function parseSchemaAlterColumns(schemaSql) {
+  if (!schemaSql || typeof schemaSql !== "string") return [];
+  const alterAddRegex = /ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?([a-zA-Z0-9_]+)\s+ADD\s+COLUMN\s+(?:IF\s+NOT\s+EXISTS\s+)?([a-zA-Z0-9_]+)\s+([^;]+);/gi;
+  let match;
+  const alterAdds = [];
+  while ((match = alterAddRegex.exec(schemaSql)) !== null) {
+    alterAdds.push({
+      table: match[1].toLowerCase(),
+      column: match[2].toLowerCase(),
+      def: match[3].trim(),
+      raw: match[0]
+    });
+  }
+  return alterAdds;
+}
+function parseSchemaDropConstraints(schemaSql) {
+  if (!schemaSql || typeof schemaSql !== "string") return [];
+  const dropConstRegex = /ALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?([a-zA-Z0-9_]+)\s+DROP\s+CONSTRAINT\s+(?:IF\s+EXISTS\s+)?([a-zA-Z0-9_]+);/gi;
+  let match;
+  const dropConstraints = [];
+  while ((match = dropConstRegex.exec(schemaSql)) !== null) {
+    dropConstraints.push({
+      table: match[1].toLowerCase(),
+      constraint: match[2].toLowerCase(),
+      raw: match[0]
+    });
+  }
+  return dropConstraints;
+}
+function parseSchemaDropIndexes(schemaSql) {
+  if (!schemaSql || typeof schemaSql !== "string") return [];
+  const dropIndexRegex = /DROP\s+INDEX\s+(?:IF\s+EXISTS\s+)?([a-zA-Z0-9_]+);/gi;
+  let match;
+  const dropIndexes = [];
+  while ((match = dropIndexRegex.exec(schemaSql)) !== null) {
+    dropIndexes.push({
+      name: match[1].toLowerCase(),
+      raw: match[0]
+    });
+  }
+  return dropIndexes;
+}
+function parseSchemaIndexes(schemaSql) {
+  if (!schemaSql || typeof schemaSql !== "string") return [];
+  const indexRegex = /CREATE\s+(UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?([a-zA-Z0-9_]+)\s+ON\s+([a-zA-Z0-9_]+)\s*([\s\S]*?);/gi;
+  let match;
+  const indexes = [];
+  while ((match = indexRegex.exec(schemaSql)) !== null) {
+    indexes.push({
+      unique: Boolean(match[1]),
+      name: match[2].toLowerCase(),
+      table: match[3].toLowerCase(),
+      rest: match[4].trim(),
+      raw: match[0]
+    });
+  }
+  return indexes;
+}
+function parseSchemaDoBlocks(schemaSql) {
+  if (!schemaSql || typeof schemaSql !== "string") return [];
+  const doRegex = /DO\s+\$\$\s*BEGIN([\s\S]*?)END\s+\$\$;/gi;
+  let match;
+  const doBlocks = [];
+  while ((match = doRegex.exec(schemaSql)) !== null) {
+    doBlocks.push(match[0]);
+  }
+  return doBlocks;
+}
+function parseSchema(schemaSql) {
+  return {
+    tables: parseSchemaTables(schemaSql),
+    alterAdds: parseSchemaAlterColumns(schemaSql),
+    dropConstraints: parseSchemaDropConstraints(schemaSql),
+    dropIndexes: parseSchemaDropIndexes(schemaSql),
+    indexes: parseSchemaIndexes(schemaSql),
+    doBlocks: parseSchemaDoBlocks(schemaSql)
+  };
+}
+async function sync_db(options = {}) {
+  const startTime = Date.now();
+  const {
+    pool,
+    query: customQuery,
+    schemaSql: directSql,
+    schemaPath,
+    tableSchema = "public",
+    freshCheckTable,
+    logger: rawLogger = console,
+    dryRun = false,
+    maxRetries = 3,
+    retryDelayMs = 300,
+    throwOnError = false
+  } = options;
+  const logger = rawLogger === false ? null : rawLogger || console;
+  const log = (msg) => {
+    if (logger && logger.log) logger.log(`[DB Sync] ${msg}`);
+  };
+  const warn = (msg) => {
+    if (logger && logger.warn) logger.warn(`[DB Sync] ${msg}`);
+  };
+  const error = (msg, err) => {
+    if (logger && logger.error) logger.error(`[DB Sync] ${msg}`, err || "");
+  };
+  let queryFn = customQuery;
+  if (!queryFn && pool) {
+    queryFn = (text, params) => pool.query(text, params);
+  }
+  if (typeof queryFn !== "function") {
+    const err = new Error("[cynx/db] No database query function or pool provided to sync_db()");
+    error(err.message);
+    if (throwOnError) throw err;
+    return {
+      success: false,
+      isFreshDb: false,
+      createdTables: [],
+      addedColumns: [],
+      createdIndexes: [],
+      droppedConstraints: [],
+      droppedIndexes: [],
+      executedDoBlocks: 0,
+      changesCount: 0,
+      durationMs: 0,
+      summary: "Failed: No query executor",
+      error: err
+    };
+  }
+  let schemaSql = directSql;
+  if (!schemaSql && schemaPath) {
+    const resolvedPath = import_path.default.resolve(schemaPath);
+    if (!import_fs.default.existsSync(resolvedPath)) {
+      const err = new Error(`[cynx/db] schema.sql not found at: ${resolvedPath}`);
+      warn(err.message);
+      if (throwOnError) throw err;
+      return {
+        success: false,
+        isFreshDb: false,
+        createdTables: [],
+        addedColumns: [],
+        createdIndexes: [],
+        droppedConstraints: [],
+        droppedIndexes: [],
+        executedDoBlocks: 0,
+        changesCount: 0,
+        durationMs: 0,
+        summary: "Failed: schema.sql file not found",
+        error: err
+      };
+    }
+    schemaSql = import_fs.default.readFileSync(resolvedPath, "utf-8");
+  }
+  if (!schemaSql || typeof schemaSql !== "string" || !schemaSql.trim()) {
+    const err = new Error("[cynx/db] No schema SQL provided to sync_db()");
+    warn(err.message);
+    if (throwOnError) throw err;
+    return {
+      success: false,
+      isFreshDb: false,
+      createdTables: [],
+      addedColumns: [],
+      createdIndexes: [],
+      droppedConstraints: [],
+      droppedIndexes: [],
+      executedDoBlocks: 0,
+      changesCount: 0,
+      durationMs: 0,
+      summary: "Failed: Empty schema SQL",
+      error: err
+    };
+  }
+  try {
+    let isFreshDb = false;
+    if (freshCheckTable) {
+      const tableCheck = await queryFn(
+        "SELECT 1 FROM information_schema.tables WHERE table_schema = $1 AND table_name = $2 LIMIT 1",
+        [tableSchema, String(freshCheckTable).toLowerCase()]
+      );
+      isFreshDb = tableCheck.rowCount === 0;
+    } else {
+      const countCheck = await queryFn(
+        "SELECT count(*)::int as count FROM information_schema.tables WHERE table_schema = $1 AND table_type = 'BASE TABLE'",
+        [tableSchema]
+      );
+      const tableCount = countCheck.rows && countCheck.rows[0] ? Number(countCheck.rows[0].count) : 0;
+      isFreshDb = tableCount === 0;
+    }
+    if (isFreshDb) {
+      log("Fresh database detected. Applying full schema.sql in one pass...");
+      if (!dryRun) {
+        await queryFn(schemaSql);
+      }
+      const durationMs2 = Date.now() - startTime;
+      log(`Fresh database schema initialized successfully (${durationMs2}ms)`);
+      return {
+        success: true,
+        isFreshDb: true,
+        createdTables: ["* (full schema applied)"],
+        addedColumns: [],
+        createdIndexes: [],
+        droppedConstraints: [],
+        droppedIndexes: [],
+        executedDoBlocks: 0,
+        changesCount: 1,
+        durationMs: durationMs2,
+        summary: `Fresh database initialized in ${durationMs2}ms`
+      };
+    }
+    log("Analyzing schema.sql and comparing with database catalogs (Zero-Lock)...");
+    const [tablesRes, colsRes, idxRes, conRes] = await Promise.all([
+      queryFn("SELECT table_name FROM information_schema.tables WHERE table_schema = $1 AND table_type = 'BASE TABLE'", [tableSchema]),
+      queryFn("SELECT table_name, column_name FROM information_schema.columns WHERE table_schema = $1", [tableSchema]),
+      queryFn("SELECT indexname FROM pg_indexes WHERE schemaname = $1", [tableSchema]),
+      queryFn("SELECT conname FROM pg_constraint")
+    ]);
+    const existingTables = new Set((tablesRes.rows || []).map((r) => String(r.table_name).toLowerCase()));
+    const existingColumns = new Set((colsRes.rows || []).map((r) => `${String(r.table_name).toLowerCase()}.${String(r.column_name).toLowerCase()}`));
+    const existingIndexes = new Set((idxRes.rows || []).map((r) => String(r.indexname).toLowerCase()));
+    const existingConstraints = new Set((conRes.rows || []).map((r) => String(r.conname).toLowerCase()));
+    const createdTables = [];
+    const addedColumns = [];
+    const createdIndexes = [];
+    const droppedConstraints = [];
+    const droppedIndexes = [];
+    let executedDoBlocks = 0;
+    const parsed = parseSchema(schemaSql);
+    const safeDdlOpts = { maxRetries, retryDelayMs, logger };
+    for (const doSql of parsed.doBlocks) {
+      if (!dryRun) {
+        await runSafeDdl(queryFn, doSql, "schema do-block", safeDdlOpts);
+      }
+      executedDoBlocks++;
+    }
+    for (const table of parsed.tables) {
+      if (!existingTables.has(table.name)) {
+        if (!dryRun) {
+          const ok = await runSafeDdl(queryFn, table.fullCreateSql, `create table ${table.name}`, safeDdlOpts);
+          if (ok) {
+            existingTables.add(table.name);
+            createdTables.push(table.name);
+            for (const col of table.columns) {
+              existingColumns.add(`${table.name}.${col.name}`);
+            }
+            log(`Created missing table: ${table.name}`);
+          }
+        } else {
+          createdTables.push(table.name);
+          log(`[DryRun] Would create table: ${table.name}`);
+        }
+      }
+    }
+    for (const table of parsed.tables) {
+      if (existingTables.has(table.name)) {
+        for (const col of table.columns) {
+          const colKey = `${table.name}.${col.name}`;
+          if (!existingColumns.has(colKey)) {
+            const sql = `ALTER TABLE ${table.name} ADD COLUMN IF NOT EXISTS ${col.name} ${col.def};`;
+            if (!dryRun) {
+              const ok = await runSafeDdl(queryFn, sql, `add column ${colKey}`, safeDdlOpts);
+              if (ok) {
+                existingColumns.add(colKey);
+                addedColumns.push(colKey);
+                log(`Added missing column: ${colKey}`);
+              }
+            } else {
+              addedColumns.push(colKey);
+              log(`[DryRun] Would add column: ${colKey}`);
+            }
+          }
+        }
+      }
+    }
+    for (const alter of parsed.alterAdds) {
+      const colKey = `${alter.table}.${alter.column}`;
+      if (existingTables.has(alter.table) && !existingColumns.has(colKey)) {
+        const sql = `ALTER TABLE ${alter.table} ADD COLUMN IF NOT EXISTS ${alter.column} ${alter.def};`;
+        if (!dryRun) {
+          const ok = await runSafeDdl(queryFn, sql, `alter add column ${colKey}`, safeDdlOpts);
+          if (ok) {
+            existingColumns.add(colKey);
+            addedColumns.push(colKey);
+            log(`Added missing column: ${colKey}`);
+          }
+        } else {
+          addedColumns.push(colKey);
+          log(`[DryRun] Would add column: ${colKey}`);
+        }
+      }
+    }
+    for (const drop of parsed.dropConstraints) {
+      if (existingConstraints.has(drop.constraint)) {
+        if (!dryRun) {
+          const ok = await runSafeDdl(queryFn, drop.raw, `drop constraint ${drop.constraint}`, safeDdlOpts);
+          if (ok) {
+            existingConstraints.delete(drop.constraint);
+            droppedConstraints.push(`${drop.table}.${drop.constraint}`);
+            log(`Dropped obsolete constraint: ${drop.table}.${drop.constraint}`);
+          }
+        } else {
+          droppedConstraints.push(`${drop.table}.${drop.constraint}`);
+          log(`[DryRun] Would drop constraint: ${drop.table}.${drop.constraint}`);
+        }
+      }
+    }
+    for (const drop of parsed.dropIndexes) {
+      if (existingIndexes.has(drop.name)) {
+        if (!dryRun) {
+          const ok = await runSafeDdl(queryFn, drop.raw, `drop index ${drop.name}`, safeDdlOpts);
+          if (ok) {
+            existingIndexes.delete(drop.name);
+            droppedIndexes.push(drop.name);
+            log(`Dropped obsolete index: ${drop.name}`);
+          }
+        } else {
+          droppedIndexes.push(drop.name);
+          log(`[DryRun] Would drop index: ${drop.name}`);
+        }
+      }
+    }
+    for (const idx of parsed.indexes) {
+      if (existingTables.has(idx.table) && !existingIndexes.has(idx.name)) {
+        const uniqueClause = idx.unique ? "UNIQUE " : "";
+        const sql = `CREATE ${uniqueClause}INDEX IF NOT EXISTS ${idx.name} ON ${idx.table} ${idx.rest};`;
+        if (!dryRun) {
+          const ok = await runSafeDdl(queryFn, sql, `create index ${idx.name}`, safeDdlOpts);
+          if (ok) {
+            existingIndexes.add(idx.name);
+            createdIndexes.push(idx.name);
+            log(`Created index: ${idx.name}`);
+          }
+        } else {
+          createdIndexes.push(idx.name);
+          log(`[DryRun] Would create index: ${idx.name}`);
+        }
+      }
+    }
+    const durationMs = Date.now() - startTime;
+    const summaryParts = [];
+    if (createdTables.length > 0) summaryParts.push(`${createdTables.length} tables created`);
+    if (addedColumns.length > 0) summaryParts.push(`${addedColumns.length} columns added`);
+    if (createdIndexes.length > 0) summaryParts.push(`${createdIndexes.length} indexes created`);
+    if (droppedConstraints.length > 0) summaryParts.push(`${droppedConstraints.length} constraints dropped`);
+    if (droppedIndexes.length > 0) summaryParts.push(`${droppedIndexes.length} indexes dropped`);
+    if (executedDoBlocks > 0) summaryParts.push(`${executedDoBlocks} migration blocks run`);
+    const changesCount = createdTables.length + addedColumns.length + createdIndexes.length + droppedConstraints.length + droppedIndexes.length;
+    const summary = summaryParts.length > 0 ? `Database synced in ${durationMs}ms: ${summaryParts.join(", ")}` : `Database schema is up to date (0 changes needed, ${durationMs}ms)`;
+    log(summary);
+    return {
+      success: true,
+      isFreshDb: false,
+      createdTables,
+      addedColumns,
+      createdIndexes,
+      droppedConstraints,
+      droppedIndexes,
+      executedDoBlocks,
+      changesCount,
+      durationMs,
+      summary
+    };
+  } catch (err) {
+    error("Database sync failed:", err.message);
+    if (throwOnError) throw err;
+    return {
+      success: false,
+      isFreshDb: false,
+      createdTables: [],
+      addedColumns: [],
+      createdIndexes: [],
+      droppedConstraints: [],
+      droppedIndexes: [],
+      executedDoBlocks: 0,
+      changesCount: 0,
+      durationMs: Date.now() - startTime,
+      summary: `Failed: ${err.message}`,
+      error: err
+    };
+  }
+}
+async function drop_db(options = {}) {
+  const startTime = Date.now();
+  const {
+    pool,
+    query: customQuery,
+    tableSchema = "public",
+    logger: rawLogger = console,
+    dryRun = false
+  } = options;
+  const logger = rawLogger === false ? null : rawLogger || console;
+  const log = (msg) => {
+    if (logger && logger.log) logger.log(`[DB Drop] ${msg}`);
+  };
+  const error = (msg, err) => {
+    if (logger && logger.error) logger.error(`[DB Drop] ${msg}`, err || "");
+  };
+  let queryFn = customQuery;
+  if (!queryFn && pool) {
+    queryFn = (text, params) => pool.query(text, params);
+  }
+  if (typeof queryFn !== "function") {
+    const err = new Error("[cynx/db] No database query function or pool provided to drop_db()");
+    error(err.message);
+    return {
+      success: false,
+      droppedTables: [],
+      durationMs: 0,
+      summary: "Failed: No query executor",
+      error: err
+    };
+  }
+  try {
+    const res = await queryFn(
+      "SELECT table_name FROM information_schema.tables WHERE table_schema = $1 AND table_type = 'BASE TABLE'",
+      [tableSchema]
+    );
+    const tables = (res.rows || []).map((r) => r.table_name);
+    if (tables.length === 0) {
+      log(`No tables found in schema '${tableSchema}'. Nothing to drop.`);
+      return {
+        success: true,
+        droppedTables: [],
+        durationMs: Date.now() - startTime,
+        summary: `0 tables dropped (schema '${tableSchema}' was already empty)`
+      };
+    }
+    if (dryRun) {
+      log(`[DryRun] Would drop ${tables.length} tables: ${tables.join(", ")}`);
+      return {
+        success: true,
+        droppedTables: tables,
+        durationMs: Date.now() - startTime,
+        summary: `[DryRun] ${tables.length} tables listed for drop`
+      };
+    }
+    log(`Dropping ${tables.length} tables from schema '${tableSchema}' with CASCADE...`);
+    const dropSql = `
+      DO $$ DECLARE
+        r RECORD;
+      BEGIN
+        FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = '${tableSchema.replace(/'/g, "''")}') LOOP
+          EXECUTE 'DROP TABLE IF EXISTS ' || quote_ident(r.tablename) || ' CASCADE';
+        END LOOP;
+      END $$;
+    `;
+    await queryFn(dropSql);
+    const durationMs = Date.now() - startTime;
+    const summary = `Successfully dropped ${tables.length} tables in ${durationMs}ms`;
+    log(summary);
+    return {
+      success: true,
+      droppedTables: tables,
+      durationMs,
+      summary
+    };
+  } catch (err) {
+    error("Failed to drop tables:", err.message);
+    return {
+      success: false,
+      droppedTables: [],
+      durationMs: Date.now() - startTime,
+      summary: `Failed: ${err.message}`,
+      error: err
+    };
+  }
+}
+async function reset_table(tableOrOptions, options = {}) {
+  const startTime = Date.now();
+  const opts = typeof tableOrOptions === "object" && tableOrOptions !== null ? { ...tableOrOptions, ...options } : { ...options, table: tableOrOptions };
+  const {
+    table,
+    pool,
+    query: customQuery,
+    where,
+    cascade = true,
+    restartIdentity = true,
+    recreate = false,
+    schemaSql,
+    schemaPath,
+    logger: rawLogger = console
+  } = opts;
+  const logger = rawLogger === false ? null : rawLogger || console;
+  const log = (msg) => {
+    if (logger && logger.log) logger.log(`[DB Reset Table] ${msg}`);
+  };
+  const error = (msg, err) => {
+    if (logger && logger.error) logger.error(`[DB Reset Table] ${msg}`, err || "");
+  };
+  if (!table || typeof table !== "string") {
+    const err = new Error("[cynx/db] Table name is required for reset_table()");
+    error(err.message);
+    return {
+      success: false,
+      table: "",
+      mode: "truncate",
+      durationMs: 0,
+      summary: "Failed: Missing table name",
+      error: err
+    };
+  }
+  const cleanTable = table.trim().toLowerCase();
+  let queryFn = customQuery;
+  if (!queryFn && pool) {
+    queryFn = (text, params) => pool.query(text, params);
+  }
+  if (typeof queryFn !== "function") {
+    const err = new Error("[cynx/db] No database query function or pool provided to reset_table()");
+    error(err.message);
+    return {
+      success: false,
+      table: cleanTable,
+      mode: "truncate",
+      durationMs: 0,
+      summary: "Failed: No query executor",
+      error: err
+    };
+  }
+  try {
+    if (where) {
+      let whereClause = "";
+      let params = [];
+      if (typeof where === "string") {
+        whereClause = where.trim().replace(/^WHERE\s+/i, "");
+      } else if (Array.isArray(where) && where.length > 0) {
+        whereClause = where[0].replace(/^WHERE\s+/i, "");
+        params = Array.isArray(where[1]) ? where[1] : [];
+      } else if (typeof where === "object") {
+        const conditions = [];
+        let pIndex = 1;
+        for (const [key, val] of Object.entries(where)) {
+          if (val === null) {
+            conditions.push(`${key} IS NULL`);
+          } else {
+            conditions.push(`${key} = $${pIndex++}`);
+            params.push(val);
+          }
+        }
+        whereClause = conditions.join(" AND ");
+      }
+      if (!whereClause) {
+        throw new Error("[cynx/db] Invalid WHERE condition provided for row reset");
+      }
+      const sql2 = `DELETE FROM ${cleanTable} WHERE ${whereClause};`;
+      const res = await queryFn(sql2, params);
+      const rowCount = res && typeof res.rowCount === "number" ? res.rowCount : 0;
+      const durationMs2 = Date.now() - startTime;
+      const summary2 = `Deleted ${rowCount} rows from table '${cleanTable}' (${durationMs2}ms)`;
+      log(summary2);
+      return {
+        success: true,
+        table: cleanTable,
+        mode: "delete",
+        rowCount,
+        durationMs: durationMs2,
+        summary: summary2
+      };
+    }
+    if (recreate) {
+      log(`Dropping table '${cleanTable}' with CASCADE for full recreation...`);
+      await queryFn(`DROP TABLE IF EXISTS ${cleanTable} CASCADE;`);
+      log(`Recreating table '${cleanTable}' via sync_db...`);
+      const syncResult = await sync_db({
+        pool,
+        query: queryFn,
+        schemaSql,
+        schemaPath,
+        logger
+      });
+      const durationMs2 = Date.now() - startTime;
+      const summary2 = `Recreated table '${cleanTable}' from schema (${durationMs2}ms)`;
+      log(summary2);
+      return {
+        success: syncResult.success,
+        table: cleanTable,
+        mode: "recreate",
+        durationMs: durationMs2,
+        summary: summary2
+      };
+    }
+    const restartClause = restartIdentity ? " RESTART IDENTITY" : "";
+    const cascadeClause = cascade ? " CASCADE" : "";
+    const sql = `TRUNCATE TABLE ${cleanTable}${restartClause}${cascadeClause};`;
+    await queryFn(sql);
+    const durationMs = Date.now() - startTime;
+    const summary = `Truncated table '${cleanTable}'${restartClause}${cascadeClause} in ${durationMs}ms`;
+    log(summary);
+    return {
+      success: true,
+      table: cleanTable,
+      mode: "truncate",
+      durationMs,
+      summary
+    };
+  } catch (err) {
+    error(`Failed to reset table '${cleanTable}':`, err.message);
+    return {
+      success: false,
+      table: cleanTable,
+      mode: where ? "delete" : recreate ? "recreate" : "truncate",
+      durationMs: Date.now() - startTime,
+      summary: `Failed: ${err.message}`,
+      error: err
+    };
+  }
+}
+async function reset_db(options = {}) {
+  const dropResult = await drop_db(options);
+  const syncResult = await sync_db(options);
+  return {
+    success: dropResult.success && syncResult.success,
+    dropResult,
+    syncResult
+  };
+}
+const init_db = sync_db;
+const initDb = sync_db;
+const dropDb = drop_db;
+const dropAllTables = drop_db;
+const resetDb = reset_db;
+const resetTable = reset_table;
+const truncate_table = reset_table;
+const truncateTable = reset_table;
+const syncDb = sync_db;
+const syncDatabaseSchema = sync_db;
+var db_default = {
+  sync_db,
+  syncDb,
+  syncDatabaseSchema,
+  init_db,
+  initDb,
+  drop_db,
+  dropDb,
+  dropAllTables,
+  reset_db,
+  resetDb,
+  reset_table,
+  resetTable,
+  truncate_table,
+  truncateTable,
+  runSafeDdl,
+  parseSchema,
+  parseSchemaTables,
+  parseSchemaAlterColumns,
+  parseSchemaDropConstraints,
+  parseSchemaDropIndexes,
+  parseSchemaIndexes,
+  parseSchemaDoBlocks
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dropAllTables,
+  dropDb,
+  drop_db,
+  initDb,
+  init_db,
+  parseSchema,
+  parseSchemaAlterColumns,
+  parseSchemaDoBlocks,
+  parseSchemaDropConstraints,
+  parseSchemaDropIndexes,
+  parseSchemaIndexes,
+  parseSchemaTables,
+  resetDb,
+  resetTable,
+  reset_db,
+  reset_table,
+  runSafeDdl,
+  syncDatabaseSchema,
+  syncDb,
+  sync_db,
+  truncateTable,
+  truncate_table
+});