@pgpmjs/core 7.18.0 → 7.19.0

package/apply/materialize.d.ts

@@ -38,3 +38,29 @@ export declare function materializeApplyModule(options: MaterializeApplyOptions)
 export declare function resolveEffectiveModulePath(moduleName: string, modulePath: string, moduleMap: ModuleMap, workspacePath: string): Promise<string>;
 /** Test seam: clear the per-process materialization cache. */
 export declare function clearApplyMaterializationCache(): void;
+export interface MaterializeWorkspaceTargetOptions {
+    /** Absolute workspace root path. */
+    workspacePath: string;
+    /** The workspace module map (proxies already synthesized in). */
+    moduleMap: ModuleMap;
+    /** Name of the apply-proxy module to materialize. */
+    target: string;
+    /** Directory to write the plain, deployable module into. */
+    outDir: string;
+}
+export interface MaterializeWorkspaceTargetResult {
+    /** The deployable module directory the bundle was written to. */
+    outDir: string;
+    /** The transpiled, content-addressed bundle that was materialized. */
+    bundle: MigrationBundle;
+    /** The resolved apply spec the materialization was driven by. */
+    spec: ResolvedApplySpec;
+}
+/**
+ * Resolve an apply-proxy module by name in a workspace and materialize it to a
+ * chosen directory as a plain, deployable module (transforms baked in — no
+ * `pgpm.apply.json`). Shared by the `pgpm materialize` command and tests; the
+ * counterpart to {@link resolveEffectiveModulePath}, but with an explicit,
+ * stable `outDir` and no per-process cache.
+ */
+export declare function materializeWorkspaceTarget(options: MaterializeWorkspaceTargetOptions): Promise<MaterializeWorkspaceTargetResult>;

package/apply/materialize.js

@@ -3,15 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.materializeApplyModule = materializeApplyModule;
 exports.resolveEffectiveModulePath = resolveEffectiveModulePath;
 exports.clearApplyMaterializationCache = clearApplyMaterializationCache;
+exports.materializeWorkspaceTarget = materializeWorkspaceTarget;
+const bundle_1 = require("@pgpmjs/bundle");
+const slice_1 = require("@pgpmjs/slice");
+const transform_1 = require("@pgpmjs/transform");
 const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
-const bundle_1 = require("@pgpmjs/bundle");
-const transform_1 = require("@pgpmjs/transform");
-const slice_1 = require("@pgpmjs/slice");
 const apply_spec_1 = require("./apply-spec");
 const profile_1 = require("./profile");
 const reuse_1 = require("./reuse");
+const types_1 = require("./types");
 // 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
@@ -200,3 +202,43 @@ async function resolveEffectiveModulePath(moduleName, modulePath, moduleMap, wor
 function clearApplyMaterializationCache() {
     materializedCache.clear();
 }
+/**
+ * Resolve an apply-proxy module by name in a workspace and materialize it to a
+ * chosen directory as a plain, deployable module (transforms baked in — no
+ * `pgpm.apply.json`). Shared by the `pgpm materialize` command and tests; the
+ * counterpart to {@link resolveEffectiveModulePath}, but with an explicit,
+ * stable `outDir` and no per-process cache.
+ */
+async function materializeWorkspaceTarget(options) {
+    const { workspacePath, moduleMap, target, outDir } = options;
+    const module = moduleMap[target];
+    if (!module) {
+        const proxies = Object.keys(moduleMap).sort();
+        throw new Error(`Module "${target}" not found in the workspace.` +
+            (proxies.length ? ` Available modules: ${proxies.join(', ')}.` : ''));
+    }
+    const modulePath = (0, path_1.resolve)(workspacePath, module.path);
+    if (!(0, apply_spec_1.hasApplySpec)(modulePath)) {
+        throw new Error(`Module "${target}" is not an apply proxy (no ${types_1.APPLY_SPEC_FILE} in ${modulePath}). ` +
+            `Only apply-proxy modules can be materialized.`);
+    }
+    const spec = (0, profile_1.resolveEffectiveApplySpec)((0, apply_spec_1.readApplySpec)(modulePath), (0, profile_1.loadWorkspaceRoutingProfile)(workspacePath));
+    if ((0, reuse_1.isReuseSpec)(spec)) {
+        throw new Error(`Apply proxy "${target}" is a reuse proxy (shared + per-tenant). ` +
+            `Reuse proxies are not yet supported by \`pgpm materialize\`.`);
+    }
+    const sourceModule = moduleMap[spec.source.module];
+    if (!sourceModule) {
+        throw new Error(`Apply spec in "${target}" 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 = (0, path_1.resolve)(workspacePath, sourceModule.path);
+    const { outDir: writtenDir, bundle } = await materializeApplyModule({
+        sourceDir,
+        spec,
+        outDir
+    });
+    return { outDir: writtenDir, bundle, spec };
+}

package/esm/apply/materialize.js

@@ -1,12 +1,13 @@
+import { bundleFromModule, materializeBundle, transpileBundle, verifyBundle } from '@pgpmjs/bundle';
+import { excludeSubsystemPrograms, stripSubsystemSql } from '@pgpmjs/slice';
+import { buildSchemaRouter, loadModule, makeSchemaTranspiler, parseSqlProgram } from '@pgpmjs/transform';
 import { mkdtempSync } from 'fs';
 import { tmpdir } from 'os';
 import { join, resolve } from 'path';
-import { bundleFromModule, materializeBundle, transpileBundle, verifyBundle } from '@pgpmjs/bundle';
-import { buildSchemaRouter, loadModule, makeSchemaTranspiler, parseSqlProgram } from '@pgpmjs/transform';
-import { excludeSubsystemPrograms, stripSubsystemSql } from '@pgpmjs/slice';
 import { hasApplySpec, readApplySpec } from './apply-spec';
 import { loadWorkspaceRoutingProfile, resolveEffectiveApplySpec } from './profile';
 import { isReuseSpec, materializeReuseModule, resolveSharedModuleName } from './reuse';
+import { APPLY_SPEC_FILE } from './types';
 // 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
@@ -195,3 +196,43 @@ export async function resolveEffectiveModulePath(moduleName, modulePath, moduleM
 export function clearApplyMaterializationCache() {
     materializedCache.clear();
 }
+/**
+ * Resolve an apply-proxy module by name in a workspace and materialize it to a
+ * chosen directory as a plain, deployable module (transforms baked in — no
+ * `pgpm.apply.json`). Shared by the `pgpm materialize` command and tests; the
+ * counterpart to {@link resolveEffectiveModulePath}, but with an explicit,
+ * stable `outDir` and no per-process cache.
+ */
+export async function materializeWorkspaceTarget(options) {
+    const { workspacePath, moduleMap, target, outDir } = options;
+    const module = moduleMap[target];
+    if (!module) {
+        const proxies = Object.keys(moduleMap).sort();
+        throw new Error(`Module "${target}" not found in the workspace.` +
+            (proxies.length ? ` Available modules: ${proxies.join(', ')}.` : ''));
+    }
+    const modulePath = resolve(workspacePath, module.path);
+    if (!hasApplySpec(modulePath)) {
+        throw new Error(`Module "${target}" is not an apply proxy (no ${APPLY_SPEC_FILE} in ${modulePath}). ` +
+            `Only apply-proxy modules can be materialized.`);
+    }
+    const spec = resolveEffectiveApplySpec(readApplySpec(modulePath), loadWorkspaceRoutingProfile(workspacePath));
+    if (isReuseSpec(spec)) {
+        throw new Error(`Apply proxy "${target}" is a reuse proxy (shared + per-tenant). ` +
+            `Reuse proxies are not yet supported by \`pgpm materialize\`.`);
+    }
+    const sourceModule = moduleMap[spec.source.module];
+    if (!sourceModule) {
+        throw new Error(`Apply spec in "${target}" 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: writtenDir, bundle } = await materializeApplyModule({
+        sourceDir,
+        spec,
+        outDir
+    });
+    return { outDir: writtenDir, bundle, spec };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/core",
-  "version": "7.18.0",
+  "version": "7.19.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PGPM Package and Migration Tools",
   "main": "index.js",
@@ -48,24 +48,24 @@
     "makage": "^0.3.0"
   },
   "dependencies": {
-    "@pgpmjs/ast": "^0.9.5",
-    "@pgpmjs/bundle": "^0.12.4",
-    "@pgpmjs/env": "^2.39.2",
+    "@pgpmjs/ast": "^0.9.6",
+    "@pgpmjs/bundle": "^0.12.5",
+    "@pgpmjs/env": "^2.39.3",
     "@pgpmjs/logger": "^2.22.1",
-    "@pgpmjs/server-utils": "^3.23.4",
-    "@pgpmjs/slice": "^0.12.0",
-    "@pgpmjs/transform": "^0.13.0",
-    "@pgpmjs/types": "^2.48.1",
+    "@pgpmjs/server-utils": "^3.23.5",
+    "@pgpmjs/slice": "^0.12.1",
+    "@pgpmjs/transform": "^0.13.1",
+    "@pgpmjs/types": "^2.48.2",
     "csv-to-pg": "^4.8.1",
     "genomic": "^5.6.2",
     "glob": "^13.0.6",
     "parse-package-name": "^1.0.0",
     "pg": "^8.21.0",
-    "pg-cache": "^3.23.4",
+    "pg-cache": "^3.23.5",
     "pg-env": "^1.26.1",
     "pgsql-deparser": "^18.1.1",
     "pgsql-parser": "^18.1.1",
     "yanse": "^0.2.1"
   },
-  "gitHead": "04b34ce4b5efcebfd8e49d64d196e651288d97f3"
+  "gitHead": "947334d361e9f4c48d451f1c7312b2d705ea154e"
 }