supabase-test 0.0.1

package/seed/sqitch.d.ts

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

package/seed/sqitch.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqitch = sqitch;
+const core_1 = require("@launchql/core");
+const env_1 = require("@launchql/env");
+function sqitch(cwd) {
+    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: false
+                }
+            }), proj.getModuleName(), true);
+        }
+    };
+}

package/seed/types.d.ts

@@ -0,0 +1,13 @@
+import { PgTestConnectionOptions } from '@launchql/types';
+import { PgConfig } from 'pg-env';
+import { DbAdmin } from '../admin';
+import { PgTestClient } from '../test-client';
+export interface SeedContext {
+    connect: PgTestConnectionOptions;
+    admin: DbAdmin;
+    config: PgConfig;
+    pg: PgTestClient;
+}
+export interface SeedAdapter {
+    seed(ctx: SeedContext): Promise<void> | void;
+}

package/seed/types.js

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

package/stream.d.ts

@@ -0,0 +1,2 @@
+import { PgConfig } from 'pg-env';
+export declare function streamSql(config: PgConfig, sql: string): Promise<void>;

package/stream.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamSql = streamSql;
+const child_process_1 = require("child_process");
+const pg_env_1 = require("pg-env");
+const stream_1 = require("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 stream_1.Readable({
+        read() {
+            this.push(text);
+            this.push(null);
+        }
+    });
+    return stream;
+}
+async function streamSql(config, sql) {
+    const args = setArgs(config);
+    return new Promise((resolve, reject) => {
+        const sqlStream = stringToStream(sql);
+        const proc = (0, child_process_1.spawn)('psql', args, {
+            env: (0, pg_env_1.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/test-client.d.ts

@@ -0,0 +1,49 @@
+import { Client, QueryResult } from 'pg';
+import { PgConfig } from 'pg-env';
+import { AuthOptions, PgTestConnectionOptions } from '@launchql/types';
+export type PgTestClientOpts = {
+    deferConnect?: boolean;
+    trackConnect?: (p: Promise<any>) => void;
+} & Partial<PgTestConnectionOptions>;
+export declare class PgTestClient {
+    config: PgConfig;
+    client: Client;
+    private opts;
+    private ctxStmts;
+    private contextSettings;
+    private _ended;
+    private connectPromise;
+    constructor(config: PgConfig, opts?: PgTestClientOpts);
+    private ensureConnected;
+    close(): Promise<void>;
+    begin(): Promise<void>;
+    savepoint(name?: string): Promise<void>;
+    rollback(name?: string): Promise<void>;
+    commit(): Promise<void>;
+    beforeEach(): Promise<void>;
+    afterEach(): Promise<void>;
+    setContext(ctx: Record<string, string | null>): void;
+    /**
+     * Set authentication context for the current session.
+     * Configures role and user ID using cascading defaults from options → opts.auth → RoleMapping.
+     */
+    auth(options?: AuthOptions): void;
+    /**
+     * 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.
+     */
+    publish(): Promise<void>;
+    /**
+     * Clear all session context variables and reset to default anonymous role.
+     */
+    clearContext(): void;
+    any<T = any>(query: string, values?: any[]): Promise<T[]>;
+    one<T = any>(query: string, values?: any[]): Promise<T>;
+    oneOrNone<T = any>(query: string, values?: any[]): Promise<T | null>;
+    many<T = any>(query: string, values?: any[]): Promise<T[]>;
+    manyOrNone<T = any>(query: string, values?: any[]): Promise<T[]>;
+    none(query: string, values?: any[]): Promise<void>;
+    result(query: string, values?: any[]): Promise<import('pg').QueryResult>;
+    query<T = any>(query: string, values?: any[]): Promise<QueryResult<T>>;
+    ctxQuery(): Promise<void>;
+}

package/test-client.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgTestClient = void 0;
+const pg_1 = require("pg");
+const roles_1 = require("./roles");
+class PgTestClient {
+    config;
+    client;
+    opts;
+    ctxStmts = '';
+    contextSettings = {};
+    _ended = false;
+    connectPromise = null;
+    constructor(config, opts = {}) {
+        this.opts = opts;
+        this.config = config;
+        this.client = new pg_1.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 ?? (0, roles_1.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 = (0, roles_1.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);
+        }
+    }
+}
+exports.PgTestClient = PgTestClient;