@pgpmjs/core 3.0.0

package/esm/packaging/transform.js

@@ -0,0 +1,70 @@
+import { deparse } from 'pgsql-deparser';
+import { parse } from 'pgsql-parser';
+/**
+ * Recursively transforms the properties of an object based on a transformation map.
+ *
+ * @param obj - The object to transform.
+ * @param props - A map of properties and their transformation rules.
+ * @returns A new object with transformed properties.
+ */
+export const transformProps = (obj, props) => {
+    let copy;
+    // Handle primitive types, null, or undefined
+    if (obj === null || typeof obj !== 'object')
+        return obj;
+    // Handle Date
+    if (obj instanceof Date) {
+        copy = new Date();
+        copy.setTime(obj.getTime());
+        return copy;
+    }
+    // Handle Array
+    if (Array.isArray(obj)) {
+        copy = [];
+        for (let i = 0, len = obj.length; i < len; i++) {
+            copy[i] = transformProps(obj[i], props);
+        }
+        return copy;
+    }
+    // Handle Object
+    if (obj instanceof Object || typeof obj === 'object') {
+        copy = {};
+        for (const attr in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, attr)) {
+                if (props.hasOwnProperty(attr)) {
+                    const propRule = props[attr];
+                    if (typeof propRule === 'function') {
+                        // Apply function transformation
+                        copy[attr] = propRule(obj[attr]);
+                    }
+                    else if (typeof propRule === 'object' && propRule !== null) {
+                        // Apply value-based transformation
+                        if (propRule.hasOwnProperty(obj[attr])) {
+                            copy[attr] = propRule[obj[attr]];
+                        }
+                        else {
+                            copy[attr] = transformProps(obj[attr], props);
+                        }
+                    }
+                }
+                else {
+                    copy[attr] = transformProps(obj[attr], props);
+                }
+            }
+        }
+        return copy;
+    }
+    throw new Error("Unable to copy obj! Its type isn't supported.");
+};
+/**
+ * Parses a SQL statement, transforms its properties, and regenerates the SQL.
+ *
+ * @param statement - The SQL statement to transform.
+ * @param props - A map of properties and their transformation rules.
+ * @returns The transformed SQL statement.
+ */
+export const transform = async (statement, props) => {
+    let tree = await parse(statement);
+    tree = transformProps(tree, props);
+    return await deparse(tree);
+};

package/esm/projects/deploy.js

@@ -0,0 +1,123 @@
+import { getEnvOptions } from '@pgpmjs/env';
+import { Logger } from '@pgpmjs/logger';
+import { errors } from '@pgpmjs/types';
+import { resolve } from 'path';
+import * as path from 'path';
+import { getPgPool } from 'pg-cache';
+import { PgpmPackage } from '../core/class/pgpm';
+import { PgpmMigrate } from '../migrate/client';
+import { packageModule } from '../packaging/package';
+// Cache for fast deployment
+const deployFastCache = {};
+const getCacheKey = (pg, name, database) => {
+    const { host, port, user } = pg ?? {};
+    return `${host}:${port}:${user}:${database}:${name}`;
+};
+const log = new Logger('deploy');
+export const deployProject = async (opts, name, database, pkg, toChange) => {
+    const mergedOpts = getEnvOptions(opts);
+    log.info(`🔍 Gathering modules from ${pkg.workspacePath}...`);
+    const modules = pkg.getModuleMap();
+    if (!modules[name]) {
+        log.error(`❌ Module "${name}" not found in modules list.`);
+        throw errors.MODULE_NOT_FOUND({ name });
+    }
+    const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
+    const moduleProject = new PgpmPackage(modulePath);
+    log.info(`📦 Resolving dependencies for ${name}...`);
+    const extensions = moduleProject.getModuleExtensions();
+    const pgPool = getPgPool({ ...opts.pg, database });
+    log.success(`🚀 Starting deployment to database ${database}...`);
+    for (const extension of extensions.resolved) {
+        try {
+            if (extensions.external.includes(extension)) {
+                const msg = `CREATE EXTENSION IF NOT EXISTS "${extension}" CASCADE;`;
+                log.info(`📥 Installing external extension: ${extension}`);
+                log.debug(`> ${msg}`);
+                await pgPool.query(msg);
+            }
+            else {
+                const modulePath = resolve(pkg.workspacePath, modules[extension].path);
+                log.info(`📂 Deploying local module: ${extension}`);
+                log.debug(`→ Path: ${modulePath}`);
+                if (mergedOpts.deployment.fast) {
+                    // Use fast deployment strategy
+                    const localProject = new PgpmPackage(modulePath);
+                    const cacheKey = getCacheKey(mergedOpts.pg, extension, database);
+                    if (mergedOpts.deployment.cache && deployFastCache[cacheKey]) {
+                        log.warn(`⚡ Using cached package for ${extension}.`);
+                        await pgPool.query(deployFastCache[cacheKey].sql);
+                        continue;
+                    }
+                    let modulePackage;
+                    try {
+                        modulePackage = await packageModule(localProject.modulePath, {
+                            usePlan: mergedOpts.deployment.usePlan,
+                            extension: false
+                        });
+                    }
+                    catch (err) {
+                        // Build comprehensive error message
+                        const errorLines = [];
+                        errorLines.push(`❌ Failed to package module "${extension}" at path: ${modulePath}`);
+                        errorLines.push(`   Module Path: ${modulePath}`);
+                        errorLines.push(`   Workspace Path: ${pkg.workspacePath}`);
+                        errorLines.push(`   Error Code: ${err.code || 'N/A'}`);
+                        errorLines.push(`   Error Message: ${err.message || 'Unknown error'}`);
+                        // Provide debugging hints
+                        if (err.code === 'ENOENT') {
+                            errorLines.push('💡 Hint: File or directory not found. Check if the module path is correct.');
+                        }
+                        else if (err.code === 'EACCES') {
+                            errorLines.push('💡 Hint: Permission denied. Check file permissions.');
+                        }
+                        else if (err.message && err.message.includes('pgpm.plan')) {
+                            errorLines.push('💡 Hint: pgpm.plan file issue. Check if the plan file exists and is valid.');
+                        }
+                        // Log the consolidated error message
+                        log.error(errorLines.join('\n'));
+                        console.error(err); // Preserve full stack trace
+                        throw errors.DEPLOYMENT_FAILED({
+                            type: 'Deployment',
+                            module: extension
+                        });
+                    }
+                    log.debug(`→ Command: sqitch deploy db:pg:${database}`);
+                    log.debug(`> ${modulePackage.sql}`);
+                    await pgPool.query(modulePackage.sql);
+                    if (mergedOpts.deployment.cache) {
+                        deployFastCache[cacheKey] = modulePackage;
+                    }
+                }
+                else {
+                    // Use new migration system
+                    log.debug(`→ Command: launchql migrate deploy db:pg:${database}`);
+                    try {
+                        const client = new PgpmMigrate(mergedOpts.pg);
+                        const result = await client.deploy({
+                            modulePath,
+                            toChange,
+                            useTransaction: mergedOpts.deployment.useTx,
+                            logOnly: mergedOpts.deployment.logOnly
+                        });
+                        if (result.failed) {
+                            throw errors.OPERATION_FAILED({ operation: 'Deployment', target: result.failed });
+                        }
+                    }
+                    catch (deployError) {
+                        log.error(`❌ Deployment failed for module ${extension}`);
+                        console.error(deployError);
+                        throw errors.DEPLOYMENT_FAILED({ type: 'Deployment', module: extension });
+                    }
+                }
+            }
+        }
+        catch (err) {
+            log.error(`🛑 Error during deployment: ${err instanceof Error ? err.message : err}`);
+            console.error(err); // Keep raw error output for stack traces
+            throw errors.DEPLOYMENT_FAILED({ type: 'Deployment', module: extension });
+        }
+    }
+    log.success(`✅ Deployment complete for ${name}.`);
+    return extensions;
+};

package/esm/projects/revert.js

@@ -0,0 +1,75 @@
+import { Logger } from '@pgpmjs/logger';
+import { errors } from '@pgpmjs/types';
+import { resolve } from 'path';
+import * as path from 'path';
+import { getPgPool } from 'pg-cache';
+import { PgpmPackage } from '../core/class/pgpm';
+import { PgpmMigrate } from '../migrate/client';
+const log = new Logger('revert');
+export const revertProject = async (opts, name, database, pkg, options) => {
+    log.info(`🔍 Gathering modules from ${pkg.workspacePath}...`);
+    const modules = pkg.getModuleMap();
+    if (!modules[name]) {
+        log.error(`❌ Module "${name}" not found in modules list.`);
+        throw errors.MODULE_NOT_FOUND({ name });
+    }
+    const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
+    const moduleProject = new PgpmPackage(modulePath);
+    log.info(`📦 Resolving dependencies for ${name}...`);
+    const extensions = moduleProject.getModuleExtensions();
+    const pgPool = getPgPool({
+        ...opts.pg,
+        database
+    });
+    log.success(`🧹 Starting revert process on database ${database}...`);
+    const reversedExtensions = [...extensions.resolved].reverse();
+    for (const extension of reversedExtensions) {
+        try {
+            if (extensions.external.includes(extension)) {
+                const msg = `DROP EXTENSION IF EXISTS "${extension}" RESTRICT;`;
+                log.warn(`⚠️ Dropping external extension: ${extension}`);
+                log.debug(`> ${msg}`);
+                try {
+                    await pgPool.query(msg);
+                }
+                catch (err) {
+                    if (err.code === '2BP01') { // dependent_objects_still_exist
+                        log.warn(`⚠️ Cannot drop extension ${extension} due to dependencies, skipping`);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+            else {
+                const modulePath = resolve(pkg.workspacePath, modules[extension].path);
+                log.info(`📂 Reverting local module: ${extension}`);
+                log.debug(`→ Path: ${modulePath}`);
+                // Use new migration system
+                log.debug(`→ Command: launchql migrate revert db:pg:${database}`);
+                try {
+                    const client = new PgpmMigrate(opts.pg);
+                    const result = await client.revert({
+                        modulePath,
+                        toChange: options?.toChange,
+                        useTransaction: options?.useTransaction
+                    });
+                    if (result.failed) {
+                        throw errors.OPERATION_FAILED({ operation: 'Revert', target: result.failed });
+                    }
+                }
+                catch (revertError) {
+                    log.error(`❌ Revert failed for module ${extension}`);
+                    throw errors.DEPLOYMENT_FAILED({ type: 'Revert', module: extension });
+                }
+            }
+        }
+        catch (e) {
+            log.error(`🛑 Error during revert: ${e instanceof Error ? e.message : e}`);
+            console.error(e); // optional raw stack trace
+            throw errors.DEPLOYMENT_FAILED({ type: 'Revert', module: extension });
+        }
+    }
+    log.success(`✅ Revert complete for ${name}.`);
+    return extensions;
+};

package/esm/projects/verify.js

@@ -0,0 +1,61 @@
+import { Logger } from '@pgpmjs/logger';
+import { errors } from '@pgpmjs/types';
+import { resolve } from 'path';
+import * as path from 'path';
+import { getPgPool } from 'pg-cache';
+import { PgpmPackage } from '../core/class/pgpm';
+import { PgpmMigrate } from '../migrate/client';
+const log = new Logger('verify');
+export const verifyProject = async (opts, name, database, pkg, options) => {
+    log.info(`🔍 Gathering modules from ${pkg.workspacePath}...`);
+    const modules = pkg.getModuleMap();
+    if (!modules[name]) {
+        log.error(`❌ Module "${name}" not found in modules list.`);
+        throw errors.MODULE_NOT_FOUND({ name });
+    }
+    const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
+    const moduleProject = new PgpmPackage(modulePath);
+    log.info(`📦 Resolving dependencies for ${name}...`);
+    const extensions = moduleProject.getModuleExtensions();
+    const pgPool = getPgPool({
+        ...opts.pg,
+        database
+    });
+    log.success(`🔎 Verifying deployment of ${name} on database ${database}...`);
+    for (const extension of extensions.resolved) {
+        try {
+            if (extensions.external.includes(extension)) {
+                const query = `SELECT 1/count(*) FROM pg_available_extensions WHERE name = $1`;
+                log.info(`🔍 Verifying external extension: ${extension}`);
+                log.debug(`> ${query}`);
+                await pgPool.query(query, [extension]);
+            }
+            else {
+                const modulePath = resolve(pkg.workspacePath, modules[extension].path);
+                log.info(`📂 Verifying local module: ${extension}`);
+                log.debug(`→ Path: ${modulePath}`);
+                log.debug(`→ Command: launchql migrate verify db:pg:${database}`);
+                try {
+                    const client = new PgpmMigrate(opts.pg);
+                    const result = await client.verify({
+                        modulePath
+                    });
+                    if (result.failed.length > 0) {
+                        throw errors.OPERATION_FAILED({ operation: 'Verification', reason: `${result.failed.length} changes: ${result.failed.join(', ')}` });
+                    }
+                }
+                catch (verifyError) {
+                    log.error(`❌ Verification failed for module ${extension}`);
+                    throw errors.DEPLOYMENT_FAILED({ type: 'Verify', module: extension });
+                }
+            }
+        }
+        catch (e) {
+            log.error(`🛑 Error during verification: ${e instanceof Error ? e.message : e}`);
+            console.error(e);
+            throw errors.DEPLOYMENT_FAILED({ type: 'Verify', module: extension });
+        }
+    }
+    log.success(`✅ Verification complete for ${name}.`);
+    return extensions;
+};