@pipeline-builder/pipeline-core 3.1.5 → 3.2.0

package/lib/template/validate.js

@@ -0,0 +1,101 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowedScopeRoots = allowedScopeRoots;
+exports.validateTemplates = validateTemplates;
+exports.detectCycles = detectCycles;
+const api_core_1 = require("@pipeline-builder/api-core");
+const evaluator_1 = require("./evaluator");
+const tokenizer_1 = require("./tokenizer");
+const topo_sort_1 = require("./topo-sort");
+const walker_1 = require("./walker");
+/**
+ * Build a predicate that accepts a template path when its root is in the
+ * given allow-list. Used by the validator to check that every `{{ path }}`
+ * resolves to a known scope root (`pipeline`, `plugin`, `env`, …).
+ *
+ * Only the root segment is checked — we don't enforce exact nested-key
+ * existence here because metadata / vars keys are user-provided per pipeline
+ * and not known at plugin upload time.
+ */
+function allowedScopeRoots(roots) {
+    const allowed = new Set(roots);
+    return (path) => {
+        const root = path[0];
+        return !!root && allowed.has(root);
+    };
+}
+/**
+ * Validate all template tokens in a document have well-formed paths and
+ * point at allowed scope roots. Returns all errors found — does NOT stop
+ * on first.
+ *
+ * Caller supplies `isTemplatable` (the schema allow-list) and
+ * `isKnownPath` (the scope-shape predicate). Template text is parsed
+ * fresh; use a TokenCache externally if repeated parsing is a concern.
+ */
+function validateTemplates(doc, isTemplatable, isKnownPath) {
+    const errors = [];
+    const entries = [];
+    // Pass 1: parse every templatable field, collecting parse errors instead
+    // of throwing on the first one.
+    (0, walker_1.visitStrings)(doc, isTemplatable, (field, source) => {
+        try {
+            entries.push({ field, tokens: (0, tokenizer_1.tokenize)(source) });
+        }
+        catch (err) {
+            if (err instanceof tokenizer_1.TokenizerError) {
+                errors.push({ field, line: err.pos.line, col: err.pos.col, code: api_core_1.ErrorCode.TEMPLATE_PARSE_ERROR, message: err.message });
+            }
+            else {
+                errors.push({ field, code: api_core_1.ErrorCode.TEMPLATE_PARSE_ERROR, message: String(err) });
+            }
+        }
+    });
+    // Pass 2: validate each expr's path is shape-allowed and not reserved
+    for (const { field, tokens } of entries) {
+        for (const tok of tokens) {
+            if (tok.kind !== 'expr')
+                continue;
+            if (tok.path[0] === 'secrets') {
+                errors.push(mkErr(field, tok.pos, api_core_1.ErrorCode.TEMPLATE_SECRETS_RESERVED, '\'secrets\' is a reserved scope — use the plugin\'s \'secrets:\' field instead', tok.path.join('.')));
+                continue;
+            }
+            if (!isKnownPath(tok.path)) {
+                errors.push(mkErr(field, tok.pos, api_core_1.ErrorCode.TEMPLATE_UNKNOWN_PATH, `Template references unknown scope root '${tok.path[0]}'`, tok.path.join('.')));
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Detect cycles in a self-referencing document. Caller supplies the
+ * templatable predicate and a function to extract the scope-path that
+ * each template field writes to (same value used as a key in deps).
+ *
+ * Example for pipeline.json: the field `metadata.env` writes to scope
+ * path `metadata.env`; a template `{{ metadata.region }}` in that field
+ * declares a dependency on `metadata.region`.
+ */
+function detectCycles(doc, isTemplatable, fieldToScopePath) {
+    const nodes = [];
+    for (const entry of (0, walker_1.walkAndBind)(doc, isTemplatable)) {
+        const key = fieldToScopePath(entry.field);
+        if (!key)
+            continue;
+        nodes.push({ key, deps: (0, evaluator_1.dependencies)(entry.tokens) });
+    }
+    const { cycles } = (0, topo_sort_1.topoSort)(nodes);
+    return cycles.map(c => ({
+        field: c[0],
+        code: api_core_1.ErrorCode.TEMPLATE_CYCLE,
+        message: `Template cycle detected: ${c.join(' -> ')}`,
+        cycle: c,
+    }));
+}
+// -- helpers -----------------------------------------------------------------
+function mkErr(field, pos, code, message, path) {
+    return { field, line: pos.line, col: pos.col, code, message, ...(path && { path }) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../src/template/validate.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ErrorCode } from '@pipeline-builder/api-core';\nimport { dependencies } from './evaluator';\nimport { SourcePosition, Token, TokenizerError, tokenize } from './tokenizer';\nimport { topoSort } from './topo-sort';\nimport { FieldPredicate, visitStrings, walkAndBind } from './walker';\n\nexport interface TemplateError {\n  field: string;\n  line?: number;\n  col?: number;\n  code: ErrorCode;\n  message: string;\n  path?: string;\n  cycle?: string[];\n}\n\nexport interface ValidationResult {\n  valid: boolean;\n  errors: TemplateError[];\n}\n\n/**\n * Build a predicate that accepts a template path when its root is in the\n * given allow-list. Used by the validator to check that every `{{ path }}`\n * resolves to a known scope root (`pipeline`, `plugin`, `env`, …).\n *\n * Only the root segment is checked — we don't enforce exact nested-key\n * existence here because metadata / vars keys are user-provided per pipeline\n * and not known at plugin upload time.\n */\nexport function allowedScopeRoots(roots: string[]): (path: string[]) => boolean {\n  const allowed = new Set(roots);\n  return (path) => {\n    const root = path[0];\n    return !!root && allowed.has(root);\n  };\n}\n\n/**\n * Validate all template tokens in a document have well-formed paths and\n * point at allowed scope roots. Returns all errors found — does NOT stop\n * on first.\n *\n * Caller supplies `isTemplatable` (the schema allow-list) and\n * `isKnownPath` (the scope-shape predicate). Template text is parsed\n * fresh; use a TokenCache externally if repeated parsing is a concern.\n */\nexport function validateTemplates<T extends object>(\n  doc: T,\n  isTemplatable: FieldPredicate,\n  isKnownPath: (path: string[]) => boolean,\n): ValidationResult {\n  const errors: TemplateError[] = [];\n  const entries: { field: string; tokens: Token[] }[] = [];\n\n  // Pass 1: parse every templatable field, collecting parse errors instead\n  // of throwing on the first one.\n  visitStrings(doc, isTemplatable, (field, source) => {\n    try {\n      entries.push({ field, tokens: tokenize(source) });\n    } catch (err) {\n      if (err instanceof TokenizerError) {\n        errors.push({ field, line: err.pos.line, col: err.pos.col, code: ErrorCode.TEMPLATE_PARSE_ERROR, message: err.message });\n      } else {\n        errors.push({ field, code: ErrorCode.TEMPLATE_PARSE_ERROR, message: String(err) });\n      }\n    }\n  });\n\n  // Pass 2: validate each expr's path is shape-allowed and not reserved\n  for (const { field, tokens } of entries) {\n    for (const tok of tokens) {\n      if (tok.kind !== 'expr') continue;\n      if (tok.path[0] === 'secrets') {\n        errors.push(mkErr(field, tok.pos, ErrorCode.TEMPLATE_SECRETS_RESERVED,\n          '\\'secrets\\' is a reserved scope — use the plugin\\'s \\'secrets:\\' field instead',\n          tok.path.join('.')));\n        continue;\n      }\n      if (!isKnownPath(tok.path)) {\n        errors.push(mkErr(field, tok.pos, ErrorCode.TEMPLATE_UNKNOWN_PATH,\n          `Template references unknown scope root '${tok.path[0]}'`,\n          tok.path.join('.')));\n      }\n    }\n  }\n\n  return { valid: errors.length === 0, errors };\n}\n\n/**\n * Detect cycles in a self-referencing document. Caller supplies the\n * templatable predicate and a function to extract the scope-path that\n * each template field writes to (same value used as a key in deps).\n *\n * Example for pipeline.json: the field `metadata.env` writes to scope\n * path `metadata.env`; a template `{{ metadata.region }}` in that field\n * declares a dependency on `metadata.region`.\n */\nexport function detectCycles<T extends object>(\n  doc: T,\n  isTemplatable: FieldPredicate,\n  fieldToScopePath: (field: string) => string | null,\n): TemplateError[] {\n  const nodes = [];\n  for (const entry of walkAndBind(doc, isTemplatable)) {\n    const key = fieldToScopePath(entry.field);\n    if (!key) continue;\n    nodes.push({ key, deps: dependencies(entry.tokens) });\n  }\n  const { cycles } = topoSort(nodes);\n  return cycles.map(c => ({\n    field: c[0]!,\n    code: ErrorCode.TEMPLATE_CYCLE,\n    message: `Template cycle detected: ${c.join(' -> ')}`,\n    cycle: c,\n  }));\n}\n\n// -- helpers -----------------------------------------------------------------\n\nfunction mkErr(\n  field: string,\n  pos: SourcePosition,\n  code: ErrorCode,\n  message: string,\n  path?: string,\n): TemplateError {\n  return { field, line: pos.line, col: pos.col, code, message, ...(path && { path }) };\n}\n\n"]}

package/lib/template/walker.d.ts

@@ -0,0 +1,24 @@
+import { Token } from './tokenizer';
+export interface WalkEntry {
+    /** Dotted path to the field inside the document, e.g. 'commands[3]' or 'env.STAGE' */
+    field: string;
+    /** Raw source string containing template tokens */
+    source: string;
+    /** Parsed token stream */
+    tokens: Token[];
+    /** Setter to write back a resolved value into the original `root` object */
+    set: (value: unknown) => void;
+}
+export type FieldPredicate = (field: string) => boolean;
+/**
+ * Visit every templatable string leaf under `root`. Calls `handler(field, source)`
+ * for each string whose field path satisfies `isTemplatable` and contains `{{`.
+ * Does NOT tokenize — callers decide whether to throw or collect errors.
+ */
+export declare function visitStrings(root: unknown, isTemplatable: FieldPredicate, handler: (field: string, source: string) => void): void;
+/**
+ * Walk all templatable string fields under `root`, returning one entry per
+ * templated field with a bound `set()` that mutates `root` in place.
+ * Tokenization happens eagerly here — parse errors throw.
+ */
+export declare function walkAndBind<T extends object>(root: T, isTemplatable: FieldPredicate): WalkEntry[];

package/lib/template/walker.js

@@ -0,0 +1,76 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitStrings = visitStrings;
+exports.walkAndBind = walkAndBind;
+const tokenizer_1 = require("./tokenizer");
+/**
+ * Visit every templatable string leaf under `root`. Calls `handler(field, source)`
+ * for each string whose field path satisfies `isTemplatable` and contains `{{`.
+ * Does NOT tokenize — callers decide whether to throw or collect errors.
+ */
+function visitStrings(root, isTemplatable, handler) {
+    step(root, '', isTemplatable, handler);
+}
+function step(node, field, isTemplatable, handler) {
+    if (Array.isArray(node)) {
+        node.forEach((child, idx) => step(child, `${field}[${idx}]`, isTemplatable, handler));
+        return;
+    }
+    if (node !== null && typeof node === 'object') {
+        for (const [key, child] of Object.entries(node)) {
+            step(child, field ? `${field}.${key}` : key, isTemplatable, handler);
+        }
+        return;
+    }
+    if (typeof node === 'string' && isTemplatable(field) && (0, tokenizer_1.hasTemplate)(node)) {
+        handler(field, node);
+    }
+}
+/**
+ * Walk all templatable string fields under `root`, returning one entry per
+ * templated field with a bound `set()` that mutates `root` in place.
+ * Tokenization happens eagerly here — parse errors throw.
+ */
+function walkAndBind(root, isTemplatable) {
+    const entries = [];
+    visitStrings(root, isTemplatable, (field, source) => {
+        const tokens = (0, tokenizer_1.tokenize)(source);
+        if (!tokens.some(t => t.kind === 'expr'))
+            return;
+        entries.push({
+            field,
+            source,
+            tokens,
+            set: (value) => writeField(root, parseFieldPath(field), value),
+        });
+    });
+    return entries;
+}
+function parseFieldPath(field) {
+    const parts = [];
+    const re = /([^.\[\]]+)|\[(\d+)\]/g;
+    let m;
+    while ((m = re.exec(field)) !== null) {
+        if (m[1] !== undefined)
+            parts.push(m[1]);
+        else if (m[2] !== undefined)
+            parts.push(Number(m[2]));
+    }
+    return parts;
+}
+function writeField(root, parts, value) {
+    if (parts.length === 0)
+        return;
+    let cur = root;
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (cur == null || typeof cur !== 'object')
+            return;
+        cur = cur[parts[i]];
+    }
+    if (cur == null || typeof cur !== 'object')
+        return;
+    cur[parts[parts.length - 1]] = value;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -25,13 +25,13 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@pipeline-builder/api-core": "3.1.4",
-    "@pipeline-builder/pipeline-data": "3.1.4",
     "aws-cdk-lib": "2.240.0",
     "axios": "1.13.5",
     "constructs": "10.5.1",
     "jsonwebtoken": "9.0.3",
-    "uuid": "13.0.0"
+    "uuid": "13.0.0",
+    "@pipeline-builder/pipeline-data": "3.2.0",
+    "@pipeline-builder/api-core": "3.2.0"
   },
   "keywords": [
     "aws",
@@ -68,7 +68,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.1.5",
+  "version": "3.2.0",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },