@pikku/inspector 0.11.2 → 0.12.1

package/dist/utils/serialize-mcp-json.js

@@ -0,0 +1,99 @@
+export const serializeMCPJson = (logger, state) => {
+    const { mcpEndpoints, functions, schemas } = state;
+    const { meta: functionsMeta, typesMap } = functions;
+    const { resourcesMeta, toolsMeta, promptsMeta } = mcpEndpoints;
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const loadSchema = (typeName) => {
+        if (!typeName ||
+            [
+                'boolean',
+                'string',
+                'number',
+                'null',
+                'undefined',
+                'void',
+                'unknown',
+                'never',
+            ].includes(typeName)) {
+            return undefined;
+        }
+        const uniqueName = typesMap.getUniqueName(typeName);
+        if (!uniqueName) {
+            return undefined;
+        }
+        const schema = schemas[uniqueName];
+        if (!schema) {
+            logger.warn(`Serialize MCP: Could not find schema for type: ${uniqueName}`);
+            return undefined;
+        }
+        return schema;
+    };
+    for (const [name, endpointMeta] of Object.entries(resourcesMeta)) {
+        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        if (!functionMeta) {
+            logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping resource ${name}.`);
+            continue;
+        }
+        const inputType = functionMeta.inputs?.[0];
+        const outputType = functionMeta.outputs?.[0];
+        const parameters = loadSchema(inputType);
+        const returns = loadSchema(outputType);
+        resources.push({
+            uri: name,
+            name,
+            description: endpointMeta.description,
+            ...(parameters && { parameters }),
+            ...(returns && { returns }),
+            ...(endpointMeta.streaming && { streaming: true }),
+        });
+    }
+    for (const [name, endpointMeta] of Object.entries(toolsMeta)) {
+        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        if (!functionMeta) {
+            logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping tool ${name}.`);
+            continue;
+        }
+        const inputType = functionMeta.inputs?.[0];
+        const outputType = functionMeta.outputs?.[0];
+        const parameters = loadSchema(inputType);
+        const returns = loadSchema(outputType);
+        tools.push({
+            name,
+            description: endpointMeta.description,
+            ...(parameters && { parameters }),
+            ...(returns && { returns }),
+            ...(endpointMeta.streaming && { streaming: true }),
+        });
+    }
+    for (const [name, endpointMeta] of Object.entries(promptsMeta)) {
+        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        if (!functionMeta) {
+            logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping prompt ${name}.`);
+            continue;
+        }
+        const inputType = functionMeta.inputs?.[0];
+        const inputSchema = loadSchema(inputType);
+        const argumentsArray = [];
+        if (inputSchema &&
+            typeof inputSchema === 'object' &&
+            !(inputSchema instanceof Array)) {
+            const properties = inputSchema.properties;
+            const required = inputSchema.required || [];
+            for (const [propName, propSchema] of Object.entries(properties)) {
+                argumentsArray.push({
+                    name: propName,
+                    description: propSchema.description || `${propName} parameter`,
+                    required: required.includes(propName),
+                });
+            }
+        }
+        prompts.push({
+            name,
+            description: endpointMeta.description,
+            arguments: argumentsArray,
+        });
+    }
+    return JSON.stringify({ tools, resources, prompts }, null, 2);
+};

package/dist/utils/serialize-middleware-groups-meta.d.ts

@@ -0,0 +1,12 @@
+import type { InspectorState } from '../types.js';
+export declare const serializeMiddlewareGroupsMeta: (state: InspectorState) => {
+    definitions: Record<string, import("../types.js").InspectorMiddlewareDefinition>;
+    instances: Record<string, import("../types.js").InspectorMiddlewareInstance>;
+    httpGroups: Record<string, any>;
+    tagGroups: Record<string, any>;
+    channelMiddleware: {
+        definitions: Record<string, import("../types.js").InspectorMiddlewareDefinition>;
+        instances: Record<string, import("../types.js").InspectorMiddlewareInstance>;
+        tagGroups: Record<string, any>;
+    };
+};

package/dist/utils/serialize-middleware-groups-meta.js

@@ -0,0 +1,28 @@
+const serializeGroupMap = (groupMap) => {
+    const result = {};
+    for (const [key, meta] of groupMap.entries()) {
+        result[key] = {
+            exportName: meta.exportName,
+            sourceFile: meta.sourceFile,
+            position: meta.position,
+            services: meta.services,
+            count: meta.count,
+            instanceIds: meta.instanceIds,
+            isFactory: meta.isFactory,
+        };
+    }
+    return result;
+};
+export const serializeMiddlewareGroupsMeta = (state) => {
+    return {
+        definitions: state.middleware.definitions,
+        instances: state.middleware.instances,
+        httpGroups: serializeGroupMap(state.http.routeMiddleware),
+        tagGroups: serializeGroupMap(state.middleware.tagMiddleware),
+        channelMiddleware: {
+            definitions: state.channelMiddleware.definitions,
+            instances: state.channelMiddleware.instances,
+            tagGroups: serializeGroupMap(state.channelMiddleware.tagMiddleware),
+        },
+    };
+};

package/dist/utils/serialize-openapi-json.d.ts

@@ -0,0 +1,85 @@
+import type { FunctionsMeta } from '@pikku/core';
+import type { HTTPWiringsMeta } from '@pikku/core/http';
+import type { InspectorLogger } from '../types.js';
+interface ErrorDetails {
+    status: number;
+    message: string;
+}
+interface OpenAPISpec {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        };
+        license?: {
+            name: string;
+            url?: string;
+        };
+    };
+    servers: {
+        url: string;
+        description?: string;
+    }[];
+    paths: Record<string, any>;
+    components: {
+        schemas: Record<string, any>;
+        responses?: Record<string, any>;
+        parameters?: Record<string, any>;
+        examples?: Record<string, any>;
+        requestBodies?: Record<string, any>;
+        headers?: Record<string, any>;
+        securitySchemes?: Record<string, any>;
+    };
+    security?: {
+        [key: string]: any[];
+    }[];
+    tags?: {
+        name: string;
+        description?: string;
+    }[];
+    externalDocs?: {
+        description?: string;
+        url: string;
+    };
+}
+export interface OpenAPISpecInfo {
+    info: {
+        title: string;
+        version: string;
+        description: string;
+        termsOfService?: string;
+        contact?: {
+            name?: string;
+            url?: string;
+            email?: string;
+        };
+        license?: {
+            name: string;
+            url?: string;
+        };
+    };
+    servers: {
+        url: string;
+        description?: string;
+    }[];
+    tags?: {
+        name: string;
+        description?: string;
+    }[];
+    externalDocs?: {
+        description?: string;
+        url: string;
+    };
+    securitySchemes?: Record<string, any>;
+    security?: {
+        [key: string]: any[];
+    }[];
+}
+export declare function generateOpenAPISpec(logger: InspectorLogger, functionsMeta: FunctionsMeta, httpMeta: HTTPWiringsMeta, schemas: Record<string, any>, additionalInfo: OpenAPISpecInfo, errors?: Map<any, ErrorDetails>): Promise<OpenAPISpec>;
+export {};

package/dist/utils/serialize-openapi-json.js

@@ -0,0 +1,151 @@
+import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema';
+const convertSchema = 'default' in _convertSchema ? _convertSchema.default : _convertSchema;
+const getErrorResponseForConstructorName = (constructorName, errors) => {
+    const entries = Array.from(errors.entries());
+    const foundError = entries.find(([e]) => e.name === constructorName);
+    if (foundError) {
+        return foundError[1];
+    }
+    return undefined;
+};
+const convertSchemasToBodyPayloads = async (functionsMeta, routesMeta, schemas) => {
+    const requiredSchemas = new Set();
+    for (const routeMeta of Object.values(routesMeta)) {
+        for (const { inputTypes, pikkuFuncId } of Object.values(routeMeta)) {
+            const output = functionsMeta[pikkuFuncId]?.outputs?.[0];
+            if (inputTypes?.body) {
+                requiredSchemas.add(inputTypes?.body);
+            }
+            if (output) {
+                requiredSchemas.add(output);
+            }
+        }
+    }
+    const convertedEntries = await Promise.all(Object.entries(schemas).map(async ([key, schema]) => {
+        if (requiredSchemas.has(key)) {
+            const convertedSchema = await convertSchema(schema, {
+                convertUnreferencedDefinitions: false,
+                dereference: { circular: 'ignore' },
+            });
+            return [key, convertedSchema];
+        }
+        return;
+    }));
+    return Object.fromEntries(convertedEntries.filter((s) => !!s));
+};
+export async function generateOpenAPISpec(logger, functionsMeta, httpMeta, schemas, additionalInfo, errors) {
+    const paths = {};
+    const errorsMap = errors ?? new Map();
+    for (const routeMeta of Object.values(httpMeta)) {
+        for (const meta of Object.values(routeMeta)) {
+            const { route, method, inputTypes, pikkuFuncId, params, query, errors, description, tags, } = meta;
+            const functionMeta = functionsMeta[pikkuFuncId];
+            if (!functionMeta) {
+                logger.error(`• No function metadata found for '${pikkuFuncId}' in route '${route}'.`);
+                continue;
+            }
+            const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+            const path = route.replace(/:(\w+)/g, '{$1}');
+            if (!paths[path]) {
+                paths[path] = {};
+            }
+            const responses = {};
+            errors?.forEach((error) => {
+                const errorResponse = getErrorResponseForConstructorName(error, errorsMap);
+                if (errorResponse) {
+                    responses[errorResponse.status] = {
+                        description: errorResponse.message,
+                    };
+                }
+            });
+            const operation = {
+                description: description ||
+                    `This endpoint handles the ${method.toUpperCase()} request for the route ${route}.`,
+                tags: tags || [route.split('/')[1] || 'default'],
+                parameters: [],
+                responses: {
+                    ...responses,
+                    '200': {
+                        description: 'Successful response',
+                        content: output
+                            ? {
+                                'application/json': {
+                                    schema: typeof output === 'string' &&
+                                        ['boolean', 'string', 'number'].includes(output)
+                                        ? { type: output }
+                                        : { $ref: `#/components/schemas/${output}` },
+                                },
+                            }
+                            : undefined,
+                    },
+                },
+            };
+            const bodyType = inputTypes?.body;
+            if (bodyType) {
+                operation.requestBody = {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: typeof bodyType === 'string' &&
+                                ['boolean', 'string', 'number'].includes(bodyType)
+                                ? { type: bodyType }
+                                : { $ref: `#/components/schemas/${bodyType}` },
+                        },
+                    },
+                };
+            }
+            if (params) {
+                operation.parameters = params.map((param) => ({
+                    name: param,
+                    in: 'path',
+                    required: true,
+                    schema: { type: 'string' },
+                }));
+            }
+            if (query) {
+                operation.parameters.push(...query.map((query) => ({
+                    name: query,
+                    in: 'query',
+                    required: false,
+                    schema: { type: 'string' },
+                })));
+            }
+            paths[path][method] = operation;
+        }
+    }
+    return {
+        openapi: '3.1.0',
+        info: additionalInfo.info,
+        servers: additionalInfo.servers,
+        paths,
+        components: {
+            schemas: await convertSchemasToBodyPayloads(functionsMeta, httpMeta, schemas),
+            responses: {},
+            parameters: {},
+            examples: {},
+            requestBodies: {},
+            headers: {},
+            securitySchemes: additionalInfo.securitySchemes || {
+                ApiKeyAuth: {
+                    type: 'apiKey',
+                    in: 'header',
+                    name: 'x-api-key',
+                },
+                BearerAuth: {
+                    type: 'http',
+                    scheme: 'bearer',
+                },
+            },
+        },
+        security: additionalInfo.security || [
+            {
+                ApiKeyAuth: [],
+            },
+            {
+                BearerAuth: [],
+            },
+        ],
+        tags: additionalInfo.tags,
+        externalDocs: additionalInfo.externalDocs,
+    };
+}

package/dist/utils/serialize-permissions-groups-meta.d.ts

@@ -0,0 +1,6 @@
+import type { InspectorState } from '../types.js';
+export declare const serializePermissionsGroupsMeta: (state: InspectorState) => {
+    definitions: Record<string, import("../types.js").InspectorPermissionDefinition>;
+    httpGroups: Record<string, any>;
+    tagGroups: Record<string, any>;
+};

package/dist/utils/serialize-permissions-groups-meta.js

@@ -0,0 +1,31 @@
+export const serializePermissionsGroupsMeta = (state) => {
+    const httpGroups = {};
+    for (const [pattern, meta] of state.http.routePermissions.entries()) {
+        httpGroups[pattern] = {
+            exportName: meta.exportName,
+            sourceFile: meta.sourceFile,
+            position: meta.position,
+            services: meta.services,
+            count: meta.count,
+            instanceIds: meta.instanceIds,
+            isFactory: meta.isFactory,
+        };
+    }
+    const tagGroups = {};
+    for (const [tag, meta] of state.permissions.tagPermissions.entries()) {
+        tagGroups[tag] = {
+            exportName: meta.exportName,
+            sourceFile: meta.sourceFile,
+            position: meta.position,
+            services: meta.services,
+            count: meta.count,
+            instanceIds: meta.instanceIds,
+            isFactory: meta.isFactory,
+        };
+    }
+    return {
+        definitions: state.permissions.definitions,
+        httpGroups,
+        tagGroups,
+    };
+};

package/dist/utils/validate-auth-sessionless.d.ts

@@ -0,0 +1,3 @@
+import * as ts from 'typescript';
+import type { InspectorLogger, InspectorState } from '../types.js';
+export declare function validateAuthSessionless(logger: InspectorLogger, obj: ts.ObjectLiteralExpression, state: InspectorState, funcName: string, wireDescription: string, inheritedAuth?: boolean): boolean;

package/dist/utils/validate-auth-sessionless.js

@@ -0,0 +1,14 @@
+import { getPropertyValue } from './get-property-value.js';
+import { ErrorCode } from '../error-codes.js';
+export function validateAuthSessionless(logger, obj, state, funcName, wireDescription, inheritedAuth) {
+    const fnMeta = state.functions.meta[funcName];
+    if (!fnMeta)
+        return true;
+    const routeAuth = getPropertyValue(obj, 'auth');
+    const resolvedAuth = routeAuth === true || routeAuth === false ? routeAuth : inheritedAuth;
+    if (resolvedAuth === false && fnMeta.sessionless === false) {
+        logger.critical(ErrorCode.AUTH_DISABLED_REQUIRES_SESSIONLESS, `${wireDescription} has auth disabled but function '${funcName}' uses pikkuFunc (requires session). Use pikkuSessionlessFunc instead.`);
+        return false;
+    }
+    return true;
+}

package/dist/utils/workflow/dsl/deserialize-dsl-workflow.js

@@ -89,6 +89,15 @@ function valueToCode(value, itemVar) {
     if (isTemplateRef(value)) {
         return templateRefToCode(value, itemVar);
     }
+    if (Array.isArray(value)) {
+        const elements = value.map((v) => valueToCode(v, itemVar));
+        return `[${elements.join(', ')}]`;
+    }
+    if (typeof value === 'object' && value !== null) {
+        const entries = Object.entries(value);
+        const props = entries.map(([k, v]) => `${k}: ${valueToCode(v, itemVar)}`);
+        return `{ ${props.join(', ')} }`;
+    }
     return JSON.stringify(value);
 }
 /**
@@ -626,6 +635,26 @@ function templateRefToGraphCode(tmpl, outputVarToNodeId) {
         .replace(/\r/g, '\\r');
     return `template('${templateStr}', [${refs.join(', ')}])`;
 }
+function valueToGraphCode(value, outputVarToNodeId, refTracker) {
+    if (isDataRef(value)) {
+        refTracker.hasRefs = true;
+        return dataRefToGraphRef(value, outputVarToNodeId);
+    }
+    if (isTemplateRef(value)) {
+        refTracker.hasRefs = true;
+        return templateRefToGraphCode(value, outputVarToNodeId);
+    }
+    if (Array.isArray(value)) {
+        const elements = value.map((v) => valueToGraphCode(v, outputVarToNodeId, refTracker));
+        return `[${elements.join(', ')}]`;
+    }
+    if (typeof value === 'object' && value !== null) {
+        const entries = Object.entries(value);
+        const props = entries.map(([k, v]) => `${k}: ${valueToGraphCode(v, outputVarToNodeId, refTracker)}`);
+        return `{ ${props.join(', ')} }`;
+    }
+    return JSON.stringify(value);
+}
 /**
  * Convert input object to graph input code using ref()
  * @param input - The input mapping
@@ -635,73 +664,15 @@ function inputToGraphCode(input, outputVarToNodeId) {
     const entries = Object.entries(input);
     if (entries.length === 0)
         return { hasRefs: false, code: '{}' };
-    let hasRefs = false;
+    const refTracker = { hasRefs: false };
     const lines = entries.map(([key, value]) => {
-        if (isDataRef(value)) {
-            hasRefs = true;
-            return `        ${key}: ${dataRefToGraphRef(value, outputVarToNodeId)},`;
-        }
-        if (isTemplateRef(value)) {
-            hasRefs = true;
-            return `        ${key}: ${templateRefToGraphCode(value, outputVarToNodeId)},`;
-        }
-        return `        ${key}: ${JSON.stringify(value)},`;
+        return `        ${key}: ${valueToGraphCode(value, outputVarToNodeId, refTracker)},`;
     });
     return {
-        hasRefs,
+        hasRefs: refTracker.hasRefs,
         code: `{\n${lines.join('\n')}\n      }`,
     };
 }
-/**
- * Serialize wires to code
- */
-function wiresToCode(wires) {
-    if (!wires || Object.keys(wires).length === 0)
-        return '{}';
-    const parts = [];
-    if (wires.http && wires.http.length > 0) {
-        const httpItems = wires.http.map((h) => `{ route: '${h.route}', method: '${h.method}', startNode: '${h.startNode}' }`);
-        parts.push(`http: [${httpItems.join(', ')}]`);
-    }
-    if (wires.channel && wires.channel.length > 0) {
-        const channelItems = wires.channel.map((c) => {
-            const channelParts = [`name: '${c.name}'`];
-            if (c.onConnect)
-                channelParts.push(`onConnect: '${c.onConnect}'`);
-            if (c.onDisconnect)
-                channelParts.push(`onDisconnect: '${c.onDisconnect}'`);
-            if (c.onMessage)
-                channelParts.push(`onMessage: '${c.onMessage}'`);
-            return `{ ${channelParts.join(', ')} }`;
-        });
-        parts.push(`channel: [${channelItems.join(', ')}]`);
-    }
-    if (wires.queue && wires.queue.length > 0) {
-        const queueItems = wires.queue.map((q) => `{ name: '${q.name}', startNode: '${q.startNode}' }`);
-        parts.push(`queue: [${queueItems.join(', ')}]`);
-    }
-    if (wires.cli && wires.cli.length > 0) {
-        const cliItems = wires.cli.map((c) => `{ command: '${c.command}', startNode: '${c.startNode}' }`);
-        parts.push(`cli: [${cliItems.join(', ')}]`);
-    }
-    if (wires.schedule && wires.schedule.length > 0) {
-        const scheduleItems = wires.schedule.map((s) => {
-            const scheduleParts = [];
-            if (s.cron)
-                scheduleParts.push(`cron: '${s.cron}'`);
-            if (s.interval)
-                scheduleParts.push(`interval: '${s.interval}'`);
-            scheduleParts.push(`startNode: '${s.startNode}'`);
-            return `{ ${scheduleParts.join(', ')} }`;
-        });
-        parts.push(`schedule: [${scheduleItems.join(', ')}]`);
-    }
-    if (wires.trigger && wires.trigger.length > 0) {
-        const triggerItems = wires.trigger.map((t) => `{ name: '${t.name}', startNode: '${t.startNode}' }`);
-        parts.push(`trigger: [${triggerItems.join(', ')}]`);
-    }
-    return `{ ${parts.join(', ')} }`;
-}
 /**
  * Check if a node is a flow node (non-RPC control flow)
  */
@@ -740,7 +711,7 @@ export function deserializeGraphWorkflow(workflow, options = {}) {
     const { pikkuImportPath = '../.pikku/workflow/pikku-workflow-types.gen.js' } = options;
     const lines = [];
     // Import statement
-    lines.push(`import { pikkuWorkflowGraph, wireWorkflow } from '${pikkuImportPath}'`);
+    lines.push(`import { pikkuWorkflowGraph } from '${pikkuImportPath}'`);
     lines.push('');
     // Add description as comment if present
     if (workflow.description) {
@@ -811,26 +782,7 @@ export function deserializeGraphWorkflow(workflow, options = {}) {
             nodeConfigs.push(`    ${nodeId}: {\n      ${configParts.join(',\n      ')},\n    }`);
         }
     }
-    // Compute entry node (first node with no incoming edges from RPC nodes)
-    const rpcNodeIds = new Set(Object.keys(nodeRpcMap));
-    const nodesWithIncomingEdges = new Set();
-    for (const [nodeId, node] of Object.entries(workflow.nodes)) {
-        if (!rpcNodeIds.has(nodeId))
-            continue;
-        if ('next' in node && node.next) {
-            const nextId = node.next;
-            // Follow through flow nodes to find the actual next RPC node
-            const actualNextId = flowNodeIds.has(nextId)
-                ? findNextRpcNode(nextId, workflow.nodes, flowNodeIds)
-                : nextId;
-            if (actualNextId && rpcNodeIds.has(actualNextId)) {
-                nodesWithIncomingEdges.add(actualNextId);
-            }
-        }
-    }
-    // Entry node is the first RPC node with no incoming edges
-    const entryNode = Object.keys(nodeRpcMap).find((id) => !nodesWithIncomingEdges.has(id));
-    // Generate the pikkuWorkflowGraph call
+    // Generate the pikkuWorkflowGraph call (builds graph and registers with core)
     lines.push(`export const ${workflow.name} = pikkuWorkflowGraph({`);
     lines.push(`  name: '${workflow.name}',`);
     if (workflow.description) {
@@ -851,12 +803,6 @@ export function deserializeGraphWorkflow(workflow, options = {}) {
     else {
         lines.push(`  nodes: {},`);
     }
-    // Generate wires with api entry point
-    if (entryNode) {
-        lines.push(`  wires: {`);
-        lines.push(`    api: '${entryNode}',`);
-        lines.push(`  },`);
-    }
     // Generate config (node configurations)
     if (nodeConfigs.length > 0) {
         lines.push(`  config: {`);
@@ -865,20 +811,6 @@ export function deserializeGraphWorkflow(workflow, options = {}) {
     }
     lines.push(`})`);
     lines.push('');
-    // Always generate wireWorkflow to register the graph workflow
-    // (needed for testing even without explicit wires)
-    if (workflow.wires && Object.keys(workflow.wires).length > 0) {
-        lines.push(`wireWorkflow({`);
-        lines.push(`  wires: ${wiresToCode(workflow.wires)},`);
-        lines.push(`  graph: ${workflow.name},`);
-        lines.push(`})`);
-    }
-    else {
-        lines.push(`wireWorkflow({`);
-        lines.push(`  graph: ${workflow.name},`);
-        lines.push(`})`);
-    }
-    lines.push('');
     return lines.join('\n');
 }
 /**

package/dist/utils/workflow/dsl/extract-dsl-workflow.d.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { WorkflowStepMeta, WorkflowContext } from '@pikku/core/workflow';
+import type { WorkflowStepMeta, WorkflowContext } from '@pikku/core/workflow';
 /**
  * Result of simple workflow extraction
  */

package/dist/utils/workflow/dsl/extract-dsl-workflow.js

@@ -1112,6 +1112,25 @@ function extractInputSources(node, context) {
     }
     return Object.keys(inputs).length > 0 ? inputs : undefined;
 }
+function inputSourceToInlineValue(source) {
+    switch (source.from) {
+        case 'literal':
+            return source.value;
+        case 'input':
+            return { $ref: 'trigger', path: source.path };
+        case 'outputVar':
+            return { $ref: source.name, path: source.path };
+        case 'item':
+            return { $ref: '$item', path: source.path };
+        case 'template':
+            return {
+                $template: {
+                    parts: source.parts,
+                    expressions: source.expressions.map(inputSourceToInlineValue),
+                },
+            };
+    }
+}
 /**
  * Extract a single input source
  */
@@ -1174,8 +1193,8 @@ function extractInputSource(node, context) {
             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;
+                if (propSource) {
+                    obj[propName] = inputSourceToInlineValue(propSource);
                 }
             }
         }
@@ -1186,8 +1205,8 @@ function extractInputSource(node, context) {
         const arr = [];
         for (const elem of node.elements) {
             const elemSource = extractInputSource(elem, context);
-            if (elemSource && elemSource.from === 'literal') {
-                arr.push(elemSource.value);
+            if (elemSource) {
+                arr.push(inputSourceToInlineValue(elemSource));
             }
         }
         return { from: 'literal', value: arr };