@pgpmjs/core 3.0.0

package/modules/modules.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExtensionsAndModulesChanges = exports.getExtensionsAndModules = exports.latestChangeAndVersion = exports.latestChange = void 0;
+const files_1 = require("../files");
+const types_1 = require("@pgpmjs/types");
+/**
+ * Get the latest change from the pgpm.plan file for a specific module.
+ */
+const latestChange = (sqlmodule, modules, basePath) => {
+    const module = modules[sqlmodule];
+    if (!module) {
+        throw types_1.errors.MODULE_NOT_FOUND({ name: sqlmodule });
+    }
+    const planPath = `${basePath}/${module.path}/pgpm.plan`;
+    return (0, files_1.getLatestChange)(planPath);
+};
+exports.latestChange = latestChange;
+/**
+ * Get the latest change and version for a specific module.
+ */
+const latestChangeAndVersion = (sqlmodule, modules, basePath) => {
+    const module = modules[sqlmodule];
+    if (!module) {
+        throw types_1.errors.MODULE_NOT_FOUND({ name: sqlmodule });
+    }
+    const planPath = `${basePath}/${module.path}/pgpm.plan`;
+    const change = (0, files_1.getLatestChange)(planPath);
+    const pkg = require(`${basePath}/${module.path}/package.json`);
+    return { change, version: pkg.version };
+};
+exports.latestChangeAndVersion = latestChangeAndVersion;
+/**
+ * Get extensions and modules required by a specific module.
+ */
+const getExtensionsAndModules = (sqlmodule, modules) => {
+    const module = modules[sqlmodule];
+    if (!module) {
+        throw types_1.errors.MODULE_NOT_FOUND({ name: sqlmodule });
+    }
+    const native = module.requires.filter((req) => !Object.keys(modules).includes(req));
+    const sqitch = module.requires.filter((req) => Object.keys(modules).includes(req));
+    return { native, sqitch };
+};
+exports.getExtensionsAndModules = getExtensionsAndModules;
+/**
+ * Get extensions and modules with their latest changes and versions.
+ */
+const getExtensionsAndModulesChanges = (sqlmodule, modules, basePath) => {
+    const { native, sqitch } = (0, exports.getExtensionsAndModules)(sqlmodule, modules);
+    const sqitchWithDetails = sqitch.map((mod) => {
+        const { change, version } = (0, exports.latestChangeAndVersion)(mod, modules, basePath);
+        return { name: mod, latest: change, version };
+    });
+    return { native, sqitch: sqitchWithDetails };
+};
+exports.getExtensionsAndModulesChanges = getExtensionsAndModulesChanges;

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@pgpmjs/core",
+  "version": "3.0.0",
+  "author": "Constructive <developers@constructive.io>",
+  "description": "PGPM Package and Migration Tools",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "scripts": {
+    "copy": "npm run copy:pkg; npm run copy:sql",
+    "copy:pkg": "makage assets",
+    "copy:sql": "copyfiles -f src/migrate/sql/* dist/migrate/sql && copyfiles -f src/migrate/sql/* dist/esm/migrate/sql && copyfiles -f src/init/sql/* dist/init/sql && copyfiles -f src/init/sql/* dist/esm/init/sql",
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build && npm run copy",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "keywords": [
+    "database",
+    "migration",
+    "postgresql",
+    "pgpm",
+    "pgpmjs",
+    "schema",
+    "sqitch"
+  ],
+  "devDependencies": {
+    "@types/pg": "^8.16.0",
+    "copyfiles": "^2.4.1",
+    "makage": "^0.1.8"
+  },
+  "dependencies": {
+    "@pgpmjs/env": "^2.7.0",
+    "@pgpmjs/logger": "^1.3.0",
+    "@pgpmjs/server-utils": "^2.8.0",
+    "@pgpmjs/types": "^2.11.0",
+    "@pgsql/types": "^17.6.2",
+    "create-gen-app": "^0.3.3",
+    "csv-to-pg": "^2.0.10",
+    "glob": "^13.0.0",
+    "komoji": "^0.7.8",
+    "parse-package-name": "^1.0.0",
+    "pg": "^8.16.3",
+    "pg-cache": "^1.6.0",
+    "pg-env": "^1.2.1",
+    "pgsql-deparser": "^17.12.2",
+    "pgsql-parser": "^17.9.2",
+    "yanse": "^0.1.5"
+  },
+  "peerDependencies": {
+    "@pgsql/types": "^17.6.1"
+  },
+  "gitHead": "e4d5396a5d9154f4886176bb00c2b460b0f320e5"
+}

package/packaging/package.d.ts

@@ -0,0 +1,19 @@
+export declare const cleanTree: (tree: any) => any;
+interface PackageModuleOptions {
+    usePlan?: boolean;
+    extension?: boolean;
+    pretty?: boolean;
+    functionDelimiter?: string;
+}
+interface WritePackageOptions extends PackageModuleOptions {
+    version: string;
+    packageDir: string;
+}
+export declare const packageModule: (packageDir: string, { usePlan, extension, pretty, functionDelimiter }?: PackageModuleOptions) => Promise<{
+    sql: string;
+    diff?: boolean;
+    tree1?: string;
+    tree2?: string;
+}>;
+export declare const writePackage: ({ version, extension, usePlan, packageDir, }: WritePackageOptions) => Promise<void>;
+export {};

package/packaging/package.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writePackage = exports.packageModule = exports.cleanTree = void 0;
+const logger_1 = require("@pgpmjs/logger");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const pgsql_deparser_1 = require("pgsql-deparser");
+const pgsql_parser_1 = require("pgsql-parser");
+const files_1 = require("../files");
+const resolve_1 = require("../resolution/resolve");
+const transform_1 = require("./transform");
+const log = new logger_1.Logger('package');
+const noop = () => undefined;
+const cleanTree = (tree) => {
+    return (0, transform_1.transformProps)(tree, {
+        stmt_len: noop,
+        stmt_location: noop,
+        location: noop,
+    });
+};
+exports.cleanTree = cleanTree;
+const filterStatements = (stmts, extension) => {
+    if (!extension)
+        return stmts;
+    return stmts.filter(node => {
+        const stmt = node.stmt;
+        return !stmt.hasOwnProperty('TransactionStmt') &&
+            !stmt.hasOwnProperty('CreateExtensionStmt');
+    });
+};
+const packageModule = async (packageDir, { usePlan = true, extension = true, pretty = true, functionDelimiter = '$EOFCODE$' } = {}) => {
+    const resolveFn = usePlan ? resolve_1.resolveWithPlan : resolve_1.resolve;
+    const sql = resolveFn(packageDir);
+    if (!sql?.trim()) {
+        log.warn(`⚠️ No SQL generated for module at ${packageDir}. Skipping.`);
+        return { sql: '' };
+    }
+    const extname = (0, files_1.getExtensionName)(packageDir);
+    try {
+        const parsed = await (0, pgsql_parser_1.parse)(sql);
+        parsed.stmts = filterStatements(parsed.stmts, extension);
+        const topLine = extension
+            ? `\\echo Use "CREATE EXTENSION ${extname}" to load this file. \\quit\n`
+            : '';
+        const finalSql = await (0, pgsql_deparser_1.deparse)(parsed, {
+            pretty,
+            functionDelimiter
+        });
+        const tree1 = parsed.stmts;
+        const tree2 = await (0, pgsql_parser_1.parse)(finalSql);
+        const results = {
+            sql: `${topLine}${finalSql}`,
+        };
+        const diff = JSON.stringify((0, exports.cleanTree)(tree1)) !== JSON.stringify((0, exports.cleanTree)(tree2));
+        if (diff) {
+            results.diff = true;
+            results.tree1 = JSON.stringify((0, exports.cleanTree)(tree1), null, 2);
+            results.tree2 = JSON.stringify((0, exports.cleanTree)(tree2), null, 2);
+        }
+        return results;
+    }
+    catch (e) {
+        log.error(`❌ Failed to parse SQL for ${packageDir}`);
+        console.error(e);
+        throw e;
+    }
+};
+exports.packageModule = packageModule;
+const writePackage = async ({ version, extension = true, usePlan = true, packageDir, }) => {
+    const pkgPath = `${packageDir}/package.json`;
+    const pkg = require(pkgPath);
+    const extname = await (0, files_1.getExtensionName)(packageDir);
+    const makePath = `${packageDir}/Makefile`;
+    const controlPath = `${packageDir}/${extname}.control`;
+    const sqlFileName = `${extname}--${version}.sql`;
+    const Makefile = (0, fs_1.readFileSync)(makePath, 'utf-8');
+    const control = (0, fs_1.readFileSync)(controlPath, 'utf-8');
+    const { sql, diff, tree1, tree2 } = await (0, exports.packageModule)(packageDir, {
+        extension,
+        usePlan,
+    });
+    const outPath = extension ? `${packageDir}/sql` : `${packageDir}/out`;
+    (0, fs_1.rmSync)(outPath, { recursive: true, force: true });
+    (0, fs_1.mkdirSync)(outPath, { recursive: true });
+    if (extension) {
+        (0, fs_1.writeFileSync)(controlPath, control.replace(/default_version = '[0-9\.]+'/, `default_version = '${version}'`));
+        pkg.version = version;
+        (0, fs_1.writeFileSync)(pkgPath, JSON.stringify(pkg, null, 2));
+        const regex = new RegExp(`${extname}--[0-9.]+.sql`);
+        (0, fs_1.writeFileSync)(makePath, Makefile.replace(regex, sqlFileName));
+    }
+    if (diff) {
+        log.warn(`⚠️ SQL diff exists! Review the ${(0, path_1.relative)(packageDir, outPath)}/ folder.`);
+        // Uncomment if needed:
+        // writeFileSync(`${outPath}/orig.${sqlFileName}.tree.json`, tree1);
+        // writeFileSync(`${outPath}/parsed.${sqlFileName}.tree.json`, tree2);
+    }
+    const writePath = `${outPath}/${sqlFileName}`;
+    (0, fs_1.writeFileSync)(writePath, sql);
+    log.success(`${(0, path_1.relative)(packageDir, writePath)} written`);
+};
+exports.writePackage = writePackage;

package/packaging/transform.d.ts

@@ -0,0 +1,22 @@
+type TransformProps = {
+    [key: string]: ((value: any) => any) | {
+        [key: string]: any;
+    };
+};
+/**
+ * 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 declare const transformProps: (obj: any, props: TransformProps) => any;
+/**
+ * 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 declare const transform: (statement: string, props: TransformProps) => Promise<string>;
+export {};

package/packaging/transform.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = exports.transformProps = void 0;
+const pgsql_deparser_1 = require("pgsql-deparser");
+const pgsql_parser_1 = require("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.
+ */
+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] = (0, exports.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] = (0, exports.transformProps)(obj[attr], props);
+                        }
+                    }
+                }
+                else {
+                    copy[attr] = (0, exports.transformProps)(obj[attr], props);
+                }
+            }
+        }
+        return copy;
+    }
+    throw new Error("Unable to copy obj! Its type isn't supported.");
+};
+exports.transformProps = transformProps;
+/**
+ * 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.
+ */
+const transform = async (statement, props) => {
+    let tree = await (0, pgsql_parser_1.parse)(statement);
+    tree = (0, exports.transformProps)(tree, props);
+    return await (0, pgsql_deparser_1.deparse)(tree);
+};
+exports.transform = transform;

package/projects/deploy.d.ts

@@ -0,0 +1,8 @@
+import { PgpmOptions } from '@pgpmjs/types';
+import { PgpmPackage } from '../core/class/pgpm';
+interface Extensions {
+    resolved: string[];
+    external: string[];
+}
+export declare const deployProject: (opts: PgpmOptions, name: string, database: string, pkg: PgpmPackage, toChange?: string) => Promise<Extensions>;
+export {};

package/projects/deploy.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployProject = void 0;
+const env_1 = require("@pgpmjs/env");
+const logger_1 = require("@pgpmjs/logger");
+const types_1 = require("@pgpmjs/types");
+const path_1 = require("path");
+const path = __importStar(require("path"));
+const pg_cache_1 = require("pg-cache");
+const pgpm_1 = require("../core/class/pgpm");
+const client_1 = require("../migrate/client");
+const package_1 = require("../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_1.Logger('deploy');
+const deployProject = async (opts, name, database, pkg, toChange) => {
+    const mergedOpts = (0, env_1.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 types_1.errors.MODULE_NOT_FOUND({ name });
+    }
+    const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
+    const moduleProject = new pgpm_1.PgpmPackage(modulePath);
+    log.info(`📦 Resolving dependencies for ${name}...`);
+    const extensions = moduleProject.getModuleExtensions();
+    const pgPool = (0, pg_cache_1.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 = (0, path_1.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 pgpm_1.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 (0, package_1.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 types_1.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 client_1.PgpmMigrate(mergedOpts.pg);
+                        const result = await client.deploy({
+                            modulePath,
+                            toChange,
+                            useTransaction: mergedOpts.deployment.useTx,
+                            logOnly: mergedOpts.deployment.logOnly
+                        });
+                        if (result.failed) {
+                            throw types_1.errors.OPERATION_FAILED({ operation: 'Deployment', target: result.failed });
+                        }
+                    }
+                    catch (deployError) {
+                        log.error(`❌ Deployment failed for module ${extension}`);
+                        console.error(deployError);
+                        throw types_1.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 types_1.errors.DEPLOYMENT_FAILED({ type: 'Deployment', module: extension });
+        }
+    }
+    log.success(`✅ Deployment complete for ${name}.`);
+    return extensions;
+};
+exports.deployProject = deployProject;

package/projects/revert.d.ts

@@ -0,0 +1,15 @@
+import { PgpmOptions } from '@pgpmjs/types';
+import { PgpmPackage } from '../core/class/pgpm';
+interface Extensions {
+    resolved: string[];
+    external: string[];
+}
+export declare const revertProject: (opts: PgpmOptions, name: string, database: string, pkg: PgpmPackage, options?: {
+    useTransaction?: boolean;
+    /**
+     * Revert to a specific change (exclusive - this change will NOT be reverted)
+     * Can be a change name or a tag reference (e.g., '@v1.0.0')
+     */
+    toChange?: string;
+}) => Promise<Extensions>;
+export {};

package/projects/revert.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revertProject = void 0;
+const logger_1 = require("@pgpmjs/logger");
+const types_1 = require("@pgpmjs/types");
+const path_1 = require("path");
+const path = __importStar(require("path"));
+const pg_cache_1 = require("pg-cache");
+const pgpm_1 = require("../core/class/pgpm");
+const client_1 = require("../migrate/client");
+const log = new logger_1.Logger('revert');
+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 types_1.errors.MODULE_NOT_FOUND({ name });
+    }
+    const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
+    const moduleProject = new pgpm_1.PgpmPackage(modulePath);
+    log.info(`📦 Resolving dependencies for ${name}...`);
+    const extensions = moduleProject.getModuleExtensions();
+    const pgPool = (0, pg_cache_1.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 = (0, path_1.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 client_1.PgpmMigrate(opts.pg);
+                    const result = await client.revert({
+                        modulePath,
+                        toChange: options?.toChange,
+                        useTransaction: options?.useTransaction
+                    });
+                    if (result.failed) {
+                        throw types_1.errors.OPERATION_FAILED({ operation: 'Revert', target: result.failed });
+                    }
+                }
+                catch (revertError) {
+                    log.error(`❌ Revert failed for module ${extension}`);
+                    throw types_1.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 types_1.errors.DEPLOYMENT_FAILED({ type: 'Revert', module: extension });
+        }
+    }
+    log.success(`✅ Revert complete for ${name}.`);
+    return extensions;
+};
+exports.revertProject = revertProject;

package/projects/verify.d.ts

@@ -0,0 +1,8 @@
+import { PgpmOptions } from '@pgpmjs/types';
+import { PgpmPackage } from '../core/class/pgpm';
+interface Extensions {
+    resolved: string[];
+    external: string[];
+}
+export declare const verifyProject: (opts: PgpmOptions, name: string, database: string, pkg: PgpmPackage, options?: {}) => Promise<Extensions>;
+export {};