@pgpmjs/core 7.11.1 → 7.14.0

package/esm/apply/apply-spec.js

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync } from 'fs';
+import { basename, dirname, join } from 'path';
+import { APPLY_SPEC_FILE } from './types';
+/** Whether a module directory is an apply-spec proxy module. */
+export function hasApplySpec(moduleDir) {
+    return existsSync(join(moduleDir, APPLY_SPEC_FILE));
+}
+/**
+ * Read, validate, and normalize a proxy module's `pgpm.apply.json`.
+ *
+ * Normalizations: `source` is expanded to its object form and `name` defaults
+ * to the proxy directory's name.
+ *
+ * @throws when the file is missing, unparsable, or structurally invalid.
+ */
+export function readApplySpec(moduleDir) {
+    const specPath = join(moduleDir, APPLY_SPEC_FILE);
+    if (!existsSync(specPath)) {
+        throw new Error(`No ${APPLY_SPEC_FILE} found in ${moduleDir}`);
+    }
+    return parseApplySpec(readFileSync(specPath, 'utf-8'), specPath);
+}
+/** In-memory core of {@link readApplySpec}. */
+export function parseApplySpec(content, specPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse ${specPath}: ${err instanceof Error ? err.message : err}`);
+    }
+    const source = typeof parsed?.source === 'string' ? { module: parsed.source } : parsed?.source;
+    if (!source || typeof source.module !== 'string' || !source.module) {
+        throw new Error(`${specPath}: "source" (source module name, or { "module": ... }) is required`);
+    }
+    const hasSchemas = parsed.schemas !== undefined;
+    if (hasSchemas) {
+        if (typeof parsed.schemas !== 'object' ||
+            Array.isArray(parsed.schemas) ||
+            Object.keys(parsed.schemas).length === 0 ||
+            Object.entries(parsed.schemas).some(([from, to]) => typeof from !== 'string' || typeof to !== 'string' || !from || !to)) {
+            throw new Error(`${specPath}: "schemas" must be a non-empty string → string map`);
+        }
+    }
+    const ROUTE_KINDS = ['table', 'view', 'function', 'procedure', 'type'];
+    const hasRoute = parsed.route !== undefined;
+    if (hasRoute) {
+        if (!Array.isArray(parsed.route) || parsed.route.length === 0) {
+            throw new Error(`${specPath}: "route" must be a non-empty array of route entries`);
+        }
+        for (const entry of parsed.route) {
+            if (!entry ||
+                typeof entry !== 'object' ||
+                typeof entry.fromSchema !== 'string' ||
+                !entry.fromSchema ||
+                typeof entry.name !== 'string' ||
+                !entry.name ||
+                typeof entry.toSchema !== 'string' ||
+                !entry.toSchema ||
+                !ROUTE_KINDS.includes(entry.kind)) {
+                throw new Error(`${specPath}: each "route" entry needs { fromSchema, kind (${ROUTE_KINDS.join('|')}), name, toSchema } as non-empty strings`);
+            }
+        }
+    }
+    if (!hasSchemas && !hasRoute) {
+        throw new Error(`${specPath}: at least one of "schemas" (string → string map) or "route" (object routes) is required`);
+    }
+    const name = parsed.name ?? basename(dirname(specPath));
+    if (typeof name !== 'string' || !name) {
+        throw new Error(`${specPath}: "name" must be a non-empty string`);
+    }
+    if (name === source.module) {
+        throw new Error(`${specPath}: apply module "${name}" cannot apply itself`);
+    }
+    const requires = parsed.requires;
+    if (requires !== undefined &&
+        (!Array.isArray(requires) || requires.some((r) => typeof r !== 'string' || !r))) {
+        throw new Error(`${specPath}: "requires" must be an array of module names`);
+    }
+    if (requires?.includes(source.module)) {
+        throw new Error(`${specPath}: "requires" must not include the source module "${source.module}" — ` +
+            `it is source material, not a runtime dependency`);
+    }
+    return { ...parsed, name, source, requires };
+}

package/esm/apply/index.js

@@ -0,0 +1,3 @@
+export * from './materialize';
+export * from './apply-spec';
+export * from './types';

package/esm/apply/materialize.js

@@ -0,0 +1,116 @@
+import { mkdtempSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, resolve } from 'path';
+import { bundleFromModule, materializeBundle, transpileBundle, verifyBundle } from '@pgpmjs/bundle';
+import { loadModule, makeSchemaTranspiler } from '@pgpmjs/transform';
+import { hasApplySpec, readApplySpec } from './apply-spec';
+// Functions that take a bare schema name as a string-literal first argument.
+// The AST pass only remaps dotted literals ('schema.object'); these helpers
+// (ubiquitous in verify scripts) name the schema alone, so a string-level
+// pre-pass remaps them.
+const SCHEMA_NAME_LITERAL_FUNCS = ['verify_schema', 'has_schema_privilege'];
+const schemaNameLiteralPass = (content, schemaMapping) => {
+    const pattern = new RegExp(`\\b(${SCHEMA_NAME_LITERAL_FUNCS.join('|')})\\s*\\(\\s*'([^']+)'`, 'gi');
+    return content.replace(pattern, (match, _fn, schema) => {
+        const mapped = schemaMapping.get(schema);
+        return mapped ? match.replace(`'${schema}'`, `'${mapped}'`) : match;
+    });
+};
+/**
+ * Transpile a source module per an apply spec and materialize the result as a
+ * deployable module directory carrying the instance's identity.
+ *
+ * Pure pipeline over existing primitives: `bundleFromModule` →
+ * `transpileBundle(makeSchemaTranspiler)` → `verifyBundle` →
+ * `materializeBundle`. Deterministic — identical source + spec always produce
+ * an identical bundle (and digest), which is what makes verify/revert able to
+ * re-derive the exact deployed artifact.
+ */
+export async function materializeApplyModule(options) {
+    const { sourceDir, spec } = options;
+    const instanceName = spec.name;
+    // the schema transpiler's SQL/PLpgSQL parser is WASM-backed and needs a
+    // one-time async init (idempotent)
+    await loadModule();
+    const source = bundleFromModule(sourceDir);
+    if (spec.source.bundleDigest && spec.source.bundleDigest !== source.manifest.digest) {
+        throw new Error(`Apply spec for "${instanceName}" pins source bundle digest ${spec.source.bundleDigest}, ` +
+            `but the installed source "${spec.source.module}" hashes to ${source.manifest.digest}. ` +
+            `Reinstall the pinned version or update the spec.`);
+    }
+    // Every distinct target schema is treated as "may already exist": apply
+    // deploys into consumer-chosen namespaces that can pre-exist (a shared schema,
+    // another tenant), so `CREATE SCHEMA` is emitted idempotently. This is what
+    // lets the same source apply cleanly whether or not the destination exists.
+    const targetSchemas = [
+        ...new Set([
+            ...Object.values(spec.schemas ?? {}),
+            ...(spec.route ?? []).map(r => r.toSchema)
+        ])
+    ];
+    const { renameChange, transformScript, result } = makeSchemaTranspiler({
+        schemaMap: spec.schemas,
+        routes: spec.route,
+        transform: {
+            prePasses: [schemaNameLiteralPass],
+            assumeSchemasExist: targetSchemas
+        }
+    });
+    const transpiled = transpileBundle(source, {
+        renameChange,
+        transformScript,
+        renameModule: instanceName,
+        provenance: {
+            appliedFrom: spec.source.module,
+            ...(spec.source.package ? { sourcePackage: spec.source.package } : {}),
+            ...(spec.source.version ? { sourceVersion: spec.source.version } : {})
+        }
+    });
+    if (result.errors.length > 0) {
+        const detail = result.errors.map(e => `${e.file}: ${e.error}`).join('; ');
+        throw new Error(`Apply transpile of "${spec.source.module}" as "${instanceName}" failed: ${detail}`);
+    }
+    const issues = verifyBundle(transpiled);
+    if (issues.length > 0) {
+        throw new Error(`Transpiled bundle for "${instanceName}" failed integrity verification: ` +
+            issues.map(i => i.kind).join(', '));
+    }
+    const outDir = options.outDir ?? mkdtempSync(join(tmpdir(), `pgpm-apply-${instanceName}-`));
+    materializeBundle(transpiled, outDir);
+    return { bundle: transpiled, outDir };
+}
+// One materialization per proxy path per process: the pipeline is
+// deterministic, so re-deriving within a process is pure waste.
+const materializedCache = new Map();
+/**
+ * Deploy-path dispatch seam: given a resolved module's directory, return the
+ * directory the migration engine should actually run against.
+ *
+ * Non-proxy modules pass through unchanged. For proxy modules (directories
+ * carrying a `pgpm.apply.json`), the source module is located in the workspace
+ * module map, transpiled per the spec, and materialized to a cached temp dir
+ * carrying the instance's identity.
+ */
+export async function resolveEffectiveModulePath(moduleName, modulePath, moduleMap, workspacePath) {
+    if (!hasApplySpec(modulePath))
+        return modulePath;
+    const cached = materializedCache.get(modulePath);
+    if (cached)
+        return cached;
+    const spec = readApplySpec(modulePath);
+    const sourceModule = moduleMap[spec.source.module];
+    if (!sourceModule) {
+        throw new Error(`Apply spec in "${moduleName}" references source module "${spec.source.module}", ` +
+            `which was not found in the workspace. Run \`pgpm install\` to install it` +
+            (spec.source.package ? ` (${spec.source.package})` : '') +
+            `.`);
+    }
+    const sourceDir = resolve(workspacePath, sourceModule.path);
+    const { outDir } = await materializeApplyModule({ sourceDir, spec });
+    materializedCache.set(modulePath, outDir);
+    return outDir;
+}
+/** Test seam: clear the per-process materialization cache. */
+export function clearApplyMaterializationCache() {
+    materializedCache.clear();
+}

package/esm/apply/types.js

@@ -0,0 +1,14 @@
+/**
+ * The apply-spec ("proxy module") types.
+ *
+ * A proxy module is a directory containing a single `pgpm.apply.json` file:
+ * "apply <source module> transpiled with this schema map, under my name". It
+ * needs no `.control`, no `pgpm.plan`, and no deploy/revert/verify scripts —
+ * workspace discovery synthesizes a module entry from the spec, so the proxy
+ * participates in dependency resolution by name exactly like a regular
+ * module. At deploy/verify/revert time the engine transpiles the source
+ * module in memory and runs the normal migration path against the result;
+ * transpiled code is never committed.
+ */
+/** File name of the apply spec inside a proxy module directory. */
+export const APPLY_SPEC_FILE = 'pgpm.apply.json';

package/esm/core/class/pgpm.js

@@ -9,6 +9,9 @@ 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 { 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';
@@ -242,11 +245,44 @@ 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];
+            moduleMap[name] = {
+                path: path
+                    .dirname(path.relative(this.workspacePath, file))
+                    .replace(/\\/g, '/'),
+                requires: spec.requires ?? source?.requires ?? [],
+                version: spec.version ?? source?.version ?? '0.0.1'
+            };
+        }
+        return moduleMap;
     }
     getModuleMap() {
         if (!this.workspacePath)
@@ -1196,6 +1232,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;
@@ -1240,8 +1308,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,10 +1321,9 @@ ${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}.`);
@@ -1266,7 +1332,7 @@ ${dependencies.length > 0 ? dependencies.map(dep => `-- requires: ${dep}`).join(
                             }
                             let pkg;
                             try {
-                                pkg = await packageModule(localProject.modulePath, {
+                                pkg = await packageModule(modulePath, {
                                     usePlan: opts.deployment.usePlan,
                                     extension: false
                                 });
@@ -1335,8 +1401,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 +1468,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 +1501,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 +1528,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 +1541,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 +1573,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/projects/deploy.js

@@ -4,9 +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 { PgpmPackage } from '../core/class/pgpm';
 import { PgpmMigrate } from '../migrate/client';
 import { packageModule } from '../packaging/package';
+import { resolveExtensionDependencies } from '../resolution/deps';
 // Cache for fast deployment
 const deployFastCache = {};
 const getCacheKey = (pg, name, database) => {
@@ -23,9 +26,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,9 +43,13 @@ 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 (modulePath !== sourcePath) {
+                    log.info(`🔁 Applying transpiled module (spec in ${sourcePath})`);
+                }
                 if (mergedOpts.deployment.fast) {
                     // Use fast deployment strategy
                     const localProject = new PgpmPackage(modulePath, { extensionsDir: pkg.extensionsDir });

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.11.1",
+  "version": "7.14.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.7.1",
-    "@pgpmjs/bundle": "^0.8.1",
-    "@pgpmjs/env": "^2.35.1",
-    "@pgpmjs/logger": "^2.20.0",
-    "@pgpmjs/server-utils": "^3.21.1",
-    "@pgpmjs/slice": "^0.7.1",
-    "@pgpmjs/types": "^2.43.1",
-    "csv-to-pg": "^4.6.0",
+    "@pgpmjs/ast": "^0.9.1",
+    "@pgpmjs/bundle": "^0.11.0",
+    "@pgpmjs/env": "^2.37.0",
+    "@pgpmjs/logger": "^2.22.0",
+    "@pgpmjs/server-utils": "^3.23.0",
+    "@pgpmjs/slice": "^0.10.0",
+    "@pgpmjs/transform": "^0.10.0",
+    "@pgpmjs/types": "^2.45.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.21.1",
-    "pg-env": "^1.24.0",
+    "pg-cache": "^3.23.0",
+    "pg-env": "^1.26.0",
     "pgsql-deparser": "^18.1.1",
     "pgsql-parser": "^18.1.1",
     "yanse": "^0.2.1"
   },
-  "gitHead": "37e83eb66e9d13d0d4d8ac3b36b5ebe394b84a43"
+  "gitHead": "d85911699e8a50a9fdfeb7506195442525c1f238"
 }

package/projects/deploy.js

@@ -40,9 +40,12 @@ const types_1 = require("@pgpmjs/types");
 const path_1 = require("path");
 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 pgpm_1 = require("../core/class/pgpm");
 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) => {
@@ -59,9 +62,12 @@ const deployProject = async (opts, name, database, pkg, toChange) => {
         throw types_1.errors.MODULE_NOT_FOUND({ name });
     }
     const modulePath = path.resolve(pkg.workspacePath, modules[name].path);
-    const moduleProject = new pgpm_1.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 = (0, apply_spec_1.hasApplySpec)(modulePath)
+        ? (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 });
     log.success(`🚀 Starting deployment to database ${database}...`);
     for (const extension of extensions.resolved) {
@@ -73,9 +79,13 @@ const deployProject = async (opts, name, database, pkg, toChange) => {
                 await pgPool.query(msg);
             }
             else {
-                const modulePath = (0, path_1.resolve)(pkg.workspacePath, modules[extension].path);
+                const sourcePath = (0, path_1.resolve)(pkg.workspacePath, modules[extension].path);
+                const modulePath = await (0, materialize_1.resolveEffectiveModulePath)(extension, sourcePath, modules, pkg.workspacePath);
                 log.info(`📂 Deploying local module: ${extension}`);
                 log.debug(`→ Path: ${modulePath}`);
+                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 });