pgsql-test 0.0.1 → 2.0.1

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;
-

package/src/admin.ts

@@ -1,135 +0,0 @@
-import { execSync } from 'child_process';
-import { PgConfig } from '@launchql/types';
-import { existsSync } from 'fs';
-import { streamSql as stream } from './stream';
-
-export class DbAdmin {
-  constructor(
-    private config: PgConfig,
-    private verbose: boolean = false
-  ) { }
-
-  private getEnv(): Record<string, string> {
-    return {
-      PGHOST: this.config.host,
-      PGPORT: String(this.config.port),
-      PGUSER: this.config.user,
-      PGPASSWORD: this.config.password,
-    };
-  }
-
-  private run(command: string): void {
-    execSync(command, {
-      stdio: this.verbose ? 'inherit' : 'pipe',
-      env: {
-        ...process.env,
-        ...this.getEnv(),
-      },
-    });
-  }
-
-  private safeDropDb(name: string): void {
-    try {
-      this.run(`dropdb "${name}"`);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      if (!message.includes('does not exist')) {
-        console.warn(`⚠️  Could not drop database ${name}: ${message}`);
-      }
-    }
-  }
-
-  drop(dbName?: string): void {
-    this.safeDropDb(dbName ?? this.config.database);
-  }
-
-  dropTemplate(dbName: string): void {
-    this.run(`psql -c "UPDATE pg_database SET datistemplate='false' WHERE datname='${dbName}';"`);
-    this.drop(dbName);
-  }
-
-  create(dbName?: string): void {
-    const db = dbName ?? this.config.database;
-    this.run(`createdb -U ${this.config.user} -h ${this.config.host} -p ${this.config.port} "${db}"`);
-  }
-
-  createFromTemplate(template: string, dbName?: string): void {
-    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: string[] | string, dbName?: string): void {
-    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?: string): string {
-    const { user, password, host, port } = this.config;
-    const db = dbName ?? this.config.database;
-    return `postgres://${user}:${password}@${host}:${port}/${db}`;
-  }
-
-  createTemplateFromBase(base: string, template: string): void {
-    this.run(`createdb -T "${base}" "${template}"`);
-    this.run(`psql -c "UPDATE pg_database SET datistemplate = true WHERE datname = '${template}';"`);
-  }
-
-  cleanupTemplate(template: string): void {
-    try {
-      this.run(`psql -c "UPDATE pg_database SET datistemplate = false WHERE datname = '${template}'"`);
-    } catch { }
-    this.safeDropDb(template);
-  }
-
-  async createRole(role: string, password: string, dbName?: string): Promise<void> {
-    const db = dbName ?? this.config.database;
-    const sql = `CREATE ROLE ${role} WITH LOGIN PASSWORD '${password}';`;
-    await this.streamSql(sql, db);
-  }
-  
-  async grantRole(role: string, user: string, dbName?: string): Promise<void> {
-    const db = dbName ?? this.config.database;
-    const sql = `GRANT ${role} TO ${user};`;
-    await this.streamSql(sql, db);
-  }
-  
-  async grantConnect(role: string, dbName?: string): Promise<void> {
-    const db = dbName ?? this.config.database;
-    const sql = `GRANT CONNECT ON DATABASE "${db}" TO ${role};`;
-    await this.streamSql(sql, db);
-  }
-  
-  async createUserRole(user: string, password: string, dbName: string): Promise<void> {
-    const sql = `
-  DO $$
-  BEGIN
-    IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${user}') THEN
-      CREATE ROLE ${user} LOGIN PASSWORD '${password}';
-      GRANT anonymous TO ${user};
-      GRANT authenticated TO ${user};
-    END IF;
-  END $$;
-    `.trim();
-
-    this.streamSql(sql, dbName);
-  }
-
-  loadSql(file: string, dbName: string): void {
-    if (!existsSync(file)) {
-      throw new Error(`Missing SQL file: ${file}`);
-    }
-    this.run(`psql -f ${file} ${dbName}`);
-  }
-
-  async streamSql(sql: string, dbName: string): Promise<void> {
-    await stream({
-      ...this.config,
-      database: dbName
-    }, sql);
-  }
-
-}

package/src/connect.ts

@@ -1,42 +0,0 @@
-import { randomUUID } from 'crypto';
-import { getPgEnvOptions, PgConfig } from '@launchql/types';
-import { PgTestConnector } from './manager';
-import { DbAdmin } from './admin';
-
-let manager: PgTestConnector;
-export const getConnections = async () => {
-  const config: PgConfig = getPgEnvOptions({
-    database: `db-${randomUUID()}`
-  });
-
-  const app_user = 'app_user';
-  const app_password = 'app_password';
-
-  const admin = new DbAdmin(config);
-
-  // Create the test database
-  admin.create(config.database);
-
-  // Main admin client (optional unless needed elsewhere)
-  manager = PgTestConnector.getInstance();
-  const db = manager.getClient(config);
-
-  // Set up test role
-  admin.createUserRole(app_user, app_password, config.database);
-  admin.grantConnect(app_user, config.database);
-
-  // App user connection
-  const conn = manager.getClient({
-    ...config,
-    user: app_user,
-    password: app_password
-  })
-//   const conn = await getTestConnection(config.database, app_user, app_password);
-  conn.setContext({ role: 'anonymous' });
-
-  const teardown = async () => {
-    await manager.closeAll();
-  };
-
-  return { db, conn, teardown };
-};

package/src/legacy-connect.ts

@@ -1,34 +0,0 @@
-import { PgTestClient } from './test-client';
-import { PgTestConnector } from './manager';
-import { randomUUID } from 'crypto';
-import { getPgEnvOptions, PgConfig } from '@launchql/types';
-
-export function connect(config: PgConfig): PgTestClient {
-  const manager = PgTestConnector.getInstance();
-  return manager.getClient(config);
-}
-
-export function close(client: PgTestClient): void {
-  client.close();
-}
-
-const manager = PgTestConnector.getInstance();
-
-export const Connection = {
-  connect(config: Partial<PgConfig>): PgTestClient {
-    const creds = getPgEnvOptions(config);
-    return manager.getClient(creds);
-  },
-
-  close(client: PgTestClient): void {
-    client.close();
-  },
-
-  closeAll(): Promise<void> {
-    return manager.closeAll();
-  },
-
-  getManager(): PgTestConnector {
-    return manager;
-  }
-};

package/src/manager.ts

@@ -1,142 +0,0 @@
-import { Pool } from 'pg';
-import chalk from 'chalk';
-import { DbAdmin } from './admin';
-import { PgConfig } from '@launchql/types';
-import { PgTestClient } from './test-client';
-
-const SYS_EVENTS = ['SIGTERM'];
-
-const end = (pool: Pool) => {
-  try {
-    if ((pool as any).ended || (pool as any).ending) {
-      console.warn(chalk.yellow('⚠️ pg pool already ended or ending'));
-      return;
-    }
-    pool.end();
-  } catch (err) {
-    console.error(chalk.red('❌ pg pool termination error:'), err);
-  }
-};
-
-export class PgTestConnector {
-  private static instance: PgTestConnector;
-
-  private readonly clients = new Set<PgTestClient>();
-  private readonly pgPools = new Map<string, Pool>();
-  private readonly seenDbConfigs = new Map<string, PgConfig>();
-
-  private verbose = false;
-
-  private constructor(verbose = false) {
-    this.verbose = verbose;
-
-    SYS_EVENTS.forEach((event) => {
-      process.on(event, () => {
-        this.log(chalk.magenta(`⏹ Received ${event}, closing all connections...`));
-        this.closeAll();
-      });
-    });
-  }
-
-  static getInstance(verbose = false): PgTestConnector {
-    if (!PgTestConnector.instance) {
-      PgTestConnector.instance = new PgTestConnector(verbose);
-    }
-    return PgTestConnector.instance;
-  }
-
-  private log(...args: any[]) {
-    if (this.verbose) console.log(...args);
-  }
-
-  private poolKey(config: PgConfig): string {
-    return `${config.user}@${config.host}:${config.port}/${config.database}`;
-  }
-
-  private dbKey(config: PgConfig): string {
-    return `${config.host}:${config.port}/${config.database}`;
-  }
-
-  getAdmin(config: PgConfig): DbAdmin {
-    return new DbAdmin(config, this.verbose);
-  }
-
-  getPool(config: PgConfig): Pool {
-    const key = this.poolKey(config);
-    if (!this.pgPools.has(key)) {
-      const pool = new Pool(config);
-      this.pgPools.set(key, pool);
-      this.log(chalk.blue(`📘 Created new pg pool: ${chalk.white(key)}`));
-    }
-    return this.pgPools.get(key)!;
-  }
-
-  getClient(config: PgConfig): PgTestClient {
-    const client = new PgTestClient(config);
-    this.clients.add(client);
-
-    const key = this.dbKey(config);
-    this.seenDbConfigs.set(key, config);
-
-    this.log(chalk.green(`🔌 New PgTestClient connected to ${config.database}`));
-    return client;
-  }
-
-  async closeAll(): Promise<void> {
-    this.log(chalk.cyan('\n🧹 Closing all PgTestClients...'));
-    await Promise.all(
-      Array.from(this.clients).map(async (client) => {
-        try {
-          await client.close();
-          this.log(chalk.green(`✅ Closed client for ${client.config.database}`));
-        } catch (err) {
-          console.warn(chalk.red(`❌ Error closing PgTestClient for ${client.config.database}:`), err);
-        }
-      })
-    );
-    this.clients.clear();
-
-    this.log(chalk.cyan('\n🧯 Disposing pg pools...'));
-    for (const [key, pool] of this.pgPools.entries()) {
-      this.log(chalk.gray(`🧯 Disposing pg pool [${key}]`));
-      end(pool);
-    }
-    this.pgPools.clear();
-
-    this.log(chalk.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 admin = new DbAdmin({...config, user: 'postgres', password: 'password'}, this.verbose);
-          // console.log(config);
-          admin.drop();
-          this.log(chalk.yellow(`🧨 Dropped database: ${chalk.white(config.database)}`));
-        } catch (err) {
-          console.warn(chalk.red(`❌ Failed to drop database ${config.database}:`), err);
-        }
-      })
-    );
-    this.seenDbConfigs.clear();
-
-    this.log(chalk.green('\n✅ All PgTestClients closed, pools disposed, databases dropped.'));
-  }
-
-  close(): void {
-    this.closeAll();
-  }
-
-  drop(config: PgConfig): void {
-    const key = this.dbKey(config);
-    const admin = new DbAdmin(config, this.verbose);
-    admin.drop();
-    this.log(chalk.red(`🧨 Dropped database: ${chalk.white(config.database)}`));
-    this.seenDbConfigs.delete(key);
-  }
-  
-  kill(client: PgTestClient): void {
-    client.close();
-    this.drop(client.config);
-  }
-  
-}

package/src/stream.ts

@@ -1,61 +0,0 @@
-import { spawn } from 'child_process';
-import { Readable } from 'stream';
-import { env } from 'process';
-import { PgConfig } from '@launchql/types';
-
-function setArgs(config: PgConfig): string[] {
-  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: string): Readable {
-  const stream = new Readable({
-    read() {
-      this.push(text);
-      this.push(null);
-    }
-  });
-  return stream;
-}
-
-export async function streamSql(config: PgConfig, sql: string): Promise<void> {
-  const args = setArgs(config);
-
-  return new Promise<void>((resolve, reject) => {
-    const sqlStream = stringToStream(sql);
-
-    // TODO set env vars!
-    const proc = spawn('psql', args, {
-      env: {
-        ...env,
-        PGUSER: config.user,
-        PGHOST: config.host,
-        PGDATABASE: config.database,
-        PGPASSWORD: config.password,
-        // PGPORT: config.port
-      }
-    });
-
-    sqlStream.pipe(proc.stdin);
-
-    proc.on('close', (code) => {
-      resolve();
-    });
-
-    proc.on('error', (error) => {
-      reject(error);
-    });
-
-    proc.stderr.on('data', (data: Buffer) => {
-      reject(new Error(data.toString()));
-    });
-  });
-}

package/src/test-client.ts

@@ -1,113 +0,0 @@
-import { Client, QueryResult } from 'pg';
-import { PgConfig } from '@launchql/types';
-
-export class PgTestClient {
-  public config: PgConfig;
-  private client: Client;
-  private ctxStmts: string = '';
-  private _ended: boolean = false;
-
-  constructor(config: PgConfig) {
-    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
-    });
-    this.client.connect();
-  }
-
-  close(): void {
-    if (!this._ended) {
-      this._ended = true;
-      this.client.end();
-    }
-  }
-
-  async begin(): Promise<void> {
-    await this.client.query('BEGIN;');
-  }
-
-  async savepoint(name: string = 'lqlsavepoint'): Promise<void> {
-    await this.client.query(`SAVEPOINT "${name}";`);
-  }
-
-  async rollback(name: string = 'lqlsavepoint'): Promise<void> {
-    await this.client.query(`ROLLBACK TO SAVEPOINT "${name}";`);
-  }
-
-  async commit(): Promise<void> {
-    await this.client.query('COMMIT;');
-  }
-
-  async beforeEach(): Promise<void> {
-    await this.begin();
-    await this.savepoint();
-  }
-
-  async afterEach(): Promise<void> {
-    await this.rollback();
-    await this.commit();
-  }
-
-  setContext(ctx: Record<string, string | null>): void {
-    this.ctxStmts = Object.entries(ctx)
-      .map(([key, val]) =>
-        val === null
-          ? `SELECT set_config('${key}', NULL, true);`
-          : `SELECT set_config('${key}', '${val}', true);`
-      )
-      .join('\n');
-  }
-
-  private async runCtxQuery<T = any>(query: string, values?: any[]): Promise<QueryResult<T>> {
-    if (this.ctxStmts) {
-      await this.client.query(this.ctxStmts);
-    }
-    const result = await this.client.query<T>(query, values);
-    return result;
-  }
-
-  async any<T = any>(query: string, values?: any[]): Promise<T[]> {
-    const result = await this.runCtxQuery(query, values);
-    return result.rows;
-  }
-
-  async one<T = any>(query: string, values?: any[]): Promise<T> {
-    const rows = await this.any<T>(query, values);
-    if (rows.length !== 1) {
-      throw new Error('Expected exactly one result');
-    }
-    return rows[0];
-  }
-
-  async oneOrNone<T = any>(query: string, values?: any[]): Promise<T | null> {
-    const rows = await this.any<T>(query, values);
-    return rows[0] || null;
-  }
-
-  async many<T = any>(query: string, values?: any[]): Promise<T[]> {
-    const rows = await this.any<T>(query, values);
-    if (rows.length === 0) throw new Error('Expected many rows, got none');
-    return rows;
-  }
-
-  async manyOrNone<T = any>(query: string, values?: any[]): Promise<T[]> {
-    return this.any<T>(query, values);
-  }
-
-  async none(query: string, values?: any[]): Promise<void> {
-    await this.runCtxQuery(query, values);
-  }
-
-  async result(query: string, values?: any[]): Promise<import('pg').QueryResult> {
-    return this.runCtxQuery(query, values);
-  }
-
-  async query<T = any>(query: string, values?: any[]): Promise<QueryResult<T>> {
-    return this.client.query<T>(query, values);
-  }
-
-}

package/src/utils.ts

@@ -1,48 +0,0 @@
-import { Client, Pool } from 'pg';
-// import { createdb, dropdb, templatedb, installExt, grantConnect } from './db';
-import { connect, close } from './legacy-connect';
-import { getPgEnvOptions, PgConfig } from '@launchql/types';
-import { getEnvOptions } from '@launchql/types';
-import { randomUUID } from 'crypto';
-import { PgTestClient } from './test-client';
-import { DbAdmin } from './admin';
-
-export interface TestOptions {
-  hot?: boolean;
-  template?: string;
-  prefix?: string;
-  extensions?: string[];
-}
-
-export function getOpts(configOpts: TestOptions = {}): TestOptions {
-  return {
-    template: configOpts.template,
-    prefix: configOpts.prefix || 'testing-db',
-    extensions: configOpts.extensions || [],
-  };
-}
-
-export function getConnection(configOpts: TestOptions, database?: string): PgTestClient {
-  const opts = getOpts(configOpts);
-  const dbName = database || `${opts.prefix}-${Date.now()}`;
-
-  const config = getPgEnvOptions({
-    database: dbName
-  });
-
-  const admin = new DbAdmin(config);
-
-  if (process.env.TEST_DB) {
-    config.database = process.env.TEST_DB;
-  } else if (opts.hot) {
-    admin.create(config.database);
-    admin.installExtensions(opts.extensions);
-  } else if (opts.template) {
-    admin.createFromTemplate(opts.template, config.database);
-  } else {
-    admin.create(config.database);
-    admin.installExtensions(opts.extensions);
-  }
-
-  return connect(config);
-}

package/test-utils/index.ts

@@ -1,2 +0,0 @@
-import path from 'path';
-import fs from 'fs';

package/tsconfig.esm.json

@@ -1,9 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "dist/esm",
-    "module": "es2022",
-    "rootDir": "src/",
-    "declaration": false
-  }
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src/"
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["dist", "node_modules", "**/*.spec.*", "**/*.test.*"]
-}