@stacksjs/database 0.70.87 → 0.70.90

package/dist/seeder.js

@@ -0,0 +1,363 @@
+import { log } from "@stacksjs/logging";
+import { db, ensureDatabaseConfigLoaded } from "./utils";
+import { faker } from "@stacksjs/faker";
+import { path } from "@stacksjs/path";
+import { hashMake } from "@stacksjs/security";
+import { fs } from "@stacksjs/storage";
+function defaultModelsPath(subpath) {
+  return path.frameworkPath(`defaults/app/Models/${subpath || ""}`);
+}
+export const PROTECTED_MODELS = Object.freeze([
+  "OauthClient",
+  "OauthAccessToken",
+  "OauthRefreshToken",
+  "PersonalAccessToken"
+]);
+export function isProtectedModel(name) {
+  return PROTECTED_MODELS.includes(name);
+}
+function snakeCase(str) {
+  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/(\d)([A-Za-z])/g, "$1_$2").toLowerCase();
+}
+async function loadModelsFromDir(modelsDir, recursive = !1) {
+  const models = [];
+  if (!fs.existsSync(modelsDir))
+    return models;
+  const entries = fs.readdirSync(modelsDir, { withFileTypes: !0 });
+  for (const entry of entries) {
+    const fullPath = path.join(modelsDir, entry.name);
+    if (entry.isDirectory() && recursive) {
+      const subModels = await loadModelsFromDir(fullPath, !0);
+      models.push(...subModels);
+      continue;
+    }
+    if (!entry.name.endsWith(".ts") || entry.name.startsWith("index") || entry.name.startsWith("_"))
+      continue;
+    try {
+      const module = await import(fullPath), modelDef = module.default || module;
+      if (!modelDef)
+        continue;
+      const useSeeder = modelDef.traits?.useSeeder ?? modelDef.traits?.seedable;
+      if (!useSeeder)
+        continue;
+      let count = 10, fixtures = [];
+      if (typeof useSeeder === "object" && "count" in useSeeder) {
+        const opts = useSeeder;
+        count = opts.count;
+        fixtures = opts.fixtures ?? [];
+      }
+      const modelName = modelDef.name || entry.name.replace(".ts", ""), tableName = modelDef.table || snakeCase(modelName) + "s";
+      models.push({
+        name: modelName,
+        table: tableName,
+        count: Math.max(count, fixtures.length),
+        fixtures,
+        attributes: modelDef.attributes || {},
+        model: modelDef,
+        filePath: fullPath
+      });
+    } catch (err) {
+      log.error(`Failed to load model ${entry.name}:`, err);
+    }
+  }
+  return models;
+}
+async function loadAllModels(userModelsDir, verbose = !1, includeDefaults = !1) {
+  const defaultDir = defaultModelsPath(), userModels = await loadModelsFromDir(userModelsDir, !1);
+  if (userModels.length > 0 && !includeDefaults)
+    return userModels;
+  const defaultModels = await loadModelsFromDir(defaultDir, !0), modelMap = new Map;
+  for (const model of defaultModels)
+    modelMap.set(model.name, model);
+  for (const model of userModels) {
+    if (modelMap.has(model.name) && verbose)
+      log.info(`  User model "${model.name}" overrides default`);
+    modelMap.set(model.name, model);
+  }
+  return Array.from(modelMap.values());
+}
+async function loadModels(modelsDir) {
+  return loadModelsFromDir(modelsDir, !1);
+}
+function isPasswordField(fieldName, attr) {
+  const lowerName = fieldName.toLowerCase();
+  if (lowerName === "password" || lowerName.endsWith("_password") || lowerName.endsWith("password"))
+    return !0;
+  if (attr.hidden === !0 && lowerName.includes("pass"))
+    return !0;
+  return !1;
+}
+async function generateRecord(attributes, modelName, verbose = !1) {
+  const record = {};
+  for (const [fieldName, attr] of Object.entries(attributes)) {
+    const columnName = snakeCase(fieldName);
+    let value;
+    if (attr.factory && typeof attr.factory === "function")
+      try {
+        value = attr.factory(faker);
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        if (verbose)
+          log.warn(`  Factory failed for ${modelName}.${fieldName}: ${errorMsg}`);
+        if (attr.default !== void 0)
+          value = attr.default;
+        else
+          value = inferDefaultValue(fieldName);
+      }
+    else if (attr.default !== void 0)
+      value = attr.default;
+    else
+      continue;
+    if (isPasswordField(fieldName, attr) && typeof value === "string")
+      try {
+        value = await hashMake(value, { algorithm: "bcrypt" });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        if (verbose)
+          log.warn(`  Failed to hash password for ${modelName}.${fieldName}: ${errorMsg}`);
+      }
+    record[columnName] = value;
+  }
+  return record;
+}
+function inferDefaultValue(fieldName) {
+  const lowerName = fieldName.toLowerCase();
+  if (lowerName.startsWith("is") || lowerName.startsWith("has") || lowerName.endsWith("able"))
+    return !1;
+  if (lowerName.includes("count") || lowerName.includes("amount") || lowerName.includes("quantity"))
+    return 0;
+  if (lowerName.includes("url") || lowerName.includes("link"))
+    return "https://example.com";
+  if (lowerName.includes("email"))
+    return faker.internet.email();
+  if (lowerName.includes("name"))
+    return faker.person.fullName();
+  return null;
+}
+function fixtureToColumns(fixture) {
+  const out = {};
+  for (const [key, value] of Object.entries(fixture))
+    out[snakeCase(key)] = value;
+  return out;
+}
+async function generateRecords(model, verbose = !1) {
+  const records = [];
+  for (let i = 0;i < model.count; i++) {
+    const record = await generateRecord(model.attributes, model.name, verbose && i === 0), fixture = model.fixtures[i];
+    records.push(fixture ? { ...record, ...fixtureToColumns(fixture) } : record);
+  }
+  return records;
+}
+export function seedModelDirect(model, options) {
+  return seedModel(model, options);
+}
+async function seedModel(model, options) {
+  const startTime = Date.now();
+  try {
+    try {
+      await db.selectFrom(model.table).limit(0).execute();
+    } catch (tableErr) {
+      const msg = tableErr?.message || "";
+      if (msg.includes("does not exist") || msg.includes("no such table") || msg.includes("doesn't exist")) {
+        log.info(`  Skipping ${model.name}: table "${model.table}" does not exist`);
+        return {
+          model: model.name,
+          table: model.table,
+          count: 0,
+          success: !0,
+          duration: Date.now() - startTime
+        };
+      }
+      throw tableErr;
+    }
+    if (!options.fresh) {
+      if (await db.selectFrom(model.table).selectAll().limit(1).executeTakeFirst()) {
+        if (options.verbose)
+          log.info(`  ${model.name}: table already has rows \u2014 skipping (use --fresh to replace)`);
+        return {
+          model: model.name,
+          table: model.table,
+          count: 0,
+          success: !0,
+          duration: Date.now() - startTime
+        };
+      }
+    }
+    const records = await generateRecords(model, options.verbose);
+    if (records.length === 0)
+      return {
+        model: model.name,
+        table: model.table,
+        count: 0,
+        success: !0,
+        duration: Date.now() - startTime
+      };
+    if (options.fresh)
+      try {
+        await db.deleteFrom(model.table).execute();
+        if (options.verbose)
+          log.info(`  Truncated table: ${model.table}`);
+      } catch {}
+    const batchSize = 100;
+    let inserted = 0;
+    for (let i = 0;i < records.length; i += batchSize) {
+      const batch = records.slice(i, i + batchSize);
+      await db.insertInto(model.table).values(batch).execute();
+      inserted += batch.length;
+    }
+    if (options.verbose)
+      log.success(`  Seeded ${model.name}: ${inserted} records`);
+    return {
+      model: model.name,
+      table: model.table,
+      count: inserted,
+      success: !0,
+      duration: Date.now() - startTime
+    };
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    if (options.verbose)
+      log.error(`  Failed to seed ${model.name}: ${errorMessage}`);
+    return {
+      model: model.name,
+      table: model.table,
+      count: 0,
+      success: !1,
+      error: errorMessage,
+      duration: Date.now() - startTime
+    };
+  }
+}
+function sortModelsByDependencies(models) {
+  const priority = {
+    User: 0,
+    Team: 1,
+    Project: 2
+  };
+  return models.sort((a, b) => {
+    const priorityA = priority[a.name] ?? 10, priorityB = priority[b.name] ?? 10;
+    return priorityA - priorityB;
+  });
+}
+export async function seed(config = {}) {
+  const startTime = Date.now();
+  await ensureDatabaseConfigLoaded();
+  const modelsDir = config.modelsDir || path.userModelsPath(), verbose = config.verbose ?? !0;
+  if (verbose) {
+    log.info("Seeding database using model factories...");
+    log.info(`User models directory: ${modelsDir}`);
+    log.info(`Default models directory: ${defaultModelsPath()}`);
+  }
+  let models = await loadAllModels(modelsDir, verbose, config.includeDefaults ?? !1);
+  if (models.length === 0) {
+    log.warn("No seedable models found in defaults or user directories");
+    return {
+      total: 0,
+      successful: 0,
+      failed: 0,
+      results: [],
+      duration: Date.now() - startTime
+    };
+  }
+  log.warn(`[seed] The \`useSeeder\` trait + auto-walker is deprecated (stacksjs/stacks#1919, #1929). Run \`./buddy seed:scaffold\` to generate a class seeder per \`useSeeder\` model AND strip the trait from the model in one pass. The walker + trait are scheduled for removal in the next major. Affected: ${models.map((m) => m.name).join(", ")}`);
+  if (config.only && config.only.length > 0)
+    models = models.filter((m) => config.only.includes(m.name));
+  if (config.except && config.except.length > 0)
+    models = models.filter((m) => !config.except.includes(m.name));
+  if (!config.fresh && !config.allowProtected) {
+    const skipped = [];
+    models = models.filter((m) => {
+      if (isProtectedModel(m.name)) {
+        skipped.push(m);
+        return !1;
+      }
+      return !0;
+    });
+    if (skipped.length > 0) {
+      log.info(`Skipped ${skipped.length} protected auth model(s) to avoid invalidating live sessions: ${skipped.map((m) => m.name).join(", ")}`);
+      log.info("  Re-run with --fresh (truncates tables first) or --allow-protected to include them.");
+    }
+  }
+  models = sortModelsByDependencies(models);
+  if (verbose)
+    log.info(`Found ${models.length} seedable model(s)`);
+  const results = [];
+  for (const model of models) {
+    if (verbose)
+      log.info(`Seeding ${model.name} (${model.count} records)...`);
+    try {
+      const result = await seedModel(model, config);
+      results.push(result);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      if (verbose)
+        log.error(`  Unexpected error seeding ${model.name}: ${errorMessage}`);
+      results.push({
+        model: model.name,
+        table: model.table,
+        count: 0,
+        success: !1,
+        error: errorMessage,
+        duration: 0
+      });
+    }
+  }
+  const successful = results.filter((r) => r.success).length, failed = results.filter((r) => !r.success).length, totalRecords = results.reduce((sum, r) => sum + r.count, 0);
+  if (verbose) {
+    log.info("");
+    if (failed === 0) {
+      log.success("Database seeded successfully!");
+      log.info(`  Total records: ${totalRecords}`);
+      log.info(`  Models seeded: ${successful}`);
+    } else {
+      log.warn(`Seeding completed with ${failed} failure(s)`);
+      log.info(`  Successful: ${successful}`);
+      log.info(`  Failed: ${failed}`);
+    }
+  }
+  return {
+    total: results.length,
+    successful,
+    failed,
+    results,
+    duration: Date.now() - startTime
+  };
+}
+export async function seedModel$(modelName, options = {}) {
+  const modelsDir = path.userModelsPath(), model = (await loadAllModels(modelsDir, options.verbose)).find((m) => m.name === modelName);
+  if (!model)
+    throw Error(`Model not found: ${modelName}`);
+  if (options.count)
+    model.count = options.count;
+  return seedModel(model, {
+    fresh: options.fresh,
+    verbose: options.verbose ?? !0
+  });
+}
+export async function freshSeed(config = {}) {
+  return seed({ ...config, fresh: !0 });
+}
+export async function listSeedableModels() {
+  const modelsDir = path.userModelsPath(), defaultDir = defaultModelsPath(), defaultModels = await loadModelsFromDir(defaultDir, !0), userModels = await loadModelsFromDir(modelsDir, !1), result = [], seen = new Set;
+  for (const m of userModels) {
+    result.push({
+      name: m.name,
+      table: m.table,
+      count: m.count,
+      source: "user"
+    });
+    seen.add(m.name);
+  }
+  for (const m of defaultModels)
+    if (!seen.has(m.name))
+      result.push({
+        name: m.name,
+        table: m.table,
+        count: m.count,
+        source: "default"
+      });
+  return result;
+}
+
+export { seed as runSeeders };
+export { freshSeed as freshWithSeed };

package/dist/sql-helpers.js

@@ -0,0 +1,24 @@
+export function sqlHelpers(driver) {
+  const isPostgres = driver === "postgres", isMysql = driver === "mysql" || driver === "singlestore";
+  return {
+    driver,
+    isPostgres,
+    isMysql,
+    isSqlite: !isPostgres && !isMysql,
+    now: isPostgres || isMysql ? "NOW()" : "datetime('now')",
+    boolTrue: isPostgres ? "true" : "1",
+    boolFalse: isPostgres ? "false" : "0",
+    autoIncrement: isPostgres ? "SERIAL" : "INTEGER",
+    primaryKey: isPostgres ? "PRIMARY KEY" : isMysql ? "PRIMARY KEY AUTO_INCREMENT" : "PRIMARY KEY AUTOINCREMENT",
+    pkColumn: isPostgres ? "id SERIAL PRIMARY KEY" : isMysql ? "id INTEGER PRIMARY KEY AUTO_INCREMENT" : "id INTEGER PRIMARY KEY AUTOINCREMENT",
+    nullableTimestamp: isMysql ? "TIMESTAMP NULL" : "TIMESTAMP",
+    param(index) {
+      return isPostgres ? `$${index}` : "?";
+    },
+    params(...values) {
+      if (isPostgres)
+        return { sql: values.map((_, i) => `$${i + 1}`).join(", "), values };
+      return { sql: values.map(() => "?").join(", "), values };
+    }
+  };
+}

package/dist/table.d.ts

@@ -0,0 +1,7 @@
+import { Column } from './column';
+export declare class Table {
+  increments(name: string): Column;
+  string(name: string, varchar?: number): Column;
+  timestamps(): void;
+  execute(): void;
+}

package/dist/table.js

@@ -0,0 +1,26 @@
+import { log } from "@stacksjs/logging";
+import { Column } from "./column";
+
+export class Table {
+  columns = [];
+  increments(name) {
+    const column = new Column(name, "integer", {
+      primaryKey: !0,
+      autoIncrement: !0
+    });
+    this.columns.push(column);
+    return column;
+  }
+  string(name, varchar = 255) {
+    const column = new Column(name, `varchar(${varchar})`);
+    this.columns.push(column);
+    return column;
+  }
+  timestamps() {
+    this.columns.push(new Column("created_at", "timestamp"));
+    this.columns.push(new Column("updated_at", "timestamp"));
+  }
+  execute() {
+    log.info(`Creating table with columns: ${this.columns.map((col) => col.name).join(", ")}`);
+  }
+}

package/dist/tools/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/setup.js

@@ -0,0 +1,6 @@
+import { dynamoDb } from "dynamodb-tooling";
+const port = 8000;
+dynamoDb.launch({
+  port,
+  additionalArgs: ["-sharedDb"]
+});

package/dist/transaction-context.js

@@ -0,0 +1,62 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const transactionStorage = new AsyncLocalStorage;
+export function isInTransaction() {
+  return transactionStorage.getStore() !== void 0;
+}
+export function enqueueAfterCommit(callback) {
+  const scope = transactionStorage.getStore();
+  if (!scope)
+    return !1;
+  scope.pending.push(callback);
+  return !0;
+}
+export async function runInTransactionScope(fn, options = {}) {
+  const existing = transactionStorage.getStore();
+  if (existing) {
+    existing.depth += 1;
+    try {
+      return await fn();
+    } finally {
+      existing.depth -= 1;
+    }
+  }
+  const scope = {
+    pending: [],
+    depth: 1,
+    onError: options.onError
+  };
+  let result;
+  try {
+    result = await transactionStorage.run(scope, fn);
+  } catch (err) {
+    scope.pending.length = 0;
+    throw err;
+  }
+  await flushScope(scope);
+  return result;
+}
+async function flushScope(scope) {
+  for (let i = 0;i < scope.pending.length; i++)
+    try {
+      await scope.pending[i]();
+    } catch (err) {
+      if (scope.onError)
+        try {
+          scope.onError(err, i);
+        } catch {}
+      else
+        console.error("[transaction-context] after-commit callback threw:", err);
+    }
+  scope.pending.length = 0;
+}
+export async function __flushAfterCommitNow() {
+  const scope = transactionStorage.getStore();
+  if (!scope)
+    return 0;
+  const count = scope.pending.length;
+  await flushScope(scope);
+  return count;
+}
+export function __pendingAfterCommitCount() {
+  return transactionStorage.getStore()?.pending.length ?? 0;
+}

package/dist/types.js

@@ -0,0 +1,23 @@
+export function sql(strings, ...values) {
+  const sqlParts = [], parameters = [];
+  for (let i = 0;i < strings.length; i++) {
+    sqlParts.push(strings[i]);
+    if (i < values.length)
+      if (values[i] && typeof values[i] === "object" && "raw" in values[i])
+        sqlParts.push(values[i].raw);
+      else {
+        sqlParts.push("?");
+        parameters.push(values[i]);
+      }
+  }
+  return {
+    sql: sqlParts.join(""),
+    parameters
+  };
+}
+sql.raw = function raw(value) {
+  return { raw: value };
+};
+sql.ref = function ref(column) {
+  return { raw: column };
+};

package/dist/unique-audit.js

@@ -0,0 +1,174 @@
+import { path } from "@stacksjs/path";
+import { plural, snakeCase } from "@stacksjs/strings";
+import { safeGlob } from "./fk-audit";
+export async function getDeclaredUniques() {
+  const modelFiles = [
+    ...safeGlob(path.userModelsPath("*.ts")),
+    ...safeGlob(path.storagePath("framework/defaults/app/Models/**/*.ts"))
+  ], declared = [];
+  for (const modelFile of modelFiles) {
+    let model;
+    try {
+      model = (await import(modelFile)).default;
+    } catch {
+      continue;
+    }
+    if (!model || typeof model !== "object")
+      continue;
+    const table = model.table || plural(snakeCase(model.name || "")), modelName = model.name || "", attributes = model.attributes;
+    if (attributes && typeof attributes === "object") {
+      for (const [field, attr] of Object.entries(attributes))
+        if (attr && typeof attr === "object" && attr.unique === !0)
+          declared.push({
+            table,
+            columns: [snakeCase(field)],
+            model: modelName,
+            source: "attribute"
+          });
+    }
+    const indexes = model.indexes;
+    if (Array.isArray(indexes)) {
+      for (const index of indexes)
+        if (index && index.unique === !0 && Array.isArray(index.columns) && index.columns.length > 0)
+          declared.push({
+            table,
+            columns: index.columns.map((c) => snakeCase(c)),
+            model: modelName,
+            source: "index",
+            indexName: index.name
+          });
+    }
+  }
+  return declared;
+}
+export async function getLiveUniqueIndexes(dialect) {
+  const { db } = await import("./utils"), d = dialect ?? await currentDialect();
+  if (d === "sqlite")
+    return getSqliteLiveUniques(db);
+  if (d === "mysql")
+    return getMysqlLiveUniques(db);
+  if (d === "postgres")
+    return getPostgresLiveUniques(db);
+  return [];
+}
+export async function auditUniqueIndexes(dialect) {
+  const d = dialect ?? await currentDialect();
+  if (d !== "sqlite" && d !== "mysql" && d !== "postgres")
+    return { supported: !1, declared: [], live: [], missing: [], skippedTables: [] };
+  const declared = await getDeclaredUniques(), live = await getLiveUniqueIndexes(d), liveTables = await getLiveTables(d), liveByTable = new Map;
+  for (const idx of live) {
+    const t = idx.table.toLowerCase(), key = columnSetKey(idx.columns);
+    if (!liveByTable.has(t))
+      liveByTable.set(t, new Set);
+    liveByTable.get(t).add(key);
+  }
+  const missing = [], skippedTables = new Set;
+  for (const decl of declared) {
+    const t = decl.table.toLowerCase();
+    if (!liveTables.has(t)) {
+      skippedTables.add(decl.table);
+      continue;
+    }
+    const key = columnSetKey(decl.columns);
+    if (!(liveByTable.get(t)?.has(key) ?? !1))
+      missing.push(decl);
+  }
+  return { supported: !0, declared, live, missing, skippedTables: [...skippedTables] };
+}
+async function getLiveTables(dialect) {
+  const { db } = await import("./utils");
+  let rows = [];
+  if (dialect === "sqlite") {
+    const r = await db.unsafe("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").execute();
+    rows = (Array.isArray(r) ? r : []).map((x) => x.name);
+  } else if (dialect === "mysql") {
+    const r = await db.unsafe("SELECT TABLE_NAME AS name FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE()").execute();
+    rows = (Array.isArray(r) ? r : []).map((x) => x.name ?? x.TABLE_NAME);
+  } else if (dialect === "postgres") {
+    const r = await db.unsafe("SELECT tablename AS name FROM pg_tables WHERE schemaname = 'public'").execute();
+    rows = (Array.isArray(r) ? r : []).map((x) => x.name ?? x.tablename);
+  }
+  return new Set(rows.filter((n) => typeof n === "string" && n.length > 0).map((n) => n.toLowerCase()));
+}
+function columnSetKey(columns) {
+  return [...columns].map((c) => c.toLowerCase()).sort().join(",");
+}
+async function currentDialect() {
+  const driver = ((await import("@stacksjs/env")).env?.DB_CONNECTION ?? "sqlite").toLowerCase();
+  if (driver === "sqlite" || driver === "mysql" || driver === "postgres")
+    return driver;
+  return "other";
+}
+async function getSqliteLiveUniques(db) {
+  const tables = await db.unsafe("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").execute(), rows = Array.isArray(tables) ? tables : [], out = [];
+  for (const row of rows) {
+    const table = row.name;
+    if (!table)
+      continue;
+    if (!/^[a-z_]\w*$/i.test(table))
+      continue;
+    const indexRows = await db.unsafe(`PRAGMA index_list("${table}")`).execute();
+    for (const idx of Array.isArray(indexRows) ? indexRows : []) {
+      const r = idx;
+      if (Number(r.unique) !== 1 || !r.name)
+        continue;
+      if (!/^[a-z_]\w*$/i.test(r.name))
+        continue;
+      const colRows = await db.unsafe(`PRAGMA index_info("${r.name}")`).execute(), columns = (Array.isArray(colRows) ? colRows : []).map((c) => String(c.name ?? "")).filter((c) => c.length > 0);
+      if (columns.length > 0)
+        out.push({ table, name: r.name, columns });
+    }
+  }
+  return out;
+}
+async function getMysqlLiveUniques(db) {
+  const rows = await db.unsafe(`
+    SELECT TABLE_NAME, INDEX_NAME, COLUMN_NAME, SEQ_IN_INDEX
+    FROM information_schema.STATISTICS
+    WHERE TABLE_SCHEMA = DATABASE()
+      AND NON_UNIQUE = 0
+    ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX
+  `).execute();
+  return groupIndexRows(Array.isArray(rows) ? rows : [], (r) => ({
+    table: String(r.TABLE_NAME ?? r.table_name ?? ""),
+    name: String(r.INDEX_NAME ?? r.index_name ?? ""),
+    column: String(r.COLUMN_NAME ?? r.column_name ?? "")
+  }));
+}
+async function getPostgresLiveUniques(db) {
+  const rows = await db.unsafe(`
+    SELECT
+      t.relname AS table_name,
+      ix.relname AS index_name,
+      a.attname AS column_name,
+      k.ord AS seq_in_index
+    FROM pg_index i
+    JOIN pg_class t ON t.oid = i.indrelid
+    JOIN pg_class ix ON ix.oid = i.indexrelid
+    JOIN pg_namespace n ON n.oid = t.relnamespace
+    JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS k(attnum, ord) ON true
+    JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+    WHERE i.indisunique = true
+      AND n.nspname = 'public'
+    ORDER BY table_name, index_name, seq_in_index
+  `).execute();
+  return groupIndexRows(Array.isArray(rows) ? rows : [], (r) => ({
+    table: String(r.table_name ?? ""),
+    name: String(r.index_name ?? ""),
+    column: String(r.column_name ?? "")
+  }));
+}
+function groupIndexRows(rows, pick) {
+  const map = new Map;
+  for (const row of rows) {
+    const { table, name, column } = pick(row);
+    if (!table || !name || !column)
+      continue;
+    const key = `${table} ${name}`, existing = map.get(key);
+    if (existing)
+      existing.columns.push(column);
+    else
+      map.set(key, { table, name, columns: [column] });
+  }
+  return [...map.values()];
+}