@cap-js/process 0.0.0 → 0.1.1

package/dist/lib/shared/input-parser.js

@@ -0,0 +1,650 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WILDCARD = void 0;
+exports.isAliasInput = isAliasInput;
+exports.isSimpleInput = isSimpleInput;
+exports.parsePath = parsePath;
+exports.parseInputsArray = parseInputsArray;
+exports.buildInputTree = buildInputTree;
+/**
+ * Type guard for alias input entries
+ */
+function isAliasInput(entry) {
+    return 'path' in entry && 'as' in entry;
+}
+/**
+ * Type guard for simple input entries
+ */
+function isSimpleInput(entry) {
+    return '=' in entry && !('path' in entry);
+}
+/**
+ * Special marker for selecting all scalar fields
+ */
+exports.WILDCARD = '*';
+/**
+ * Parses a path string like "$self.items.title" into ["items", "title"]
+ * Strips the "$self." prefix and splits by "."
+ *
+ * Special case: "$self" alone returns ['*'] to indicate all scalar fields
+ */
+function parsePath(pathString) {
+    // Handle $self alone - means all scalar fields
+    if (pathString === '$self') {
+        return [exports.WILDCARD];
+    }
+    return pathString.replace(/^\$self\./, '').split('.');
+}
+/**
+ * Parses the inputs CSN array into parsed entries
+ *
+ * @param inputsCSN - Array of CSN input entries from the annotation
+ * @returns Array of parsed entries with path segments and optional alias
+ *
+ * @example
+ * // Input:
+ * [
+ *   { '=': '$self' },                              // Wildcard: all scalar fields
+ *   { '=': '$self.ID' },
+ *   { '=': '$self.items.title' },
+ *   { path: { '=': '$self.price' }, as: 'Amount' }
+ * ]
+ *
+ * Output:
+ * [
+ *   { path: ['*'], alias: undefined },             // Wildcard marker
+ *   { path: ['ID'], alias: undefined },
+ *   { path: ['items', 'title'], alias: undefined },
+ *   { path: ['price'], alias: 'Amount' }
+ * ]
+ */
+function parseInputsArray(inputsCSN) {
+    if (!inputsCSN || inputsCSN.length === 0) {
+        return [];
+    }
+    const parsedEntries = [];
+    for (const entry of inputsCSN) {
+        if (isAliasInput(entry)) {
+            parsedEntries.push({
+                path: parsePath(entry.path['=']),
+                alias: entry.as,
+            });
+        }
+        else if (isSimpleInput(entry)) {
+            parsedEntries.push({
+                path: parsePath(entry['=']),
+                alias: undefined,
+            });
+        }
+    }
+    return parsedEntries;
+}
+/**
+ * Classification of how an element group should be processed
+ */
+var ElementKind;
+(function (ElementKind) {
+    /** Simple scalar field */
+    ElementKind["SCALAR"] = "SCALAR";
+    /** Association/Composition to expand all fields */
+    ElementKind["ASSOC_EXPAND_ALL"] = "ASSOC_EXPAND_ALL";
+    /** Association/Composition with specific nested fields */
+    ElementKind["ASSOC_WITH_NESTED"] = "ASSOC_WITH_NESTED";
+    /** Multiple aliases on same element (no non-aliased entry) */
+    ElementKind["MULTI_ALIAS"] = "MULTI_ALIAS";
+})(ElementKind || (ElementKind = {}));
+/**
+ * Groups entries by their first path segment.
+ *
+ * This is the first step in preprocessing - it collects all entries that reference
+ * the same root element so they can be analyzed together.
+ *
+ * @example
+ *  Input: entries from annotation like:
+ *  inputs: [$self.ID, $self.title, $self.items, $self.items.quantity]
+ * const entries = [
+ *   { path: ['ID'], alias: undefined },
+ *   { path: ['title'], alias: undefined },
+ *   { path: ['items'], alias: undefined },
+ *   { path: ['items', 'quantity'], alias: undefined }
+ * ];
+ *
+ *  Output: Map grouping by first segment
+ *  Map {
+ *    'ID'    => [{ path: ['ID'], alias: undefined }],
+ *    'title' => [{ path: ['title'], alias: undefined }],
+ *    'items' => [
+ *      { path: ['items'], alias: undefined },           // direct reference
+ *      { path: ['items', 'quantity'], alias: undefined } // nested reference
+ *    ]
+ *  }
+ *
+ * @example
+ *  Multiple aliases on same element:
+ *  inputs: [{ path: $self.ID, as: 'OrderId' }, { path: $self.ID, as: 'RefId' }]
+ * const entries = [
+ *   { path: ['ID'], alias: 'OrderId' },
+ *   { path: ['ID'], alias: 'RefId' }
+ * ];
+ *
+ *  Output:
+ *  Map {
+ *    'ID' => [
+ *      { path: ['ID'], alias: 'OrderId' },
+ *      { path: ['ID'], alias: 'RefId' }
+ *    ]
+ *  }
+ */
+function groupEntriesByFirstSegment(entries) {
+    const groups = new Map();
+    for (const entry of entries) {
+        const firstSegment = entry.path[0];
+        if (!groups.has(firstSegment)) {
+            groups.set(firstSegment, []);
+        }
+        groups.get(firstSegment).push(entry);
+    }
+    return groups;
+}
+/**
+ * Analyzes a group of entries for the same element and categorizes them.
+ *
+ * Separates entries into:
+ * - directEntries: References to the element itself (path length = 1)
+ * - nonAliasedDirect: The first direct entry without an alias (used as primary)
+ * - aliasedDirect: Direct entries with aliases (may create additional nodes)
+ * - nestedEntries: References to nested fields (path length > 1), with first segment stripped
+ *
+ * @example
+ *  Simple scalar field: [$self.ID]
+ * analyzeEntryGroup([{ path: ['ID'], alias: undefined }])
+ *  Returns:
+ *  {
+ *    directEntries: [{ path: ['ID'], alias: undefined }],
+ *    nonAliasedDirect: { path: ['ID'], alias: undefined },
+ *    aliasedDirect: [],
+ *    nestedEntries: []
+ *  }
+ *
+ * @example
+ *  Composition with nested fields: [$self.items, $self.items.quantity, $self.items.price]
+ * analyzeEntryGroup([
+ *   { path: ['items'], alias: undefined },
+ *   { path: ['items', 'quantity'], alias: undefined },
+ *   { path: ['items', 'price'], alias: undefined }
+ * ])
+ *  Returns:
+ *  {
+ *    directEntries: [{ path: ['items'], alias: undefined }],
+ *    nonAliasedDirect: { path: ['items'], alias: undefined },
+ *    aliasedDirect: [],
+ *    nestedEntries: [
+ *      { path: ['quantity'], alias: undefined },  // 'items' stripped
+ *      { path: ['price'], alias: undefined }      // 'items' stripped
+ *    ]
+ *  }
+ *
+ * @example
+ *  Multiple aliases without non-aliased: [{ path: $self.ID, as: 'OrderId' }, { path: $self.ID, as: 'RefId' }]
+ * analyzeEntryGroup([
+ *   { path: ['ID'], alias: 'OrderId' },
+ *   { path: ['ID'], alias: 'RefId' }
+ * ])
+ *  Returns:
+ *  {
+ *    directEntries: [{ path: ['ID'], alias: 'OrderId' }, { path: ['ID'], alias: 'RefId' }],
+ *    nonAliasedDirect: undefined,  // No non-aliased entry!
+ *    aliasedDirect: [{ path: ['ID'], alias: 'OrderId' }, { path: ['ID'], alias: 'RefId' }],
+ *    nestedEntries: []
+ *  }
+ *
+ * @example
+ * Both aliased and non-aliased: [$self.ID, { path: $self.ID, as: 'EntityId' }]
+ * analyzeEntryGroup([
+ *   { path: ['ID'], alias: undefined },
+ *   { path: ['ID'], alias: 'EntityId' }
+ * ])
+ *  Returns:
+ *  {
+ *    directEntries: [{ path: ['ID'], alias: undefined }, { path: ['ID'], alias: 'EntityId' }],
+ *    nonAliasedDirect: { path: ['ID'], alias: undefined },
+ *    aliasedDirect: [{ path: ['ID'], alias: 'EntityId' }],
+ *    nestedEntries: []
+ *  }
+ */
+function analyzeEntryGroup(group) {
+    const directEntries = group.filter((e) => e.path.length === 1);
+    const nonAliasedDirect = directEntries.find((e) => !e.alias);
+    const aliasedDirect = directEntries.filter((e) => e.alias);
+    const nestedEntries = group
+        .filter((e) => e.path.length > 1)
+        .map((e) => ({ path: e.path.slice(1), alias: e.alias }));
+    return { directEntries, nonAliasedDirect, aliasedDirect, nestedEntries };
+}
+/**
+ * Classifies an element and determines how it should be processed.
+ *
+ * This determines which state machine handler will process the element:
+ * - SCALAR: Simple field → creates one node (+ extra nodes for additional aliases)
+ * - ASSOC_EXPAND_ALL: Composition without nested fields → expands all fields
+ * - ASSOC_WITH_NESTED: Composition with specific nested fields → recurses
+ * - MULTI_ALIAS: Multiple aliases without non-aliased entry → creates node per alias
+ *
+ * @example
+ *  Case 1: MULTI_ALIAS - Multiple aliases, no non-aliased entry
+ *  inputs: [{ path: $self.ID, as: 'OrderId' }, { path: $self.ID, as: 'RefId' }]
+ * classifyElement('ID', {
+ *   nonAliasedDirect: undefined,
+ *   aliasedDirect: [{ path: ['ID'], alias: 'OrderId' }, { path: ['ID'], alias: 'RefId' }],
+ *   nestedEntries: []
+ * }, false)
+ *  Returns: { kind: MULTI_ALIAS, primaryAlias: undefined, additionalAliasedNodes: [{ alias: 'OrderId' }, { alias: 'RefId' }] }
+ *  Result: Two separate nodes, one per alias
+ *
+ * @example
+ *  Case 2: SCALAR with additional aliases - Both aliased and non-aliased
+ *  inputs: [$self.ID, { path: $self.ID, as: 'EntityId' }]
+ * classifyElement('ID', {
+ *   nonAliasedDirect: { path: ['ID'], alias: undefined },
+ *   aliasedDirect: [{ path: ['ID'], alias: 'EntityId' }],
+ *   nestedEntries: []
+ * }, false)
+ *  Returns: { kind: SCALAR, primaryAlias: undefined, additionalAliasedNodes: [{ alias: 'EntityId' }] }
+ *  Result: Primary node 'ID', plus extra node 'EntityId'
+ *
+ * @example
+ *  Case 3: ASSOC_WITH_NESTED - Composition with specific nested fields
+ *  inputs: [$self.items.quantity, $self.items.price]
+ * classifyElement('items', {
+ *   nonAliasedDirect: undefined,
+ *   aliasedDirect: [],
+ *   nestedEntries: [{ path: ['quantity'] }, { path: ['price'] }]
+ * }, true)
+ *  Returns: { kind: ASSOC_WITH_NESTED, primaryAlias: undefined, additionalAliasedNodes: [] }
+ *  Result: items node with nested quantity and price
+ *
+ * @example
+ *  Case 4: ASSOC_EXPAND_ALL - Composition without nested fields
+ *  inputs: [$self.items]
+ * classifyElement('items', {
+ *   nonAliasedDirect: { path: ['items'], alias: undefined },
+ *   aliasedDirect: [],
+ *   nestedEntries: []
+ * }, true)
+ *  Returns: { kind: ASSOC_EXPAND_ALL, primaryAlias: undefined, additionalAliasedNodes: [] }
+ *  Result: items node that expands all fields (associatedInputElements: [])
+ *
+ * @example
+ *  Case 5: Simple SCALAR
+ *  inputs: [$self.title]
+ * classifyElement('title', {
+ *   nonAliasedDirect: { path: ['title'], alias: undefined },
+ *   aliasedDirect: [],
+ *   nestedEntries: []
+ * }, false)
+ *  Returns: { kind: SCALAR, primaryAlias: undefined, additionalAliasedNodes: [] }
+ *  Result: Simple { sourceElement: 'title' } node
+ */
+function classifyElement(analysis, isAssocOrComp) {
+    const { nonAliasedDirect, aliasedDirect, nestedEntries } = analysis;
+    // Case 1: Multiple aliases without non-aliased entry → MULTI_ALIAS
+    // e.g., [{ path: $self.ID, as: 'OrderId' }, { path: $self.ID, as: 'RefId' }]
+    if (aliasedDirect.length > 1 && !nonAliasedDirect) {
+        return {
+            kind: ElementKind.MULTI_ALIAS,
+            primaryAlias: undefined,
+            additionalAliasedNodes: aliasedDirect.map((e) => ({ alias: e.alias })),
+        };
+    }
+    // Case 2: Scalar field with both aliased and non-aliased entries
+    // e.g., [$self.ID, { path: $self.ID, as: 'EntityId' }]
+    // → primary is non-aliased, aliased become additional nodes
+    if (!isAssocOrComp && aliasedDirect.length > 0 && nonAliasedDirect) {
+        return {
+            kind: ElementKind.SCALAR,
+            primaryAlias: undefined,
+            additionalAliasedNodes: aliasedDirect.map((e) => ({ alias: e.alias })),
+        };
+    }
+    // Case 3: Association with nested entries → ASSOC_WITH_NESTED
+    if (nestedEntries.length > 0) {
+        return {
+            kind: ElementKind.ASSOC_WITH_NESTED,
+            primaryAlias: analysis.directEntries[0]?.alias,
+            additionalAliasedNodes: [],
+        };
+    }
+    // Case 4: Association without nested → ASSOC_EXPAND_ALL
+    if (isAssocOrComp) {
+        return {
+            kind: ElementKind.ASSOC_EXPAND_ALL,
+            primaryAlias: analysis.directEntries[0]?.alias,
+            additionalAliasedNodes: [],
+        };
+    }
+    // Case 5: Simple scalar field → SCALAR
+    return {
+        kind: ElementKind.SCALAR,
+        primaryAlias: analysis.directEntries[0]?.alias,
+        additionalAliasedNodes: [],
+    };
+}
+/**
+ * Preprocesses all entries into enriched element descriptors.
+ *
+ * This is the main preprocessing function that does all upfront analysis:
+ * 1. Groups entries by first segment
+ * 2. Resolves element types (scalar vs association/composition)
+ * 3. Classifies how each element should be processed
+ * 4. Prepares nested entries with wildcard injection if needed
+ *
+ * The result is a flat list of PreprocessedElement objects that the state machine
+ * can process sequentially without any additional lookups or analysis.
+ *
+ * @example
+ *  Full preprocessing example:
+ *  Entity: { ID: scalar, title: scalar, items: Composition of Items }
+ *  Items: { quantity: Integer, price: Decimal }
+ *
+ *  Annotation inputs: [$self.ID, $self.title, $self.items, $self.items.quantity]
+ *
+ * preprocessEntries([
+ *   { path: ['ID'], alias: undefined },
+ *   { path: ['title'], alias: undefined },
+ *   { path: ['items'], alias: undefined },
+ *   { path: ['items', 'quantity'], alias: undefined }
+ * ], rootEntity, resolver)
+ *
+ *  Returns:
+ *  [
+ *    {
+ *      name: 'ID',
+ *      kind: SCALAR,
+ *      primaryAlias: undefined,
+ *      nestedEntries: [],
+ *      additionalAliasedNodes: [],
+ *      isAssocOrComp: false,
+ *      element: <ID element>,
+ *      targetEntity: rootEntity
+ *    },
+ *    {
+ *      name: 'title',
+ *      kind: SCALAR,
+ *      primaryAlias: undefined,
+ *      nestedEntries: [],
+ *      additionalAliasedNodes: [],
+ *      isAssocOrComp: false,
+ *      element: <title element>,
+ *      targetEntity: rootEntity
+ *    },
+ *    {
+ *      name: 'items',
+ *      kind: ASSOC_WITH_NESTED,
+ *      primaryAlias: undefined,
+ *      nestedEntries: [
+ *        { path: ['*'], alias: undefined },        // Wildcard injected!
+ *        { path: ['quantity'], alias: undefined }
+ *      ],
+ *      additionalAliasedNodes: [],
+ *      isAssocOrComp: true,
+ *      targetEntity: <Items entity context>
+ *    }
+ * ]
+ *
+ *  Note: The wildcard ['*'] was injected because we have both:
+ *  - $self.items (expand all) AND $self.items.quantity (specific nested)
+ *  This means "expand all items fields PLUS include quantity explicitly (for aliasing)"
+ *
+ * @example
+ *  Multiple aliases preprocessing:
+ *  inputs: [{ path: $self.ID, as: 'OrderId' }, { path: $self.ID, as: 'RefId' }]
+ *
+ * preprocessEntries([
+ *   { path: ['ID'], alias: 'OrderId' },
+ *   { path: ['ID'], alias: 'RefId' }
+ * ], rootEntity)
+ *
+ *  Returns:
+ *  [
+ *    {
+ *      name: 'ID',
+ *      kind: MULTI_ALIAS,
+ *      primaryAlias: undefined,
+ *      nestedEntries: [],
+ *      additionalAliasedNodes: [{ alias: 'OrderId' }, { alias: 'RefId' }],
+ *      isAssocOrComp: false,
+ *      targetEntity: rootEntity
+ *    }
+ *  ]
+ */
+function preprocessEntries(entries, rootEntity) {
+    const groups = groupEntriesByFirstSegment(entries);
+    const result = [];
+    for (const [elementName, group] of groups) {
+        const element = rootEntity.getElement(elementName);
+        const isAssocOrComp = element?.isAssocOrComp ?? false;
+        const targetEntity = element?.targetEntity ?? rootEntity;
+        const analysis = analyzeEntryGroup(group);
+        const classification = classifyElement(analysis, isAssocOrComp);
+        // Prepare nested entries with wildcard injection for composition expand-all + nested fields
+        let nestedEntries = analysis.nestedEntries;
+        if (isAssocOrComp &&
+            analysis.nonAliasedDirect &&
+            nestedEntries.length > 0 &&
+            classification.kind !== ElementKind.MULTI_ALIAS) {
+            // Inject wildcard to expand all fields plus specific nested fields
+            nestedEntries = [{ path: [exports.WILDCARD], alias: undefined }, ...nestedEntries];
+        }
+        result.push({
+            name: elementName,
+            kind: classification.kind,
+            primaryAlias: classification.primaryAlias,
+            nestedEntries,
+            additionalAliasedNodes: classification.additionalAliasedNodes,
+            isAssocOrComp,
+            targetEntity,
+        });
+    }
+    return result;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// STATE MACHINE
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * State Machine for building input tree from preprocessed elements
+ *
+ * Simplified Grammar (after preprocessing):
+ *   <start>       ::= INIT
+ *   INIT          ::= NEXT_ELEMENT
+ *   NEXT_ELEMENT  ::= SELECT_HANDLER | DONE
+ *   SELECT_HANDLER::= BUILD_SCALAR | BUILD_ASSOC_EXPAND | BUILD_ASSOC_NESTED | BUILD_MULTI_ALIAS
+ *   BUILD_*       ::= ADD_EXTRA_ALIASES
+ *   ADD_EXTRA     ::= NEXT_ELEMENT
+ *   <end>         ::= DONE
+ */
+var BuildState;
+(function (BuildState) {
+    /** Initialize processing */
+    BuildState["INIT"] = "INIT";
+    /** Move to next element */
+    BuildState["NEXT_ELEMENT"] = "NEXT_ELEMENT";
+    /** Select appropriate handler based on element kind */
+    BuildState["SELECT_HANDLER"] = "SELECT_HANDLER";
+    /** Build a simple scalar field node */
+    BuildState["BUILD_SCALAR"] = "BUILD_SCALAR";
+    /** Build an association node that expands all fields */
+    BuildState["BUILD_ASSOC_EXPAND"] = "BUILD_ASSOC_EXPAND";
+    /** Build an association node with specific nested fields */
+    BuildState["BUILD_ASSOC_NESTED"] = "BUILD_ASSOC_NESTED";
+    /** Build multiple nodes for multi-alias case */
+    BuildState["BUILD_MULTI_ALIAS"] = "BUILD_MULTI_ALIAS";
+    /** Add any additional aliased nodes */
+    BuildState["ADD_EXTRA_ALIASES"] = "ADD_EXTRA_ALIASES";
+    /** Processing complete */
+    BuildState["DONE"] = "DONE";
+})(BuildState || (BuildState = {}));
+/**
+ * Builds a tree structure from parsed input entries
+ *
+ * @param entries - Parsed input entries from parseInputsArray
+ * @param rootEntity - The root entity context to resolve elements from
+ *
+ * @example
+ * Input → Output mappings:
+ *
+ * 1. Wildcard (all scalar fields):
+ *    [{ path: ['*'] }] → [{ sourceElement: '*' }]
+ *
+ * 2. Simple field:
+ *    [{ path: ['ID'] }] → [{ sourceElement: 'ID' }]
+ *
+ * 3. Association (expand all) - 'items' is a Composition:
+ *    [{ path: ['items'] }] → [{ sourceElement: 'items', associatedInputElements: [] }]
+ *
+ * 4. Nested path:
+ *    [{ path: ['items', 'title'] }]
+ *    → [{ sourceElement: 'items', associatedInputElements: [{ sourceElement: 'title' }] }]
+ *
+ * 5. With alias:
+ *    [{ path: ['price'], alias: 'Amount' }]
+ *    → [{ sourceElement: 'price', targetVariable: 'Amount' }]
+ *
+ * 6. Composition expand-all + nested alias:
+ *    [{ path: ['items'] }, { path: ['items', 'ID'], alias: 'ItemId' }]
+ *    → [{ sourceElement: 'items', associatedInputElements: [
+ *         { sourceElement: '*' },
+ *         { sourceElement: 'ID', targetVariable: 'ItemId' }
+ *       ]}]
+ *
+ * 7. Multiple aliases on scalar (no non-aliased entry):
+ *    [{ path: ['ID'], alias: 'OrderId' }, { path: ['ID'], alias: 'RefId' }]
+ *    → [{ sourceElement: 'ID', targetVariable: 'OrderId' },
+ *       { sourceElement: 'ID', targetVariable: 'RefId' }]
+ *
+ * 8. Multiple aliases on composition:
+ *    [{ path: ['items'], alias: 'Order' }, { path: ['items'], alias: 'ItemOrder' }]
+ *    → [{ sourceElement: 'items', targetVariable: 'Order', associatedInputElements: [] },
+ *       { sourceElement: 'items', targetVariable: 'ItemOrder', associatedInputElements: [] }]
+ *
+ * @returns Tree of InputTreeNode representing the input structure
+ */
+function buildInputTree(entries, rootEntity) {
+    if (entries.length === 0) {
+        return [];
+    }
+    // Preprocess entries to classify and enrich them for easier processing in the state machine
+    const preprocessedElements = preprocessEntries(entries, rootEntity);
+    const result = [];
+    let state = BuildState.INIT;
+    let currentIndex = 0;
+    let currentElement = null;
+    while (state !== BuildState.DONE) {
+        switch (state) {
+            case BuildState.INIT: {
+                currentIndex = 0;
+                state = BuildState.NEXT_ELEMENT;
+                break;
+            }
+            case BuildState.NEXT_ELEMENT: {
+                if (currentIndex >= preprocessedElements.length) {
+                    state = BuildState.DONE;
+                }
+                else {
+                    currentElement = preprocessedElements[currentIndex];
+                    state = BuildState.SELECT_HANDLER;
+                }
+                break;
+            }
+            case BuildState.SELECT_HANDLER: {
+                switch (currentElement.kind) {
+                    case ElementKind.SCALAR:
+                        state = BuildState.BUILD_SCALAR;
+                        break;
+                    case ElementKind.ASSOC_EXPAND_ALL:
+                        state = BuildState.BUILD_ASSOC_EXPAND;
+                        break;
+                    case ElementKind.ASSOC_WITH_NESTED:
+                        state = BuildState.BUILD_ASSOC_NESTED;
+                        break;
+                    case ElementKind.MULTI_ALIAS:
+                        state = BuildState.BUILD_MULTI_ALIAS;
+                        break;
+                }
+                break;
+            }
+            case BuildState.BUILD_SCALAR: {
+                result.push({
+                    sourceElement: currentElement.name,
+                    targetVariable: currentElement.primaryAlias,
+                });
+                state = BuildState.ADD_EXTRA_ALIASES;
+                break;
+            }
+            case BuildState.BUILD_ASSOC_EXPAND: {
+                result.push({
+                    sourceElement: currentElement.name,
+                    targetVariable: currentElement.primaryAlias,
+                    associatedInputElements: [],
+                });
+                state = BuildState.ADD_EXTRA_ALIASES;
+                break;
+            }
+            case BuildState.BUILD_ASSOC_NESTED: {
+                const nestedResults = buildInputTree(currentElement.nestedEntries, currentElement.targetEntity);
+                result.push({
+                    sourceElement: currentElement.name,
+                    targetVariable: currentElement.primaryAlias,
+                    associatedInputElements: nestedResults,
+                });
+                state = BuildState.ADD_EXTRA_ALIASES;
+                break;
+            }
+            case BuildState.BUILD_MULTI_ALIAS: {
+                // Build a node for each alias
+                for (const { alias } of currentElement.additionalAliasedNodes) {
+                    if (currentElement.isAssocOrComp) {
+                        if (currentElement.nestedEntries.length > 0) {
+                            const nestedResults = buildInputTree(currentElement.nestedEntries, currentElement.targetEntity);
+                            result.push({
+                                sourceElement: currentElement.name,
+                                targetVariable: alias,
+                                associatedInputElements: nestedResults,
+                            });
+                        }
+                        else {
+                            result.push({
+                                sourceElement: currentElement.name,
+                                targetVariable: alias,
+                                associatedInputElements: [],
+                            });
+                        }
+                    }
+                    else {
+                        result.push({
+                            sourceElement: currentElement.name,
+                            targetVariable: alias,
+                        });
+                    }
+                }
+                // Skip ADD_EXTRA_ALIASES since MULTI_ALIAS handles all aliases
+                currentIndex++;
+                state = BuildState.NEXT_ELEMENT;
+                break;
+            }
+            case BuildState.ADD_EXTRA_ALIASES: {
+                // Add any additional aliased nodes (e.g., from [$self.ID, { path: $self.ID, as: 'EntityId' }])
+                for (const { alias } of currentElement.additionalAliasedNodes) {
+                    result.push({
+                        sourceElement: currentElement.name,
+                        targetVariable: alias,
+                    });
+                }
+                currentIndex++;
+                state = BuildState.NEXT_ELEMENT;
+                break;
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=input-parser.js.map

package/dist/lib/shared/input-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-parser.js","sourceRoot":"","sources":["../../../lib/shared/input-parser.ts"],"names":[],"mappings":"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"}