sof-mssql 2.1.0 → 2.2.0

package/dist/queryGenerator/treeWalker/operators/columnsOnly.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Walker for ColumnsOnly nodes — emits the projected columns for the
+ * select.column[] array using the current transpiler context.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectColumns = projectColumns;
+exports.walkColumnsOnly = walkColumnsOnly;
+/**
+ * Projects an array of ViewDefinition column descriptors into SQL expressions.
+ *
+ * Delegates expression generation to `ColumnExpressionGenerator`, which
+ * translates each column's FHIRPath expression into a T-SQL expression
+ * relative to the current transpiler context (iteration source, aliases, etc.).
+ *
+ * @param columns - The column descriptors from the ViewDefinition select node.
+ * @param ctx - The current walker context supplying the transpiler context
+ *   used for FHIRPath-to-SQL translation.
+ * @param columnGenerator - The generator that converts each column descriptor
+ *   into its SQL expression string.
+ * @returns An ordered array of `ProjectedColumn` objects, each pairing the
+ *   column's logical name with its SQL expression.
+ */
+function projectColumns(columns, ctx, columnGenerator) {
+    return columns.map((column) => ({
+        name: column.name,
+        sqlExpr: columnGenerator.generateExpression(column, ctx.transpilerCtx),
+    }));
+}
+/**
+ * Walker for ColumnsOnly nodes — emits the projected columns for a leaf select node.
+ *
+ * Produces a Fragment with no CTEs, no FROM extensions, and columns derived
+ * from `node.column[]` via `projectColumns`.  If `node.column` is absent or
+ * empty, the returned Fragment has an empty columns array.
+ *
+ * @param node - The leaf select node whose `column[]` array is projected.
+ * @param ctx - The current walker context supplying partition keys and the
+ *   transpiler context for expression generation.
+ * @param columnGenerator - The generator that converts column descriptors into
+ *   T-SQL expressions.
+ * @returns A Fragment carrying only projected columns; `ctes` and
+ *   `fromExtensions` are always empty.
+ */
+function walkColumnsOnly(node, ctx, columnGenerator) {
+    const columns = node.column
+        ? projectColumns(node.column, ctx, columnGenerator)
+        : [];
+    return {
+        ctes: [],
+        fromExtensions: "",
+        columns,
+        partitionKeys: ctx.partitionKeys,
+    };
+}
+//# sourceMappingURL=columnsOnly.js.map

package/dist/queryGenerator/treeWalker/operators/columnsOnly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnsOnly.js","sourceRoot":"","sources":["../../../../src/queryGenerator/treeWalker/operators/columnsOnly.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAwBH,wCASC;AAiBD,0CAcC;AAvDD;;;;;;;;;;;;;;GAcG;AACH,SAAgB,cAAc,CAC5B,OAA+B,EAC/B,GAAY,EACZ,eAA0C;IAE1C,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAC9B,IAAI,EAAE,MAAM,CAAC,IAAI;QACjB,OAAO,EAAE,eAAe,CAAC,kBAAkB,CAAC,MAAM,EAAE,GAAG,CAAC,aAAa,CAAC;KACvE,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,eAAe,CAC7B,IAA0B,EAC1B,GAAY,EACZ,eAA0C;IAE1C,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM;QACzB,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,eAAe,CAAC;QACnD,CAAC,CAAC,EAAE,CAAC;IACP,OAAO;QACL,IAAI,EAAE,EAAE;QACR,cAAc,EAAE,EAAE;QAClB,OAAO;QACP,aAAa,EAAE,GAAG,CAAC,aAAa;KACjC,CAAC;AACJ,CAAC"}

package/dist/queryGenerator/treeWalker/operators/forEach.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Walker for ForEach / ForEachOrNull nodes.
+ *
+ * Emits a CROSS APPLY (or OUTER APPLY) clause that iterates over a JSON
+ * array. Threads `ctx.source` and `ctx.transpilerCtx` so child nodes
+ * project columns relative to the iteration value, and appends a
+ * `<alias>_key` partition key.
+ *
+ * Path-handling parity is delegated to PathParser (`.where()`, `.first()`,
+ * array indexing, multi-segment array flattening).
+ */
+import type { ViewDefinitionSelect } from "../../../types.js";
+import type { PathParser } from "../../PathParser.js";
+import { type Context, type Fragment } from "../types.js";
+interface ForEachDeps {
+    pathParser: PathParser;
+}
+/**
+ * Walker for ForEach and ForEachOrNull nodes.
+ *
+ * Emits a `CROSS APPLY` (or `OUTER APPLY` for `forEachOrNull`) clause that
+ * iterates over a JSON array identified by the node's FHIRPath expression.
+ * Updates `ctx.source`, `ctx.transpilerCtx`, and `ctx.partitionKeys` so that
+ * child nodes project columns relative to each iteration value, then walks
+ * the child sub-tree (`column`, `select`, `unionAll`) in that inner context.
+ * The apply clause is prepended to the inner Fragment's `fromExtensions`.
+ *
+ * Path features handled via `PathParser`: `.where()` filters, `.first()`
+ * selectors, array indexing, and multi-segment array flattening (nested
+ * `CROSS APPLY OPENJSON` chains).
+ *
+ * @param node - The ForEach or ForEachOrNull select node.  `node.forEach` or
+ *   `node.forEachOrNull` supplies the FHIRPath expression to iterate.
+ * @param ctx - The current walker context; the inner context is derived from
+ *   it by updating `source`, `partitionKeys`, `ancestorApplies`, `nullable`,
+ *   and `transpilerCtx`.
+ * @param walk - The recursive walk function used to visit the inner sub-tree.
+ * @param deps - Dependencies containing the `PathParser` used to parse and
+ *   decompose the FHIRPath expression.
+ * @returns A Fragment whose `fromExtensions` begins with the generated APPLY
+ *   clause followed by any extensions produced by the inner walk.
+ */
+export declare function walkForEach(node: ViewDefinitionSelect, ctx: Context, walk: (n: ViewDefinitionSelect, c: Context) => Fragment, deps: ForEachDeps): Fragment;
+export {};
+//# sourceMappingURL=forEach.d.ts.map

package/dist/queryGenerator/treeWalker/operators/forEach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forEach.d.ts","sourceRoot":"","sources":["../../../../src/queryGenerator/treeWalker/operators/forEach.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,QAAQ,EAGd,MAAM,aAAa,CAAC;AAErB,UAAU,WAAW;IACnB,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,oBAAoB,EAC1B,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,CAAC,CAAC,EAAE,oBAAoB,EAAE,CAAC,EAAE,OAAO,KAAK,QAAQ,EACvD,IAAI,EAAE,WAAW,GAChB,QAAQ,CA2BV"}

package/dist/queryGenerator/treeWalker/operators/forEach.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Walker for ForEach / ForEachOrNull nodes.
+ *
+ * Emits a CROSS APPLY (or OUTER APPLY) clause that iterates over a JSON
+ * array. Threads `ctx.source` and `ctx.transpilerCtx` so child nodes
+ * project columns relative to the iteration value, and appends a
+ * `<alias>_key` partition key.
+ *
+ * Path-handling parity is delegated to PathParser (`.where()`, `.first()`,
+ * array indexing, multi-segment array flattening).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkForEach = walkForEach;
+const aliasGenerator_js_1 = require("../aliasGenerator.js");
+const types_js_1 = require("../types.js");
+/**
+ * Walker for ForEach and ForEachOrNull nodes.
+ *
+ * Emits a `CROSS APPLY` (or `OUTER APPLY` for `forEachOrNull`) clause that
+ * iterates over a JSON array identified by the node's FHIRPath expression.
+ * Updates `ctx.source`, `ctx.transpilerCtx`, and `ctx.partitionKeys` so that
+ * child nodes project columns relative to each iteration value, then walks
+ * the child sub-tree (`column`, `select`, `unionAll`) in that inner context.
+ * The apply clause is prepended to the inner Fragment's `fromExtensions`.
+ *
+ * Path features handled via `PathParser`: `.where()` filters, `.first()`
+ * selectors, array indexing, and multi-segment array flattening (nested
+ * `CROSS APPLY OPENJSON` chains).
+ *
+ * @param node - The ForEach or ForEachOrNull select node.  `node.forEach` or
+ *   `node.forEachOrNull` supplies the FHIRPath expression to iterate.
+ * @param ctx - The current walker context; the inner context is derived from
+ *   it by updating `source`, `partitionKeys`, `ancestorApplies`, `nullable`,
+ *   and `transpilerCtx`.
+ * @param walk - The recursive walk function used to visit the inner sub-tree.
+ * @param deps - Dependencies containing the `PathParser` used to parse and
+ *   decompose the FHIRPath expression.
+ * @returns A Fragment whose `fromExtensions` begins with the generated APPLY
+ *   clause followed by any extensions produced by the inner walk.
+ */
+function walkForEach(node, ctx, walk, deps) {
+    const isOrNull = node.forEachOrNull !== undefined;
+    const rawPath = node.forEach ?? node.forEachOrNull ?? "";
+    const applyType = isOrNull ? "OUTER APPLY" : "CROSS APPLY";
+    const alias = (0, aliasGenerator_js_1.freshAlias)(ctx, "forEach");
+    const applyClause = buildForEachApply(rawPath, ctx.source, alias, applyType, ctx.transpilerCtx, deps.pathParser);
+    const innerCtx = buildInnerCtx(ctx, alias, rawPath, applyClause, isOrNull);
+    const innerNode = {
+        column: node.column,
+        select: node.select,
+        unionAll: node.unionAll,
+    };
+    const inner = walk(innerNode, innerCtx);
+    return {
+        ...inner,
+        fromExtensions: applyClause + inner.fromExtensions,
+    };
+}
+function buildInnerCtx(ctx, alias, rawPath, applyClause, isOrNull) {
+    const innerTranspilerCtx = {
+        ...ctx.transpilerCtx,
+        iterationContext: `${alias}.value`,
+        currentForEachAlias: alias,
+        forEachSource: ctx.source,
+        forEachPath: `$.${rawPath}`,
+    };
+    const innerKey = {
+        name: `${alias}_key`,
+        sqlExpr: `${alias}.[key]`,
+        sqlType: types_js_1.SQL_NVARCHAR_4000,
+    };
+    return {
+        ...ctx,
+        source: `${alias}.value`,
+        partitionKeys: [...ctx.partitionKeys, innerKey],
+        ancestorApplies: ctx.ancestorApplies + applyClause,
+        nullable: ctx.nullable || isOrNull,
+        transpilerCtx: innerTranspilerCtx,
+    };
+}
+/**
+ * Builds the CROSS/OUTER APPLY clause string for a forEach path, handling
+ * `.where()`, `.first()`, array indexing, and multi-segment array
+ * flattening.
+ */
+function buildForEachApply(rawPath, source, alias, applyType, transpilerCtx, pathParser) {
+    const { path: pathWithoutWhere, whereCondition, useFirst, } = pathParser.parseFhirPathWhere(rawPath, transpilerCtx);
+    const { path: forEachPath, arrayIndex } = pathParser.parseArrayIndexing(pathWithoutWhere);
+    const arrayPaths = pathParser.detectArrayFlatteningPaths(forEachPath);
+    if (arrayPaths.length > 1) {
+        return buildNestedApply(arrayPaths, source, alias, applyType, pathParser, arrayIndex, whereCondition);
+    }
+    return buildSimpleApply(applyType, source, forEachPath, alias, arrayIndex, whereCondition, useFirst);
+}
+function buildSimpleApply(applyType, source, path, alias, arrayIndex, whereCondition, useFirst) {
+    const whereClauses = [];
+    if (arrayIndex !== null)
+        whereClauses.push(`[key] = '${arrayIndex}'`);
+    if (whereCondition !== null)
+        whereClauses.push(whereCondition);
+    if (whereClauses.length > 0 || useFirst) {
+        const topClause = useFirst ? "TOP 1 " : "";
+        const orderBy = useFirst ? " ORDER BY [key]" : "";
+        const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+        return `\n${applyType} (
+        SELECT ${topClause}* FROM OPENJSON(${source}, '$.${path}')
+        ${whereClause}${orderBy}
+      ) AS ${alias}`;
+    }
+    return `\n${applyType} OPENJSON(${source}, '$.${path}') AS ${alias}`;
+}
+function buildNestedApply(arrayPaths, source, finalAlias, applyType, pathParser, arrayIndex, whereCondition) {
+    let clauses = "";
+    let currentSource = source;
+    for (let i = 0; i < arrayPaths.length; i++) {
+        const isLast = i === arrayPaths.length - 1;
+        const alias = isLast ? finalAlias : `${finalAlias}_nest${i}`;
+        const segment = pathParser.extractPathSegment(arrayPaths, i);
+        const { cleanSegment, segmentIndex } = pathParser.parseSegmentIndexing(segment);
+        const jsonPath = `$.${cleanSegment}`;
+        const whereClauses = [];
+        if (segmentIndex !== null) {
+            whereClauses.push(`[key] = '${segmentIndex}'`);
+        }
+        else if (isLast && arrayIndex !== null) {
+            whereClauses.push(`[key] = '${arrayIndex}'`);
+        }
+        if (isLast && whereCondition !== null)
+            whereClauses.push(whereCondition);
+        if (whereClauses.length > 0) {
+            clauses += `\n${applyType} (
+        SELECT * FROM OPENJSON(${currentSource}, '${jsonPath}')
+        WHERE ${whereClauses.join(" AND ")}
+      ) AS ${alias}`;
+        }
+        else {
+            clauses += `\n${applyType} OPENJSON(${currentSource}, '${jsonPath}') AS ${alias}`;
+        }
+        currentSource = `${alias}.value`;
+    }
+    return clauses;
+}
+//# sourceMappingURL=forEach.js.map

package/dist/queryGenerator/treeWalker/operators/forEach.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"forEach.js","sourceRoot":"","sources":["../../../../src/queryGenerator/treeWalker/operators/forEach.ts"],"names":[],"mappings":"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"}

package/dist/queryGenerator/treeWalker/operators/group.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Walker for Group nodes — visits each child and merges their fragments.
+ *
+ * If the node has both `column` and `select`, the columns are emitted as
+ * an implicit first ColumnsOnly child so they appear before the children's
+ * projections in lexical order.
+ */
+import type { ViewDefinitionSelect } from "../../../types.js";
+import type { ColumnExpressionGenerator } from "../../ColumnExpressionGenerator.js";
+import type { Context, Fragment } from "../types.js";
+import { projectColumns } from "./columnsOnly.js";
+/**
+ * Walker for Group nodes — visits each child select and merges their Fragments.
+ *
+ * If the node has both `column[]` and `select[]`, the columns are emitted as
+ * an implicit first ColumnsOnly child so they appear before the child select
+ * projections in lexical order.  All children are walked with the same
+ * unmodified `ctx`; their Fragments are merged via `mergeSiblings`.
+ *
+ * Returns an empty Fragment when the node has neither `column[]` nor
+ * `select[]` children.
+ *
+ * @param node - The Group select node, which may carry `column[]`, `select[]`,
+ *   or both.
+ * @param ctx - The current walker context passed unchanged to every child.
+ * @param walk - The recursive walk function used to visit each child select
+ *   node.
+ * @param columnGenerator - The generator forwarded to `walkColumnsOnly` when
+ *   the node also carries inline `column[]` entries.
+ * @returns A merged Fragment whose columns, CTEs, and FROM extensions are the
+ *   ordered union of all child Fragments.
+ */
+export declare function walkGroup(node: ViewDefinitionSelect, ctx: Context, walk: (n: ViewDefinitionSelect, c: Context) => Fragment, columnGenerator: ColumnExpressionGenerator): Fragment;
+export { projectColumns };
+//# sourceMappingURL=group.d.ts.map

package/dist/queryGenerator/treeWalker/operators/group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../../../../src/queryGenerator/treeWalker/operators/group.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAEpF,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,cAAc,EAAmB,MAAM,kBAAkB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,oBAAoB,EAC1B,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,CAAC,CAAC,EAAE,oBAAoB,EAAE,CAAC,EAAE,OAAO,KAAK,QAAQ,EACvD,eAAe,EAAE,yBAAyB,GACzC,QAAQ,CAuBV;AAGD,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/queryGenerator/treeWalker/operators/group.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Walker for Group nodes — visits each child and merges their fragments.
+ *
+ * If the node has both `column` and `select`, the columns are emitted as
+ * an implicit first ColumnsOnly child so they appear before the children's
+ * projections in lexical order.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectColumns = void 0;
+exports.walkGroup = walkGroup;
+const mergeSiblings_js_1 = require("../mergeSiblings.js");
+const columnsOnly_js_1 = require("./columnsOnly.js");
+Object.defineProperty(exports, "projectColumns", { enumerable: true, get: function () { return columnsOnly_js_1.projectColumns; } });
+/**
+ * Walker for Group nodes — visits each child select and merges their Fragments.
+ *
+ * If the node has both `column[]` and `select[]`, the columns are emitted as
+ * an implicit first ColumnsOnly child so they appear before the child select
+ * projections in lexical order.  All children are walked with the same
+ * unmodified `ctx`; their Fragments are merged via `mergeSiblings`.
+ *
+ * Returns an empty Fragment when the node has neither `column[]` nor
+ * `select[]` children.
+ *
+ * @param node - The Group select node, which may carry `column[]`, `select[]`,
+ *   or both.
+ * @param ctx - The current walker context passed unchanged to every child.
+ * @param walk - The recursive walk function used to visit each child select
+ *   node.
+ * @param columnGenerator - The generator forwarded to `walkColumnsOnly` when
+ *   the node also carries inline `column[]` entries.
+ * @returns A merged Fragment whose columns, CTEs, and FROM extensions are the
+ *   ordered union of all child Fragments.
+ */
+function walkGroup(node, ctx, walk, columnGenerator) {
+    const children = [];
+    if (node.column && node.column.length > 0) {
+        children.push((0, columnsOnly_js_1.walkColumnsOnly)(node, ctx, columnGenerator));
+    }
+    if (node.select) {
+        for (const child of node.select) {
+            children.push(walk(child, ctx));
+        }
+    }
+    if (children.length === 0) {
+        return {
+            ctes: [],
+            fromExtensions: "",
+            columns: [],
+            partitionKeys: ctx.partitionKeys,
+        };
+    }
+    return (0, mergeSiblings_js_1.mergeSiblings)(children, ctx);
+}
+//# sourceMappingURL=group.js.map

package/dist/queryGenerator/treeWalker/operators/group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.js","sourceRoot":"","sources":["../../../../src/queryGenerator/treeWalker/operators/group.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AA6BH,8BA4BC;AArDD,0DAAoD;AAEpD,qDAAmE;AAsD1D,+FAtDA,+BAAc,OAsDA;AApDvB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,SAAS,CACvB,IAA0B,EAC1B,GAAY,EACZ,IAAuD,EACvD,eAA0C;IAE1C,MAAM,QAAQ,GAAe,EAAE,CAAC;IAEhC,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1C,QAAQ,CAAC,IAAI,CAAC,IAAA,gCAAe,EAAC,IAAI,EAAE,GAAG,EAAE,eAAe,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;QAChB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAED,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO;YACL,IAAI,EAAE,EAAE;YACR,cAAc,EAAE,EAAE;YAClB,OAAO,EAAE,EAAE;YACX,aAAa,EAAE,GAAG,CAAC,aAAa;SACjC,CAAC;IACJ,CAAC;IAED,OAAO,IAAA,gCAAa,EAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;AACtC,CAAC"}

package/dist/queryGenerator/treeWalker/operators/repeat.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Walker for Repeat nodes — emits a recursive CTE and returns a set Fragment.
+ *
+ * The CTE projects the current partition keys and any baked scalar columns
+ * plus a content-derived `__path` for stable identity across re-evaluations.
+ * The Fragment's `fromExtensions` is an INNER JOIN to the CTE on the partition key
+ * `[id]`; sibling-level composite-key joins are added by `mergeSiblings`.
+ */
+import type { ViewDefinitionSelect } from "../../../types.js";
+import { type Context, type Fragment } from "../types.js";
+export interface RepeatDeps {
+    schemaName: string;
+    tableName: string;
+}
+/**
+ * Walker for Repeat nodes — emits a recursive CTE and returns a set Fragment.
+ *
+ * Generates a `WITH RECURSIVE`-style CTE (via `buildRepeatCte`) whose anchor
+ * member starts at the resource root and whose recursive members re-expand
+ * each element's `item_json` using the same path list.  The CTE accumulates a
+ * `__path` string for stable per-element identity across recursion levels.
+ *
+ * The returned Fragment contains the CTE plus an `INNER JOIN` to it in
+ * `fromExtensions`; the join is keyed on all current partition keys so that
+ * only rows belonging to the enclosing resource (and any ancestor forEach)
+ * are included.  The inner context updates `source` to `<cteAlias>.item_json`
+ * and appends a new `<cteAlias>_path` partition key so that nested operators
+ * can further partition the result set.
+ *
+ * @param node - The Repeat select node; `node.repeat` supplies the ordered
+ *   list of FHIRPath strings used as the anchor and recursive paths.
+ * @param ctx - The current walker context; the inner context is derived from
+ *   it by updating `source`, `partitionKeys`, `ancestorApplies`, and
+ *   `transpilerCtx`.
+ * @param walk - The recursive walk function used to visit the inner sub-tree
+ *   (`column`, `select`, `unionAll`) in the repeat-item context.
+ * @param deps - Schema and table name needed to construct the resource FROM
+ *   clause inside the CTE anchor.
+ * @returns A Fragment whose `ctes` list begins with the recursive CTE,
+ *   `fromExtensions` begins with the INNER JOIN to that CTE, and `columns`
+ *   are those produced by the inner walk.
+ * @throws {Error} When `node.repeat` is absent or empty.
+ */
+export declare function walkRepeat(node: ViewDefinitionSelect, ctx: Context, walk: (n: ViewDefinitionSelect, c: Context) => Fragment, deps: RepeatDeps): Fragment;
+//# sourceMappingURL=repeat.d.ts.map

package/dist/queryGenerator/treeWalker/operators/repeat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repeat.d.ts","sourceRoot":"","sources":["../../../../src/queryGenerator/treeWalker/operators/repeat.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAG9D,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,QAAQ,EAGd,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,oBAAoB,EAC1B,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,CAAC,CAAC,EAAE,oBAAoB,EAAE,CAAC,EAAE,OAAO,KAAK,QAAQ,EACvD,IAAI,EAAE,UAAU,GACf,QAAQ,CAmCV"}

package/dist/queryGenerator/treeWalker/operators/repeat.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Walker for Repeat nodes — emits a recursive CTE and returns a set Fragment.
+ *
+ * The CTE projects the current partition keys and any baked scalar columns
+ * plus a content-derived `__path` for stable identity across re-evaluations.
+ * The Fragment's `fromExtensions` is an INNER JOIN to the CTE on the partition key
+ * `[id]`; sibling-level composite-key joins are added by `mergeSiblings`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkRepeat = walkRepeat;
+const aliasGenerator_js_1 = require("../aliasGenerator.js");
+const cteTemplates_js_1 = require("../cteTemplates.js");
+const types_js_1 = require("../types.js");
+/**
+ * Walker for Repeat nodes — emits a recursive CTE and returns a set Fragment.
+ *
+ * Generates a `WITH RECURSIVE`-style CTE (via `buildRepeatCte`) whose anchor
+ * member starts at the resource root and whose recursive members re-expand
+ * each element's `item_json` using the same path list.  The CTE accumulates a
+ * `__path` string for stable per-element identity across recursion levels.
+ *
+ * The returned Fragment contains the CTE plus an `INNER JOIN` to it in
+ * `fromExtensions`; the join is keyed on all current partition keys so that
+ * only rows belonging to the enclosing resource (and any ancestor forEach)
+ * are included.  The inner context updates `source` to `<cteAlias>.item_json`
+ * and appends a new `<cteAlias>_path` partition key so that nested operators
+ * can further partition the result set.
+ *
+ * @param node - The Repeat select node; `node.repeat` supplies the ordered
+ *   list of FHIRPath strings used as the anchor and recursive paths.
+ * @param ctx - The current walker context; the inner context is derived from
+ *   it by updating `source`, `partitionKeys`, `ancestorApplies`, and
+ *   `transpilerCtx`.
+ * @param walk - The recursive walk function used to visit the inner sub-tree
+ *   (`column`, `select`, `unionAll`) in the repeat-item context.
+ * @param deps - Schema and table name needed to construct the resource FROM
+ *   clause inside the CTE anchor.
+ * @returns A Fragment whose `ctes` list begins with the recursive CTE,
+ *   `fromExtensions` begins with the INNER JOIN to that CTE, and `columns`
+ *   are those produced by the inner walk.
+ * @throws {Error} When `node.repeat` is absent or empty.
+ */
+function walkRepeat(node, ctx, walk, deps) {
+    const cteAlias = (0, aliasGenerator_js_1.freshAlias)(ctx, "repeat");
+    const paths = node.repeat ?? [];
+    if (paths.length === 0) {
+        throw new Error("walkRepeat: repeat node has empty paths array");
+    }
+    const tableRef = `[${deps.schemaName}].[${deps.tableName}]`;
+    const cte = (0, cteTemplates_js_1.buildRepeatCte)({
+        cteAlias,
+        paths,
+        source: ctx.source,
+        fromClause: `FROM ${tableRef} AS [${ctx.resourceAlias}]`,
+        ancestorApplies: ctx.ancestorApplies,
+        partitionKeys: ctx.partitionKeys,
+        resourcePredicate: null, // Resource-level WHERE goes in the outer SELECT.
+    });
+    const joinClause = buildJoinClause(cteAlias, ctx);
+    const innerCtx = buildRepeatInnerCtx(ctx, cteAlias, paths, joinClause);
+    const innerNode = {
+        column: node.column,
+        select: node.select,
+        unionAll: node.unionAll,
+    };
+    const inner = walk(innerNode, innerCtx);
+    return {
+        ctes: [cte, ...inner.ctes],
+        // Join the CTE FIRST so subsequent applies/joins inside the repeat
+        // (which reference `<cteAlias>.item_json`) have the alias in scope.
+        fromExtensions: joinClause + inner.fromExtensions,
+        columns: inner.columns,
+        partitionKeys: innerCtx.partitionKeys,
+    };
+}
+/**
+ * Outer-SELECT join condition aligning this CTE's rows with the enclosing
+ * partition (resource id plus any forEach/repeat keys above this scope).
+ */
+function buildJoinClause(cteAlias, ctx) {
+    const joinConditions = ctx.partitionKeys
+        .map((k) => `${cteAlias}.[${k.name}] = ${k.sqlExpr}`)
+        .join(" AND ");
+    return `\nINNER JOIN ${cteAlias} ON ${joinConditions}`;
+}
+function buildRepeatInnerCtx(ctx, cteAlias, paths, joinClause) {
+    const newKey = {
+        name: `${cteAlias}_path`,
+        sqlExpr: `${cteAlias}.__path`,
+        sqlType: types_js_1.SQL_NVARCHAR_MAX,
+    };
+    const innerTranspilerCtx = {
+        ...ctx.transpilerCtx,
+        iterationContext: `${cteAlias}.item_json`,
+        currentForEachAlias: cteAlias,
+        forEachSource: ctx.source,
+        forEachPath: paths.map((p) => `$.${p}`).join(", "),
+    };
+    // Propagate the join into ancestorApplies so any *nested* Repeat builds
+    // its CTE anchor with this CTE in scope.
+    return {
+        ...ctx,
+        source: `${cteAlias}.item_json`,
+        partitionKeys: [...ctx.partitionKeys, newKey],
+        ancestorApplies: ctx.ancestorApplies + joinClause,
+        transpilerCtx: innerTranspilerCtx,
+    };
+}
+//# sourceMappingURL=repeat.js.map

package/dist/queryGenerator/treeWalker/operators/repeat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repeat.js","sourceRoot":"","sources":["../../../../src/queryGenerator/treeWalker/operators/repeat.ts"],"names":[],"mappings":"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"}

package/dist/queryGenerator/treeWalker/operators/unionAll.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Walker for UnionAll nodes.
+ *
+ * Emits a local derived table with one SELECT per branch, joined by
+ * `UNION ALL`, wrapped as `CROSS APPLY (...) AS ua_<n>`. CTEs from any
+ * branch (e.g. enclosed Repeats) bubble up to the top-level WITH clause.
+ *
+ * Branches must produce the same column names and types (SoF spec
+ * requirement). The walker aligns them positionally — branch[0]'s names
+ * become the outer projection.
+ *
+ * If the same node also has `column[]` or `select[]` alongside `unionAll`,
+ * those are emitted as outer siblings (they live in the SELECT list at the
+ * same level as the ua_<n> projection, evaluated in the parent scope).
+ */
+import type { ViewDefinitionSelect } from "../../../types.js";
+import type { ColumnExpressionGenerator } from "../../ColumnExpressionGenerator.js";
+import type { Context, Fragment } from "../types.js";
+export interface UnionAllDeps {
+    columnGenerator: ColumnExpressionGenerator;
+}
+/**
+ * Walker for UnionAll nodes.
+ *
+ * Walks each branch of `node.unionAll` in the current context and assembles
+ * them into a `CROSS APPLY (...) AS ua_<n>` derived table where each branch
+ * contributes a `SELECT … FROM (SELECT 1 AS _) AS _seed …` statement joined
+ * by `UNION ALL`.  Branch columns are aligned positionally to branch[0]'s
+ * names, satisfying the SoF spec requirement that all branches produce the
+ * same column names and types.
+ *
+ * CTEs from any branch (e.g. produced by enclosed Repeat nodes) bubble up
+ * into the returned Fragment's `ctes` list so they appear in the top-level
+ * `WITH` clause.
+ *
+ * If the same node also carries `column[]` or `select[]` alongside
+ * `unionAll`, those are emitted as outer siblings in the enclosing SELECT
+ * scope and merged with the union fragment via `mergeSiblings`.
+ *
+ * @param node - The UnionAll select node; `node.unionAll` must be a non-empty
+ *   array of branch select nodes.
+ * @param ctx - The current walker context, passed unchanged to every branch
+ *   and to any sibling column/select processing.
+ * @param walk - The recursive walk function used to visit each branch and any
+ *   outer sibling select nodes.
+ * @param deps - Dependencies containing the `ColumnExpressionGenerator` used
+ *   to project any outer sibling `column[]` entries.
+ * @returns A Fragment whose `fromExtensions` contains the `CROSS APPLY`
+ *   derived-table clause, `ctes` aggregates all branch CTEs, and `columns`
+ *   contains the outer projection (plus any sibling columns).
+ * @throws {Error} When `node.unionAll` is empty.
+ */
+export declare function walkUnionAll(node: ViewDefinitionSelect, ctx: Context, walk: (n: ViewDefinitionSelect, c: Context) => Fragment, deps: UnionAllDeps): Fragment;
+//# sourceMappingURL=unionAll.d.ts.map

package/dist/queryGenerator/treeWalker/operators/unionAll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unionAll.d.ts","sourceRoot":"","sources":["../../../../src/queryGenerator/treeWalker/operators/unionAll.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAGpF,OAAO,KAAK,EACV,OAAO,EAEP,QAAQ,EAET,MAAM,aAAa,CAAC;AAGrB,MAAM,WAAW,YAAY;IAC3B,eAAe,EAAE,yBAAyB,CAAC;CAC5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,oBAAoB,EAC1B,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,CAAC,CAAC,EAAE,oBAAoB,EAAE,CAAC,EAAE,OAAO,KAAK,QAAQ,EACvD,IAAI,EAAE,YAAY,GACjB,QAAQ,CAWV"}