supabase-test 0.0.1

package/esm/test-client.js

@@ -0,0 +1,150 @@
+import { Client } from 'pg';
+import { getRoleName } from './roles';
+export class PgTestClient {
+    config;
+    client;
+    opts;
+    ctxStmts = '';
+    contextSettings = {};
+    _ended = false;
+    connectPromise = null;
+    constructor(config, opts = {}) {
+        this.opts = opts;
+        this.config = config;
+        this.client = new Client({
+            host: this.config.host,
+            port: this.config.port,
+            database: this.config.database,
+            user: this.config.user,
+            password: this.config.password
+        });
+        if (!opts.deferConnect) {
+            this.connectPromise = this.client.connect();
+            if (opts.trackConnect)
+                opts.trackConnect(this.connectPromise);
+        }
+    }
+    async ensureConnected() {
+        if (this.connectPromise) {
+            try {
+                await this.connectPromise;
+            }
+            catch { }
+        }
+    }
+    async close() {
+        if (!this._ended) {
+            this._ended = true;
+            await this.ensureConnected();
+            this.client.end();
+        }
+    }
+    async begin() {
+        await this.client.query('BEGIN;');
+    }
+    async savepoint(name = 'lqlsavepoint') {
+        await this.client.query(`SAVEPOINT "${name}";`);
+    }
+    async rollback(name = 'lqlsavepoint') {
+        await this.client.query(`ROLLBACK TO SAVEPOINT "${name}";`);
+    }
+    async commit() {
+        await this.client.query('COMMIT;');
+    }
+    async beforeEach() {
+        await this.begin();
+        await this.savepoint();
+    }
+    async afterEach() {
+        await this.rollback();
+        await this.commit();
+    }
+    setContext(ctx) {
+        Object.assign(this.contextSettings, ctx);
+        this.ctxStmts = Object.entries(this.contextSettings)
+            .map(([key, val]) => val === null
+            ? `SELECT set_config('${key}', NULL, true);`
+            : `SELECT set_config('${key}', '${val}', true);`)
+            .join('\n');
+    }
+    /**
+     * Set authentication context for the current session.
+     * Configures role and user ID using cascading defaults from options → opts.auth → RoleMapping.
+     */
+    auth(options = {}) {
+        const role = options.role ?? this.opts.auth?.role ?? getRoleName('authenticated', this.opts);
+        const userIdKey = options.userIdKey ?? this.opts.auth?.userIdKey ?? 'jwt.claims.user_id';
+        const userId = options.userId ?? this.opts.auth?.userId ?? null;
+        this.setContext({
+            role,
+            [userIdKey]: userId !== null ? String(userId) : null
+        });
+    }
+    /**
+     * Commit current transaction to make data visible to other connections, then start fresh transaction.
+     * Maintains test isolation by creating a savepoint and reapplying session context.
+     */
+    async publish() {
+        await this.commit(); // make data visible to other sessions
+        await this.begin(); // fresh tx
+        await this.savepoint(); // keep rollback harness
+        await this.ctxQuery(); // reapply all setContext()
+    }
+    /**
+     * Clear all session context variables and reset to default anonymous role.
+     */
+    clearContext() {
+        const defaultRole = getRoleName('anonymous', this.opts);
+        const nulledSettings = {};
+        Object.keys(this.contextSettings).forEach(key => {
+            nulledSettings[key] = null;
+        });
+        nulledSettings.role = defaultRole;
+        this.ctxStmts = Object.entries(nulledSettings)
+            .map(([key, val]) => val === null
+            ? `SELECT set_config('${key}', NULL, true);`
+            : `SELECT set_config('${key}', '${val}', true);`)
+            .join('\n');
+        this.contextSettings = { role: defaultRole };
+    }
+    async any(query, values) {
+        const result = await this.query(query, values);
+        return result.rows;
+    }
+    async one(query, values) {
+        const rows = await this.any(query, values);
+        if (rows.length !== 1) {
+            throw new Error('Expected exactly one result');
+        }
+        return rows[0];
+    }
+    async oneOrNone(query, values) {
+        const rows = await this.any(query, values);
+        return rows[0] || null;
+    }
+    async many(query, values) {
+        const rows = await this.any(query, values);
+        if (rows.length === 0)
+            throw new Error('Expected many rows, got none');
+        return rows;
+    }
+    async manyOrNone(query, values) {
+        return this.any(query, values);
+    }
+    async none(query, values) {
+        await this.query(query, values);
+    }
+    async result(query, values) {
+        return this.query(query, values);
+    }
+    async query(query, values) {
+        await this.ctxQuery();
+        const result = await this.client.query(query, values);
+        return result;
+    }
+    async ctxQuery() {
+        if (this.ctxStmts) {
+            await this.client.query(this.ctxStmts);
+        }
+    }
+}

package/index.d.ts

@@ -0,0 +1,6 @@
+export * from './admin';
+export * from './connect';
+export * from './manager';
+export * from './roles';
+export * from './seed';
+export * from './test-client';

package/index.js

@@ -0,0 +1,22 @@
+"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("./admin"), exports);
+__exportStar(require("./connect"), exports);
+__exportStar(require("./manager"), exports);
+__exportStar(require("./roles"), exports);
+__exportStar(require("./seed"), exports);
+__exportStar(require("./test-client"), exports);

package/manager.d.ts

@@ -0,0 +1,25 @@
+import { Pool } from 'pg';
+import { PgConfig } from 'pg-env';
+import { PgTestClient, PgTestClientOpts } from './test-client';
+export declare class PgTestConnector {
+    private static instance;
+    private readonly clients;
+    private readonly pgPools;
+    private readonly seenDbConfigs;
+    private readonly pendingConnects;
+    private verbose;
+    private shuttingDown;
+    private constructor();
+    static getInstance(verbose?: boolean): PgTestConnector;
+    private poolKey;
+    private dbKey;
+    beginTeardown(): void;
+    private registerConnect;
+    private awaitPendingConnects;
+    getPool(config: PgConfig): Pool;
+    getClient(config: PgConfig, opts?: Partial<PgTestClientOpts>): PgTestClient;
+    closeAll(): Promise<void>;
+    close(): void;
+    drop(config: PgConfig): void;
+    kill(client: PgTestClient): Promise<void>;
+}

package/manager.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgTestConnector = void 0;
+const logger_1 = require("@launchql/logger");
+const pg_1 = require("pg");
+const pg_env_1 = require("pg-env");
+const admin_1 = require("./admin");
+const test_client_1 = require("./test-client");
+const log = new logger_1.Logger('test-connector');
+const SYS_EVENTS = ['SIGTERM'];
+const end = (pool) => {
+    try {
+        if (pool.ended || pool.ending) {
+            log.warn('⚠️ pg pool already ended or ending');
+            return;
+        }
+        pool.end();
+    }
+    catch (err) {
+        log.error('❌ pg pool termination error:', err);
+    }
+};
+class PgTestConnector {
+    static instance;
+    clients = new Set();
+    pgPools = new Map();
+    seenDbConfigs = new Map();
+    pendingConnects = new Set();
+    verbose = false;
+    shuttingDown = false;
+    constructor(verbose = false) {
+        this.verbose = verbose;
+        SYS_EVENTS.forEach((event) => {
+            process.on(event, () => {
+                log.info(`⏹ Received ${event}, closing all connections...`);
+                this.closeAll();
+            });
+        });
+    }
+    static getInstance(verbose = false) {
+        if (!PgTestConnector.instance) {
+            PgTestConnector.instance = new PgTestConnector(verbose);
+        }
+        return PgTestConnector.instance;
+    }
+    poolKey(config) {
+        return `${config.user}@${config.host}:${config.port}/${config.database}`;
+    }
+    dbKey(config) {
+        return `${config.host}:${config.port}/${config.database}`;
+    }
+    beginTeardown() {
+        this.shuttingDown = true;
+    }
+    registerConnect(p) {
+        this.pendingConnects.add(p);
+        p.finally(() => this.pendingConnects.delete(p));
+    }
+    async awaitPendingConnects() {
+        const arr = Array.from(this.pendingConnects);
+        if (arr.length) {
+            await Promise.allSettled(arr);
+        }
+    }
+    getPool(config) {
+        const key = this.poolKey(config);
+        if (!this.pgPools.has(key)) {
+            const pool = new pg_1.Pool(config);
+            this.pgPools.set(key, pool);
+            log.info(`📘 Created new pg pool: ${key}`);
+        }
+        return this.pgPools.get(key);
+    }
+    getClient(config, opts = {}) {
+        if (this.shuttingDown) {
+            throw new Error('PgTestConnector is shutting down; no new clients allowed');
+        }
+        const client = new test_client_1.PgTestClient(config, {
+            trackConnect: (p) => this.registerConnect(p),
+            ...opts
+        });
+        this.clients.add(client);
+        const key = this.dbKey(config);
+        this.seenDbConfigs.set(key, config);
+        log.info(`🔌 New PgTestClient connected to ${config.database}`);
+        return client;
+    }
+    async closeAll() {
+        this.beginTeardown();
+        await this.awaitPendingConnects();
+        log.info('🧹 Closing all PgTestClients...');
+        await Promise.all(Array.from(this.clients).map(async (client) => {
+            try {
+                await client.close();
+                log.success(`✅ Closed client for ${client.config.database}`);
+            }
+            catch (err) {
+                log.error(`❌ Error closing PgTestClient for ${client.config.database}:`, err);
+            }
+        }));
+        this.clients.clear();
+        log.info('🧯 Disposing pg pools...');
+        for (const [key, pool] of this.pgPools.entries()) {
+            log.debug(`🧯 Disposing pg pool [${key}]`);
+            end(pool);
+        }
+        this.pgPools.clear();
+        log.info('🗑️ Dropping seen databases...');
+        await Promise.all(Array.from(this.seenDbConfigs.values()).map(async (config) => {
+            try {
+                const rootPg = (0, pg_env_1.getPgEnvOptions)();
+                const admin = new admin_1.DbAdmin({ ...config, user: rootPg.user, password: rootPg.password }, this.verbose);
+                admin.drop();
+                log.warn(`🧨 Dropped database: ${config.database}`);
+            }
+            catch (err) {
+                log.error(`❌ Failed to drop database ${config.database}:`, err);
+            }
+        }));
+        this.seenDbConfigs.clear();
+        log.success('✅ All PgTestClients closed, pools disposed, databases dropped.');
+        this.pendingConnects.clear();
+        this.shuttingDown = false;
+    }
+    close() {
+        this.closeAll();
+    }
+    drop(config) {
+        const key = this.dbKey(config);
+        const admin = new admin_1.DbAdmin(config, this.verbose);
+        admin.drop();
+        log.warn(`🧨 Dropped database: ${config.database}`);
+        this.seenDbConfigs.delete(key);
+    }
+    async kill(client) {
+        await client.close();
+        this.drop(client.config);
+    }
+}
+exports.PgTestConnector = PgTestConnector;

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "supabase-test",
+  "version": "0.0.1",
+  "author": "Dan Lynch <pyramation@gmail.com>",
+  "description": "supabase-test offers isolated, role-aware, and rollback-friendly PostgreSQL environments for integration tests — giving developers realistic test coverage without external state pollution",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/launchql/launchql",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/launchql/launchql"
+  },
+  "bugs": {
+    "url": "https://github.com/launchql/launchql/issues"
+  },
+  "keywords": [
+    "postgres",
+    "postgresql",
+    "testing",
+    "integration-tests",
+    "database-testing",
+    "pg",
+    "rls",
+    "role-based-access",
+    "test-database",
+    "test-runner",
+    "jest",
+    "mocha",
+    "sqitch",
+    "launchql",
+    "graphile",
+    "typeorm",
+    "knex",
+    "seed",
+    "fixtures",
+    "transactions",
+    "rollback",
+    "node-postgres",
+    "pg-pool",
+    "pg-client"
+  ],
+  "scripts": {
+    "copy": "copyfiles -f ../../LICENSE README.md package.json dist",
+    "clean": "rimraf dist/**",
+    "prepare": "npm run build",
+    "build": "npm run clean; tsc; tsc -p tsconfig.esm.json; npm run copy",
+    "build:dev": "npm run clean; tsc --declarationMap; tsc -p tsconfig.esm.json; npm run copy",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "devDependencies": {
+    "@types/pg": "^8.15.2",
+    "@types/pg-copy-streams": "^1.2.5"
+  },
+  "dependencies": {
+    "@launchql/core": "^2.11.1",
+    "@launchql/env": "^2.4.1",
+    "@launchql/server-utils": "^2.4.1",
+    "@launchql/types": "^2.6.0",
+    "pg": "^8.16.0",
+    "pg-cache": "^1.3.1",
+    "pg-copy-streams": "^6.0.6",
+    "pg-env": "^1.1.0"
+  }
+}

package/roles.d.ts

@@ -0,0 +1,17 @@
+import { PgTestConnectionOptions, RoleMapping } from '@launchql/types';
+/**
+ * Default role mapping configuration
+ */
+export declare const DEFAULT_ROLE_MAPPING: Required<RoleMapping>;
+/**
+ * Get resolved role mapping with defaults
+ */
+export declare const getRoleMapping: (options?: PgTestConnectionOptions) => Required<RoleMapping>;
+/**
+ * Get role name by key with fallback to default mapping
+ */
+export declare const getRoleName: (roleKey: keyof Omit<RoleMapping, "default">, options?: PgTestConnectionOptions) => string;
+/**
+ * Get default role name
+ */
+export declare const getDefaultRole: (options?: PgTestConnectionOptions) => string;

package/roles.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultRole = exports.getRoleName = exports.getRoleMapping = exports.DEFAULT_ROLE_MAPPING = void 0;
+/**
+ * Default role mapping configuration
+ */
+exports.DEFAULT_ROLE_MAPPING = {
+    anonymous: 'anonymous',
+    authenticated: 'authenticated',
+    administrator: 'administrator',
+    default: 'anonymous'
+};
+/**
+ * Get resolved role mapping with defaults
+ */
+const getRoleMapping = (options) => {
+    return {
+        ...exports.DEFAULT_ROLE_MAPPING,
+        ...(options?.roles || {})
+    };
+};
+exports.getRoleMapping = getRoleMapping;
+/**
+ * Get role name by key with fallback to default mapping
+ */
+const getRoleName = (roleKey, options) => {
+    const mapping = (0, exports.getRoleMapping)(options);
+    return mapping[roleKey];
+};
+exports.getRoleName = getRoleName;
+/**
+ * Get default role name
+ */
+const getDefaultRole = (options) => {
+    const mapping = (0, exports.getRoleMapping)(options);
+    return mapping.default;
+};
+exports.getDefaultRole = getDefaultRole;

package/seed/adapters.d.ts

@@ -0,0 +1,4 @@
+import { SeedAdapter, SeedContext } from './types';
+export declare function sqlfile(files: string[]): SeedAdapter;
+export declare function fn(fn: (ctx: SeedContext) => Promise<void>): SeedAdapter;
+export declare function compose(adapters: SeedAdapter[]): SeedAdapter;

package/seed/adapters.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlfile = sqlfile;
+exports.fn = fn;
+exports.compose = compose;
+function sqlfile(files) {
+    return {
+        seed(ctx) {
+            for (const file of files) {
+                ctx.admin.loadSql(file, ctx.config.database);
+            }
+        }
+    };
+}
+function fn(fn) {
+    return {
+        seed: fn
+    };
+}
+function compose(adapters) {
+    return {
+        async seed(ctx) {
+            for (const adapter of adapters) {
+                await adapter.seed(ctx);
+            }
+        }
+    };
+}

package/seed/csv.d.ts

@@ -0,0 +1,9 @@
+import { PgTestClient } from '../test-client';
+import { SeedAdapter } from './types';
+interface CsvSeedMap {
+    [tableName: string]: string;
+}
+export declare function csv(tables: CsvSeedMap): SeedAdapter;
+export declare function copyCsvIntoTable(pg: PgTestClient, table: string, filePath: string): Promise<void>;
+export declare function exportTableToCsv(pg: PgTestClient, table: string, filePath: string): Promise<void>;
+export {};

package/seed/csv.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csv = csv;
+exports.copyCsvIntoTable = copyCsvIntoTable;
+exports.exportTableToCsv = exportTableToCsv;
+const promises_1 = require("node:stream/promises");
+const logger_1 = require("@launchql/logger");
+const fs_1 = require("fs");
+const pg_copy_streams_1 = require("pg-copy-streams");
+const log = new logger_1.Logger('csv');
+function csv(tables) {
+    return {
+        async seed(ctx) {
+            for (const [table, filePath] of Object.entries(tables)) {
+                if (!(0, fs_1.existsSync)(filePath)) {
+                    throw new Error(`CSV file not found: ${filePath}`);
+                }
+                log.info(`📥 Seeding "${table}" from ${filePath}`);
+                await copyCsvIntoTable(ctx.pg, table, filePath);
+            }
+        }
+    };
+}
+async function copyCsvIntoTable(pg, table, filePath) {
+    const client = pg.client;
+    const stream = client.query((0, pg_copy_streams_1.from)(`COPY ${table} FROM STDIN WITH CSV HEADER`));
+    const source = (0, fs_1.createReadStream)(filePath);
+    try {
+        await (0, promises_1.pipeline)(source, stream);
+        log.success(`✅ Successfully seeded "${table}"`);
+    }
+    catch (err) {
+        log.error(`❌ COPY failed for "${table}": ${err.message}`);
+        throw err;
+    }
+}
+async function exportTableToCsv(pg, table, filePath) {
+    const client = pg.client;
+    const stream = client.query((0, pg_copy_streams_1.to)(`COPY ${table} TO STDOUT WITH CSV HEADER`));
+    const target = (0, fs_1.createWriteStream)(filePath);
+    try {
+        await (0, promises_1.pipeline)(stream, target);
+        log.success(`✅ Exported "${table}" to ${filePath}`);
+    }
+    catch (err) {
+        log.error(`❌ Failed to export "${table}": ${err.message}`);
+        throw err;
+    }
+}

package/seed/index.d.ts

@@ -0,0 +1,16 @@
+import { compose, fn, sqlfile } from './adapters';
+import { csv } from './csv';
+import { json } from './json';
+import { launchql } from './launchql';
+import { sqitch } from './sqitch';
+export * from './csv';
+export * from './types';
+export declare const seed: {
+    launchql: typeof launchql;
+    sqitch: typeof sqitch;
+    json: typeof json;
+    csv: typeof csv;
+    compose: typeof compose;
+    fn: typeof fn;
+    sqlfile: typeof sqlfile;
+};

package/seed/index.js

@@ -0,0 +1,33 @@
+"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 });
+exports.seed = void 0;
+const adapters_1 = require("./adapters");
+const csv_1 = require("./csv");
+const json_1 = require("./json");
+const launchql_1 = require("./launchql");
+const sqitch_1 = require("./sqitch");
+__exportStar(require("./csv"), exports);
+__exportStar(require("./types"), exports);
+exports.seed = {
+    launchql: launchql_1.launchql,
+    sqitch: sqitch_1.sqitch,
+    json: json_1.json,
+    csv: csv_1.csv,
+    compose: adapters_1.compose,
+    fn: adapters_1.fn,
+    sqlfile: adapters_1.sqlfile
+};

package/seed/json.d.ts

@@ -0,0 +1,6 @@
+import { SeedAdapter } from './types';
+interface JsonSeedMap {
+    [table: string]: Record<string, any>[];
+}
+export declare function json(data: JsonSeedMap): SeedAdapter;
+export {};

package/seed/json.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.json = json;
+function json(data) {
+    return {
+        async seed(ctx) {
+            const { pg } = ctx;
+            for (const [table, rows] of Object.entries(data)) {
+                if (!Array.isArray(rows) || rows.length === 0)
+                    continue;
+                const columns = Object.keys(rows[0]);
+                const placeholders = columns.map((_, i) => `$${i + 1}`).join(', ');
+                const sql = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${placeholders})`;
+                for (const row of rows) {
+                    const values = columns.map((c) => row[c]);
+                    await pg.query(sql, values);
+                }
+            }
+        }
+    };
+}

package/seed/launchql.d.ts

@@ -0,0 +1,2 @@
+import { SeedAdapter } from './types';
+export declare function launchql(cwd?: string, cache?: boolean): SeedAdapter;

package/seed/launchql.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchql = launchql;
+const core_1 = require("@launchql/core");
+const env_1 = require("@launchql/env");
+function launchql(cwd, cache = false) {
+    return {
+        async seed(ctx) {
+            const proj = new core_1.LaunchQLPackage(cwd ?? ctx.connect.cwd);
+            if (!proj.isInModule())
+                return;
+            await proj.deploy((0, env_1.getEnvOptions)({
+                pg: ctx.config,
+                deployment: {
+                    fast: true,
+                    usePlan: true,
+                    cache
+                }
+            }), proj.getModuleName());
+        }
+    };
+}