supabase-test 0.0.1 → 0.0.4

package/esm/admin.js

@@ -1,178 +0,0 @@
-import { Logger } from '@launchql/logger';
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
-import { getPgEnvOptions } from 'pg-env';
-import { getRoleName } from './roles';
-import { streamSql as stream } from './stream';
-const log = new Logger('db-admin');
-export class DbAdmin {
-    config;
-    verbose;
-    roleConfig;
-    constructor(config, verbose = false, roleConfig) {
-        this.config = config;
-        this.verbose = verbose;
-        this.roleConfig = roleConfig;
-        this.config = getPgEnvOptions(config);
-    }
-    getEnv() {
-        return {
-            PGHOST: this.config.host,
-            PGPORT: String(this.config.port),
-            PGUSER: this.config.user,
-            PGPASSWORD: this.config.password
-        };
-    }
-    run(command) {
-        try {
-            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 = getRoleName('anonymous', this.roleConfig);
-        const authRole = getRoleName('authenticated', this.roleConfig);
-        const adminRole = 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 (!existsSync(file)) {
-            throw new Error(`Missing SQL file: ${file}`);
-        }
-        this.run(`psql -f ${file} ${dbName}`);
-    }
-    async streamSql(sql, dbName) {
-        await stream({
-            ...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);
-    }
-}

package/esm/manager.js

@@ -1,136 +0,0 @@
-import { Logger } from '@launchql/logger';
-import { Pool } from 'pg';
-import { getPgEnvOptions } from 'pg-env';
-import { DbAdmin } from './admin';
-import { PgTestClient } from './test-client';
-const log = new 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);
-    }
-};
-export 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 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 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 = getPgEnvOptions();
-                const admin = new 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 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);
-    }
-}

package/esm/roles.js

@@ -1,32 +0,0 @@
-/**
- * Default role mapping configuration
- */
-export const DEFAULT_ROLE_MAPPING = {
-    anonymous: 'anonymous',
-    authenticated: 'authenticated',
-    administrator: 'administrator',
-    default: 'anonymous'
-};
-/**
- * Get resolved role mapping with defaults
- */
-export const getRoleMapping = (options) => {
-    return {
-        ...DEFAULT_ROLE_MAPPING,
-        ...(options?.roles || {})
-    };
-};
-/**
- * Get role name by key with fallback to default mapping
- */
-export const getRoleName = (roleKey, options) => {
-    const mapping = getRoleMapping(options);
-    return mapping[roleKey];
-};
-/**
- * Get default role name
- */
-export const getDefaultRole = (options) => {
-    const mapping = getRoleMapping(options);
-    return mapping.default;
-};

package/esm/seed/adapters.js

@@ -1,23 +0,0 @@
-export function sqlfile(files) {
-    return {
-        seed(ctx) {
-            for (const file of files) {
-                ctx.admin.loadSql(file, ctx.config.database);
-            }
-        }
-    };
-}
-export function fn(fn) {
-    return {
-        seed: fn
-    };
-}
-export function compose(adapters) {
-    return {
-        async seed(ctx) {
-            for (const adapter of adapters) {
-                await adapter.seed(ctx);
-            }
-        }
-    };
-}

package/esm/seed/csv.js

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

package/esm/seed/index.js

@@ -1,16 +0,0 @@
-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 const seed = {
-    launchql,
-    sqitch,
-    json,
-    csv,
-    compose,
-    fn,
-    sqlfile
-};

package/esm/seed/json.js

@@ -1,18 +0,0 @@
-export 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/esm/seed/launchql.js

@@ -1,19 +0,0 @@
-import { LaunchQLPackage } from '@launchql/core';
-import { getEnvOptions } from '@launchql/env';
-export function launchql(cwd, cache = false) {
-    return {
-        async seed(ctx) {
-            const proj = new LaunchQLPackage(cwd ?? ctx.connect.cwd);
-            if (!proj.isInModule())
-                return;
-            await proj.deploy(getEnvOptions({
-                pg: ctx.config,
-                deployment: {
-                    fast: true,
-                    usePlan: true,
-                    cache
-                }
-            }), proj.getModuleName());
-        }
-    };
-}

package/esm/seed/sqitch.js

@@ -1,17 +0,0 @@
-import { LaunchQLPackage } from '@launchql/core';
-import { getEnvOptions } from '@launchql/env';
-export function sqitch(cwd) {
-    return {
-        async seed(ctx) {
-            const proj = new LaunchQLPackage(cwd ?? ctx.connect.cwd);
-            if (!proj.isInModule())
-                return;
-            await proj.deploy(getEnvOptions({
-                pg: ctx.config,
-                deployment: {
-                    fast: false
-                }
-            }), proj.getModuleName(), true);
-        }
-    };
-}

package/esm/seed/types.js

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

package/esm/stream.js

@@ -1,43 +0,0 @@
-import { spawn } from 'child_process';
-import { getSpawnEnvWithPg } from 'pg-env';
-import { Readable } from 'stream';
-function setArgs(config) {
-    const args = [
-        '-U', config.user,
-        '-h', config.host,
-        '-d', config.database
-    ];
-    if (config.port) {
-        args.push('-p', String(config.port));
-    }
-    return args;
-}
-// Converts a string to a readable stream (replaces streamify-string)
-function stringToStream(text) {
-    const stream = new Readable({
-        read() {
-            this.push(text);
-            this.push(null);
-        }
-    });
-    return stream;
-}
-export async function streamSql(config, sql) {
-    const args = setArgs(config);
-    return new Promise((resolve, reject) => {
-        const sqlStream = stringToStream(sql);
-        const proc = spawn('psql', args, {
-            env: getSpawnEnvWithPg(config)
-        });
-        sqlStream.pipe(proc.stdin);
-        proc.on('close', (code) => {
-            resolve();
-        });
-        proc.on('error', (error) => {
-            reject(error);
-        });
-        proc.stderr.on('data', (data) => {
-            reject(new Error(data.toString()));
-        });
-    });
-}

package/esm/test-client.js

@@ -1,150 +0,0 @@
-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);
-        }
-    }
-}