@pikku/inspector 0.11.0 → 0.11.1

package/dist/workflow/extract-simple-workflow.js

@@ -0,0 +1,803 @@
+import * as ts from 'typescript';
+import { extractStringLiteral, extractNumberLiteral, } from '../utils/extract-node-value.js';
+import { isWorkflowDoCall, isWorkflowSleepCall, isParallelFanout, isParallelGroup, isSequentialFanout, extractForOfVariable, isArrayType, getSourceText, } from './patterns.js';
+import { validateNoDisallowedPatterns, validateAwaitedCalls, formatValidationErrors, } from './validation.js';
+/**
+ * Extract simple workflow metadata from a function declaration
+ */
+export function extractSimpleWorkflow(funcNode, checker) {
+    try {
+        // Find the async arrow function
+        const arrowFunc = findWorkflowFunction(funcNode);
+        if (!arrowFunc) {
+            return {
+                status: 'error',
+                reason: 'Could not find async arrow function in workflow definition',
+                simple: false,
+            };
+        }
+        // Extract input parameter name (second parameter)
+        const inputParamName = extractInputParamName(arrowFunc);
+        if (!inputParamName) {
+            return {
+                status: 'error',
+                reason: 'Could not determine input parameter name',
+                simple: false,
+            };
+        }
+        // Initialize extraction context
+        const context = {
+            checker,
+            outputVars: new Map(),
+            arrayVars: new Set(),
+            conditionalVars: new Set(),
+            inputParamName,
+            errors: [],
+        };
+        // Validate no disallowed patterns
+        const patternErrors = validateNoDisallowedPatterns(arrowFunc.body);
+        if (patternErrors.length > 0) {
+            return {
+                status: 'error',
+                reason: formatValidationErrors(patternErrors),
+                simple: false,
+            };
+        }
+        // Validate all workflow calls are awaited
+        const awaitErrors = validateAwaitedCalls(arrowFunc.body);
+        if (awaitErrors.length > 0) {
+            return {
+                status: 'error',
+                reason: formatValidationErrors(awaitErrors),
+                simple: false,
+            };
+        }
+        // Extract steps from function body
+        const steps = extractSteps(arrowFunc.body, context);
+        // Check for any accumulated errors
+        if (context.errors.length > 0) {
+            return {
+                status: 'error',
+                reason: formatValidationErrors(context.errors),
+                simple: false,
+            };
+        }
+        return {
+            status: 'ok',
+            steps,
+            simple: true,
+        };
+    }
+    catch (error) {
+        return {
+            status: 'error',
+            reason: error instanceof Error ? error.message : String(error),
+            simple: false,
+        };
+    }
+}
+/**
+ * Find the workflow function (async arrow function)
+ */
+function findWorkflowFunction(node) {
+    // Handle pikkuSimpleWorkflowFunc(async () => {}) or pikkuWorkflowFunc(async () => {})
+    if (ts.isCallExpression(node)) {
+        const arg = node.arguments[0];
+        if (arg && ts.isArrowFunction(arg)) {
+            return arg;
+        }
+        // Also check if first argument is an object with func property
+        if (arg && ts.isObjectLiteralExpression(arg)) {
+            for (const prop of arg.properties) {
+                if (ts.isPropertyAssignment(prop) &&
+                    ts.isIdentifier(prop.name) &&
+                    prop.name.text === 'func') {
+                    if (ts.isArrowFunction(prop.initializer)) {
+                        return prop.initializer;
+                    }
+                }
+            }
+        }
+    }
+    // Handle pikkuSimpleWorkflowFunc({ func: async () => {} })
+    if (ts.isObjectLiteralExpression(node)) {
+        for (const prop of node.properties) {
+            if (ts.isPropertyAssignment(prop) &&
+                ts.isIdentifier(prop.name) &&
+                prop.name.text === 'func') {
+                if (ts.isArrowFunction(prop.initializer)) {
+                    return prop.initializer;
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Extract the input parameter name from the arrow function
+ */
+function extractInputParamName(arrowFunc) {
+    if (arrowFunc.parameters.length < 2) {
+        return null;
+    }
+    const secondParam = arrowFunc.parameters[1];
+    if (ts.isIdentifier(secondParam.name)) {
+        return secondParam.name.text;
+    }
+    return null;
+}
+/**
+ * Extract steps from the function body
+ */
+function extractSteps(body, context) {
+    const steps = [];
+    if (!ts.isBlock(body)) {
+        return steps;
+    }
+    for (const statement of body.statements) {
+        const extracted = extractStep(statement, context);
+        if (extracted) {
+            steps.push(extracted);
+        }
+    }
+    return steps;
+}
+/**
+ * Extract a single step from a statement
+ */
+function extractStep(statement, context) {
+    // Variable declaration with workflow.do assignment
+    if (ts.isVariableStatement(statement)) {
+        return extractVariableDeclaration(statement, context);
+    }
+    // Expression statement (await workflow.do without assignment)
+    if (ts.isExpressionStatement(statement)) {
+        return extractExpressionStatement(statement, context);
+    }
+    // If statement (branch)
+    if (ts.isIfStatement(statement)) {
+        return extractBranch(statement, context);
+    }
+    // For-of statement (sequential fanout)
+    if (ts.isForOfStatement(statement)) {
+        return extractSequentialFanout(statement, context);
+    }
+    // Return statement
+    if (ts.isReturnStatement(statement)) {
+        return extractReturn(statement, context);
+    }
+    return null;
+}
+/**
+ * Extract variable declaration (const x = await workflow.do(...))
+ */
+function extractVariableDeclaration(statement, context) {
+    const declList = statement.declarationList;
+    if (declList.declarations.length !== 1) {
+        return null;
+    }
+    const decl = declList.declarations[0];
+    if (!ts.isIdentifier(decl.name)) {
+        return null;
+    }
+    const varName = decl.name.text;
+    const init = decl.initializer;
+    if (!init) {
+        return null;
+    }
+    // Check for await workflow.do(...)
+    if (ts.isAwaitExpression(init) && ts.isCallExpression(init.expression)) {
+        const call = init.expression;
+        if (isWorkflowDoCall(call, context.checker)) {
+            const step = extractRpcStep(call, context, varName);
+            if (step) {
+                // Track output variable
+                const type = context.checker.getTypeAtLocation(decl);
+                context.outputVars.set(varName, { type, node: decl });
+                // Check if it's an array type
+                if (isArrayType(type, context.checker)) {
+                    context.arrayVars.add(varName);
+                }
+                // Check if it's a conditional variable (let x: T | undefined)
+                if (declList.flags & ts.NodeFlags.Let) {
+                    const typeNode = decl.type;
+                    if (typeNode && ts.isUnionTypeNode(typeNode)) {
+                        // Check if union includes undefined
+                        const hasUndefined = typeNode.types.some((t) => (ts.isLiteralTypeNode(t) &&
+                            t.literal.kind === ts.SyntaxKind.UndefinedKeyword) ||
+                            t.kind === ts.SyntaxKind.UndefinedKeyword);
+                        if (hasUndefined) {
+                            context.conditionalVars.add(varName);
+                        }
+                    }
+                }
+                return step;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Extract expression statement (await workflow.do(...) without assignment)
+ */
+function extractExpressionStatement(statement, context) {
+    let expr = statement.expression;
+    // Handle assignment: owner = await workflow.do(...)
+    let outputVar;
+    if (ts.isBinaryExpression(expr) &&
+        expr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+        // Extract variable name from left side
+        if (ts.isIdentifier(expr.left)) {
+            outputVar = expr.left.text;
+        }
+        // Use right side as the expression to extract from
+        expr = expr.right;
+    }
+    // await workflow.do(...)
+    if (ts.isAwaitExpression(expr) && ts.isCallExpression(expr.expression)) {
+        const call = expr.expression;
+        if (isWorkflowDoCall(call, context.checker)) {
+            const step = extractRpcStep(call, context, outputVar);
+            // Track output variable if this is an assignment
+            if (outputVar && step) {
+                const type = context.checker.getTypeAtLocation(expr);
+                context.outputVars.set(outputVar, { type, node: expr });
+                // Check if it's an array type
+                if (isArrayType(type, context.checker)) {
+                    context.arrayVars.add(outputVar);
+                }
+            }
+            return step;
+        }
+        if (isWorkflowSleepCall(call, context.checker)) {
+            return extractSleepStep(call, context);
+        }
+        // Check for parallel group or fanout
+        if (isParallelFanout(call)) {
+            return extractParallelFanout(call, context);
+        }
+        if (isParallelGroup(call)) {
+            return extractParallelGroup(call, context);
+        }
+    }
+    return null;
+}
+/**
+ * Extract RPC step from workflow.do() call
+ */
+function extractRpcStep(call, context, outputVar) {
+    const args = call.arguments;
+    if (args.length < 2) {
+        return null;
+    }
+    try {
+        const stepName = extractStringLiteral(args[0], context.checker);
+        const rpcName = extractStringLiteral(args[1], context.checker);
+        // Extract inputs from third argument
+        const inputs = args.length >= 3 ? extractInputSources(args[2], context) : undefined;
+        // Extract options from fourth argument
+        const options = args.length >= 4 && ts.isObjectLiteralExpression(args[3])
+            ? extractStepOptions(args[3], context)
+            : undefined;
+        return {
+            type: 'rpc',
+            stepName,
+            rpcName,
+            outputVar,
+            inputs,
+            options,
+        };
+    }
+    catch (error) {
+        context.errors.push({
+            message: `Failed to extract RPC step: ${error instanceof Error ? error.message : String(error)}`,
+            node: call,
+        });
+        return null;
+    }
+}
+/**
+ * Extract step options from options object
+ */
+function extractStepOptions(optionsNode, context) {
+    const options = {};
+    for (const prop of optionsNode.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            const propName = prop.name.text;
+            if (propName === 'retries') {
+                const retries = extractNumberLiteral(prop.initializer);
+                if (retries !== null) {
+                    options.retries = retries;
+                }
+            }
+            else if (propName === 'retryDelay') {
+                try {
+                    if (ts.isStringLiteral(prop.initializer)) {
+                        options.retryDelay = prop.initializer.text;
+                    }
+                    else {
+                        const delay = extractNumberLiteral(prop.initializer);
+                        if (delay !== null) {
+                            options.retryDelay = delay;
+                        }
+                    }
+                }
+                catch {
+                    // Ignore extraction errors for retryDelay
+                }
+            }
+            else if (propName === 'description') {
+                try {
+                    options.description = extractStringLiteral(prop.initializer, context.checker);
+                }
+                catch {
+                    // Ignore extraction errors for description
+                }
+            }
+        }
+    }
+    return Object.keys(options).length > 0 ? options : undefined;
+}
+/**
+ * Extract sleep step from workflow.sleep() call
+ */
+function extractSleepStep(call, context) {
+    const args = call.arguments;
+    if (args.length < 2) {
+        return null;
+    }
+    try {
+        const stepName = extractStringLiteral(args[0], context.checker);
+        let duration;
+        const numValue = extractNumberLiteral(args[1]);
+        if (numValue !== null) {
+            duration = numValue;
+        }
+        else {
+            duration = extractStringLiteral(args[1], context.checker);
+        }
+        return {
+            type: 'sleep',
+            stepName,
+            duration,
+        };
+    }
+    catch (error) {
+        context.errors.push({
+            message: `Failed to extract sleep step: ${error instanceof Error ? error.message : String(error)}`,
+            node: call,
+        });
+        return null;
+    }
+}
+/**
+ * Extract branch step from if statement
+ */
+function extractBranch(statement, context) {
+    const condition = getSourceText(statement.expression);
+    // Handle both block statements and single statements
+    const thenSteps = ts.isBlock(statement.thenStatement)
+        ? extractSteps(statement.thenStatement, context)
+        : extractStepsFromStatement(statement.thenStatement, context);
+    const elseSteps = statement.elseStatement
+        ? ts.isBlock(statement.elseStatement)
+            ? extractSteps(statement.elseStatement, context)
+            : extractStepsFromStatement(statement.elseStatement, context)
+        : undefined;
+    return {
+        type: 'branch',
+        condition,
+        branches: {
+            then: thenSteps,
+            else: elseSteps,
+        },
+    };
+}
+/**
+ * Extract steps from a single statement (non-block)
+ */
+function extractStepsFromStatement(statement, context) {
+    const step = extractStep(statement, context);
+    return step ? [step] : [];
+}
+/**
+ * Extract parallel fanout from Promise.all(array.map(...))
+ */
+function extractParallelFanout(call, context) {
+    const mapCall = call.arguments[0];
+    if (!ts.isCallExpression(mapCall)) {
+        return null;
+    }
+    if (!ts.isPropertyAccessExpression(mapCall.expression)) {
+        return null;
+    }
+    // Extract source array
+    const sourceExpr = mapCall.expression.expression;
+    let sourceVar = null;
+    if (ts.isIdentifier(sourceExpr)) {
+        sourceVar = sourceExpr.text;
+    }
+    else if (ts.isPropertyAccessExpression(sourceExpr) &&
+        ts.isIdentifier(sourceExpr.expression)) {
+        sourceVar = sourceExpr.expression.text;
+    }
+    if (!sourceVar) {
+        return null;
+    }
+    // Extract map function
+    const mapFn = mapCall.arguments[0];
+    if (!ts.isArrowFunction(mapFn)) {
+        return null;
+    }
+    // Extract item variable
+    const itemParam = mapFn.parameters[0];
+    if (!itemParam || !ts.isIdentifier(itemParam.name)) {
+        return null;
+    }
+    const itemVar = itemParam.name.text;
+    // Extract workflow.do call from map body
+    let doCall = null;
+    if (ts.isCallExpression(mapFn.body)) {
+        doCall = mapFn.body;
+    }
+    else if (ts.isAwaitExpression(mapFn.body)) {
+        // Handle: async (email) => await workflow.do(...)
+        if (ts.isCallExpression(mapFn.body.expression)) {
+            doCall = mapFn.body.expression;
+        }
+    }
+    else if (ts.isBlock(mapFn.body)) {
+        // Look for workflow.do in block
+        for (const stmt of mapFn.body.statements) {
+            if (ts.isReturnStatement(stmt) && stmt.expression) {
+                if (ts.isCallExpression(stmt.expression)) {
+                    doCall = stmt.expression;
+                    break;
+                }
+                else if (ts.isAwaitExpression(stmt.expression)) {
+                    // Handle: return await workflow.do(...)
+                    if (ts.isCallExpression(stmt.expression.expression)) {
+                        doCall = stmt.expression.expression;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    if (!doCall || !isWorkflowDoCall(doCall, context.checker)) {
+        return null;
+    }
+    // Create a temporary context for the child step
+    const childContext = {
+        ...context,
+        outputVars: new Map(context.outputVars),
+    };
+    const childStep = extractRpcStep(doCall, childContext);
+    if (!childStep) {
+        return null;
+    }
+    return {
+        type: 'fanout',
+        stepName: childStep.stepName,
+        sourceVar,
+        itemVar,
+        mode: 'parallel',
+        child: childStep,
+    };
+}
+/**
+ * Extract parallel group from Promise.all([...])
+ */
+function extractParallelGroup(call, context) {
+    const arrayArg = call.arguments[0];
+    if (!ts.isArrayLiteralExpression(arrayArg)) {
+        return null;
+    }
+    const children = [];
+    for (const elem of arrayArg.elements) {
+        if (ts.isCallExpression(elem) && isWorkflowDoCall(elem, context.checker)) {
+            const step = extractRpcStep(elem, context);
+            if (step) {
+                children.push(step);
+            }
+        }
+    }
+    if (children.length === 0) {
+        return null;
+    }
+    return {
+        type: 'parallel',
+        children,
+    };
+}
+/**
+ * Extract sequential fanout from for-of loop
+ */
+function extractSequentialFanout(statement, context) {
+    if (!isSequentialFanout(statement)) {
+        return null;
+    }
+    const vars = extractForOfVariable(statement);
+    if (!vars) {
+        return null;
+    }
+    const { itemVar, sourceVar } = vars;
+    // Extract child step and optional sleep from loop body
+    if (!ts.isBlock(statement.statement)) {
+        return null;
+    }
+    let childStep = null;
+    let timeBetween = undefined;
+    for (const stmt of statement.statement.statements) {
+        // Look for workflow.do
+        if (ts.isExpressionStatement(stmt)) {
+            const expr = stmt.expression;
+            if (ts.isAwaitExpression(expr) && ts.isCallExpression(expr.expression)) {
+                const call = expr.expression;
+                if (isWorkflowDoCall(call, context.checker)) {
+                    const step = extractRpcStep(call, context);
+                    if (step) {
+                        childStep = step;
+                    }
+                }
+                if (isWorkflowSleepCall(call, context.checker)) {
+                    // Extract duration for timeBetween
+                    const args = call.arguments;
+                    if (args.length >= 2) {
+                        try {
+                            const numValue = extractNumberLiteral(args[1]);
+                            if (numValue !== null) {
+                                timeBetween = `${numValue}ms`;
+                            }
+                            else {
+                                timeBetween = extractStringLiteral(args[1], context.checker);
+                            }
+                        }
+                        catch {
+                            // Ignore extraction errors
+                        }
+                    }
+                }
+            }
+        }
+        // Look for if statement with sleep
+        if (ts.isIfStatement(stmt)) {
+            if (ts.isBlock(stmt.thenStatement)) {
+                for (const thenStmt of stmt.thenStatement.statements) {
+                    if (ts.isExpressionStatement(thenStmt)) {
+                        const expr = thenStmt.expression;
+                        if (ts.isAwaitExpression(expr) &&
+                            ts.isCallExpression(expr.expression)) {
+                            const call = expr.expression;
+                            if (isWorkflowSleepCall(call, context.checker)) {
+                                const args = call.arguments;
+                                if (args.length >= 2) {
+                                    try {
+                                        const numValue = extractNumberLiteral(args[1]);
+                                        if (numValue !== null) {
+                                            timeBetween = `${numValue}ms`;
+                                        }
+                                        else {
+                                            timeBetween = extractStringLiteral(args[1], context.checker);
+                                        }
+                                    }
+                                    catch {
+                                        // Ignore extraction errors
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (!childStep) {
+        return null;
+    }
+    return {
+        type: 'fanout',
+        stepName: childStep.stepName,
+        sourceVar,
+        itemVar,
+        mode: 'sequential',
+        child: childStep,
+        timeBetween,
+    };
+}
+/**
+ * Extract return step
+ */
+function extractReturn(statement, context) {
+    if (!statement.expression) {
+        return null;
+    }
+    if (!ts.isObjectLiteralExpression(statement.expression)) {
+        return null;
+    }
+    const outputs = {};
+    for (const prop of statement.expression.properties) {
+        if (ts.isPropertyAssignment(prop) ||
+            ts.isShorthandPropertyAssignment(prop)) {
+            const propName = ts.isIdentifier(prop.name) ? prop.name.text : null;
+            if (!propName) {
+                continue;
+            }
+            let binding = null;
+            if (ts.isShorthandPropertyAssignment(prop)) {
+                // { orgId } - must be an output variable
+                const varName = prop.name.text;
+                if (context.outputVars.has(varName)) {
+                    binding = { from: 'outputVar', name: varName };
+                }
+            }
+            else if (ts.isPropertyAssignment(prop)) {
+                const init = prop.initializer;
+                // Check for property access (e.g., org.id, owner?.id)
+                if (ts.isPropertyAccessExpression(init)) {
+                    const objName = ts.isIdentifier(init.expression)
+                        ? init.expression.text
+                        : null;
+                    const propPath = init.name.text;
+                    if (objName && context.outputVars.has(objName)) {
+                        binding = { from: 'outputVar', name: objName, path: propPath };
+                    }
+                }
+                // Check for optional chaining (e.g., owner?.id)
+                if (init.kind === ts.SyntaxKind.PropertyAccessExpression ||
+                    init.kind === ts.SyntaxKind.NonNullExpression) {
+                    const text = init.getText();
+                    const match = text.match(/^(\w+)\??\.(\w+)$/);
+                    if (match) {
+                        const [, objName, propPath] = match;
+                        if (context.outputVars.has(objName)) {
+                            binding = { from: 'outputVar', name: objName, path: propPath };
+                        }
+                    }
+                }
+                // Check for identifier (simple variable reference)
+                if (ts.isIdentifier(init)) {
+                    const varName = init.text;
+                    if (context.outputVars.has(varName)) {
+                        binding = { from: 'outputVar', name: varName };
+                    }
+                }
+            }
+            if (binding) {
+                outputs[propName] = binding;
+            }
+        }
+    }
+    if (Object.keys(outputs).length === 0) {
+        return null;
+    }
+    return {
+        type: 'return',
+        outputs,
+    };
+}
+/**
+ * Extract input sources from an argument node
+ */
+function extractInputSources(node, context) {
+    if (!ts.isObjectLiteralExpression(node)) {
+        return undefined;
+    }
+    const inputs = {};
+    for (const prop of node.properties) {
+        if (ts.isPropertyAssignment(prop) ||
+            ts.isShorthandPropertyAssignment(prop)) {
+            const propName = ts.isIdentifier(prop.name) ? prop.name.text : null;
+            if (!propName) {
+                continue;
+            }
+            let source = null;
+            if (ts.isShorthandPropertyAssignment(prop)) {
+                // { email } - could be from input or output var
+                const varName = prop.name.text;
+                if (context.outputVars.has(varName)) {
+                    source = { from: 'outputVar', name: varName };
+                }
+                else {
+                    source = { from: 'input', path: varName };
+                }
+            }
+            else if (ts.isPropertyAssignment(prop)) {
+                source = extractInputSource(prop.initializer, context);
+            }
+            if (source) {
+                inputs[propName] = source;
+            }
+        }
+        if (ts.isSpreadAssignment(prop)) {
+            // Handle spread: { ...data }
+            if (ts.isIdentifier(prop.expression)) {
+                const varName = prop.expression.text;
+                if (varName === context.inputParamName) {
+                    // This is spreading the input data
+                    // We can't fully model this in v1, so we'll skip it
+                    continue;
+                }
+            }
+        }
+    }
+    return Object.keys(inputs).length > 0 ? inputs : undefined;
+}
+/**
+ * Extract a single input source
+ */
+function extractInputSource(node, context) {
+    // Property access: data.email, org.id
+    if (ts.isPropertyAccessExpression(node)) {
+        const objExpr = node.expression;
+        const propName = node.name.text;
+        if (ts.isIdentifier(objExpr)) {
+            const objName = objExpr.text;
+            if (objName === context.inputParamName) {
+                return { from: 'input', path: propName };
+            }
+            if (context.outputVars.has(objName)) {
+                return { from: 'outputVar', name: objName, path: propName };
+            }
+        }
+    }
+    // Identifier: email, orgId
+    if (ts.isIdentifier(node)) {
+        const varName = node.text;
+        if (context.outputVars.has(varName)) {
+            return { from: 'outputVar', name: varName };
+        }
+        // Assume it's from input
+        return { from: 'input', path: varName };
+    }
+    // Literal: "string", 123, true, false, null
+    if (ts.isStringLiteral(node) ||
+        ts.isNumericLiteral(node) ||
+        node.kind === ts.SyntaxKind.TrueKeyword ||
+        node.kind === ts.SyntaxKind.FalseKeyword ||
+        node.kind === ts.SyntaxKind.NullKeyword) {
+        let value;
+        if (ts.isStringLiteral(node)) {
+            value = node.text;
+        }
+        else if (ts.isNumericLiteral(node)) {
+            value = Number(node.text);
+        }
+        else if (node.kind === ts.SyntaxKind.TrueKeyword) {
+            value = true;
+        }
+        else if (node.kind === ts.SyntaxKind.FalseKeyword) {
+            value = false;
+        }
+        else if (node.kind === ts.SyntaxKind.NullKeyword) {
+            value = null;
+        }
+        return { from: 'literal', value };
+    }
+    // Object literal
+    if (ts.isObjectLiteralExpression(node)) {
+        const obj = {};
+        for (const prop of node.properties) {
+            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                const propName = prop.name.text;
+                const propSource = extractInputSource(prop.initializer, context);
+                if (propSource && propSource.from === 'literal') {
+                    obj[propName] = propSource.value;
+                }
+            }
+        }
+        return { from: 'literal', value: obj };
+    }
+    // Array literal
+    if (ts.isArrayLiteralExpression(node)) {
+        const arr = [];
+        for (const elem of node.elements) {
+            const elemSource = extractInputSource(elem, context);
+            if (elemSource && elemSource.from === 'literal') {
+                arr.push(elemSource.value);
+            }
+        }
+        return { from: 'literal', value: arr };
+    }
+    return null;
+}