Add getTransformer() to Node transforms with full cross-type chaining

Node transforms now have getTransformer(bblockId, transformId) injected,
mirroring Python's get_transformer() builtin. Any combination of transform
types (python, node, jq, xslt, jsonld-frame) can call each other arbitrarily
deep, with cycle detection working across process and language boundaries.

Bblock context is now consistently derived from a single _bblock_context_dict()
function in transform.py and stored in the transforms registry, so direct calls
and get_transformer/getTransformer calls see the same context fields.

Also fixes two bugs: a Node v24 spawnSync encoding crash, and stdout output
from dispatched Python transforms leaking into the JSON response.

Author: avillar

ogc/bblocks/transform.py

@@ -299,7 +299,63 @@ def cleanup_sandbox(sandbox_dir: Path, bblocks: list[BuildingBlock]) -> None:
 _GET_TRANSFORMER_TYPES = frozenset({'python', 'node', 'jq', 'xslt', 'jsonld-frame'})
 
 
-def _build_transforms_registry(bblocks_register: BuildingBlockRegister) -> dict:
+def _bblock_context_dict(bblock_id: str, bblock, cwd: Path) -> dict:
+    """Return a JSON-serializable dict of the bblock-level TransformContext fields.
+
+    Accepts either a local BuildingBlock or an imported bblock raw dict. The returned
+    dict can be spread into TransformContext(...) alongside the run-specific fields
+    (example_index, example, snippet_index, snippet, output_file, output_dir, working_dir,
+    base_url, github_base_url, git_repository, id_prefix, imported_register_urls,
+    transform_plugins).
+    """
+    if isinstance(bblock, BuildingBlock):
+        bblock_metadata = json.loads(json.dumps(bblock.metadata, default=str))
+        source_schema_path = None
+        if bblock.schema:
+            source_schema_path = _rel(bblock.schema.path, cwd) if bblock.schema.is_path else bblock.schema.url
+        return {
+            'bblock_id': bblock_id,
+            'bblock_name': bblock.name,
+            'bblock_version': bblock.version,
+            'bblock_tags': list(bblock.metadata.get('tags') or []),
+            'bblock_files_path': _rel(bblock.files_path, cwd),
+            'bblock_annotated_path': _rel(bblock.annotated_path, cwd),
+            'bblock_metadata': bblock_metadata,
+            'source_schema_path': source_schema_path,
+            'annotated_schema_path': _rel(bblock.annotated_schema, cwd) if bblock.annotated_schema.is_file() else None,
+            'jsonld_context_path': _rel(bblock.jsonld_context, cwd) if bblock.jsonld_context and bblock.jsonld_context.is_file() else None,
+            'shacl_shapes_paths': [s if isinstance(s, str) else _rel(s, cwd) for s in (bblock.shacl_shapes or [])],
+        }
+    else:
+        # Imported bblock raw dict
+        raw_copy = {k: v for k, v in bblock.items() if k != 'register'}
+        bblock_metadata = json.loads(json.dumps(raw_copy, default=str))
+        schema = bblock.get('schema')
+        schema_url = None
+        if isinstance(schema, dict):
+            schema_url = schema.get('application/json') or schema.get('application/yaml') or next(iter(schema.values()), None)
+        elif isinstance(schema, str):
+            schema_url = schema
+        shacl_shapes = bblock.get('shaclShapes') or bblock.get('shaclRules') or []
+        if isinstance(shacl_shapes, dict):
+            shacl_shapes = [s for shapes in shacl_shapes.values()
+                            for s in (shapes if isinstance(shapes, list) else [shapes])]
+        return {
+            'bblock_id': bblock_id,
+            'bblock_name': bblock.get('name', bblock_id),
+            'bblock_version': bblock.get('version'),
+            'bblock_tags': list(bblock.get('tags') or []),
+            'bblock_files_path': None,
+            'bblock_annotated_path': None,
+            'bblock_metadata': bblock_metadata,
+            'source_schema_path': schema_url,
+            'annotated_schema_path': schema_url,
+            'jsonld_context_path': bblock.get('ldContext'),
+            'shacl_shapes_paths': [s for s in shacl_shapes if isinstance(s, str)],
+        }
+
+
+def _build_transforms_registry(bblocks_register: BuildingBlockRegister, cwd: Path) -> dict:
     registry = {}
 
     for bblock_id, bblock in bblocks_register.bblocks.items():
@@ -312,11 +368,8 @@ def _build_transforms_registry(bblocks_register: BuildingBlockRegister) -> dict:
         }
         if not supported_transforms:
             continue
-        bblock_metadata = json.loads(json.dumps(bblock.metadata, default=str))
         registry[bblock_id] = {
-            'name': bblock.metadata.get('name', bblock_id),
-            'version': bblock.metadata.get('version'),
-            'bblock_metadata': bblock_metadata,
+            'context': _bblock_context_dict(bblock_id, bblock, cwd),
             'transforms': supported_transforms,
         }
 
@@ -328,12 +381,8 @@ def _build_transforms_registry(bblocks_register: BuildingBlockRegister) -> dict:
         }
         if not supported_transforms:
             continue
-        raw_copy = {k: v for k, v in raw.items() if k != 'register'}
-        bblock_metadata = json.loads(json.dumps(raw_copy, default=str))
         registry[bblock_id] = {
-            'name': raw.get('name', bblock_id),
-            'version': raw.get('version'),
-            'bblock_metadata': bblock_metadata,
+            'context': _bblock_context_dict(bblock_id, raw, cwd),
             'transforms': supported_transforms,
         }
 
@@ -360,7 +409,12 @@ def apply_transforms(bblock: BuildingBlock,
     shutil.rmtree(output_dir, ignore_errors=True)
     output_dir.mkdir(parents=True, exist_ok=True)
 
-    transforms_registry = _build_transforms_registry(bblocks_register) if bblocks_register else {}
+    transforms_registry = _build_transforms_registry(bblocks_register, cwd) if bblocks_register else {}
+
+    # Bblock-level context fields — constant for all examples/snippets of this bblock.
+    # Prefer the registry entry (already computed) to avoid redundant Path → str conversions.
+    bblock_ctx = (transforms_registry.get(bblock.identifier) or {}).get('context') \
+        or _bblock_context_dict(bblock.identifier, bblock, cwd)
 
     # Collects ValidationReportItems per profile across all snippets/transforms,
     # so we can write one consolidated _report.json per profile at the end.
@@ -453,29 +507,14 @@ def apply_transforms(bblock: BuildingBlock,
                     metadata['_prefixes'] = example_prefixes
 
                 ctx = TransformContext(
-                    bblock_id=bblock.identifier,
-                    bblock_name=bblock.name,
-                    bblock_version=bblock.version,
-                    bblock_tags=list(bblock.metadata.get('tags') or []),
-                    bblock_files_path=_rel(bblock.files_path, cwd),
-                    bblock_annotated_path=_rel(bblock.annotated_path, cwd),
-                    bblock_metadata=bblock.metadata,
+                    **bblock_ctx,
                     example_index=example_id,
                     example={k: v for k, v in example.items() if k != 'snippets'},
                     snippet_index=snippet_id,
                     snippet={k: v for k, v in snippet.items() if k != 'code'},
                     output_file=_rel(output_fn, cwd),
                     output_dir=_rel(output_dir, cwd),
                     working_dir=str(cwd),
-                    source_schema_path=(
-                        _rel(bblock.schema.path, cwd) if bblock.schema.is_path else bblock.schema.url
-                    ) if bblock.schema else None,
-                    annotated_schema_path=_rel(bblock.annotated_schema, cwd) if bblock.annotated_schema.is_file() else None,
-                    jsonld_context_path=_rel(bblock.jsonld_context, cwd) if bblock.jsonld_context.is_file() else None,
-                    shacl_shapes_paths=[
-                        s if isinstance(s, str) else _rel(s, cwd)
-                        for s in (bblock.shacl_shapes or [])
-                    ],
                     base_url=base_url,
                     github_base_url=github_base_url,
                     git_repository=git_repository,

ogc/bblocks/transformers/node.py

@@ -6,11 +6,13 @@
 import os
 import shutil
 import subprocess
+import sys
 import tempfile
 from pathlib import Path
 
 from ogc.bblocks.log import log_indent
 from ogc.bblocks.models import TransformMetadata, TransformResult, Transformer
+from ogc.bblocks.transformers.python import _NON_PYTHON_HARNESS_CODE
 
 logger = logging.getLogger(__name__)
 
@@ -42,6 +44,12 @@ def transform(self, metadata: TransformMetadata) -> TransformResult:
         sandbox_dir = metadata.sandbox_dir
         node_path = str(sandbox_dir / 'node' / 'node_modules') if sandbox_dir else None
 
+        transforms_registry = metadata._transforms_registry or {}
+        main_python = sys.executable
+        sandbox_base = str(metadata._sandbox_base_dir) if metadata._sandbox_base_dir else None
+        self_key = (f"{metadata.ctx.bblock_id}:{metadata.id}"
+                    if metadata.ctx and metadata.id else None)
+
         transform_metadata_dict = {
             'sourceMimeType': metadata.source_mime_type,
             'targetMimeType': metadata.target_mime_type,
@@ -52,10 +60,124 @@ def transform(self, metadata: TransformMetadata) -> TransformResult:
 
         harness = f"""\
 const fs = require('fs');
+const path = require('path');
+const {{spawnSync}} = require('child_process');
 const transformMetadata = {json.dumps(transform_metadata_dict)};
 const inputData = fs.readFileSync(0, 'utf8');
 let outputData = null;
 
+const _TRANSFORMS_REGISTRY = {json.dumps(transforms_registry)};
+const _MAIN_PYTHON = {json.dumps(main_python)};
+const _SANDBOX_BASE = {json.dumps(sandbox_base)};
+const _DISPATCH_HARNESS = {json.dumps(_NON_PYTHON_HARNESS_CODE)};
+const _SELF_KEY = {json.dumps(self_key)};
+
+// Call stack inherited from the process that invoked this Node transform (may be empty at root).
+const _INITIAL_CALL_STACK = process.env._BBLOCKS_CALL_STACK
+    ? JSON.parse(process.env._BBLOCKS_CALL_STACK) : [];
+
+// Execution context of this process: ancestors + self. Used as the base for cycle detection
+// and as the child call stack prefix when dispatching sub-transforms.
+const _SELF_STACK = (_SELF_KEY && _INITIAL_CALL_STACK.indexOf(_SELF_KEY) === -1)
+    ? _INITIAL_CALL_STACK.concat([_SELF_KEY])
+    : _INITIAL_CALL_STACK;
+
+const _getTransformerCache = {{}};
+
+function getTransformer(bblockId, transformId) {{
+    const cacheKey = bblockId + ':' + transformId;
+    if (_getTransformerCache[cacheKey]) return _getTransformerCache[cacheKey];
+
+    const bblockEntry = _TRANSFORMS_REGISTRY[bblockId];
+    if (!bblockEntry) throw new Error('Building block ' + JSON.stringify(bblockId) + ' not found in transforms registry');
+    const transformEntry = bblockEntry.transforms[transformId];
+    if (!transformEntry) throw new Error('Transform ' + JSON.stringify(transformId) + ' not found for building block ' + JSON.stringify(bblockId));
+
+    if (transformEntry.type === 'node' && _SANDBOX_BASE) {{
+        let npmDeps = ((transformEntry.metadata || {{}}).dependencies || {{}}).npm || [];
+        if (!Array.isArray(npmDeps)) npmDeps = [npmDeps];
+        if (npmDeps.length > 0) {{
+            const nodeDir = path.join(_SANDBOX_BASE, 'get_transformer',
+                bblockId.replace(/\\./g, '_'), transformId, 'node');
+            fs.mkdirSync(nodeDir, {{recursive: true}});
+            const r = spawnSync('npm', ['install', '--prefix', nodeDir].concat(npmDeps),
+                {{encoding: 'utf8'}});
+            if (r.status !== 0) throw new Error('npm install failed: ' + (r.stderr || ''));
+        }}
+    }}
+
+    const fn = function(content, opts) {{
+        opts = opts || {{}};
+        const sourceMimeType = opts.sourceMimeType || null;
+        const extraMetadata = opts.extraMetadata || {{}};
+
+        // Cycle detection: check if the target transform is already in the execution context.
+        // _SELF_STACK contains all ancestors (from the env var) plus this Node transform's own key,
+        // so cross-type cycles (Python → Node → Python, Node → Python → Node) are caught here.
+        if (_SELF_STACK.indexOf(cacheKey) !== -1) {{
+            throw new Error('Cycle detected: transform ' + JSON.stringify(transformId) +
+                ' of ' + JSON.stringify(bblockId) + ' is already executing');
+        }}
+        // Child processes see _SELF_STACK plus the transform being dispatched.
+        const _childStack = _SELF_STACK.concat([cacheKey]);
+        const _childStackStr = JSON.stringify(_childStack);
+
+        const inputBytes = typeof content === 'string'
+            ? Buffer.from(content, 'utf8')
+            : (Buffer.isBuffer(content) ? content : Buffer.from(String(content)));
+
+        const meta = Object.assign({{}}, transformEntry.metadata || {{}}, extraMetadata,
+            {{_nested_transform: true}});
+
+        let sandboxDir = null;
+        if (transformEntry.type === 'node' && _SANDBOX_BASE) {{
+            let deps = ((transformEntry.metadata || {{}}).dependencies || {{}}).npm || [];
+            if (!Array.isArray(deps)) deps = [deps];
+            if (deps.length > 0) {{
+                sandboxDir = path.join(_SANDBOX_BASE, 'get_transformer',
+                    bblockId.replace(/\\./g, '_'), transformId);
+            }}
+        }}
+
+        const req = {{
+            type: transformEntry.type,
+            transform_content: transformEntry.code,
+            input: inputBytes.toString('base64'),
+            source_mime_type: sourceMimeType,
+            target_mime_type: null,
+            metadata: meta,
+            bblock_id: bblockId,
+            transform_id: transformId,
+            sandbox_dir: sandboxDir,
+            transforms_registry: _TRANSFORMS_REGISTRY,
+            main_python: _MAIN_PYTHON,
+            sandbox_base: _SANDBOX_BASE,
+            non_python_harness: _DISPATCH_HARNESS,
+            call_stack: _childStack,
+        }};
+
+        const spawnEnv = Object.assign({{}}, process.env,
+            {{_BBLOCKS_CALL_STACK: _childStackStr}});
+        const proc = spawnSync(_MAIN_PYTHON, ['-c', _DISPATCH_HARNESS],
+            {{input: Buffer.from(JSON.stringify(req), 'utf8'), encoding: 'buffer', env: spawnEnv}});
+
+        const stdoutStr = (proc.stdout || Buffer.alloc(0)).toString('utf8').trim();
+        if (!stdoutStr) {{
+            const stderrStr = (proc.stderr || Buffer.alloc(0)).toString('utf8');
+            throw new Error('getTransformer sub-process for ' + JSON.stringify(transformEntry.type) +
+                ' produced no output\\n' + stderrStr);
+        }}
+        const resp = JSON.parse(stdoutStr);
+        if (!resp.success) throw new Error(resp.stderr || (JSON.stringify(transformEntry.type) + ' sub-transform failed'));
+        if (resp.output == null) return null;
+        const outBuf = Buffer.from(resp.output, 'base64');
+        return resp.binary ? outBuf : outBuf.toString('utf8');
+    }};
+
+    _getTransformerCache[cacheKey] = fn;
+    return fn;
+}}
+
 const _origStdoutWrite = process.stdout.write.bind(process.stdout);
 process.stdout.write = process.stderr.write.bind(process.stderr);