@pgpmjs/core 7.14.0 → 7.16.0

package/projects/deploy.js

@@ -42,16 +42,11 @@ const path = __importStar(require("path"));
 const pg_cache_1 = require("pg-cache");
 const materialize_1 = require("../apply/materialize");
 const apply_spec_1 = require("../apply/apply-spec");
+const deploy_bundled_1 = require("../bundle/deploy-bundled");
 const pgpm_1 = require("../core/class/pgpm");
+const extensions_1 = require("../extensions");
 const client_1 = require("../migrate/client");
-const package_1 = require("../packaging/package");
 const deps_1 = require("../resolution/deps");
-// 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);
@@ -69,14 +64,28 @@ const deployProject = async (opts, name, database, pkg, toChange) => {
         ? (0, deps_1.resolveExtensionDependencies)(name, modules)
         : new pgpm_1.PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir }).getModuleExtensions();
     const pgPool = (0, pg_cache_1.getPgPool)({ ...opts.pg, database });
+    // Local modules (in resolve order) that may carry an `extensions.json`
+    // declaring how an external extension should be installed (schema + grants).
+    const localModules = extensions.resolved.filter((m) => !extensions.external.includes(m));
+    const roleMap = (0, extensions_1.roleMapFromRoles)(mergedOpts.db?.roles);
     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);
+                const install = (0, extensions_1.findExtensionInstall)(extension, localModules, modules, pkg.workspacePath, { roleMap });
+                if (install) {
+                    log.info(`📥 Installing external extension (declarative): ${extension}`);
+                    for (const stmt of install.deploy) {
+                        log.debug(`> ${stmt}`);
+                        await pgPool.query(stmt);
+                    }
+                }
+                else {
+                    const msg = `CREATE EXTENSION IF NOT EXISTS "${extension}" CASCADE;`;
+                    log.info(`📥 Installing external extension: ${extension}`);
+                    log.debug(`> ${msg}`);
+                    await pgPool.query(msg);
+                }
             }
             else {
                 const sourcePath = (0, path_1.resolve)(pkg.workspacePath, modules[extension].path);
@@ -86,56 +95,25 @@ const deployProject = async (opts, name, database, pkg, toChange) => {
                 if (modulePath !== sourcePath) {
                     log.info(`🔁 Applying transpiled module (spec in ${sourcePath})`);
                 }
-                if (mergedOpts.deployment.fast) {
-                    // Use fast deployment strategy
-                    const localProject = new pgpm_1.PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
-                    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);
+                // The fast strategy is opt-in; everything else uses the per-change path.
+                if (mergedOpts.deployment.fast || mergedOpts.deployment.bundled) {
+                    // Fast strategy: execute the module in one shot AND record the
+                    // migration ledger, from the pre-built bundle artifact when one
+                    // verifies and from `deploy/` otherwise. If the semantics cannot be
+                    // honoured, fall through to the per-change migration path rather than
+                    // deploying without a ledger.
+                    const outcome = await (0, deploy_bundled_1.deployModuleFast)(modulePath, {
+                        config: { ...mergedOpts.pg, database },
+                        logOnly: mergedOpts.deployment.logOnly,
+                        useTransaction: mergedOpts.deployment.useTx,
+                        hashMethod: mergedOpts.deployment.hashMethod
+                    });
+                    if ((0, deploy_bundled_1.isBundledDeployResult)(outcome)) {
                         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;
-                    }
+                    log.info(`↩️ Fast deploy unavailable for ${extension} (${outcome}); using per-change path.`);
                 }
-                else {
+                {
                     // Use new migration system
                     log.debug(`→ Command: constructive migrate deploy db:pg:${database}`);
                     try {