pgrift 1.0.0

package/.env.example

@@ -0,0 +1,38 @@
+# Connection (URL preferred)
+SOURCE_URL=postgresql://postgres:password@localhost:5432
+TARGET_URL=postgresql://postgres:password@localhost:5432/tenants
+
+# OR individual fields (used only if URL not set)
+# SOURCE_HOST=localhost
+# SOURCE_PORT=5432
+# SOURCE_USER=postgres
+# SOURCE_PASSWORD=
+# TARGET_HOST=localhost
+# TARGET_PORT=5432
+# TARGET_USER=postgres
+# TARGET_PASSWORD=
+# TARGET_DATABASE=tenants
+
+# Migration
+FILTER_PREFIX=
+DUMP_DIR=/tmp/pg_migration_dumps
+STATE_FILE=./migration-state.json
+CONCURRENCY=10
+EXEC_TIMEOUT_MS=600000
+# Skip checksum verification for tables with more than N rows (optional)
+# SKIP_CHECKSUM_ABOVE_ROWS=100000
+
+# Benchmark / script helpers
+# Path to JSON array of DB or schema names (used by comparison, manyBases, manySchemas)
+DB_LIST_PATH=./scripts/db-list.json
+# Table name used by benchmark scripts (e.g. users_data)
+BENCH_TABLE=users_data
+# Column used as synthetic ID in benchmarks (e.g. dbId)
+BENCH_ID_COLUMN=dbId
+# Column used as name field in benchmarks (e.g. name)
+BENCH_NAME_COLUMN=name
+
+# createRandomDb script only
+# CREATE_DB_COUNT=1000
+# CREATE_DB_PREFIX=bench_db_
+# CREATE_DB_PROJECT_PATH=

package/README.md

@@ -0,0 +1,63 @@
+# pgrift
+
+Moves many PostgreSQL databases (one per tenant) into a single DB: each tenant becomes a schema. Uses in-place rename on source (`public` → tenant name), `pg_dump`, then `psql` into the target. State is saved so you can resume after a crash.
+
+**Requires:** Node 18+, `pg_dump` and `psql` in PATH.
+
+## Setup
+
+```bash
+cp .env.example .env
+# edit .env: SOURCE_URL, TARGET_URL (and optionally DUMP_DIR, STATE_FILE, CONCURRENCY, FILTER_PREFIX)
+npm install
+```
+
+Config is read from env (see `.env.example`). Main options: `SOURCE_URL`, `TARGET_URL`, `TARGET_DATABASE` (default `tenants`), `DUMP_DIR`, `STATE_FILE`, `CONCURRENCY`, `FILTER_PREFIX` (e.g. `bench_db_` to only migrate those DBs).
+
+## Commands
+
+| Command | What it does |
+|--------|----------------|
+| `pgrift` / `npx pgrift` / `npm run dev` | Run migration |
+| `npm run verify` | Compare source DBs vs target schemas: table list, row counts, optional checksums |
+| `npm run cleanup` | Remove all tenant schemas from target, state file, dump dir contents, and `migration-report.json`. Asks for `DELETE ALL` before dropping schemas |
+| `npm run lint` | Run Biome linter (`just lint`) |
+| `npm run lint:fix` | Lint and apply safe fixes |
+| `npm run format` | Format code with Biome |
+
+After an interrupt, run `npm run dev` again; completed tenants are skipped.
+
+## What the migration does per tenant
+
+1. Terminate connections to the source DB.
+2. In source: `ALTER SCHEMA public RENAME TO "<tenant>"`, create new `public`, set DB `search_path`.
+3. `pg_dump -n "<tenant>"` to a file (fixes `gin_trgm_ops` schema in dump if present).
+4. Rollback source: restore `public`, reset `search_path`.
+5. In target: create schema `"<tenant>"`, apply dump with `psql -f`.
+
+Extensions from the source DB are created in target `public` if possible; no custom format or `pg_restore`.
+
+## Verification
+
+Built-in (after each tenant in the migration): same tables, row counts, and MD5 checksums per table (optional skip for large tables via `SKIP_CHECKSUM_ABOVE_ROWS`).
+
+Standalone: `npm run verify` [db1 db2 ...]. With no args, uses all tenant DBs from source.
+
+## Other scripts
+
+- `npm run comparison` — load test: separate DBs vs single-DB schemas (writes `heavy-load-results.json`).
+- `npm run many-schemas` / `many-bases` — benchmark helpers.
+- `npm run create-db` — create random DBs for testing.
+
+## Caveats
+
+- Source must have only `public` (or you’ll need to handle other schemas yourself). Test on one tenant first.
+- Extensions are re-created in target from the list in source; some may fail if already present or incompatible.
+- Cleanup wipes all non-system schemas in the target and local migration state; use for dev/test only.
+
+## Publishing to npm
+
+1. Create an account at [npmjs.com](https://www.npmjs.com) and run `npm login`.
+2. Bump version if needed: `npm version patch` (or `minor` / `major`).
+3. Build and publish: `npm run build && npm publish`.
+4. For scoped packages (e.g. `@username/pgrift`): use `npm publish --access public`.

package/dist/cleanup.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env ts-node
+/**
+ * Cleanup script - removes all custom schemas from target database,
+ * state file, dump directory contents, and migration report.
+ * Use only for testing!
+ *
+ * Usage: npm run cleanup  (or ts-node cleanup.ts)
+ */
+export {};

package/dist/cleanup.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env ts-node
+"use strict";
+/**
+ * Cleanup script - removes all custom schemas from target database,
+ * state file, dump directory contents, and migration report.
+ * Use only for testing!
+ *
+ * Usage: npm run cleanup  (or ts-node cleanup.ts)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const pg_1 = require("pg");
+const config_1 = require("./src/config");
+function cleanLocalFiles() {
+    // State file
+    if (node_fs_1.default.existsSync(config_1.CONFIG.stateFile)) {
+        node_fs_1.default.unlinkSync(config_1.CONFIG.stateFile);
+        console.log("Deleted state file:", config_1.CONFIG.stateFile);
+    }
+    // Migration report
+    const reportPath = "./migration-report.json";
+    if (node_fs_1.default.existsSync(reportPath)) {
+        node_fs_1.default.unlinkSync(reportPath);
+        console.log("Deleted:", reportPath);
+    }
+    // Dump directory: remove all files (e.g. *.final.dump)
+    if (node_fs_1.default.existsSync(config_1.CONFIG.dumpDir)) {
+        const entries = node_fs_1.default.readdirSync(config_1.CONFIG.dumpDir, { withFileTypes: true });
+        let removed = 0;
+        for (const ent of entries) {
+            const full = node_path_1.default.join(config_1.CONFIG.dumpDir, ent.name);
+            if (ent.isFile()) {
+                node_fs_1.default.unlinkSync(full);
+                removed++;
+            }
+        }
+        if (removed > 0) {
+            console.log(`Deleted ${removed} file(s) in dump dir: ${config_1.CONFIG.dumpDir}`);
+        }
+    }
+}
+async function cleanupSchemas() {
+    cleanLocalFiles();
+    const client = new pg_1.Client(config_1.CONFIG.target);
+    try {
+        await client.connect();
+        console.log("Connected to target DB:", config_1.CONFIG.target.database);
+        // Get all custom schemas (exclude system schemas)
+        const { rows } = await client.query(`
+      SELECT schema_name 
+      FROM information_schema.schemata 
+      WHERE schema_name NOT IN (
+        'information_schema', 
+        'pg_catalog', 
+        'pg_toast', 
+        'public'
+      )
+      ORDER BY schema_name
+    `);
+        const schemas = rows.map((r) => r.schema_name);
+        if (schemas.length === 0) {
+            console.log("No custom schemas found. Cleanup complete.");
+            return;
+        }
+        console.log(`Found ${schemas.length} schemas to delete:`);
+        for (const schema of schemas)
+            console.log(`  ${schema}`);
+        // Confirmation
+        const readline = require("node:readline").createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const response = await new Promise((resolve) => {
+            readline.question("Type 'DELETE ALL' to continue: ", (answer) => {
+                readline.close();
+                resolve(answer);
+            });
+        });
+        if (response !== "DELETE ALL") {
+            console.log("Aborted");
+            return;
+        }
+        // Delete schemas
+        let deleted = 0;
+        for (const schema of schemas) {
+            try {
+                // Terminate active connections to schema
+                await client.query(`
+          SELECT pg_terminate_backend(pid)
+          FROM pg_stat_activity 
+          WHERE datname = $1 
+            AND pid <> pg_backend_pid()
+            AND query LIKE $2
+          `, [config_1.CONFIG.target.database, `%${schema}%`]);
+                // Drop schema
+                await client.query(`DROP SCHEMA IF EXISTS "${schema}" CASCADE`);
+                console.log(`Deleted schema: ${schema}`);
+                deleted++;
+            }
+            catch (error) {
+                console.error(`Failed to delete ${schema}:`, error);
+            }
+        }
+        console.log(`Cleanup complete. Deleted ${deleted}/${schemas.length} schemas`);
+    }
+    finally {
+        await client.end();
+    }
+}
+cleanupSchemas().catch(console.error);

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/index"), exports);

package/dist/migrate.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/migrate.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runner_1 = require("./src/runner");
+const utils_1 = require("./src/utils");
+(0, runner_1.runMigration)().catch((err) => {
+    (0, utils_1.log)("error", `fatal: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
+    process.exit(1);
+});

package/dist/src/config.d.ts

@@ -0,0 +1,29 @@
+import "dotenv/config";
+import type { ClientConfig } from "pg";
+/** Build a connection URL from config and optional database name. */
+export declare function buildConnectionString(cfg: ClientConfig, database?: string): string;
+export declare const CONFIG: {
+    source: ClientConfig;
+    target: ClientConfig;
+    dumpDir: string;
+    stateFile: string;
+    concurrency: number;
+    excludeDatabases: string[];
+    filterPrefix: string | null;
+    execTimeoutMs: number;
+    skipChecksumAboveRows: number | undefined;
+    /** Path to JSON array of DB/schema names (benchmark scripts). Default: ./scripts/db-list.json */
+    dbListPath: string;
+    /** Table name used by benchmark scripts (e.g. comparison, manyBases, manySchemas). Default: users_data */
+    benchTable: string;
+    /** Column used as synthetic ID in benchmarks. Default: dbId */
+    benchIdColumn: string;
+    /** Column used as name field in benchmarks. Default: name */
+    benchNameColumn: string;
+    /** createRandomDb script: number of DBs to create. Default: 1000 */
+    createDbCount: number;
+    /** createRandomDb script: DB name prefix. Default: bench_db_ */
+    createDbPrefix: string;
+    /** createRandomDb script: path to project that runs postinstall-dev for each DB. Optional. */
+    createDbProjectPath: string | null;
+};

package/dist/src/config.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
+exports.buildConnectionString = buildConnectionString;
+require("dotenv/config");
+function parseConnectionString(url) {
+    const u = new URL(url);
+    return {
+        host: u.hostname,
+        port: u.port ? parseInt(u.port, 10) : 5432,
+        user: u.username || undefined,
+        password: u.password ? decodeURIComponent(u.password) : undefined,
+        database: u.pathname.slice(1) || undefined,
+    };
+}
+function resolveConfig(urlEnv, hostEnv, portEnv, userEnv, passEnv, dbEnv) {
+    if (urlEnv) {
+        const parsed = parseConnectionString(urlEnv);
+        return dbEnv ? { ...parsed, database: dbEnv } : parsed;
+    }
+    return {
+        host: hostEnv ?? "localhost",
+        port: parseInt(portEnv ?? "5432", 10),
+        user: userEnv ?? "postgres",
+        password: passEnv ?? "",
+        ...(dbEnv ? { database: dbEnv } : {}),
+    };
+}
+/** Build a connection URL from config and optional database name. */
+function buildConnectionString(cfg, database) {
+    const db = database ?? cfg.database ?? "postgres";
+    const user = cfg.user ?? "postgres";
+    const pwRaw = typeof cfg.password === "string" ? cfg.password : "";
+    const pw = pwRaw ? `:${encodeURIComponent(pwRaw)}` : "";
+    const port = cfg.port ?? 5432;
+    return `postgresql://${user}${pw}@${cfg.host}:${port}/${db}`;
+}
+exports.CONFIG = {
+    source: resolveConfig(process.env.SOURCE_URL, process.env.SOURCE_HOST, process.env.SOURCE_PORT, process.env.SOURCE_USER, process.env.SOURCE_PASSWORD),
+    target: resolveConfig(process.env.TARGET_URL, process.env.TARGET_HOST, process.env.TARGET_PORT, process.env.TARGET_USER, process.env.TARGET_PASSWORD, process.env.TARGET_DATABASE ?? "tenants"),
+    dumpDir: process.env.DUMP_DIR ?? "/tmp/pg_migration_dumps",
+    stateFile: process.env.STATE_FILE ?? "./migration-state.json",
+    concurrency: parseInt(process.env.CONCURRENCY ?? "10", 10),
+    excludeDatabases: [
+        "postgres",
+        "template0",
+        "template1",
+        process.env.TARGET_DATABASE ?? "tenants",
+    ],
+    filterPrefix: process.env.FILTER_PREFIX ?? null,
+    execTimeoutMs: parseInt(process.env.EXEC_TIMEOUT_MS ?? "600000", 10),
+    skipChecksumAboveRows: process.env.SKIP_CHECKSUM_ABOVE_ROWS
+        ? parseInt(process.env.SKIP_CHECKSUM_ABOVE_ROWS, 10)
+        : undefined,
+    /** Path to JSON array of DB/schema names (benchmark scripts). Default: ./scripts/db-list.json */
+    dbListPath: process.env.DB_LIST_PATH ?? "./scripts/db-list.json",
+    /** Table name used by benchmark scripts (e.g. comparison, manyBases, manySchemas). Default: users_data */
+    benchTable: process.env.BENCH_TABLE ?? "users_data",
+    /** Column used as synthetic ID in benchmarks. Default: dbId */
+    benchIdColumn: process.env.BENCH_ID_COLUMN ?? "dbId",
+    /** Column used as name field in benchmarks. Default: name */
+    benchNameColumn: process.env.BENCH_NAME_COLUMN ?? "name",
+    /** createRandomDb script: number of DBs to create. Default: 1000 */
+    createDbCount: parseInt(process.env.CREATE_DB_COUNT ?? "1000", 10),
+    /** createRandomDb script: DB name prefix. Default: bench_db_ */
+    createDbPrefix: process.env.CREATE_DB_PREFIX ?? "bench_db_",
+    /** createRandomDb script: path to project that runs postinstall-dev for each DB. Optional. */
+    createDbProjectPath: process.env.CREATE_DB_PROJECT_PATH ?? null,
+};

package/dist/src/db.d.ts

@@ -0,0 +1,4 @@
+import { Client } from "pg";
+export declare function withClient<T>(config: object, fn: (client: Client) => Promise<T>): Promise<T>;
+export declare function ensureTargetDatabase(): Promise<void>;
+export declare function getTenants(): Promise<string[]>;

package/dist/src/db.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withClient = withClient;
+exports.ensureTargetDatabase = ensureTargetDatabase;
+exports.getTenants = getTenants;
+const pg_1 = require("pg");
+const config_1 = require("./config");
+const utils_1 = require("./utils");
+async function withClient(config, fn) {
+    const client = new pg_1.Client(config);
+    await client.connect();
+    try {
+        return await fn(client);
+    }
+    finally {
+        await client.end();
+    }
+}
+async function ensureTargetDatabase() {
+    await withClient({ ...config_1.CONFIG.target, database: "postgres" }, async (client) => {
+        const { rows } = await client.query("SELECT 1 FROM pg_database WHERE datname = $1", [
+            config_1.CONFIG.target.database,
+        ]);
+        if (rows.length === 0) {
+            await client.query(`CREATE DATABASE "${config_1.CONFIG.target.database}"`);
+            (0, utils_1.log)("info", `created database: ${config_1.CONFIG.target.database}`);
+        }
+    });
+}
+async function getTenants() {
+    return withClient({ ...config_1.CONFIG.source, database: "postgres" }, async (client) => {
+        const placeholders = config_1.CONFIG.excludeDatabases.map((_, i) => `$${i + 1}`).join(", ");
+        const { rows } = await client.query(`SELECT datname FROM pg_database
+       WHERE datname NOT IN (${placeholders})
+         AND datname NOT LIKE 'pg_%'
+       ORDER BY datname`, config_1.CONFIG.excludeDatabases);
+        let tenants = rows.map((r) => r.datname);
+        if (config_1.CONFIG.filterPrefix) {
+            tenants = tenants.filter((db) => db.startsWith(config_1.CONFIG.filterPrefix));
+        }
+        return tenants;
+    });
+}

package/dist/src/disk.d.ts

@@ -0,0 +1,2 @@
+export declare function getFreeBytesOnDir(dir: string): number;
+export declare function assertDiskSpace(dir: string, minBytes?: number): void;

package/dist/src/disk.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFreeBytesOnDir = getFreeBytesOnDir;
+exports.assertDiskSpace = assertDiskSpace;
+const node_child_process_1 = require("node:child_process");
+function getFreeBytesOnDir(dir) {
+    const out = (0, node_child_process_1.execSync)(`df -k "${dir}"`, { encoding: "utf-8" });
+    const line = out.trim().split("\n")[1];
+    const available = parseInt(line.trim().split(/\s+/)[3], 10);
+    return available * 1024;
+}
+function assertDiskSpace(dir, minBytes = 512 * 1024 * 1024) {
+    const free = getFreeBytesOnDir(dir);
+    if (free < minBytes) {
+        throw new Error(`Not enough disk space in ${dir}: ${Math.round(free / 1024 / 1024)} MB free, need at least ${Math.round(minBytes / 1024 / 1024)} MB`);
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * pgrift – PostgreSQL multi-tenant migration (separate DBs → single DB with schemas)
+ *
+ * Entry points:
+ * - migrate.ts  → runMigration() from ./src/runner
+ * - verify.ts   → uses getTenants from ./src/db, CONFIG from ./src/config
+ * - cleanup.ts  → uses CONFIG from ./src/config
+ */
+export { buildConnectionString, CONFIG } from "./config";
+export { ensureTargetDatabase, getTenants, withClient } from "./db";
+export { migrateTenant } from "./migrate-tenant";
+export { runMigration } from "./runner";
+export { loadState, saveState } from "./state";
+export { FailedEntry, State } from "./types";
+export { atomicWrite, exec, log } from "./utils";
+export { tableChecksum, verifyMigration } from "./verify-migration";

package/dist/src/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * pgrift – PostgreSQL multi-tenant migration (separate DBs → single DB with schemas)
+ *
+ * Entry points:
+ * - migrate.ts  → runMigration() from ./src/runner
+ * - verify.ts   → uses getTenants from ./src/db, CONFIG from ./src/config
+ * - cleanup.ts  → uses CONFIG from ./src/config
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyMigration = exports.tableChecksum = exports.log = exports.exec = exports.atomicWrite = exports.saveState = exports.loadState = exports.runMigration = exports.migrateTenant = exports.withClient = exports.getTenants = exports.ensureTargetDatabase = exports.CONFIG = exports.buildConnectionString = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "buildConnectionString", { enumerable: true, get: function () { return config_1.buildConnectionString; } });
+Object.defineProperty(exports, "CONFIG", { enumerable: true, get: function () { return config_1.CONFIG; } });
+var db_1 = require("./db");
+Object.defineProperty(exports, "ensureTargetDatabase", { enumerable: true, get: function () { return db_1.ensureTargetDatabase; } });
+Object.defineProperty(exports, "getTenants", { enumerable: true, get: function () { return db_1.getTenants; } });
+Object.defineProperty(exports, "withClient", { enumerable: true, get: function () { return db_1.withClient; } });
+var migrate_tenant_1 = require("./migrate-tenant");
+Object.defineProperty(exports, "migrateTenant", { enumerable: true, get: function () { return migrate_tenant_1.migrateTenant; } });
+var runner_1 = require("./runner");
+Object.defineProperty(exports, "runMigration", { enumerable: true, get: function () { return runner_1.runMigration; } });
+var state_1 = require("./state");
+Object.defineProperty(exports, "loadState", { enumerable: true, get: function () { return state_1.loadState; } });
+Object.defineProperty(exports, "saveState", { enumerable: true, get: function () { return state_1.saveState; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "atomicWrite", { enumerable: true, get: function () { return utils_1.atomicWrite; } });
+Object.defineProperty(exports, "exec", { enumerable: true, get: function () { return utils_1.exec; } });
+Object.defineProperty(exports, "log", { enumerable: true, get: function () { return utils_1.log; } });
+var verify_migration_1 = require("./verify-migration");
+Object.defineProperty(exports, "tableChecksum", { enumerable: true, get: function () { return verify_migration_1.tableChecksum; } });
+Object.defineProperty(exports, "verifyMigration", { enumerable: true, get: function () { return verify_migration_1.verifyMigration; } });

package/dist/src/migrate-tenant.d.ts

@@ -0,0 +1 @@
+export declare function migrateTenant(dbName: string): Promise<void>;

package/dist/src/migrate-tenant.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateTenant = migrateTenant;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("./config");
+const db_1 = require("./db");
+const disk_1 = require("./disk");
+const utils_1 = require("./utils");
+async function migrateTenant(dbName) {
+    const finalDumpFile = node_path_1.default.join(config_1.CONFIG.dumpDir, `${dbName}.final.dump`);
+    const src = config_1.CONFIG.source;
+    const tgt = config_1.CONFIG.target;
+    const srcPw = String(src.password ?? "");
+    const tgtPw = String(tgt.password ?? "");
+    const dbNameEsc = dbName.replace(/"/g, '""');
+    (0, disk_1.assertDiskSpace)(config_1.CONFIG.dumpDir);
+    const extensions = await (0, db_1.withClient)({ ...src, database: dbName }, async (client) => {
+        const { rows } = await client.query(`SELECT extname FROM pg_extension WHERE extname != 'plpgsql' ORDER BY extname`);
+        return rows.map((r) => r.extname);
+    });
+    let rollbackNeeded = false;
+    try {
+        (0, utils_1.log)("info", `  [${dbName}] terminating connections...`);
+        await (0, db_1.withClient)({ ...src, database: "postgres" }, async (client) => {
+            await client.query(`SELECT pg_terminate_backend(pid)
+         FROM pg_stat_activity
+         WHERE datname = $1 AND pid <> pg_backend_pid()`, [dbName]);
+        });
+        (0, utils_1.log)("info", `  [${dbName}] renaming schema in source...`);
+        await (0, db_1.withClient)({ ...src, database: dbName }, async (client) => {
+            await client.query(`ALTER SCHEMA public RENAME TO "${dbNameEsc}"`);
+            await client.query(`CREATE SCHEMA public`);
+            await client.query(`ALTER DATABASE "${dbNameEsc}" SET search_path = '"${dbNameEsc}"'`);
+        });
+        rollbackNeeded = true;
+        (0, utils_1.log)("info", `  [${dbName}] dumping renamed schema...`);
+        (0, utils_1.exec)([
+            "pg_dump",
+            `-h "${src.host}"`,
+            `-p ${src.port}`,
+            `-U "${src.user}"`,
+            `-d "${dbName}"`,
+            `-n "${dbName}"`,
+            `--no-owner`,
+            `--no-acl`,
+            `-f "${finalDumpFile}"`,
+        ].join(" "), srcPw);
+        (0, utils_1.log)("info", `  [${dbName}] rolling back source schema...`);
+        await (0, db_1.withClient)({ ...src, database: dbName }, async (client) => {
+            await client.query(`ALTER DATABASE "${dbNameEsc}" RESET search_path`);
+            await client.query(`DROP SCHEMA public`);
+            await client.query(`ALTER SCHEMA "${dbNameEsc}" RENAME TO public`);
+        });
+        rollbackNeeded = false;
+        (0, utils_1.log)("info", `  [${dbName}] restoring to target database...`);
+        await (0, db_1.withClient)(tgt, async (client) => {
+            await client.query(`DROP SCHEMA IF EXISTS "${dbNameEsc}" CASCADE`);
+            for (const extname of extensions) {
+                try {
+                    await client.query(`CREATE EXTENSION IF NOT EXISTS "${extname}" WITH SCHEMA public`);
+                }
+                catch {
+                    // extension may already exist
+                }
+            }
+        });
+        let dumpSql = node_fs_1.default.readFileSync(finalDumpFile, "utf-8");
+        const opclassSchema = `${dbName}.gin_trgm_ops`;
+        if (dumpSql.includes(opclassSchema)) {
+            dumpSql = dumpSql.split(opclassSchema).join("public.gin_trgm_ops");
+        }
+        node_fs_1.default.writeFileSync(finalDumpFile, dumpSql, "utf-8");
+        (0, utils_1.exec)([
+            "psql",
+            `-h "${tgt.host}"`,
+            `-p ${tgt.port}`,
+            `-U "${tgt.user}"`,
+            `-d "${tgt.database}"`,
+            `-v ON_ERROR_STOP=1`,
+            `-f "${finalDumpFile}"`,
+        ].join(" "), tgtPw);
+        (0, utils_1.log)("info", `  [${dbName}] migration completed`);
+    }
+    finally {
+        if (rollbackNeeded) {
+            (0, utils_1.log)("warn", `  [${dbName}] rollback after error...`);
+            try {
+                await (0, db_1.withClient)({ ...src, database: dbName }, async (client) => {
+                    await client.query(`ALTER DATABASE "${dbNameEsc}" RESET search_path`);
+                    await client.query(`DROP SCHEMA IF EXISTS public`);
+                    await client.query(`ALTER SCHEMA "${dbNameEsc}" RENAME TO public`);
+                });
+            }
+            catch (err) {
+                (0, utils_1.log)("error", `  [${dbName}] rollback failed: ${err}`);
+            }
+        }
+        if (node_fs_1.default.existsSync(finalDumpFile))
+            node_fs_1.default.unlinkSync(finalDumpFile);
+    }
+}

package/dist/src/runner.d.ts

@@ -0,0 +1 @@
+export declare function runMigration(): Promise<void>;

package/dist/src/runner.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMigration = runMigration;
+const node_fs_1 = __importDefault(require("node:fs"));
+const readline = __importStar(require("node:readline"));
+const config_1 = require("./config");
+const db_1 = require("./db");
+const migrate_tenant_1 = require("./migrate-tenant");
+const state_1 = require("./state");
+const utils_1 = require("./utils");
+const verify_migration_1 = require("./verify-migration");
+async function runBatch(tenants, state) {
+    const results = await Promise.allSettled(tenants.map(async (db) => {
+        await (0, migrate_tenant_1.migrateTenant)(db);
+        const { ok, reasons } = await (0, verify_migration_1.verifyMigration)(db);
+        if (!ok) {
+            throw new Error(`verification failed: ${reasons.join(" | ")}`);
+        }
+        return db;
+    }));
+    for (let i = 0; i < results.length; i++) {
+        const db = tenants[i];
+        const result = results[i];
+        if (result.status === "fulfilled") {
+            state.completed.push(db);
+            (0, utils_1.log)("done", `${db} (${state.completed.length} total)`);
+        }
+        else {
+            const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
+            const existing = state.failed.find((f) => f.db === db);
+            if (existing) {
+                existing.attempts++;
+                existing.error = message;
+            }
+            else {
+                state.failed.push({ db, error: message, attempts: 1 });
+            }
+            (0, utils_1.log)("fail", `${db}: ${message.slice(0, 200)}`);
+        }
+    }
+}
+function askConfirm(prompt) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer.trim().toUpperCase() === "Y");
+        });
+    });
+}
+async function runMigration() {
+    const confirmed = await askConfirm("Run migration? (Y/N): ");
+    if (!confirmed) {
+        (0, utils_1.log)("info", "Aborted.");
+        return;
+    }
+    node_fs_1.default.mkdirSync(config_1.CONFIG.dumpDir, { recursive: true });
+    await (0, db_1.ensureTargetDatabase)();
+    const state = (0, state_1.loadState)();
+    const allTenants = await (0, db_1.getTenants)();
+    const completed = new Set(state.completed);
+    const remaining = allTenants.filter((db) => !completed.has(db));
+    (0, utils_1.log)("info", `total: ${allTenants.length} | done: ${state.completed.length} | ` +
+        `remaining: ${remaining.length} | failed: ${state.failed.length}`);
+    if (remaining.length === 0) {
+        (0, utils_1.log)("info", "nothing to migrate");
+        return;
+    }
+    const batches = [];
+    for (let i = 0; i < remaining.length; i += config_1.CONFIG.concurrency) {
+        batches.push(remaining.slice(i, i + config_1.CONFIG.concurrency));
+    }
+    const startTime = Date.now();
+    const initialDone = state.completed.length;
+    for (let i = 0; i < batches.length; i++) {
+        const elapsed = Math.round((Date.now() - startTime) / 1000);
+        const migratedSoFar = state.completed.length - initialDone;
+        const pct = Math.round((state.completed.length / allTenants.length) * 100);
+        const remainingCount = remaining.length - migratedSoFar;
+        const eta = migratedSoFar > 0 ? Math.round((elapsed / migratedSoFar) * remainingCount) : "?";
+        (0, utils_1.log)("info", `batch ${i + 1}/${batches.length} | ${pct}% | ${elapsed}s elapsed | ETA ~${eta}s`);
+        await runBatch(batches[i], state);
+        (0, state_1.saveState)(state);
+    }
+    const totalTime = Math.round((Date.now() - startTime) / 1000);
+    (0, utils_1.log)("info", `completed: ${state.completed.length} | failed: ${state.failed.length} | time: ${totalTime}s`);
+    if (state.failed.length > 0) {
+        (0, utils_1.log)("warn", "failed tenants:");
+        for (const f of state.failed)
+            (0, utils_1.log)("fail", `  ${f.db} (${f.attempts} attempts): ${f.error.slice(0, 200)}`);
+    }
+    (0, utils_1.atomicWrite)("./migration-report.json", JSON.stringify({
+        ...state,
+        totalDatabases: allTenants.length,
+        totalTimeSeconds: totalTime,
+    }, null, 2));
+}

package/dist/src/state.d.ts

@@ -0,0 +1,3 @@
+import type { State } from "./types";
+export declare function loadState(): State;
+export declare function saveState(state: State): void;

package/dist/src/state.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadState = loadState;
+exports.saveState = saveState;
+const node_fs_1 = __importDefault(require("node:fs"));
+const config_1 = require("./config");
+const utils_1 = require("./utils");
+function loadState() {
+    if (node_fs_1.default.existsSync(config_1.CONFIG.stateFile)) {
+        try {
+            return JSON.parse(node_fs_1.default.readFileSync(config_1.CONFIG.stateFile, "utf-8"));
+        }
+        catch {
+            (0, utils_1.log)("warn", "state file is corrupted, starting fresh");
+        }
+    }
+    return {
+        completed: [],
+        failed: [],
+        startedAt: new Date().toISOString(),
+        lastUpdated: new Date().toISOString(),
+    };
+}
+function saveState(state) {
+    state.lastUpdated = new Date().toISOString();
+    (0, utils_1.atomicWrite)(config_1.CONFIG.stateFile, JSON.stringify(state, null, 2));
+}

package/dist/src/types.d.ts

@@ -0,0 +1,11 @@
+export interface FailedEntry {
+    db: string;
+    error: string;
+    attempts: number;
+}
+export interface State {
+    completed: string[];
+    failed: FailedEntry[];
+    startedAt: string;
+    lastUpdated: string;
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils.d.ts

@@ -0,0 +1,5 @@
+export type LogLevel = "info" | "warn" | "error" | "done" | "fail";
+export declare function log(level: LogLevel, msg: string): void;
+/** Atomic file write: write to temp file then rename. */
+export declare function atomicWrite(filePath: string, data: string): void;
+export declare function exec(cmd: string, password: string): void;

package/dist/src/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = log;
+exports.atomicWrite = atomicWrite;
+exports.exec = exec;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const config_1 = require("./config");
+function log(level, msg) {
+    const prefix = {
+        info: "[info]",
+        warn: "[warn]",
+        error: "[error]",
+        done: "[done]",
+        fail: "[fail]",
+    };
+    const out = level === "error" || level === "fail" ? process.stderr : process.stdout;
+    out.write(`${prefix[level]} ${msg}\n`);
+}
+/** Atomic file write: write to temp file then rename. */
+function atomicWrite(filePath, data) {
+    const tmp = `${filePath}.tmp`;
+    node_fs_1.default.writeFileSync(tmp, data, "utf-8");
+    node_fs_1.default.renameSync(tmp, filePath);
+}
+function exec(cmd, password) {
+    const opts = {
+        env: { ...process.env, PGPASSWORD: password },
+        stdio: "pipe",
+        timeout: config_1.CONFIG.execTimeoutMs ?? 10 * 60 * 1000,
+    };
+    (0, node_child_process_1.execSync)(cmd, opts);
+}

package/dist/src/verify-migration.d.ts

@@ -0,0 +1,6 @@
+import type { Client } from "pg";
+export declare function tableChecksum(client: Client, schema: string, table: string): Promise<string>;
+export declare function verifyMigration(dbName: string): Promise<{
+    ok: boolean;
+    reasons: string[];
+}>;

package/dist/src/verify-migration.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableChecksum = tableChecksum;
+exports.verifyMigration = verifyMigration;
+const config_1 = require("./config");
+const db_1 = require("./db");
+const utils_1 = require("./utils");
+async function tableChecksum(client, schema, table) {
+    const { rows: cols } = await client.query(`SELECT column_name, data_type
+     FROM information_schema.columns
+     WHERE table_schema = $1 AND table_name = $2
+     ORDER BY ordinal_position`, [schema, table]);
+    if (cols.length === 0)
+        return "empty";
+    const orderBy = cols
+        .map((c) => {
+        const colExpr = c.data_type === "json" || c.data_type === "jsonb"
+            ? `"${c.column_name}"::text`
+            : `"${c.column_name}"`;
+        return `${colExpr} NULLS FIRST`;
+    })
+        .join(", ");
+    const { rows } = await client.query(`SELECT md5(string_agg(row_md5, ',' ORDER BY rn)) AS checksum
+     FROM (
+       SELECT ROW_NUMBER() OVER (ORDER BY ${orderBy}) AS rn,
+              md5(ROW(${cols.map((c) => `"${c.column_name}"`).join(", ")})::text) AS row_md5
+       FROM ${schema === "public" ? "public" : `"${schema}"`}."${table}"
+     ) sub`);
+    return rows[0]?.checksum ?? "null";
+}
+async function verifyMigration(dbName) {
+    const reasons = [];
+    await (0, db_1.withClient)({ ...config_1.CONFIG.source, database: dbName }, async (srcClient) => {
+        await (0, db_1.withClient)(config_1.CONFIG.target, async (tgtClient) => {
+            const { rows: srcTables } = await srcClient.query(`SELECT table_name FROM information_schema.tables
+         WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+         ORDER BY table_name`);
+            const { rows: tgtTables } = await tgtClient.query(`SELECT table_name FROM information_schema.tables
+         WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+         ORDER BY table_name`, [dbName]);
+            const srcTableNames = srcTables.map((r) => r.table_name);
+            const tgtTableNames = new Set(tgtTables.map((r) => r.table_name));
+            const missingTables = srcTableNames.filter((t) => !tgtTableNames.has(t));
+            if (missingTables.length > 0) {
+                reasons.push(`missing tables: ${missingTables.join(", ")}`);
+            }
+            for (const table of srcTableNames) {
+                if (!tgtTableNames.has(table))
+                    continue;
+                const { rows: srcCnt } = await srcClient.query(`SELECT COUNT(*)::text AS cnt FROM public."${table}"`);
+                const { rows: tgtCnt } = await tgtClient.query(`SELECT COUNT(*)::text AS cnt FROM "${dbName}"."${table}"`);
+                const srcCount = srcCnt[0].cnt;
+                const tgtCount = tgtCnt[0].cnt;
+                if (srcCount !== tgtCount) {
+                    reasons.push(`${table}: row count mismatch (src: ${srcCount}, tgt: ${tgtCount})`);
+                    continue;
+                }
+                const rowCount = parseInt(srcCount, 10);
+                const skipAbove = config_1.CONFIG.skipChecksumAboveRows;
+                if (skipAbove !== undefined && rowCount > skipAbove) {
+                    (0, utils_1.log)("warn", `  ${table}: checksum skipped (${rowCount} rows > threshold ${skipAbove})`);
+                    continue;
+                }
+                const [srcChecksum, tgtChecksum] = await Promise.all([
+                    tableChecksum(srcClient, "public", table),
+                    tableChecksum(tgtClient, dbName, table),
+                ]);
+                if (srcChecksum !== tgtChecksum) {
+                    reasons.push(`${table}: checksum mismatch (src: ${srcChecksum}, tgt: ${tgtChecksum})`);
+                }
+            }
+        });
+    });
+    return { ok: reasons.length === 0, reasons };
+}

package/dist/verify.d.ts

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

package/dist/verify.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pg_1 = require("pg");
+const config_1 = require("./src/config");
+const db_1 = require("./src/db");
+async function verifyTenant(dbName) {
+    const sourceClient = new pg_1.Client({ ...config_1.CONFIG.source, database: dbName });
+    const targetClient = new pg_1.Client(config_1.CONFIG.target);
+    await sourceClient.connect();
+    await targetClient.connect();
+    try {
+        // 1. Compare table lists
+        const { rows: srcTables } = await sourceClient.query(`SELECT table_name FROM information_schema.tables
+       WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+       ORDER BY table_name`);
+        const { rows: tgtTables } = await targetClient.query(`SELECT table_name FROM information_schema.tables
+       WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+       ORDER BY table_name`, [dbName]);
+        const srcNames = srcTables.map((r) => r.table_name);
+        const tgtNames = tgtTables.map((r) => r.table_name);
+        const missing = srcNames.filter((t) => !tgtNames.includes(t));
+        if (missing.length > 0) {
+            return { db: dbName, status: "fail", reason: `missing tables: ${missing.join(", ")}` };
+        }
+        const extra = tgtNames.filter((t) => !srcNames.includes(t));
+        if (extra.length > 0) {
+            return { db: dbName, status: "fail", reason: `unexpected tables: ${extra.join(", ")}` };
+        }
+        // 2. Compare row counts per table
+        for (const table of srcNames) {
+            const { rows: s } = await sourceClient.query(`SELECT COUNT(*) AS cnt FROM public."${table}"`);
+            const { rows: t } = await targetClient.query(`SELECT COUNT(*) AS cnt FROM "${dbName}"."${table}"`);
+            const srcCnt = parseInt(s[0].cnt, 10);
+            const tgtCnt = parseInt(t[0].cnt, 10);
+            if (srcCnt !== tgtCnt) {
+                return {
+                    db: dbName,
+                    status: "fail",
+                    reason: `${table}: row count mismatch (src: ${srcCnt}, tgt: ${tgtCnt})`,
+                };
+            }
+        }
+        return { db: dbName, status: "ok" };
+    }
+    finally {
+        await sourceClient.end();
+        await targetClient.end();
+    }
+}
+async function main() {
+    // Optional: pass specific DBs as args: npx ts-node verify.ts db-company1 db-company2
+    const args = process.argv.slice(2);
+    const tenants = args.length > 0 ? args : await (0, db_1.getTenants)();
+    console.log(`Verifying ${tenants.length} tenant(s)...\n`);
+    const results = [];
+    // Run sequentially to avoid overloading the database
+    for (const db of tenants) {
+        process.stdout.write(`  ${db} ... `);
+        const result = await verifyTenant(db);
+        results.push(result);
+        console.log(result.status === "ok" ? "✓" : `✗ ${result.reason}`);
+    }
+    const failed = results.filter((r) => r.status === "fail");
+    console.log(`\n${results.length - failed.length}/${results.length} passed`);
+    if (failed.length > 0) {
+        console.log("\nFailed:");
+        for (const r of failed)
+            console.log(`  ${r.db}: ${r.reason}`);
+        process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error("fatal:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "pgrift",
+  "version": "1.0.0",
+  "description": "Migrate many PostgreSQL databases (one per tenant) into a single DB with one schema per tenant. Uses pg_dump and psql with resumable state.",
+  "license": "ISC",
+  "author": "Satoru Fujinuma",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "bin": { "pgrift": "./dist/migrate.js" },
+  "repository": { "type": "git", "url": "https://github.com/SatoruFF/pgrift.git" },
+  "keywords": ["postgresql", "migration", "multi-tenant", "pg_dump", "schema"],
+  "scripts": {
+    "dev": "node dist/migrate.js",
+    "migrate": "node dist/migrate.js",
+    "cleanup": "node dist/cleanup.js",
+    "verify": "node dist/verify.js",
+    "create-db": "npx tsx scripts/createRandomDb.test.ts",
+    "many-bases": "npx tsx scripts/manyBases.test.ts",
+    "many-schemas": "npx tsx scripts/manySchemas.test.ts",
+    "comparison": "npx tsx scripts/comparison.test.ts",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "build": "tsc -p tsconfig.json",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "dotenv": "^17.3.1",
+    "p-map": "^7.0.4",
+    "pg": "^8.18.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.4",
+    "@types/pg": "^8.16.0",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    ".env.example"
+  ],
+  "engines": { "node": ">=18" }
+}