supabase-test 0.0.1 → 0.0.4

package/connect.js

@@ -1,83 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConnections = exports.getPgRootAdmin = void 0;
-const env_1 = require("@launchql/env");
-const crypto_1 = require("crypto");
-const pg_cache_1 = require("pg-cache");
+exports.getConnections = void 0;
 const pg_env_1 = require("pg-env");
-const admin_1 = require("./admin");
-const manager_1 = require("./manager");
-const roles_1 = require("./roles");
-const seed_1 = require("./seed");
-let manager;
-const getPgRootAdmin = (connOpts = {}) => {
-    const opts = (0, pg_env_1.getPgEnvOptions)({
-        database: connOpts.rootDb
-    });
-    const admin = new admin_1.DbAdmin(opts, false, connOpts);
-    return admin;
+const pgsql_test_1 = require("pgsql-test");
+/**
+ * Supabase default connection options
+ */
+const SUPABASE_DEFAULTS = {
+    roles: {
+        anonymous: 'anon',
+        authenticated: 'authenticated',
+        administrator: 'service_role',
+        default: 'anon',
+    }
 };
-exports.getPgRootAdmin = getPgRootAdmin;
-const getConnOopts = (cn = {}) => {
-    const connect = (0, env_1.getConnEnvOptions)(cn.db);
-    const config = (0, pg_env_1.getPgEnvOptions)({
-        database: `${connect.prefix}${(0, crypto_1.randomUUID)()}`,
-        ...cn.pg
-    });
-    return {
-        pg: config,
-        db: connect
-    };
+/**
+ * Supabase default PostgreSQL config
+ */
+const SUPABASE_PG_DEFAULTS = {
+    port: 54322,
+    user: 'supabase_admin',
+    password: 'postgres',
 };
-const getConnections = async (cn = {}, seedAdapters = [seed_1.seed.launchql()]) => {
-    cn = getConnOopts(cn);
-    const config = cn.pg;
-    const connOpts = cn.db;
-    const root = (0, exports.getPgRootAdmin)(connOpts);
-    await root.createUserRole(connOpts.connection.user, connOpts.connection.password, connOpts.rootDb);
-    const admin = new admin_1.DbAdmin(config, false, connOpts);
-    if (process.env.TEST_DB) {
-        config.database = process.env.TEST_DB;
-    }
-    else if (connOpts.template) {
-        admin.createFromTemplate(connOpts.template, config.database);
-    }
-    else {
-        admin.create(config.database);
-        admin.installExtensions(connOpts.extensions);
-    }
-    await admin.grantConnect(connOpts.connection.user, config.database);
-    manager = manager_1.PgTestConnector.getInstance();
-    const pg = manager.getClient(config);
-    const teardown = async () => {
-        manager.beginTeardown();
-        await (0, pg_cache_1.teardownPgPools)();
-        await manager.closeAll();
+/**
+ * Get connections with Supabase defaults applied.
+ * Environment variables take precedence over Supabase defaults.
+ * User-provided options take precedence over both.
+ *
+ * Note: Uses PGUSER/PGPASSWORD for both pg config and db.connection
+ * (DB_CONNECTION_ROLE can still be used to override the default role)
+ */
+const getConnections = async (cn = {}, seedAdapters) => {
+    // Get environment variables - these should take precedence over our defaults
+    const pgEnvVars = (0, pg_env_1.getPgEnvVars)();
+    // Build pg config: env vars > Supabase defaults, then user overrides will override both
+    const pgConfig = {};
+    pgConfig.port = pgEnvVars.port ?? SUPABASE_PG_DEFAULTS.port;
+    pgConfig.user = pgEnvVars.user ?? SUPABASE_PG_DEFAULTS.user;
+    pgConfig.password = pgEnvVars.password ?? SUPABASE_PG_DEFAULTS.password;
+    // Build connection config: use same user/password as pg config (from env vars or Supabase defaults)
+    // Default role is 'anon' (Supabase default), but DB_CONNECTION_ROLE can override it
+    const connectionConfig = {
+        user: pgConfig.user,
+        password: pgConfig.password,
+        role: process.env.DB_CONNECTION_ROLE ?? SUPABASE_DEFAULTS.roles.default,
     };
-    if (seedAdapters.length) {
-        try {
-            await seed_1.seed.compose(seedAdapters).seed({
-                connect: connOpts,
-                admin,
-                config: config,
-                pg: manager.getClient(config)
-            });
-        }
-        catch (error) {
-            await teardown();
-            throw error;
+    // Build roles config: Supabase defaults, then user overrides will override
+    const rolesConfig = {
+        ...SUPABASE_DEFAULTS.roles,
+    };
+    // Build the merged options, respecting precedence: env vars > Supabase defaults > user overrides
+    const mergedOpts = {
+        pg: {
+            ...pgConfig,
+            ...cn.pg, // User overrides take precedence
+        },
+        db: {
+            connection: {
+                ...connectionConfig,
+                ...cn.db?.connection, // User overrides take precedence
+            },
+            roles: {
+                ...rolesConfig,
+                ...cn.db?.roles, // User overrides take precedence
+            },
+            ...cn.db, // Other user overrides
         }
-    }
-    const dbConfig = {
-        ...config,
-        user: connOpts.connection.user,
-        password: connOpts.connection.password
     };
-    const db = manager.getClient(dbConfig, {
-        auth: connOpts.auth,
-        roles: connOpts.roles
-    });
-    db.setContext({ role: (0, roles_1.getDefaultRole)(connOpts) });
-    return { pg, db, teardown, manager, admin };
+    return (0, pgsql_test_1.getConnections)(mergedOpts, seedAdapters);
 };
 exports.getConnections = getConnections;

package/esm/connect.js

@@ -1,78 +1,68 @@
-import { getConnEnvOptions } from '@launchql/env';
-import { randomUUID } from 'crypto';
-import { teardownPgPools } from 'pg-cache';
-import { getPgEnvOptions, } from 'pg-env';
-import { DbAdmin } from './admin';
-import { PgTestConnector } from './manager';
-import { getDefaultRole } from './roles';
-import { seed } from './seed';
-let manager;
-export const getPgRootAdmin = (connOpts = {}) => {
-    const opts = getPgEnvOptions({
-        database: connOpts.rootDb
-    });
-    const admin = new DbAdmin(opts, false, connOpts);
-    return admin;
+import { getPgEnvVars } from 'pg-env';
+import { getConnections as getPgConnections } from 'pgsql-test';
+/**
+ * Supabase default connection options
+ */
+const SUPABASE_DEFAULTS = {
+    roles: {
+        anonymous: 'anon',
+        authenticated: 'authenticated',
+        administrator: 'service_role',
+        default: 'anon',
+    }
 };
-const getConnOopts = (cn = {}) => {
-    const connect = getConnEnvOptions(cn.db);
-    const config = getPgEnvOptions({
-        database: `${connect.prefix}${randomUUID()}`,
-        ...cn.pg
-    });
-    return {
-        pg: config,
-        db: connect
-    };
+/**
+ * Supabase default PostgreSQL config
+ */
+const SUPABASE_PG_DEFAULTS = {
+    port: 54322,
+    user: 'supabase_admin',
+    password: 'postgres',
 };
-export const getConnections = async (cn = {}, seedAdapters = [seed.launchql()]) => {
-    cn = getConnOopts(cn);
-    const config = cn.pg;
-    const connOpts = cn.db;
-    const root = getPgRootAdmin(connOpts);
-    await root.createUserRole(connOpts.connection.user, connOpts.connection.password, connOpts.rootDb);
-    const admin = new DbAdmin(config, false, connOpts);
-    if (process.env.TEST_DB) {
-        config.database = process.env.TEST_DB;
-    }
-    else if (connOpts.template) {
-        admin.createFromTemplate(connOpts.template, config.database);
-    }
-    else {
-        admin.create(config.database);
-        admin.installExtensions(connOpts.extensions);
-    }
-    await admin.grantConnect(connOpts.connection.user, config.database);
-    manager = PgTestConnector.getInstance();
-    const pg = manager.getClient(config);
-    const teardown = async () => {
-        manager.beginTeardown();
-        await teardownPgPools();
-        await manager.closeAll();
+/**
+ * Get connections with Supabase defaults applied.
+ * Environment variables take precedence over Supabase defaults.
+ * User-provided options take precedence over both.
+ *
+ * Note: Uses PGUSER/PGPASSWORD for both pg config and db.connection
+ * (DB_CONNECTION_ROLE can still be used to override the default role)
+ */
+export const getConnections = async (cn = {}, seedAdapters) => {
+    // Get environment variables - these should take precedence over our defaults
+    const pgEnvVars = getPgEnvVars();
+    // Build pg config: env vars > Supabase defaults, then user overrides will override both
+    const pgConfig = {};
+    pgConfig.port = pgEnvVars.port ?? SUPABASE_PG_DEFAULTS.port;
+    pgConfig.user = pgEnvVars.user ?? SUPABASE_PG_DEFAULTS.user;
+    pgConfig.password = pgEnvVars.password ?? SUPABASE_PG_DEFAULTS.password;
+    // Build connection config: use same user/password as pg config (from env vars or Supabase defaults)
+    // Default role is 'anon' (Supabase default), but DB_CONNECTION_ROLE can override it
+    const connectionConfig = {
+        user: pgConfig.user,
+        password: pgConfig.password,
+        role: process.env.DB_CONNECTION_ROLE ?? SUPABASE_DEFAULTS.roles.default,
     };
-    if (seedAdapters.length) {
-        try {
-            await seed.compose(seedAdapters).seed({
-                connect: connOpts,
-                admin,
-                config: config,
-                pg: manager.getClient(config)
-            });
-        }
-        catch (error) {
-            await teardown();
-            throw error;
+    // Build roles config: Supabase defaults, then user overrides will override
+    const rolesConfig = {
+        ...SUPABASE_DEFAULTS.roles,
+    };
+    // Build the merged options, respecting precedence: env vars > Supabase defaults > user overrides
+    const mergedOpts = {
+        pg: {
+            ...pgConfig,
+            ...cn.pg, // User overrides take precedence
+        },
+        db: {
+            connection: {
+                ...connectionConfig,
+                ...cn.db?.connection, // User overrides take precedence
+            },
+            roles: {
+                ...rolesConfig,
+                ...cn.db?.roles, // User overrides take precedence
+            },
+            ...cn.db, // Other user overrides
         }
-    }
-    const dbConfig = {
-        ...config,
-        user: connOpts.connection.user,
-        password: connOpts.connection.password
     };
-    const db = manager.getClient(dbConfig, {
-        auth: connOpts.auth,
-        roles: connOpts.roles
-    });
-    db.setContext({ role: getDefaultRole(connOpts) });
-    return { pg, db, teardown, manager, admin };
+    return getPgConnections(mergedOpts, seedAdapters);
 };

package/esm/index.js

@@ -1,6 +1,4 @@
-export * from './admin';
-export * from './connect';
-export * from './manager';
-export * from './roles';
-export * from './seed';
-export * from './test-client';
+// Re-export everything from pgsql-test
+export * from 'pgsql-test';
+// Export Supabase-specific getConnections with defaults baked in
+export { getConnections } from './connect';

package/index.d.ts

@@ -1,6 +1,3 @@
-export * from './admin';
-export * from './connect';
-export * from './manager';
-export * from './roles';
-export * from './seed';
-export * from './test-client';
+export * from 'pgsql-test';
+export { getConnections } from './connect';
+export type { GetConnectionOpts, GetConnectionResult } from './connect';

package/index.js

@@ -14,9 +14,9 @@ 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);
+exports.getConnections = void 0;
+// Re-export everything from pgsql-test
+__exportStar(require("pgsql-test"), exports);
+// Export Supabase-specific getConnections with defaults baked in
+var connect_1 = require("./connect");
+Object.defineProperty(exports, "getConnections", { enumerable: true, get: function () { return connect_1.getConnections; } });

package/package.json

@@ -1,8 +1,8 @@
 {
   "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",
+  "version": "0.0.4",
+  "author": "Interweb <developers@interweb.io>",
+  "description": "supabase-test offers isolated, role-aware, and rollback-friendly PostgreSQL environments for integration tests with Supabase defaults baked in",
   "main": "index.js",
   "module": "esm/index.js",
   "types": "index.d.ts",
@@ -20,6 +20,7 @@
     "url": "https://github.com/launchql/launchql/issues"
   },
   "keywords": [
+    "supabase",
     "postgres",
     "postgresql",
     "testing",
@@ -32,11 +33,6 @@
     "test-runner",
     "jest",
     "mocha",
-    "sqitch",
-    "launchql",
-    "graphile",
-    "typeorm",
-    "knex",
     "seed",
     "fixtures",
     "transactions",
@@ -55,18 +51,10 @@
     "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"
-  }
+    "@launchql/types": "^2.6.1",
+    "pg-env": "^1.1.0",
+    "pgsql-test": "^2.11.6"
+  },
+  "gitHead": "0b26f726ac2ca19886af7553a06e95ce826d515b"
 }

package/admin.d.ts

@@ -1,26 +0,0 @@
-import { PgTestConnectionOptions } from '@launchql/types';
-import { PgConfig } from 'pg-env';
-import { SeedAdapter } from './seed/types';
-export declare class DbAdmin {
-    private config;
-    private verbose;
-    private roleConfig?;
-    constructor(config: PgConfig, verbose?: boolean, roleConfig?: PgTestConnectionOptions);
-    private getEnv;
-    private run;
-    private safeDropDb;
-    drop(dbName?: string): void;
-    dropTemplate(dbName: string): void;
-    create(dbName?: string): void;
-    createFromTemplate(template: string, dbName?: string): void;
-    installExtensions(extensions: string[] | string, dbName?: string): void;
-    connectionString(dbName?: string): string;
-    createTemplateFromBase(base: string, template: string): void;
-    cleanupTemplate(template: string): void;
-    grantRole(role: string, user: string, dbName?: string): Promise<void>;
-    grantConnect(role: string, dbName?: string): Promise<void>;
-    createUserRole(user: string, password: string, dbName: string): Promise<void>;
-    loadSql(file: string, dbName: string): void;
-    streamSql(sql: string, dbName: string): Promise<void>;
-    createSeededTemplate(templateName: string, adapter: SeedAdapter): Promise<void>;
-}

package/admin.js

@@ -1,182 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbAdmin = void 0;
-const logger_1 = require("@launchql/logger");
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const pg_env_1 = require("pg-env");
-const roles_1 = require("./roles");
-const stream_1 = require("./stream");
-const log = new logger_1.Logger('db-admin');
-class DbAdmin {
-    config;
-    verbose;
-    roleConfig;
-    constructor(config, verbose = false, roleConfig) {
-        this.config = config;
-        this.verbose = verbose;
-        this.roleConfig = roleConfig;
-        this.config = (0, pg_env_1.getPgEnvOptions)(config);
-    }
-    getEnv() {
-        return {
-            PGHOST: this.config.host,
-            PGPORT: String(this.config.port),
-            PGUSER: this.config.user,
-            PGPASSWORD: this.config.password
-        };
-    }
-    run(command) {
-        try {
-            (0, child_process_1.execSync)(command, {
-                stdio: this.verbose ? 'inherit' : 'pipe',
-                env: {
-                    ...process.env,
-                    ...this.getEnv()
-                }
-            });
-            if (this.verbose)
-                log.success(`Executed: ${command}`);
-        }
-        catch (err) {
-            log.error(`Command failed: ${command}`);
-            if (this.verbose)
-                log.error(err.message);
-            throw err;
-        }
-    }
-    safeDropDb(name) {
-        try {
-            this.run(`dropdb "${name}"`);
-        }
-        catch (err) {
-            if (!err.message.includes('does not exist')) {
-                log.warn(`Could not drop database ${name}: ${err.message}`);
-            }
-        }
-    }
-    drop(dbName) {
-        this.safeDropDb(dbName ?? this.config.database);
-    }
-    dropTemplate(dbName) {
-        this.run(`psql -c "UPDATE pg_database SET datistemplate='false' WHERE datname='${dbName}';"`);
-        this.drop(dbName);
-    }
-    create(dbName) {
-        const db = dbName ?? this.config.database;
-        this.run(`createdb -U ${this.config.user} -h ${this.config.host} -p ${this.config.port} "${db}"`);
-    }
-    createFromTemplate(template, dbName) {
-        const db = dbName ?? this.config.database;
-        this.run(`createdb -U ${this.config.user} -h ${this.config.host} -p ${this.config.port} -e "${db}" -T "${template}"`);
-    }
-    installExtensions(extensions, dbName) {
-        const db = dbName ?? this.config.database;
-        const extList = typeof extensions === 'string' ? extensions.split(',') : extensions;
-        for (const extension of extList) {
-            this.run(`psql --dbname "${db}" -c 'CREATE EXTENSION IF NOT EXISTS "${extension}" CASCADE;'`);
-        }
-    }
-    connectionString(dbName) {
-        const { user, password, host, port } = this.config;
-        const db = dbName ?? this.config.database;
-        return `postgres://${user}:${password}@${host}:${port}/${db}`;
-    }
-    createTemplateFromBase(base, template) {
-        this.run(`createdb -T "${base}" "${template}"`);
-        this.run(`psql -c "UPDATE pg_database SET datistemplate = true WHERE datname = '${template}';"`);
-    }
-    cleanupTemplate(template) {
-        try {
-            this.run(`psql -c "UPDATE pg_database SET datistemplate = false WHERE datname = '${template}'"`);
-        }
-        catch {
-            log.warn(`Skipping failed UPDATE of datistemplate for ${template}`);
-        }
-        this.safeDropDb(template);
-    }
-    async grantRole(role, user, dbName) {
-        const db = dbName ?? this.config.database;
-        const sql = `GRANT ${role} TO ${user};`;
-        await this.streamSql(sql, db);
-    }
-    async grantConnect(role, dbName) {
-        const db = dbName ?? this.config.database;
-        const sql = `GRANT CONNECT ON DATABASE "${db}" TO ${role};`;
-        await this.streamSql(sql, db);
-    }
-    // TODO: make adminRole a configurable option
-    // ONLY granting admin role for testing purposes, normally the db connection for apps won't have admin role
-    // DO NOT USE THIS FOR PRODUCTION
-    async createUserRole(user, password, dbName) {
-        const anonRole = (0, roles_1.getRoleName)('anonymous', this.roleConfig);
-        const authRole = (0, roles_1.getRoleName)('authenticated', this.roleConfig);
-        const adminRole = (0, roles_1.getRoleName)('administrator', this.roleConfig);
-        const sql = `
-      DO $$
-      BEGIN
-        -- Create role if it doesn't exist
-        IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${user}') THEN
-          CREATE ROLE ${user} LOGIN PASSWORD '${password}';
-        END IF;
-        
-        -- Grant anonymous role if not already granted
-        IF NOT EXISTS (
-          SELECT 1 FROM pg_auth_members am 
-          JOIN pg_roles r1 ON am.roleid = r1.oid 
-          JOIN pg_roles r2 ON am.member = r2.oid 
-          WHERE r1.rolname = '${anonRole}' AND r2.rolname = '${user}'
-        ) THEN
-          GRANT ${anonRole} TO ${user};
-        END IF;
-        
-        -- Grant authenticated role if not already granted
-        IF NOT EXISTS (
-          SELECT 1 FROM pg_auth_members am 
-          JOIN pg_roles r1 ON am.roleid = r1.oid 
-          JOIN pg_roles r2 ON am.member = r2.oid 
-          WHERE r1.rolname = '${authRole}' AND r2.rolname = '${user}'
-        ) THEN
-          GRANT ${authRole} TO ${user};
-        END IF;
-        
-        -- Grant administrator role if not already granted
-        IF NOT EXISTS (
-          SELECT 1 FROM pg_auth_members am 
-          JOIN pg_roles r1 ON am.roleid = r1.oid 
-          JOIN pg_roles r2 ON am.member = r2.oid 
-          WHERE r1.rolname = '${adminRole}' AND r2.rolname = '${user}'
-        ) THEN
-          GRANT ${adminRole} TO ${user};
-        END IF;
-      END $$;
-    `.trim();
-        await this.streamSql(sql, dbName);
-    }
-    loadSql(file, dbName) {
-        if (!(0, fs_1.existsSync)(file)) {
-            throw new Error(`Missing SQL file: ${file}`);
-        }
-        this.run(`psql -f ${file} ${dbName}`);
-    }
-    async streamSql(sql, dbName) {
-        await (0, stream_1.streamSql)({
-            ...this.config,
-            database: dbName
-        }, sql);
-    }
-    async createSeededTemplate(templateName, adapter) {
-        const seedDb = this.config.database;
-        this.create(seedDb);
-        await adapter.seed({
-            admin: this,
-            config: this.config,
-            pg: null, // placeholder for PgTestClient
-            connect: null // placeholder for connection factory
-        });
-        this.cleanupTemplate(templateName);
-        this.createTemplateFromBase(seedDb, templateName);
-        this.drop(seedDb);
-    }
-}
-exports.DbAdmin = DbAdmin;