pgsql-test 0.0.1 → 2.0.1

package/manager.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgTestConnector = void 0;
+const pg_1 = require("pg");
+const chalk_1 = __importDefault(require("chalk"));
+const admin_1 = require("./admin");
+const types_1 = require("@launchql/types");
+const test_client_1 = require("./test-client");
+const SYS_EVENTS = ['SIGTERM'];
+const end = (pool) => {
+    try {
+        if (pool.ended || pool.ending) {
+            console.warn(chalk_1.default.yellow('⚠️ pg pool already ended or ending'));
+            return;
+        }
+        pool.end();
+    }
+    catch (err) {
+        console.error(chalk_1.default.red('❌ pg pool termination error:'), err);
+    }
+};
+class PgTestConnector {
+    static instance;
+    clients = new Set();
+    pgPools = new Map();
+    seenDbConfigs = new Map();
+    verbose = false;
+    constructor(verbose = false) {
+        this.verbose = verbose;
+        SYS_EVENTS.forEach((event) => {
+            process.on(event, () => {
+                this.log(chalk_1.default.magenta(`⏹ Received ${event}, closing all connections...`));
+                this.closeAll();
+            });
+        });
+    }
+    static getInstance(verbose = false) {
+        if (!PgTestConnector.instance) {
+            PgTestConnector.instance = new PgTestConnector(verbose);
+        }
+        return PgTestConnector.instance;
+    }
+    log(...args) {
+        if (this.verbose)
+            console.log(...args);
+    }
+    poolKey(config) {
+        return `${config.user}@${config.host}:${config.port}/${config.database}`;
+    }
+    dbKey(config) {
+        return `${config.host}:${config.port}/${config.database}`;
+    }
+    getPool(config) {
+        const key = this.poolKey(config);
+        if (!this.pgPools.has(key)) {
+            const pool = new pg_1.Pool(config);
+            this.pgPools.set(key, pool);
+            this.log(chalk_1.default.blue(`📘 Created new pg pool: ${chalk_1.default.white(key)}`));
+        }
+        return this.pgPools.get(key);
+    }
+    getClient(config) {
+        const client = new test_client_1.PgTestClient(config);
+        this.clients.add(client);
+        const key = this.dbKey(config);
+        this.seenDbConfigs.set(key, config);
+        this.log(chalk_1.default.green(`🔌 New PgTestClient connected to ${config.database}`));
+        return client;
+    }
+    async closeAll() {
+        this.log(chalk_1.default.cyan('\n🧹 Closing all PgTestClients...'));
+        await Promise.all(Array.from(this.clients).map(async (client) => {
+            try {
+                await client.close();
+                this.log(chalk_1.default.green(`✅ Closed client for ${client.config.database}`));
+            }
+            catch (err) {
+                console.warn(chalk_1.default.red(`❌ Error closing PgTestClient for ${client.config.database}:`), err);
+            }
+        }));
+        this.clients.clear();
+        this.log(chalk_1.default.cyan('\n🧯 Disposing pg pools...'));
+        for (const [key, pool] of this.pgPools.entries()) {
+            this.log(chalk_1.default.gray(`🧯 Disposing pg pool [${key}]`));
+            end(pool);
+        }
+        this.pgPools.clear();
+        this.log(chalk_1.default.cyan('\n🗑️ Dropping seen databases...'));
+        await Promise.all(Array.from(this.seenDbConfigs.values()).map(async (config) => {
+            try {
+                // somehow an "admin" db had app_user creds?
+                const rootPg = (0, types_1.getPgEnvOptions)();
+                const admin = new admin_1.DbAdmin({ ...config, user: rootPg.user, password: rootPg.password }, this.verbose);
+                // console.log(config);
+                admin.drop();
+                this.log(chalk_1.default.yellow(`🧨 Dropped database: ${chalk_1.default.white(config.database)}`));
+            }
+            catch (err) {
+                console.warn(chalk_1.default.red(`❌ Failed to drop database ${config.database}:`), err);
+            }
+        }));
+        this.seenDbConfigs.clear();
+        this.log(chalk_1.default.green('\n✅ All PgTestClients closed, pools disposed, databases dropped.'));
+    }
+    close() {
+        this.closeAll();
+    }
+    drop(config) {
+        const key = this.dbKey(config);
+        // for drop, no need for conn opts
+        const admin = new admin_1.DbAdmin(config, this.verbose);
+        admin.drop();
+        this.log(chalk_1.default.red(`🧨 Dropped database: ${chalk_1.default.white(config.database)}`));
+        this.seenDbConfigs.delete(key);
+    }
+    kill(client) {
+        client.close();
+        this.drop(client.config);
+    }
+}
+exports.PgTestConnector = PgTestConnector;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-test",
-  "version": "0.0.1",
+  "version": "2.0.1",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "description": "PostgreSQL Testing in TypeScript",
   "main": "index.js",
@@ -30,7 +30,11 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@launchql/types": "^2.0.4",
-    "chalk": "^4.1.0"
-  }
-}
+    "@launchql/migrate": "^2.0.12",
+    "@launchql/server-utils": "^2.0.5",
+    "@launchql/types": "^2.0.5",
+    "chalk": "^4.1.0",
+    "deepmerge": "^4.3.1"
+  },
+  "gitHead": "77a8acdaa9513791b3bb47b11dcfc3b141d856ab"
+}

package/seed.d.ts

@@ -0,0 +1,22 @@
+import { PgConfig } from "@launchql/types";
+import { DbAdmin } from "./admin";
+import { PgTestClient } from "./test-client";
+interface SeedContext {
+    admin: DbAdmin;
+    config: PgConfig;
+    pg: PgTestClient;
+}
+export interface SeedAdapter {
+    seed(ctx: SeedContext): Promise<void> | void;
+}
+declare function sqlfile(files: string[]): SeedAdapter;
+declare function fn(fn: (ctx: SeedContext) => Promise<void>): SeedAdapter;
+declare function csv(fn: (ctx: SeedContext) => Promise<void>): SeedAdapter;
+declare function compose(adapters: SeedAdapter[]): SeedAdapter;
+export declare const seed: {
+    compose: typeof compose;
+    fn: typeof fn;
+    csv: typeof csv;
+    sqlfile: typeof sqlfile;
+};
+export {};

package/seed.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seed = void 0;
+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 csv(fn) {
+    throw new Error('not yet implemented');
+    return {
+        seed: fn
+    };
+}
+function compose(adapters) {
+    return {
+        async seed(ctx) {
+            for (const adapter of adapters) {
+                await adapter.seed(ctx);
+            }
+        }
+    };
+}
+exports.seed = {
+    compose,
+    fn,
+    csv,
+    sqlfile
+};

package/stream.d.ts

@@ -0,0 +1,2 @@
+import { PgConfig } from '@launchql/types';
+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 stream_1 = require("stream");
+const types_1 = require("@launchql/types");
+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, types_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,25 @@
+import { QueryResult } from 'pg';
+import { PgConfig } from '@launchql/types';
+export declare class PgTestClient {
+    config: PgConfig;
+    private client;
+    private ctxStmts;
+    private _ended;
+    constructor(config: PgConfig);
+    close(): 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;
+    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>>;
+}

package/test-client.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgTestClient = void 0;
+const pg_1 = require("pg");
+class PgTestClient {
+    config;
+    client;
+    ctxStmts = '';
+    _ended = false;
+    constructor(config) {
+        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
+        });
+        this.client.connect();
+    }
+    close() {
+        if (!this._ended) {
+            this._ended = true;
+            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) {
+        this.ctxStmts = Object.entries(ctx)
+            .map(([key, val]) => val === null
+            ? `SELECT set_config('${key}', NULL, true);`
+            : `SELECT set_config('${key}', '${val}', true);`)
+            .join('\n');
+    }
+    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) {
+        if (this.ctxStmts) {
+            await this.client.query(this.ctxStmts);
+        }
+        const result = await this.client.query(query, values);
+        return result;
+    }
+}
+exports.PgTestClient = PgTestClient;

package/__tests__/postgres-test.connections.test.ts

@@ -1,81 +0,0 @@
-import { getConnections } from '../src/connect';
-import { PgTestClient } from '../src/test-client';
-
-let conn: PgTestClient;
-let db: PgTestClient;
-let teardown: () => Promise<void>;
-
-beforeAll(async () => {
-  ({ conn, db, teardown } = await getConnections());
-
-  // Setup schema + seed ONCE globally
-  await db.query(`
-    CREATE TABLE users (
-      id SERIAL PRIMARY KEY,
-      name TEXT NOT NULL
-    );
-    CREATE TABLE posts (
-      id SERIAL PRIMARY KEY,
-      user_id INT NOT NULL REFERENCES users(id),
-      content TEXT NOT NULL
-    );
-  `);
-
-  await db.query(`
-    INSERT INTO users (name) VALUES ('Alice'), ('Bob');
-    INSERT INTO posts (user_id, content) VALUES
-      (1, 'Hello world!'),
-      (2, 'Graphile is cool!');
-  `);
-});
-
-afterAll(async () => {
-  await teardown();
-});
-
-describe('anonymous', () => {
-  beforeEach(async () => {
-    await db.beforeEach();  // this starts tx + savepoint
-  });
-
-  afterEach(async () => {
-    await db.afterEach();   // this rolls back and commits
-  });
-
-  it('inserts a user but rollback leaves baseline intact', async () => {
-    await db.query(`INSERT INTO users (name) VALUES ('Carol')`);
-    const res = await db.query('SELECT COUNT(*) FROM users');
-    expect(res.rows[0].count).toBe('3');
-  });
-
-  it('should still have 2 users after rollback', async () => {
-    const res = await db.query('SELECT COUNT(*) FROM users');
-    expect(res.rows[0].count).toBe('2');
-  });
-
-  it('runs under anonymous context', async () => {
-    const result = await conn.query('SELECT current_setting(\'role\', true) AS role');
-    console.log(JSON.stringify({result}, null, 2))
-    console.error(JSON.stringify({result}, null, 2))
-    // expect(result.rows[0].role).toBe('anonymous');
-  });
-});
-
-describe('authenticated', () => {
-  beforeEach(async () => {
-    conn.setContext({
-      role: 'authenticated'
-    });
-    await conn.beforeEach();  // required for rollback later
-  });
-
-  afterEach(async () => {
-    await conn.afterEach();   // now safe to rollback
-  });
-
-  it('runs under authenticated context', async () => {
-    const result = await conn.query('SELECT current_setting(\'role\', true) AS role');
-    // expect(result.rows[0].role).toBe('authenticated');
-    console.error('why no JWT')
-  });
-});

package/__tests__/postgres-test.grants.test.ts

@@ -1,53 +0,0 @@
-import { getPgEnvOptions, PgConfig } from '@launchql/types';
-
-import {
-  getConnection,
-  Connection,
-} from '../src';
-import { randomUUID } from 'crypto';
-import { PgTestClient } from '../src/test-client';
-import { DbAdmin } from '../src/admin';
-import { resolve } from 'path';
-
-const sql = (file: string) => resolve(__dirname, '../sql', file);
-
-const TEST_DB_BASE = `postgres_test_${randomUUID()}`; 
-
-function setupBaseDB(config: PgConfig): void {
-  const admin = new DbAdmin(config);
-  admin.create(config.database)
-  admin.loadSql(sql('test.sql'), config.database);
-  admin.loadSql(sql('roles.sql'), config.database);
-  admin.drop(config.database);
-}
-
-const config = getPgEnvOptions({
-    database: TEST_DB_BASE
-});
-
-beforeAll(() => {
-  setupBaseDB(config);
-});
-
-afterAll(() => {
-  Connection.getManager().closeAll();
-});
-
-
-describe('Postgres Test Framework', () => {
-  let db: PgTestClient;
-
-  afterEach(() => {
-    // if (db) closeConnection(db);
-  });
-
-  it('creates a test DB with hot mode (FAST_TEST)', () => {
-    db = getConnection({ hot: true, extensions: ['uuid-ossp'] });
-    expect(db).toBeDefined();
-  });
-
-  it('creates a test DB from scratch (default)', () => {
-    db = getConnection({});
-    expect(db).toBeDefined();
-  });
-});

package/__tests__/postgres-test.records.test.ts

@@ -1,66 +0,0 @@
-import { getConnections } from '../src/connect';
-import { PgTestClient } from '../src/test-client';
-
-let conn: PgTestClient;
-let db: PgTestClient;
-let teardown: () => Promise<void>;
-
-const setupSchemaSQL = `
-  CREATE TABLE users (
-    id SERIAL PRIMARY KEY,
-    name TEXT NOT NULL
-  );
-
-  CREATE TABLE posts (
-    id SERIAL PRIMARY KEY,
-    user_id INT NOT NULL REFERENCES users(id),
-    content TEXT NOT NULL
-  );
-`;
-
-const seedDataSQL = `
-  INSERT INTO users (name) VALUES ('Alice'), ('Bob');
-  INSERT INTO posts (user_id, content) VALUES
-    (1, 'Hello world!'),
-    (2, 'Graphile is cool!');
-`;
-
-beforeAll(async () => {
-  ({ conn, db, teardown } = await getConnections());
-  // create schema + seed *once*
-  await db.query(setupSchemaSQL);
-  await db.query(seedDataSQL);
-});
-
-afterAll(async () => {
-  await teardown();
-});
-
-describe('Postgres Test Framework', () => {
-  beforeEach(async () => {
-    await db.beforeEach();  // BEGIN + SAVEPOINT
-  });
-
-  afterEach(async () => {
-    await db.afterEach();   // ROLLBACK TO SAVEPOINT + COMMIT
-  });
-
-  it('should have 2 users initially', async () => {
-    const { rows } = await db.query('SELECT COUNT(*) FROM users');
-    expect(rows[0].count).toBe('2');
-  });
-
-  it('inserts a user but rollback leaves baseline intact', async () => {
-    await db.query(`INSERT INTO users (name) VALUES ('Carol')`);
-    let res = await db.query('SELECT COUNT(*) FROM users');
-    expect(res.rows[0].count).toBe('3');   // inside this tx
-
-    // after rollback (next test) we’ll still see 2
-  });
-
-  it('still sees 2 users after previous insert test', async () => {
-    const { rows } = await db.query('SELECT COUNT(*) FROM users');
-    expect(rows[0].count).toBe('2');
-  });
-
-});

package/__tests__/postgres-test.template.test.ts

@@ -1,52 +0,0 @@
-import { getPgEnvOptions, PgConfig } from '@launchql/types';
-import path from 'path';
-
-import {
-  getConnection,
-  Connection
-} from '../src';
-import { PgTestClient } from '../src/test-client';
-import { DbAdmin } from '../src/admin';
-
-const sql = (file: string) => path.resolve(__dirname, '../sql', file);
-
-const TEMPLATE_NAME = 'test_template';
-const TEST_DB_BASE = 'postgres_test_db_template';
-
-function setupTemplateDB(config: PgConfig, template: string): void {
-  const admin = new DbAdmin(config);
-  try {
-    admin.drop(config.database);
-  } catch {}
-  admin.create(config.database);
-  admin.loadSql(sql('test.sql'), config.database);
-  admin.loadSql(sql('roles.sql'), config.database);
-  admin.cleanupTemplate(template);
-  admin.createTemplateFromBase(config.database, template);
-  admin.drop(config.database);
-}
-
-const config = getPgEnvOptions({
-    database: TEST_DB_BASE
-});
-
-beforeAll(() => {
-  setupTemplateDB(config, TEMPLATE_NAME);
-});
-
-afterAll(() => {
-  Connection.getManager().closeAll();
-});
-
-describe('Template Database Test', () => {
-  let db: PgTestClient;
-
-  afterEach(() => {
-    // if (db) closeConnection(db);
-  });
-
-  it('creates a test DB from a template', () => {
-    db = getConnection({ template: TEMPLATE_NAME });
-    expect(db).toBeDefined();
-  });
-});

package/__tests__/postgres-test.test.ts

@@ -1,36 +0,0 @@
-import { getPgEnvOptions, PgConfig } from '@launchql/types';
-
-import {
-  getConnection,
-  Connection
-} from '../src';
-import { randomUUID } from 'crypto';
-import { PgTestClient } from '../src/test-client';
-
-const TEST_DB_BASE = `postgres_test_${randomUUID()}`; 
-
-const config = getPgEnvOptions({
-    database: TEST_DB_BASE
-});
-
-afterAll(() => {
-  Connection.getManager().closeAll();
-});
-
-describe('Postgres Test Framework', () => {
-  let db: PgTestClient;
-
-  afterEach(() => {
-    // if (db) closeConnection(db);
-  });
-
-  it('creates a test DB with hot mode (FAST_TEST)', () => {
-    db = getConnection({ hot: true, extensions: ['uuid-ossp'] });
-    expect(db).toBeDefined();
-  });
-
-  it('creates a test DB from scratch (default)', () => {
-    db = getConnection({});
-    expect(db).toBeDefined();
-  });
-});

package/jest.config.js

@@ -1,18 +0,0 @@
-/** @type {import('ts-jest').JestConfigWithTsJest} */
-module.exports = {
-    preset: "ts-jest",
-    testEnvironment: "node",
-    transform: {
-        "^.+\\.tsx?$": [
-            "ts-jest",
-            {
-                babelConfig: false,
-                tsconfig: "tsconfig.json",
-            },
-        ],
-    },
-    transformIgnorePatterns: [`/node_modules/*`],
-    testRegex: "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
-    moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
-    modulePathIgnorePatterns: ["dist/*"]
-};