pgsql-test 0.0.1 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-test",
-  "version": "0.0.1",
+  "version": "2.0.2",
   "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": "db786d9e5d7a784c57f2bacbf1eb2f4b541cb21e"
+}

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/*"]
-};

package/sql/roles.sql

@@ -1,48 +0,0 @@
-BEGIN;
-DO $do$
-BEGIN
-    IF NOT EXISTS (
-        SELECT
-        FROM
-            pg_catalog.pg_roles
-        WHERE
-            rolname = 'administrator') THEN
-    CREATE ROLE administrator;
-END IF;
-    IF NOT EXISTS (
-        SELECT
-        FROM
-            pg_catalog.pg_roles
-        WHERE
-            rolname = 'anonymous') THEN
-    CREATE ROLE anonymous;
-END IF;
-    IF NOT EXISTS (
-        SELECT
-        FROM
-            pg_catalog.pg_roles
-        WHERE
-            rolname = 'authenticated') THEN
-    CREATE ROLE authenticated;
-END IF;
-END
-$do$;
-ALTER USER administrator WITH NOCREATEDB;
-ALTER USER administrator WITH NOCREATEROLE;
-ALTER USER administrator WITH NOLOGIN;
-ALTER USER administrator WITH NOREPLICATION;
-ALTER USER administrator WITH BYPASSRLS;
-ALTER USER anonymous WITH NOCREATEDB;
-ALTER USER anonymous WITH NOCREATEROLE;
-ALTER USER anonymous WITH NOLOGIN;
-ALTER USER anonymous WITH NOREPLICATION;
-ALTER USER anonymous WITH NOBYPASSRLS;
-ALTER USER authenticated WITH NOCREATEDB;
-ALTER USER authenticated WITH NOCREATEROLE;
-ALTER USER authenticated WITH NOLOGIN;
-ALTER USER authenticated WITH NOREPLICATION;
-ALTER USER authenticated WITH NOBYPASSRLS;
-GRANT anonymous TO administrator;
-GRANT authenticated TO administrator;
-COMMIT;
-

package/sql/test.sql

@@ -1,36 +0,0 @@
--- https://en.wikipedia.org/wiki/Role-based_access_control
-BEGIN;
-CREATE EXTENSION IF NOT EXISTS citext;
-DROP SCHEMA IF EXISTS app_public CASCADE;
-CREATE SCHEMA app_public;
-CREATE TABLE app_public.users (
-    id serial PRIMARY KEY,
-    username citext,
-    UNIQUE (username),
-    CHECK (length(username) < 127)
-);
-CREATE TABLE app_public.roles (
-    id serial PRIMARY KEY,
-    org_id bigint NOT NULL REFERENCES app_public.users (id)
-);
-CREATE TABLE app_public.user_settings (
-    user_id bigint NOT NULL PRIMARY KEY REFERENCES app_public.users (id),
-    setting1 text,
-    UNIQUE (user_id)
-);
-CREATE TABLE app_public.permissions (
-    id serial PRIMARY KEY,
-    name citext
-);
-CREATE TABLE app_public.permission_assignment (
-    perm_id bigint NOT NULL REFERENCES app_public.permissions (id),
-    role_id bigint NOT NULL REFERENCES app_public.roles (id),
-    PRIMARY KEY (perm_id, role_id)
-);
-CREATE TABLE app_public.subject_assignment (
-    subj_id bigint NOT NULL REFERENCES app_public.users (id),
-    role_id bigint NOT NULL REFERENCES app_public.roles (id),
-    PRIMARY KEY (subj_id, role_id)
-);
-COMMIT;
-