@pgpmjs/core 3.0.0

package/esm/files/plan/writer.js

@@ -0,0 +1,114 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Write a Sqitch plan file based on the provided rows
+ */
+export function writeSqitchPlan(rows, opts) {
+    const dir = path.resolve(path.join(opts.outdir, opts.name));
+    fs.mkdirSync(dir, { recursive: true });
+    const date = () => '2017-08-11T08:11:51Z'; // stubbed timestamp
+    const author = opts.author || 'launchql';
+    const email = `${author}@5b0c196eeb62`;
+    const duplicates = {};
+    const plan = opts.replacer(`%syntax-version=1.0.0
+%project=launchql-extension-name
+%uri=launchql-extension-name
+
+${rows
+        .map((row) => {
+        if (duplicates[row.deploy]) {
+            console.log('DUPLICATE ' + row.deploy);
+            return '';
+        }
+        duplicates[row.deploy] = true;
+        if (row.deps?.length) {
+            return `${row.deploy} [${row.deps.join(' ')}] ${date()} ${author} <${email}> # add ${row.name}`;
+        }
+        return `${row.deploy} ${date()} ${author} <${email}> # add ${row.name}`;
+    })
+        .join('\n')}
+`);
+    fs.writeFileSync(path.join(dir, 'pgpm.plan'), plan);
+}
+/**
+ * Write a plan file with the provided content
+ */
+export function writePlanFile(planPath, plan) {
+    const content = generatePlanFileContent(plan);
+    fs.writeFileSync(planPath, content);
+}
+/**
+ * Generate content for a plan file
+ */
+export function generatePlanFileContent(plan) {
+    const { package: packageName, uri, changes, tags } = plan;
+    let content = `%syntax-version=1.0.0\n`;
+    content += `%project=${packageName}\n`;
+    if (uri) {
+        content += `%uri=${uri}\n`;
+    }
+    content += `\n`;
+    // Add changes and their associated tags
+    for (const change of changes) {
+        content += generateChangeLineContent(change);
+        content += `\n`;
+        const associatedTags = tags.filter(tag => tag.change === change.name);
+        for (const tag of associatedTags) {
+            content += generateTagLineContent(tag);
+            content += `\n`;
+        }
+    }
+    return content;
+}
+/**
+ * Generate a line for a change in a plan file
+ */
+export function generateChangeLineContent(change) {
+    const { name, dependencies, timestamp, planner, email, comment } = change;
+    let line = name;
+    // Add dependencies if present
+    if (dependencies && dependencies.length > 0) {
+        line += ` [${dependencies.join(' ')}]`;
+    }
+    // Add timestamp if present
+    if (timestamp) {
+        line += ` ${timestamp}`;
+        // Add planner if present
+        if (planner) {
+            line += ` ${planner}`;
+            // Add email if present
+            if (email) {
+                line += ` <${email}>`;
+            }
+        }
+    }
+    // Add comment if present
+    if (comment) {
+        line += ` # ${comment}`;
+    }
+    return line;
+}
+/**
+ * Generate a line for a tag in a plan file
+ */
+export function generateTagLineContent(tag) {
+    const { name, timestamp, planner, email, comment } = tag;
+    let line = `@${name}`;
+    // Add timestamp if present
+    if (timestamp) {
+        line += ` ${timestamp}`;
+        // Add planner if present
+        if (planner) {
+            line += ` ${planner}`;
+            // Add email if present
+            if (email) {
+                line += ` <${email}>`;
+            }
+        }
+    }
+    // Add comment if present
+    if (comment) {
+        line += ` # ${comment}`;
+    }
+    return line;
+}

package/esm/files/sql/index.js

@@ -0,0 +1 @@
+export * from './writer';

package/esm/files/sql/writer.js

@@ -0,0 +1,107 @@
+import { getEnvOptions } from '@pgpmjs/env';
+import fs from 'fs';
+import path from 'path';
+/**
+ * Write SQL files for Sqitch migrations (deploy, revert, verify)
+ */
+export const writeSqitchFiles = (rows, opts) => {
+    rows.forEach((row) => writeVerify(row, opts));
+    rows.forEach((row) => writeRevert(row, opts));
+    rows.forEach((row) => writeDeploy(row, opts));
+};
+/**
+ * Sort dependencies in a consistent order
+ */
+const ordered = (arr) => {
+    if (!arr)
+        return [];
+    return arr.sort((a, b) => a.length - b.length || a.localeCompare(b));
+};
+/**
+ * Write a deploy SQL file for a Sqitch change
+ */
+const writeDeploy = (row, opts) => {
+    const globalOpts = getEnvOptions({
+        migrations: {
+            codegen: {
+                useTx: opts.useTx
+            }
+        }
+    });
+    const useTx = globalOpts.migrations.codegen.useTx;
+    const deploy = opts.replacer(row.deploy);
+    const dir = path.dirname(deploy);
+    const prefix = path.join(opts.outdir, opts.name, 'deploy');
+    const actualDir = path.resolve(prefix, dir);
+    const actualFile = path.resolve(prefix, `${deploy}.sql`);
+    fs.mkdirSync(actualDir, { recursive: true });
+    const sqlContent = opts.replacer(row.content);
+    const content = `-- Deploy: ${deploy}
+-- made with <3 @ constructive.io
+
+${opts.replacer(ordered(row?.deps)
+        .map((dep) => `-- requires: ${dep}`)
+        .join('\n') || '')}
+
+${useTx ? 'BEGIN;' : ''}
+${sqlContent}
+${useTx ? 'COMMIT;' : ''}
+`;
+    fs.writeFileSync(actualFile, content);
+};
+/**
+ * Write a verify SQL file for a Sqitch change
+ */
+const writeVerify = (row, opts) => {
+    const globalOpts = getEnvOptions({
+        migrations: {
+            codegen: {
+                useTx: opts.useTx
+            }
+        }
+    });
+    const useTx = globalOpts.migrations.codegen.useTx;
+    const deploy = opts.replacer(row.deploy);
+    const dir = path.dirname(deploy);
+    const prefix = path.join(opts.outdir, opts.name, 'verify');
+    const actualDir = path.resolve(prefix, dir);
+    const actualFile = path.resolve(prefix, `${deploy}.sql`);
+    fs.mkdirSync(actualDir, { recursive: true });
+    const sqlContent = opts.replacer(row.verify);
+    const content = opts.replacer(`-- Verify: ${deploy}
+
+${useTx ? 'BEGIN;' : ''}
+${sqlContent}
+${useTx ? 'COMMIT;' : ''}
+
+`);
+    fs.writeFileSync(actualFile, content);
+};
+/**
+ * Write a revert SQL file for a Sqitch change
+ */
+const writeRevert = (row, opts) => {
+    const globalOpts = getEnvOptions({
+        migrations: {
+            codegen: {
+                useTx: opts.useTx
+            }
+        }
+    });
+    const useTx = globalOpts.migrations.codegen.useTx;
+    const deploy = opts.replacer(row.deploy);
+    const dir = path.dirname(deploy);
+    const prefix = path.join(opts.outdir, opts.name, 'revert');
+    const actualDir = path.resolve(prefix, dir);
+    const actualFile = path.resolve(prefix, `${deploy}.sql`);
+    fs.mkdirSync(actualDir, { recursive: true });
+    const sqlContent = opts.replacer(row.revert);
+    const content = `-- Revert: ${deploy}
+
+${useTx ? 'BEGIN;' : ''}
+${sqlContent}
+${useTx ? 'COMMIT;' : ''}
+
+`;
+    fs.writeFileSync(actualFile, content);
+};

package/esm/files/sql-scripts/index.js

@@ -0,0 +1,2 @@
+// Re-export all sql-scripts functionality
+export * from './reader';

package/esm/files/sql-scripts/reader.js

@@ -0,0 +1,19 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+/**
+ * Read a SQL script file, return empty string if not found
+ */
+export function readScript(basePath, scriptType, changeName) {
+    const scriptPath = join(basePath, scriptType, `${changeName}.sql`);
+    if (!existsSync(scriptPath)) {
+        return '';
+    }
+    return readFileSync(scriptPath, 'utf-8');
+}
+/**
+ * Check if a script file exists
+ */
+export function scriptExists(basePath, scriptType, changeName) {
+    const scriptPath = join(basePath, scriptType, `${changeName}.sql`);
+    return existsSync(scriptPath);
+}

package/esm/files/types/index.js

@@ -0,0 +1 @@
+export * from './package';

package/esm/files/types/package.js

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

package/esm/index.js

@@ -0,0 +1,21 @@
+export * from './core/class/pgpm';
+export * from './export/export-meta';
+export * from './export/export-migrations';
+export * from './extensions/extensions';
+export * from './modules/modules';
+export * from './packaging/package';
+export * from './packaging/transform';
+export * from './resolution/deps';
+export * from './resolution/resolve';
+export * from './workspace/paths';
+export * from './workspace/utils';
+export * from './core/template-scaffold';
+export * from './core/boilerplate-types';
+export * from './core/boilerplate-scanner';
+// Export package-files functionality (now integrated into core)
+export * from './files';
+export { cleanSql } from './migrate/clean';
+export { PgpmMigrate } from './migrate/client';
+export { PgpmInit } from './init/client';
+export { hashFile, hashString } from './migrate/utils/hash';
+export { executeQuery, withTransaction } from './migrate/utils/transaction';

package/esm/init/client.js

@@ -0,0 +1,144 @@
+import { Logger } from '@pgpmjs/logger';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { getPgPool } from 'pg-cache';
+const log = new Logger('init');
+export class PgpmInit {
+    pool;
+    pgConfig;
+    constructor(config) {
+        this.pgConfig = config;
+        this.pool = getPgPool(this.pgConfig);
+    }
+    /**
+     * Bootstrap standard roles (anonymous, authenticated, administrator)
+     */
+    async bootstrapRoles() {
+        try {
+            log.info('Bootstrapping PGPM roles...');
+            const sqlPath = join(__dirname, 'sql', 'bootstrap-roles.sql');
+            const sql = readFileSync(sqlPath, 'utf-8');
+            await this.pool.query(sql);
+            log.success('Successfully bootstrapped PGPM roles');
+        }
+        catch (error) {
+            log.error('Failed to bootstrap roles:', error);
+            throw error;
+        }
+    }
+    /**
+     * Bootstrap test roles (roles only, no users)
+     */
+    async bootstrapTestRoles() {
+        try {
+            log.warn('WARNING: This command creates test roles and should NEVER be run on a production database!');
+            log.info('Bootstrapping PGPM test roles...');
+            const sqlPath = join(__dirname, 'sql', 'bootstrap-test-roles.sql');
+            const sql = readFileSync(sqlPath, 'utf-8');
+            await this.pool.query(sql);
+            log.success('Successfully bootstrapped PGPM test roles');
+        }
+        catch (error) {
+            log.error('Failed to bootstrap test roles:', error);
+            throw error;
+        }
+    }
+    /**
+     * Bootstrap database roles with custom username and password
+     */
+    async bootstrapDbRoles(username, password) {
+        try {
+            log.info(`Bootstrapping PGPM database roles for user: ${username}...`);
+            const sql = `
+BEGIN;
+DO $do$
+DECLARE
+  v_username TEXT := '${username.replace(/'/g, "''")}';
+  v_password TEXT := '${password.replace(/'/g, "''")}';
+BEGIN
+  BEGIN
+    EXECUTE format('CREATE ROLE %I LOGIN PASSWORD %L', v_username, v_password);
+  EXCEPTION
+    WHEN duplicate_object THEN
+      -- Role already exists; optionally sync attributes here with ALTER ROLE
+      NULL;
+  END;
+END
+$do$;
+
+-- Robust GRANTs under concurrency: GRANT can race on pg_auth_members unique index.
+-- Catch unique_violation (23505) and continue so CI/CD concurrent jobs don't fail.
+DO $do$
+DECLARE
+  v_username TEXT := '${username.replace(/'/g, "''")}';
+BEGIN
+  BEGIN
+    EXECUTE format('GRANT %I TO %I', 'anonymous', v_username);
+  EXCEPTION
+    WHEN unique_violation THEN
+      -- Membership was granted concurrently; ignore.
+      NULL;
+    WHEN undefined_object THEN
+      -- One of the roles doesn't exist yet; order operations as needed.
+      RAISE NOTICE 'Missing role when granting % to %', 'anonymous', v_username;
+  END;
+
+  BEGIN
+    EXECUTE format('GRANT %I TO %I', 'authenticated', v_username);
+  EXCEPTION
+    WHEN unique_violation THEN
+      -- Membership was granted concurrently; ignore.
+      NULL;
+    WHEN undefined_object THEN
+      RAISE NOTICE 'Missing role when granting % to %', 'authenticated', v_username;
+  END;
+END
+$do$;
+COMMIT;
+      `;
+            await this.pool.query(sql);
+            log.success(`Successfully bootstrapped PGPM database roles for user: ${username}`);
+        }
+        catch (error) {
+            log.error(`Failed to bootstrap database roles for user ${username}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Remove database roles and revoke grants
+     */
+    async removeDbRoles(username) {
+        try {
+            log.info(`Removing PGPM database roles for user: ${username}...`);
+            const sql = `
+BEGIN;
+DO $do$
+BEGIN
+    IF EXISTS (
+        SELECT 1
+        FROM
+            pg_catalog.pg_roles
+        WHERE
+            rolname = '${username}') THEN
+    REVOKE anonymous FROM ${username};
+    REVOKE authenticated FROM ${username};
+    DROP ROLE ${username};
+END IF;
+END
+$do$;
+COMMIT;
+      `;
+            await this.pool.query(sql);
+            log.success(`Successfully removed PGPM database roles for user: ${username}`);
+        }
+        catch (error) {
+            log.error(`Failed to remove database roles for user ${username}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Close the database connection
+     */
+    async close() {
+    }
+}

package/esm/init/sql/bootstrap-roles.sql

@@ -0,0 +1,55 @@
+BEGIN;
+DO $do$
+BEGIN
+  -- anonymous
+  BEGIN
+    EXECUTE format('CREATE ROLE %I', 'anonymous');
+  EXCEPTION
+    WHEN duplicate_object THEN
+      -- Role already exists; optionally sync attributes here with ALTER ROLE
+      NULL;
+  END;
+  
+  -- authenticated
+  BEGIN
+    EXECUTE format('CREATE ROLE %I', 'authenticated');
+  EXCEPTION
+    WHEN duplicate_object THEN
+      -- Role already exists; optionally sync attributes here with ALTER ROLE
+      NULL;
+  END;
+  
+  -- administrator
+  BEGIN
+    EXECUTE format('CREATE ROLE %I', 'administrator');
+  EXCEPTION
+    WHEN duplicate_object THEN
+      -- Role already exists; optionally sync attributes here with ALTER ROLE
+      NULL;
+  END;
+END
+$do$;
+
+-- Set role attributes (safe to run even if role already exists)
+ALTER USER anonymous WITH NOCREATEDB;
+ALTER USER anonymous WITH NOSUPERUSER;
+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 NOSUPERUSER;
+ALTER USER authenticated WITH NOCREATEROLE;
+ALTER USER authenticated WITH NOLOGIN;
+ALTER USER authenticated WITH NOREPLICATION;
+ALTER USER authenticated WITH NOBYPASSRLS;
+
+ALTER USER administrator WITH NOCREATEDB;
+ALTER USER administrator WITH NOSUPERUSER;
+ALTER USER administrator WITH NOCREATEROLE;
+ALTER USER administrator WITH NOLOGIN;
+ALTER USER administrator WITH NOREPLICATION;
+-- they CAN bypass RLS
+ALTER USER administrator WITH BYPASSRLS;
+COMMIT;

package/esm/init/sql/bootstrap-test-roles.sql

@@ -0,0 +1,72 @@
+BEGIN;
+DO $do$
+BEGIN
+  BEGIN
+    EXECUTE format('CREATE ROLE %I LOGIN PASSWORD %L', 'app_user', 'app_password');
+  EXCEPTION
+    WHEN duplicate_object THEN
+      -- Role already exists; optionally sync attributes here with ALTER ROLE
+      NULL;
+  END;
+  
+  BEGIN
+    EXECUTE format('CREATE ROLE %I LOGIN PASSWORD %L', 'app_admin', 'admin_password');
+  EXCEPTION
+    WHEN duplicate_object THEN
+      -- Role already exists; optionally sync attributes here with ALTER ROLE
+      NULL;
+  END;
+END
+$do$;
+
+DO $do$
+BEGIN
+  BEGIN
+    EXECUTE format('GRANT %I TO %I', 'anonymous', 'app_user');
+  EXCEPTION
+    WHEN unique_violation THEN
+      -- Membership was granted concurrently; ignore.
+      NULL;
+    WHEN undefined_object THEN
+      -- One of the roles doesn't exist yet; order operations as needed.
+      RAISE NOTICE 'Missing role when granting % to %', 'anonymous', 'app_user';
+  END;
+
+  BEGIN
+    EXECUTE format('GRANT %I TO %I', 'authenticated', 'app_user');
+  EXCEPTION
+    WHEN unique_violation THEN
+      NULL;
+    WHEN undefined_object THEN
+      RAISE NOTICE 'Missing role when granting % to %', 'authenticated', 'app_user';
+  END;
+
+  BEGIN
+    EXECUTE format('GRANT %I TO %I', 'anonymous', 'administrator');
+  EXCEPTION
+    WHEN unique_violation THEN
+      NULL;
+    WHEN undefined_object THEN
+      RAISE NOTICE 'Missing role when granting % to %', 'anonymous', 'administrator';
+  END;
+
+  BEGIN
+    EXECUTE format('GRANT %I TO %I', 'authenticated', 'administrator');
+  EXCEPTION
+    WHEN unique_violation THEN
+      NULL;
+    WHEN undefined_object THEN
+      RAISE NOTICE 'Missing role when granting % to %', 'authenticated', 'administrator';
+  END;
+
+  BEGIN
+    EXECUTE format('GRANT %I TO %I', 'administrator', 'app_admin');
+  EXCEPTION
+    WHEN unique_violation THEN
+      NULL;
+    WHEN undefined_object THEN
+      RAISE NOTICE 'Missing role when granting % to %', 'administrator', 'app_admin';
+  END;
+END
+$do$;
+COMMIT;

package/esm/migrate/clean.js

@@ -0,0 +1,23 @@
+import { deparse, parse } from 'pgsql-parser';
+const filterStatements = (stmts) => {
+    const filteredStmts = stmts.filter(node => {
+        const stmt = node.stmt;
+        return stmt && !stmt.hasOwnProperty('TransactionStmt') &&
+            !stmt.hasOwnProperty('CreateExtensionStmt');
+    });
+    const hasFiltered = filteredStmts.length !== stmts.length;
+    return { filteredStmts, hasFiltered };
+};
+export const cleanSql = async (sql, pretty, functionDelimiter) => {
+    const parsed = await parse(sql);
+    const { filteredStmts, hasFiltered } = filterStatements(parsed.stmts);
+    if (!hasFiltered) {
+        return sql;
+    }
+    parsed.stmts = filteredStmts;
+    const finalSql = await deparse(parsed, {
+        pretty,
+        functionDelimiter
+    });
+    return finalSql;
+};