@pgpmjs/core 7.13.0 → 7.15.0

package/esm/core/class/pgpm.js

@@ -9,6 +9,10 @@ import { parse } from 'parse-package-name';
 import path, { dirname, resolve } from 'path';
 import { getPgPool } from 'pg-cache';
 import yanse from 'yanse';
+import { resolveEffectiveModulePath } from '../../apply/materialize';
+import { hasApplySpec, readApplySpec } from '../../apply/apply-spec';
+import { isReuseSpec, resolveSharedModuleName } from '../../apply/reuse';
+import { APPLY_SPEC_FILE } from '../../apply/types';
 import { getAvailableExtensions } from '../../extensions/extensions';
 import { generatePlan, writePlan, writePlanFile } from '@pgpmjs/ast/files';
 import { getExtensionInfo, getExtensionName, getInstalledExtensions, parseControlFile, writeExtensions } from '@pgpmjs/ast/files';
@@ -18,7 +22,7 @@ import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
 import { isValidChangeName, isValidTagName, parseReference } from '@pgpmjs/ast/files/plan/validators';
 import { PgpmMigrate } from '../../migrate/client';
 import { getExtensionsAndModules, getExtensionsAndModulesChanges, latestChange, latestChangeAndVersion } from '../../modules/modules';
-import { packageModule } from '../../packaging/package';
+import { deployModuleFast, isBundledDeployResult } from '../../bundle/deploy-bundled';
 import { syncModuleVersions } from '../../packaging/sync-versions';
 import { resolveDependencies, resolveExtensionDependencies } from '../../resolution/deps';
 import { movePath } from '../../utils/fs';
@@ -242,11 +246,61 @@ export class PgpmPackage {
             }
         });
         // Parse the selected control files
-        return Array.from(selectedFiles.entries()).reduce((acc, [moduleName, file]) => {
+        const moduleMap = Array.from(selectedFiles.entries()).reduce((acc, [moduleName, file]) => {
             const module = parseControlFile(file, this.workspacePath);
             acc[moduleName] = module;
             return acc;
         }, {});
+        return this.addApplyModules(moduleMap, packageDirs);
+    }
+    /**
+     * Discover apply-spec proxy modules (`pgpm.apply.json`) and synthesize
+     * module-map entries for them so they participate in dependency resolution
+     * by name like any other module. A proxy needs no `.control` or `pgpm.plan`;
+     * its `requires` default to the source module's requires. Control-file
+     * modules win name collisions.
+     */
+    addApplyModules(moduleMap, packageDirs) {
+        const specFiles = [...new Set(packageDirs.flatMap(dir => glob.sync(globPattern(dir, `**/${APPLY_SPEC_FILE}`))))].filter((file) => !/node_modules/.test(file)).sort((a, b) => a.localeCompare(b));
+        for (const file of specFiles) {
+            let spec;
+            try {
+                spec = readApplySpec(path.dirname(file));
+            }
+            catch (err) {
+                console.warn(`Skipping invalid apply spec ${file}: ${err instanceof Error ? err.message : err}`);
+                continue;
+            }
+            const name = spec.name;
+            if (moduleMap[name])
+                continue;
+            const source = moduleMap[spec.source.module];
+            const relPath = path
+                .dirname(path.relative(this.workspacePath, file))
+                .replace(/\\/g, '/');
+            const baseRequires = spec.requires ?? source?.requires ?? [];
+            const version = spec.version ?? source?.version ?? '0.0.1';
+            if (isReuseSpec(spec)) {
+                // A reuse proxy expands into two modules that both materialize from
+                // this one directory: a shared module (deployed once, reused across
+                // tenants) and the per-tenant module that `requires` it. Multiple
+                // tenant proxies over the same source/shared/seed config resolve to
+                // the same deterministic shared name, so it is added at most once.
+                const sharedName = resolveSharedModuleName(spec);
+                if (!moduleMap[sharedName]) {
+                    moduleMap[sharedName] = { path: relPath, requires: baseRequires, version };
+                }
+                moduleMap[name] = {
+                    path: relPath,
+                    requires: [...baseRequires, sharedName],
+                    version
+                };
+            }
+            else {
+                moduleMap[name] = { path: relPath, requires: baseRequires, version };
+            }
+        }
+        return moduleMap;
     }
     getModuleMap() {
         if (!this.workspacePath)
@@ -1196,6 +1250,38 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
             external: external
         };
     }
+    /**
+     * Dependency closure for a named module. Proxy (apply-spec) modules have no
+     * pgpm.plan, so they resolve straight off the workspace module map instead
+     * of instantiating a module-rooted package.
+     */
+    getModuleExtensionsFor(name) {
+        const modules = this.getModuleMap();
+        if (!modules[name]) {
+            throw errors.MODULE_NOT_FOUND({ name });
+        }
+        const modulePath = resolve(this.workspacePath, modules[name].path);
+        if (hasApplySpec(modulePath)) {
+            return resolveExtensionDependencies(name, modules);
+        }
+        return this.getModuleProject(name).getModuleExtensions();
+    }
+    /**
+     * Directory the migration engine should run against for a named module:
+     * the module's own directory, or — for proxy (apply-spec) modules — the
+     * materialized transpiled instance.
+     */
+    async getEffectiveModulePathFor(name) {
+        const modules = this.getModuleMap();
+        if (!modules[name]) {
+            throw errors.MODULE_NOT_FOUND({ name });
+        }
+        const modulePath = resolve(this.workspacePath, modules[name].path);
+        if (hasApplySpec(modulePath)) {
+            return resolveEffectiveModulePath(name, modulePath, modules, this.workspacePath);
+        }
+        return this.getModuleProject(name).getModulePath();
+    }
     parsePackageTarget(target) {
         let name;
         let toChange;
@@ -1227,12 +1313,6 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
         const log = new Logger('deploy');
         const { name, toChange } = this.parsePackageTarget(target);
         if (recursive) {
-            // Cache for fast deployment
-            const deployFastCache = {};
-            const getCacheKey = (pg, name, database) => {
-                const { host, port, user } = pg ?? {};
-                return `${host}:${port}:${user}:${database}:${name}`;
-            };
             const modules = this.getModuleMap();
             let extensions;
             if (name === null) {
@@ -1240,8 +1320,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
                 extensions = await this.resolveWorkspaceExtensionDependencies();
             }
             else {
-                const moduleProject = this.getModuleProject(name);
-                extensions = moduleProject.getModuleExtensions();
+                extensions = this.getModuleExtensionsFor(name);
             }
             const pgPool = getPgPool(opts.pg);
             const targetDescription = name === null ? 'all modules' : name;
@@ -1254,52 +1333,24 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
                         await pgPool.query(msg);
                     }
                     else {
-                        const modulePath = resolve(this.workspacePath, modules[extension].path);
+                        const modulePath = await resolveEffectiveModulePath(extension, resolve(this.workspacePath, modules[extension].path), modules, this.workspacePath);
                         log.info(`📂 Deploying local module: ${extension}`);
-                        if (opts.deployment.fast) {
-                            const localProject = this.getModuleProject(extension);
-                            const cacheKey = getCacheKey(opts.pg, extension, opts.pg.database);
-                            if (opts.deployment.cache && deployFastCache[cacheKey]) {
-                                log.warn(`⚡ Using cached pkg for ${extension}.`);
-                                await pgPool.query(deployFastCache[cacheKey].sql);
+                        if (opts.deployment.fast || opts.deployment.bundled) {
+                            // Fast strategy: one-shot execution plus a bulk-written
+                            // pgpm_migrate ledger, from the module's verified bundle artifact
+                            // when it has one and from `deploy/` when it does not.
+                            const outcome = await deployModuleFast(modulePath, {
+                                config: opts.pg,
+                                logOnly: opts.deployment.logOnly,
+                                useTransaction: opts.deployment.useTx,
+                                hashMethod: opts.deployment.hashMethod
+                            });
+                            if (isBundledDeployResult(outcome)) {
                                 continue;
                             }
-                            let pkg;
-                            try {
-                                pkg = await packageModule(localProject.modulePath, {
-                                    usePlan: opts.deployment.usePlan,
-                                    extension: false
-                                });
-                            }
-                            catch (err) {
-                                const errorLines = [];
-                                errorLines.push(`❌ Failed to package module "${extension}" at path: ${modulePath}`);
-                                errorLines.push(`   Module Path: ${modulePath}`);
-                                errorLines.push(`   Workspace Path: ${this.workspacePath}`);
-                                errorLines.push(`   Error Code: ${err.code || 'N/A'}`);
-                                errorLines.push(`   Error Message: ${err.message || 'Unknown error'}`);
-                                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.error(errorLines.join('\n'));
-                                console.error(err);
-                                throw errors.DEPLOYMENT_FAILED({
-                                    type: 'Deployment',
-                                    module: extension
-                                });
-                            }
-                            await pgPool.query(pkg.sql);
-                            if (opts.deployment.cache) {
-                                deployFastCache[cacheKey] = pkg;
-                            }
+                            log.info(`↩️ Fast deploy unavailable for ${extension} (${outcome}); using per-change path.`);
                         }
-                        else {
+                        {
                             try {
                                 const client = new PgpmMigrate(opts.pg);
                                 // Only apply toChange to the target module, not its dependencies
@@ -1335,8 +1386,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
             if (name === null) {
                 throw errors.WORKSPACE_OPERATION_ERROR({ operation: 'deployment' });
             }
-            const moduleProject = this.getModuleProject(name);
-            const modulePath = moduleProject.getModulePath();
+            const modulePath = await this.getEffectiveModulePathFor(name);
             if (!modulePath) {
                 throw errors.PATH_NOT_FOUND({ path: name, type: 'module' });
             }
@@ -1403,7 +1453,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
                         }
                     }
                     else {
-                        const modulePath = resolve(this.workspacePath, modules[extension].path);
+                        const modulePath = await resolveEffectiveModulePath(extension, resolve(this.workspacePath, modules[extension].path), modules, this.workspacePath);
                         log.info(`📂 Reverting local module: ${extension}`);
                         try {
                             const client = new PgpmMigrate(opts.pg);
@@ -1436,8 +1486,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
             if (name === null) {
                 throw errors.WORKSPACE_OPERATION_ERROR({ operation: 'revert' });
             }
-            const moduleProject = this.getModuleProject(name);
-            const modulePath = moduleProject.getModulePath();
+            const modulePath = await this.getEffectiveModulePathFor(name);
             if (!modulePath) {
                 throw errors.PATH_NOT_FOUND({ path: name, type: 'module' });
             }
@@ -1464,8 +1513,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
                 extensions = await this.resolveWorkspaceExtensionDependencies();
             }
             else {
-                const moduleProject = this.getModuleProject(name);
-                extensions = moduleProject.getModuleExtensions();
+                extensions = this.getModuleExtensionsFor(name);
             }
             const pgPool = getPgPool(opts.pg);
             const targetDescription = name === null ? 'all modules' : name;
@@ -1478,7 +1526,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
                         await pgPool.query(query, [extension]);
                     }
                     else {
-                        const modulePath = resolve(this.workspacePath, modules[extension].path);
+                        const modulePath = await resolveEffectiveModulePath(extension, resolve(this.workspacePath, modules[extension].path), modules, this.workspacePath);
                         log.info(`📂 Verifying local module: ${extension}`);
                         try {
                             const client = new PgpmMigrate(opts.pg);
@@ -1510,8 +1558,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
             if (name === null) {
                 throw errors.WORKSPACE_OPERATION_ERROR({ operation: 'verification' });
             }
-            const moduleProject = this.getModuleProject(name);
-            const modulePath = moduleProject.getModulePath();
+            const modulePath = await this.getEffectiveModulePathFor(name);
             if (!modulePath) {
                 throw errors.PATH_NOT_FOUND({ path: name, type: 'module' });
             }

package/esm/index.js

@@ -16,6 +16,7 @@ export * from './core/boilerplate-scanner';
 // Re-export the module AST layer (moved to the @pgpmjs/ast leaf package)
 export * from '@pgpmjs/ast/files';
 export * from '@pgpmjs/ast/module';
+export * from './apply';
 export * from './bundle';
 export * from './refactor';
 export { cleanSql } from './migrate/clean';

package/esm/packaging/package.js

@@ -4,6 +4,7 @@ import { relative } from 'path';
 import { deparse } from 'pgsql-deparser';
 import { parse } from 'pgsql-parser';
 import { getExtensionName } from '@pgpmjs/ast/files';
+import { writeBundleArtifact } from '../bundle/artifact';
 import { resolve, resolveWithPlan } from '../resolution/resolve';
 import { transformProps } from './transform';
 const log = new Logger('package');
@@ -78,7 +79,7 @@ export const packageModule = async (packageDir, { usePlan = true, extension = tr
         throw e;
     }
 };
-export const writePackage = async ({ version, extension = true, usePlan = true, packageDir, outputDiff = false, }) => {
+export const writePackage = async ({ version, extension = true, usePlan = true, packageDir, outputDiff = false, bundle = true, }) => {
     const pkgPath = `${packageDir}/package.json`;
     const pkg = require(pkgPath);
     const extname = await getExtensionName(packageDir);
@@ -115,4 +116,10 @@ export const writePackage = async ({ version, extension = true, usePlan = true,
     const writePath = `${outPath}/${sqlFileName}`;
     writeFileSync(writePath, sql);
     log.success(`${relative(packageDir, writePath)} written`);
+    if (bundle) {
+        const bundlePath = await writeBundleArtifact(packageDir, version, {
+            createdWith: '@pgpmjs/core'
+        });
+        log.success(`${relative(packageDir, bundlePath)} written`);
+    }
 };

package/esm/projects/deploy.js

@@ -4,15 +4,12 @@ import { errors } from '@pgpmjs/types';
 import { resolve } from 'path';
 import * as path from 'path';
 import { getPgPool } from 'pg-cache';
+import { resolveEffectiveModulePath } from '../apply/materialize';
+import { hasApplySpec } from '../apply/apply-spec';
+import { deployModuleFast, isBundledDeployResult } from '../bundle/deploy-bundled';
 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}`;
-};
+import { resolveExtensionDependencies } from '../resolution/deps';
 const log = new Logger('deploy');
 export const deployProject = async (opts, name, database, pkg, toChange) => {
     const mergedOpts = getEnvOptions(opts);
@@ -23,9 +20,12 @@ export const deployProject = async (opts, name, database, pkg, toChange) => {
         throw errors.MODULE_NOT_FOUND({ name });
     }
     const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
-    const moduleProject = new PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
     log.info(`📦 Resolving dependencies for ${name}...`);
-    const extensions = moduleProject.getModuleExtensions();
+    // Proxy (apply-spec) modules have no pgpm.plan, so resolve straight off the
+    // workspace module map instead of instantiating a module-rooted package.
+    const extensions = hasApplySpec(modulePath)
+        ? resolveExtensionDependencies(name, modules)
+        : new PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir }).getModuleExtensions();
     const pgPool = getPgPool({ ...opts.pg, database });
     log.success(`🚀 Starting deployment to database ${database}...`);
     for (const extension of extensions.resolved) {
@@ -37,59 +37,32 @@ export const deployProject = async (opts, name, database, pkg, toChange) => {
                 await pgPool.query(msg);
             }
             else {
-                const modulePath = resolve(pkg.workspacePath, modules[extension].path);
+                const sourcePath = resolve(pkg.workspacePath, modules[extension].path);
+                const modulePath = await resolveEffectiveModulePath(extension, sourcePath, modules, pkg.workspacePath);
                 log.info(`📂 Deploying local module: ${extension}`);
                 log.debug(`→ Path: ${modulePath}`);
-                if (mergedOpts.deployment.fast) {
-                    // Use fast deployment strategy
-                    const localProject = new 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);
+                if (modulePath !== sourcePath) {
+                    log.info(`🔁 Applying transpiled module (spec in ${sourcePath})`);
+                }
+                // 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 deployModuleFast(modulePath, {
+                        config: { ...mergedOpts.pg, database },
+                        logOnly: mergedOpts.deployment.logOnly,
+                        useTransaction: mergedOpts.deployment.useTx,
+                        hashMethod: mergedOpts.deployment.hashMethod
+                    });
+                    if (isBundledDeployResult(outcome)) {
                         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;
-                    }
+                    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 {

package/esm/projects/revert.js

@@ -3,8 +3,11 @@ import { errors } from '@pgpmjs/types';
 import { resolve } from 'path';
 import * as path from 'path';
 import { getPgPool } from 'pg-cache';
+import { resolveEffectiveModulePath } from '../apply/materialize';
+import { hasApplySpec } from '../apply/apply-spec';
 import { PgpmPackage } from '../core/class/pgpm';
 import { PgpmMigrate } from '../migrate/client';
+import { resolveExtensionDependencies } from '../resolution/deps';
 const log = new Logger('revert');
 export const revertProject = async (opts, name, database, pkg, options) => {
     log.info(`🔍 Gathering modules from ${pkg.workspacePath}...`);
@@ -14,9 +17,12 @@ export const revertProject = async (opts, name, database, pkg, options) => {
         throw errors.MODULE_NOT_FOUND({ name });
     }
     const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
-    const moduleProject = new PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
     log.info(`📦 Resolving dependencies for ${name}...`);
-    const extensions = moduleProject.getModuleExtensions();
+    // Proxy (apply-spec) modules have no pgpm.plan, so resolve straight off the
+    // workspace module map instead of instantiating a module-rooted package.
+    const extensions = hasApplySpec(modulePath)
+        ? resolveExtensionDependencies(name, modules)
+        : new PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir }).getModuleExtensions();
     const pgPool = getPgPool({
         ...opts.pg,
         database
@@ -42,7 +48,8 @@ export const revertProject = async (opts, name, database, pkg, options) => {
                 }
             }
             else {
-                const modulePath = resolve(pkg.workspacePath, modules[extension].path);
+                const sourcePath = resolve(pkg.workspacePath, modules[extension].path);
+                const modulePath = await resolveEffectiveModulePath(extension, sourcePath, modules, pkg.workspacePath);
                 log.info(`📂 Reverting local module: ${extension}`);
                 log.debug(`→ Path: ${modulePath}`);
                 // Use new migration system

package/esm/projects/verify.js

@@ -3,8 +3,11 @@ import { errors } from '@pgpmjs/types';
 import { resolve } from 'path';
 import * as path from 'path';
 import { getPgPool } from 'pg-cache';
+import { resolveEffectiveModulePath } from '../apply/materialize';
+import { hasApplySpec } from '../apply/apply-spec';
 import { PgpmPackage } from '../core/class/pgpm';
 import { PgpmMigrate } from '../migrate/client';
+import { resolveExtensionDependencies } from '../resolution/deps';
 const log = new Logger('verify');
 export const verifyProject = async (opts, name, database, pkg, options) => {
     log.info(`🔍 Gathering modules from ${pkg.workspacePath}...`);
@@ -14,9 +17,12 @@ export const verifyProject = async (opts, name, database, pkg, options) => {
         throw errors.MODULE_NOT_FOUND({ name });
     }
     const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
-    const moduleProject = new PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });
     log.info(`📦 Resolving dependencies for ${name}...`);
-    const extensions = moduleProject.getModuleExtensions();
+    // Proxy (apply-spec) modules have no pgpm.plan, so resolve straight off the
+    // workspace module map instead of instantiating a module-rooted package.
+    const extensions = hasApplySpec(modulePath)
+        ? resolveExtensionDependencies(name, modules)
+        : new PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir }).getModuleExtensions();
     const pgPool = getPgPool({
         ...opts.pg,
         database
@@ -31,7 +37,8 @@ export const verifyProject = async (opts, name, database, pkg, options) => {
                 await pgPool.query(query, [extension]);
             }
             else {
-                const modulePath = resolve(pkg.workspacePath, modules[extension].path);
+                const sourcePath = resolve(pkg.workspacePath, modules[extension].path);
+                const modulePath = await resolveEffectiveModulePath(extension, sourcePath, modules, pkg.workspacePath);
                 log.info(`📂 Verifying local module: ${extension}`);
                 log.debug(`→ Path: ${modulePath}`);
                 log.debug(`→ Command: constructive migrate verify db:pg:${database}`);

package/index.d.ts

@@ -15,6 +15,7 @@ export * from './core/boilerplate-types';
 export * from './core/boilerplate-scanner';
 export * from '@pgpmjs/ast/files';
 export * from '@pgpmjs/ast/module';
+export * from './apply';
 export * from './bundle';
 export * from './refactor';
 export { cleanSql } from './migrate/clean';

package/index.js

@@ -33,6 +33,7 @@ __exportStar(require("./core/boilerplate-scanner"), exports);
 // Re-export the module AST layer (moved to the @pgpmjs/ast leaf package)
 __exportStar(require("@pgpmjs/ast/files"), exports);
 __exportStar(require("@pgpmjs/ast/module"), exports);
+__exportStar(require("./apply"), exports);
 __exportStar(require("./bundle"), exports);
 __exportStar(require("./refactor"), exports);
 var clean_1 = require("./migrate/clean");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/core",
-  "version": "7.13.0",
+  "version": "7.15.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PGPM Package and Migration Tools",
   "main": "index.js",
@@ -48,23 +48,24 @@
     "makage": "^0.3.0"
   },
   "dependencies": {
-    "@pgpmjs/ast": "^0.9.0",
-    "@pgpmjs/bundle": "^0.10.0",
-    "@pgpmjs/env": "^2.37.0",
+    "@pgpmjs/ast": "^0.9.2",
+    "@pgpmjs/bundle": "^0.12.0",
+    "@pgpmjs/env": "^2.38.0",
     "@pgpmjs/logger": "^2.22.0",
-    "@pgpmjs/server-utils": "^3.23.0",
-    "@pgpmjs/slice": "^0.9.0",
-    "@pgpmjs/types": "^2.45.0",
+    "@pgpmjs/server-utils": "^3.23.1",
+    "@pgpmjs/slice": "^0.10.1",
+    "@pgpmjs/transform": "^0.11.0",
+    "@pgpmjs/types": "^2.46.0",
     "csv-to-pg": "^4.8.0",
     "genomic": "^5.6.2",
     "glob": "^13.0.6",
     "parse-package-name": "^1.0.0",
     "pg": "^8.21.0",
-    "pg-cache": "^3.23.0",
+    "pg-cache": "^3.23.1",
     "pg-env": "^1.26.0",
     "pgsql-deparser": "^18.1.1",
     "pgsql-parser": "^18.1.1",
     "yanse": "^0.2.1"
   },
-  "gitHead": "72961803894504c1a9308f9c6c349ff7b48bbe14"
+  "gitHead": "5ef8341033a8fbd85841b770e996e468dd15333b"
 }

package/packaging/package.d.ts

@@ -9,6 +9,12 @@ interface PackageModuleOptions {
 interface WritePackageOptions extends PackageModuleOptions {
     version: string;
     packageDir: string;
+    /**
+     * Also emit the content-addressed bundle artifact
+     * `sql/<name>--<version>.bundle.tar.gz` (default true). It is what
+     * `deploy --bundled` consumes.
+     */
+    bundle?: boolean;
 }
 export interface MergeSqlOptions {
     /** Strip `TransactionStmt`/`CreateExtensionStmt` before deparsing (extension mode) */
@@ -38,5 +44,5 @@ export declare const packageModule: (packageDir: string, { usePlan, extension, p
     tree1?: string;
     tree2?: string;
 }>;
-export declare const writePackage: ({ version, extension, usePlan, packageDir, outputDiff, }: WritePackageOptions) => Promise<void>;
+export declare const writePackage: ({ version, extension, usePlan, packageDir, outputDiff, bundle, }: WritePackageOptions) => Promise<void>;
 export {};

package/packaging/package.js

@@ -7,6 +7,7 @@ const path_1 = require("path");
 const pgsql_deparser_1 = require("pgsql-deparser");
 const pgsql_parser_1 = require("pgsql-parser");
 const files_1 = require("@pgpmjs/ast/files");
+const artifact_1 = require("../bundle/artifact");
 const resolve_1 = require("../resolution/resolve");
 const transform_1 = require("./transform");
 const log = new logger_1.Logger('package');
@@ -84,7 +85,7 @@ const packageModule = async (packageDir, { usePlan = true, extension = true, pre
     }
 };
 exports.packageModule = packageModule;
-const writePackage = async ({ version, extension = true, usePlan = true, packageDir, outputDiff = false, }) => {
+const writePackage = async ({ version, extension = true, usePlan = true, packageDir, outputDiff = false, bundle = true, }) => {
     const pkgPath = `${packageDir}/package.json`;
     const pkg = require(pkgPath);
     const extname = await (0, files_1.getExtensionName)(packageDir);
@@ -121,5 +122,11 @@ const writePackage = async ({ version, extension = true, usePlan = true, package
     const writePath = `${outPath}/${sqlFileName}`;
     (0, fs_1.writeFileSync)(writePath, sql);
     log.success(`${(0, path_1.relative)(packageDir, writePath)} written`);
+    if (bundle) {
+        const bundlePath = await (0, artifact_1.writeBundleArtifact)(packageDir, version, {
+            createdWith: '@pgpmjs/core'
+        });
+        log.success(`${(0, path_1.relative)(packageDir, bundlePath)} written`);
+    }
 };
 exports.writePackage = writePackage;