@pgpmjs/core 3.1.4 → 3.2.1

package/README.md

@@ -64,7 +64,6 @@ Common issues and solutions for pgpm, PostgreSQL, and testing.
 * [@pgsql/enums](https://www.npmjs.com/package/@pgsql/enums): **🏷️ TypeScript enums** for PostgreSQL AST for safe and ergonomic parsing logic.
 * [@pgsql/types](https://www.npmjs.com/package/@pgsql/types): **📝 Type definitions** for PostgreSQL AST nodes in TypeScript.
 * [@pgsql/utils](https://www.npmjs.com/package/@pgsql/utils): **🛠️ AST utilities** for constructing and transforming PostgreSQL syntax trees.
-* [pg-ast](https://www.npmjs.com/package/pg-ast): **🔍 Low-level AST tools** and transformations for Postgres query structures.
 
 ### 🚀 API & Dev Tools
 

package/core/class/pgpm.d.ts

@@ -121,6 +121,60 @@ export declare class PgpmPackage {
       * and automatically adds it to the current module’s package.json dependencies.
       */
     installModules(...pkgstrs: string[]): Promise<void>;
+    /**
+     * Returns information about which of the specified modules are installed.
+     * Checks the module's package.json dependencies to determine installation status.
+     *
+     * @param moduleNames - Array of npm package names to check (e.g., '@pgpm/base32')
+     * @returns Object with installed (array of installed module names) and
+     *          installedVersions (map of module name to installed version)
+     */
+    modulesInstalled(moduleNames: string[]): {
+        installed: string[];
+        installedVersions: Record<string, string>;
+    };
+    /**
+     * Returns all installed pgpm modules from the module's package.json dependencies.
+     * Only returns dependencies that exist in the workspace extensions directory.
+     *
+     * @returns Object with installed module names and their versions
+     */
+    getInstalledModules(): {
+        installed: string[];
+        installedVersions: Record<string, string>;
+    };
+    /**
+     * Updates installed pgpm modules to their latest versions from npm.
+     * Re-installs each module to get the latest version.
+     * Also updates package.json for ALL modules in the workspace that reference the upgraded packages.
+     *
+     * Note: Extensions are installed globally in the workspace's extensions/ directory,
+     * so upgrading affects all modules that depend on the upgraded package.
+     *
+     * @param options - Options for the update operation
+     * @param options.modules - Specific modules to update (defaults to all installed modules)
+     * @param options.dryRun - If true, only returns what would be updated without making changes
+     * @returns Object with updated modules and their old/new versions
+     */
+    upgradeModules(options?: {
+        modules?: string[];
+        dryRun?: boolean;
+    }): Promise<{
+        updates: Array<{
+            name: string;
+            oldVersion: string;
+            newVersion: string | null;
+        }>;
+        affectedModules: string[];
+    }>;
+    /**
+     * Updates package.json dependencies for all modules in the workspace that reference
+     * the specified packages with their new versions.
+     *
+     * @param packageVersions - Map of package name to new version
+     * @returns Array of module names that were updated
+     */
+    private updateWorkspaceModuleVersions;
     /**
      * Get the set of modules that have been deployed to the database
      */

package/core/class/pgpm.js

@@ -848,6 +848,185 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
         const updatedDeps = Array.from(new Set([...currentDeps, ...newlyAdded])).sort();
         (0, files_2.writeExtensions)(this.modulePath, updatedDeps);
     }
+    /**
+     * Returns information about which of the specified modules are installed.
+     * Checks the module's package.json dependencies to determine installation status.
+     *
+     * @param moduleNames - Array of npm package names to check (e.g., '@pgpm/base32')
+     * @returns Object with installed (array of installed module names) and
+     *          installedVersions (map of module name to installed version)
+     */
+    modulesInstalled(moduleNames) {
+        this.ensureModule();
+        const pkgJsonPath = path_1.default.join(this.modulePath, 'package.json');
+        if (!fs_1.default.existsSync(pkgJsonPath)) {
+            return { installed: [], installedVersions: {} };
+        }
+        const pkgData = JSON.parse(fs_1.default.readFileSync(pkgJsonPath, 'utf-8'));
+        const dependencies = pkgData.dependencies || {};
+        const installed = [];
+        const installedVersions = {};
+        for (const moduleName of moduleNames) {
+            const { name } = (0, parse_package_name_1.parse)(moduleName);
+            if (dependencies[name]) {
+                installed.push(name);
+                installedVersions[name] = dependencies[name];
+            }
+        }
+        return { installed, installedVersions };
+    }
+    /**
+     * Returns all installed pgpm modules from the module's package.json dependencies.
+     * Only returns dependencies that exist in the workspace extensions directory.
+     *
+     * @returns Object with installed module names and their versions
+     */
+    getInstalledModules() {
+        this.ensureModule();
+        this.ensureWorkspace();
+        const pkgJsonPath = path_1.default.join(this.modulePath, 'package.json');
+        if (!fs_1.default.existsSync(pkgJsonPath)) {
+            return { installed: [], installedVersions: {} };
+        }
+        const pkgData = JSON.parse(fs_1.default.readFileSync(pkgJsonPath, 'utf-8'));
+        const dependencies = pkgData.dependencies || {};
+        const skitchExtDir = path_1.default.join(this.workspacePath, 'extensions');
+        const installed = [];
+        const installedVersions = {};
+        for (const [name, version] of Object.entries(dependencies)) {
+            const extPath = path_1.default.join(skitchExtDir, name);
+            if (fs_1.default.existsSync(extPath)) {
+                installed.push(name);
+                installedVersions[name] = version;
+            }
+        }
+        return { installed, installedVersions };
+    }
+    /**
+     * Updates installed pgpm modules to their latest versions from npm.
+     * Re-installs each module to get the latest version.
+     * Also updates package.json for ALL modules in the workspace that reference the upgraded packages.
+     *
+     * Note: Extensions are installed globally in the workspace's extensions/ directory,
+     * so upgrading affects all modules that depend on the upgraded package.
+     *
+     * @param options - Options for the update operation
+     * @param options.modules - Specific modules to update (defaults to all installed modules)
+     * @param options.dryRun - If true, only returns what would be updated without making changes
+     * @returns Object with updated modules and their old/new versions
+     */
+    async upgradeModules(options) {
+        this.ensureWorkspace();
+        this.ensureModule();
+        const { modules: specificModules, dryRun = false } = options || {};
+        const { installed, installedVersions } = this.getInstalledModules();
+        const modulesToUpdate = specificModules
+            ? installed.filter(m => specificModules.includes(m))
+            : installed;
+        if (modulesToUpdate.length === 0) {
+            logger.info('No modules to update.');
+            return { updates: [], affectedModules: [] };
+        }
+        const updates = [];
+        for (const moduleName of modulesToUpdate) {
+            const oldVersion = installedVersions[moduleName];
+            let newVersion = null;
+            try {
+                const result = (0, child_process_1.execSync)(`npm view ${moduleName} version`, {
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe']
+                }).trim();
+                newVersion = result || null;
+            }
+            catch {
+                logger.warn(`Could not fetch latest version for ${moduleName}`);
+            }
+            updates.push({
+                name: moduleName,
+                oldVersion,
+                newVersion
+            });
+        }
+        if (dryRun) {
+            logger.info('Dry run - no changes made.');
+            for (const update of updates) {
+                if (update.newVersion && update.newVersion !== update.oldVersion) {
+                    logger.info(`  ${update.name}: ${update.oldVersion} -> ${update.newVersion}`);
+                }
+                else if (update.newVersion === update.oldVersion) {
+                    logger.info(`  ${update.name}: ${update.oldVersion} (already up to date)`);
+                }
+                else {
+                    logger.warn(`  ${update.name}: ${update.oldVersion} (could not fetch latest)`);
+                }
+            }
+            const updatesWithChanges = updates.filter(u => u.newVersion && u.newVersion !== u.oldVersion);
+            return { updates: updatesWithChanges, affectedModules: [] };
+        }
+        const modulesToReinstall = updates
+            .filter(u => u.newVersion && u.newVersion !== u.oldVersion)
+            .map(u => u.name);
+        if (modulesToReinstall.length === 0) {
+            logger.success('All modules are already up to date.');
+            return { updates, affectedModules: [] };
+        }
+        logger.info(`Upgrading ${modulesToReinstall.length} module(s)...`);
+        await this.installModules(...modulesToReinstall);
+        const { installedVersions: newVersions } = this.getInstalledModules();
+        for (const update of updates) {
+            if (modulesToReinstall.includes(update.name)) {
+                update.newVersion = newVersions[update.name] || update.newVersion;
+            }
+        }
+        // Update package.json for ALL modules in the workspace that reference the upgraded packages
+        const affectedModules = this.updateWorkspaceModuleVersions(modulesToReinstall.reduce((acc, name) => {
+            const update = updates.find(u => u.name === name);
+            if (update?.newVersion) {
+                acc[name] = update.newVersion;
+            }
+            return acc;
+        }, {}));
+        if (affectedModules.length > 0) {
+            logger.info(`Updated package.json for ${affectedModules.length} module(s) in workspace.`);
+        }
+        logger.success('Upgrade complete.');
+        return { updates, affectedModules };
+    }
+    /**
+     * Updates package.json dependencies for all modules in the workspace that reference
+     * the specified packages with their new versions.
+     *
+     * @param packageVersions - Map of package name to new version
+     * @returns Array of module names that were updated
+     */
+    updateWorkspaceModuleVersions(packageVersions) {
+        this.ensureWorkspace();
+        const moduleMap = this.getModuleMap();
+        const affectedModules = [];
+        for (const [moduleName, moduleInfo] of Object.entries(moduleMap)) {
+            const modulePath = path_1.default.resolve(this.workspacePath, moduleInfo.path);
+            const pkgJsonPath = path_1.default.join(modulePath, 'package.json');
+            if (!fs_1.default.existsSync(pkgJsonPath)) {
+                continue;
+            }
+            const pkgData = JSON.parse(fs_1.default.readFileSync(pkgJsonPath, 'utf-8'));
+            const dependencies = pkgData.dependencies || {};
+            let updated = false;
+            for (const [pkgName, newVersion] of Object.entries(packageVersions)) {
+                if (dependencies[pkgName] && dependencies[pkgName] !== newVersion) {
+                    dependencies[pkgName] = newVersion;
+                    updated = true;
+                }
+            }
+            if (updated) {
+                pkgData.dependencies = sortObjectByKey(dependencies);
+                fs_1.default.writeFileSync(pkgJsonPath, JSON.stringify(pkgData, null, 2));
+                affectedModules.push(moduleName);
+                logger.info(`  Updated ${moduleName}/package.json`);
+            }
+        }
+        return affectedModules;
+    }
     // ──────────────── Package Operations ────────────────
     /**
      * Get the set of modules that have been deployed to the database

package/esm/core/class/pgpm.js

@@ -809,6 +809,185 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
         const updatedDeps = Array.from(new Set([...currentDeps, ...newlyAdded])).sort();
         writeExtensions(this.modulePath, updatedDeps);
     }
+    /**
+     * Returns information about which of the specified modules are installed.
+     * Checks the module's package.json dependencies to determine installation status.
+     *
+     * @param moduleNames - Array of npm package names to check (e.g., '@pgpm/base32')
+     * @returns Object with installed (array of installed module names) and
+     *          installedVersions (map of module name to installed version)
+     */
+    modulesInstalled(moduleNames) {
+        this.ensureModule();
+        const pkgJsonPath = path.join(this.modulePath, 'package.json');
+        if (!fs.existsSync(pkgJsonPath)) {
+            return { installed: [], installedVersions: {} };
+        }
+        const pkgData = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+        const dependencies = pkgData.dependencies || {};
+        const installed = [];
+        const installedVersions = {};
+        for (const moduleName of moduleNames) {
+            const { name } = parse(moduleName);
+            if (dependencies[name]) {
+                installed.push(name);
+                installedVersions[name] = dependencies[name];
+            }
+        }
+        return { installed, installedVersions };
+    }
+    /**
+     * Returns all installed pgpm modules from the module's package.json dependencies.
+     * Only returns dependencies that exist in the workspace extensions directory.
+     *
+     * @returns Object with installed module names and their versions
+     */
+    getInstalledModules() {
+        this.ensureModule();
+        this.ensureWorkspace();
+        const pkgJsonPath = path.join(this.modulePath, 'package.json');
+        if (!fs.existsSync(pkgJsonPath)) {
+            return { installed: [], installedVersions: {} };
+        }
+        const pkgData = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+        const dependencies = pkgData.dependencies || {};
+        const skitchExtDir = path.join(this.workspacePath, 'extensions');
+        const installed = [];
+        const installedVersions = {};
+        for (const [name, version] of Object.entries(dependencies)) {
+            const extPath = path.join(skitchExtDir, name);
+            if (fs.existsSync(extPath)) {
+                installed.push(name);
+                installedVersions[name] = version;
+            }
+        }
+        return { installed, installedVersions };
+    }
+    /**
+     * Updates installed pgpm modules to their latest versions from npm.
+     * Re-installs each module to get the latest version.
+     * Also updates package.json for ALL modules in the workspace that reference the upgraded packages.
+     *
+     * Note: Extensions are installed globally in the workspace's extensions/ directory,
+     * so upgrading affects all modules that depend on the upgraded package.
+     *
+     * @param options - Options for the update operation
+     * @param options.modules - Specific modules to update (defaults to all installed modules)
+     * @param options.dryRun - If true, only returns what would be updated without making changes
+     * @returns Object with updated modules and their old/new versions
+     */
+    async upgradeModules(options) {
+        this.ensureWorkspace();
+        this.ensureModule();
+        const { modules: specificModules, dryRun = false } = options || {};
+        const { installed, installedVersions } = this.getInstalledModules();
+        const modulesToUpdate = specificModules
+            ? installed.filter(m => specificModules.includes(m))
+            : installed;
+        if (modulesToUpdate.length === 0) {
+            logger.info('No modules to update.');
+            return { updates: [], affectedModules: [] };
+        }
+        const updates = [];
+        for (const moduleName of modulesToUpdate) {
+            const oldVersion = installedVersions[moduleName];
+            let newVersion = null;
+            try {
+                const result = execSync(`npm view ${moduleName} version`, {
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe']
+                }).trim();
+                newVersion = result || null;
+            }
+            catch {
+                logger.warn(`Could not fetch latest version for ${moduleName}`);
+            }
+            updates.push({
+                name: moduleName,
+                oldVersion,
+                newVersion
+            });
+        }
+        if (dryRun) {
+            logger.info('Dry run - no changes made.');
+            for (const update of updates) {
+                if (update.newVersion && update.newVersion !== update.oldVersion) {
+                    logger.info(`  ${update.name}: ${update.oldVersion} -> ${update.newVersion}`);
+                }
+                else if (update.newVersion === update.oldVersion) {
+                    logger.info(`  ${update.name}: ${update.oldVersion} (already up to date)`);
+                }
+                else {
+                    logger.warn(`  ${update.name}: ${update.oldVersion} (could not fetch latest)`);
+                }
+            }
+            const updatesWithChanges = updates.filter(u => u.newVersion && u.newVersion !== u.oldVersion);
+            return { updates: updatesWithChanges, affectedModules: [] };
+        }
+        const modulesToReinstall = updates
+            .filter(u => u.newVersion && u.newVersion !== u.oldVersion)
+            .map(u => u.name);
+        if (modulesToReinstall.length === 0) {
+            logger.success('All modules are already up to date.');
+            return { updates, affectedModules: [] };
+        }
+        logger.info(`Upgrading ${modulesToReinstall.length} module(s)...`);
+        await this.installModules(...modulesToReinstall);
+        const { installedVersions: newVersions } = this.getInstalledModules();
+        for (const update of updates) {
+            if (modulesToReinstall.includes(update.name)) {
+                update.newVersion = newVersions[update.name] || update.newVersion;
+            }
+        }
+        // Update package.json for ALL modules in the workspace that reference the upgraded packages
+        const affectedModules = this.updateWorkspaceModuleVersions(modulesToReinstall.reduce((acc, name) => {
+            const update = updates.find(u => u.name === name);
+            if (update?.newVersion) {
+                acc[name] = update.newVersion;
+            }
+            return acc;
+        }, {}));
+        if (affectedModules.length > 0) {
+            logger.info(`Updated package.json for ${affectedModules.length} module(s) in workspace.`);
+        }
+        logger.success('Upgrade complete.');
+        return { updates, affectedModules };
+    }
+    /**
+     * Updates package.json dependencies for all modules in the workspace that reference
+     * the specified packages with their new versions.
+     *
+     * @param packageVersions - Map of package name to new version
+     * @returns Array of module names that were updated
+     */
+    updateWorkspaceModuleVersions(packageVersions) {
+        this.ensureWorkspace();
+        const moduleMap = this.getModuleMap();
+        const affectedModules = [];
+        for (const [moduleName, moduleInfo] of Object.entries(moduleMap)) {
+            const modulePath = path.resolve(this.workspacePath, moduleInfo.path);
+            const pkgJsonPath = path.join(modulePath, 'package.json');
+            if (!fs.existsSync(pkgJsonPath)) {
+                continue;
+            }
+            const pkgData = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+            const dependencies = pkgData.dependencies || {};
+            let updated = false;
+            for (const [pkgName, newVersion] of Object.entries(packageVersions)) {
+                if (dependencies[pkgName] && dependencies[pkgName] !== newVersion) {
+                    dependencies[pkgName] = newVersion;
+                    updated = true;
+                }
+            }
+            if (updated) {
+                pkgData.dependencies = sortObjectByKey(dependencies);
+                fs.writeFileSync(pkgJsonPath, JSON.stringify(pkgData, null, 2));
+                affectedModules.push(moduleName);
+                logger.info(`  Updated ${moduleName}/package.json`);
+            }
+        }
+        return affectedModules;
+    }
     // ──────────────── Package Operations ────────────────
     /**
      * Get the set of modules that have been deployed to the database

package/esm/export/export-meta.js

@@ -13,7 +13,7 @@ const config = {
     },
     database_extension: {
         schema: 'collections_public',
-        table: 'database_extensions',
+        table: 'database_extension',
         fields: {
             name: 'text',
             database_id: 'uuid'
@@ -224,6 +224,7 @@ export const exportMeta = async ({ opts, dbname, database_id }) => {
     await queryAndParse('database', `SELECT * FROM collections_public.database WHERE id = $1`);
     await queryAndParse('schema', `SELECT * FROM collections_public.schema WHERE database_id = $1`);
     await queryAndParse('table', `SELECT * FROM collections_public.table WHERE database_id = $1`);
+    await queryAndParse('field', `SELECT * FROM collections_public.field WHERE database_id = $1`);
     await queryAndParse('domains', `SELECT * FROM meta_public.domains WHERE database_id = $1`);
     await queryAndParse('apis', `SELECT * FROM meta_public.apis WHERE database_id = $1`);
     await queryAndParse('sites', `SELECT * FROM meta_public.sites WHERE database_id = $1`);

package/export/export-meta.js

@@ -16,7 +16,7 @@ const config = {
     },
     database_extension: {
         schema: 'collections_public',
-        table: 'database_extensions',
+        table: 'database_extension',
         fields: {
             name: 'text',
             database_id: 'uuid'
@@ -227,6 +227,7 @@ const exportMeta = async ({ opts, dbname, database_id }) => {
     await queryAndParse('database', `SELECT * FROM collections_public.database WHERE id = $1`);
     await queryAndParse('schema', `SELECT * FROM collections_public.schema WHERE database_id = $1`);
     await queryAndParse('table', `SELECT * FROM collections_public.table WHERE database_id = $1`);
+    await queryAndParse('field', `SELECT * FROM collections_public.field WHERE database_id = $1`);
     await queryAndParse('domains', `SELECT * FROM meta_public.domains WHERE database_id = $1`);
     await queryAndParse('apis', `SELECT * FROM meta_public.apis WHERE database_id = $1`);
     await queryAndParse('sites', `SELECT * FROM meta_public.sites WHERE database_id = $1`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/core",
-  "version": "3.1.4",
+  "version": "3.2.1",
   "author": "Constructive <developers@constructive.io>",
   "description": "PGPM Package and Migration Tools",
   "main": "index.js",
@@ -49,9 +49,9 @@
   "dependencies": {
     "@pgpmjs/env": "^2.8.8",
     "@pgpmjs/logger": "^1.3.5",
-    "@pgpmjs/server-utils": "^2.8.8",
+    "@pgpmjs/server-utils": "^2.8.9",
     "@pgpmjs/types": "^2.12.6",
-    "create-gen-app": "^0.6.0",
+    "create-gen-app": "^0.6.2",
     "csv-to-pg": "^2.0.10",
     "glob": "^13.0.0",
     "komoji": "^0.7.11",
@@ -59,9 +59,9 @@
     "pg": "^8.16.3",
     "pg-cache": "^1.6.9",
     "pg-env": "^1.2.4",
-    "pgsql-deparser": "^17.12.2",
-    "pgsql-parser": "^17.9.2",
+    "pgsql-deparser": "^17.13.0",
+    "pgsql-parser": "^17.9.3",
     "yanse": "^0.1.8"
   },
-  "gitHead": "fc182ff9e4c4745a3e86eda6d58e3b0061f36564"
+  "gitHead": "976cc9e0e09201c7df40518a1797f4178fc21c2c"
 }