@pikku/inspector 0.12.9 → 0.12.10

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## 0.12.0
 
+## 0.12.10
+
+### Patch Changes
+
+- ba8d6ff: Support inline functions in pikkuWorkflowComplexFunc with full DSL extraction
+- d3ace0e: Inspector now captures the `deploy: 'serverless' | 'server' | 'auto'` option
+  from `pikkuFunc` / `pikkuSessionlessFunc` calls, alongside the other runtime
+  metadata (`expose`, `remote`, `mcp`, `readonly`, `approvalRequired`).
+
+  Previously this field was defined on `FunctionRuntimeMeta` but never read
+  from the user's source, so `deploy: 'server'` was silently dropped. That
+  left downstream consumers — notably `@pikku/cli`'s deployment analyzer,
+  which routes server-targeted functions to a container unit — treating
+  every function as `serverless` regardless of its declared intent.
+
+- Updated dependencies [311c0c4]
+  - @pikku/core@0.12.18
+
 ## 0.12.9
 
 ### Patch Changes

package/dist/add/add-functions.js

@@ -245,6 +245,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
     let remote;
     let mcp;
     let readonly_;
+    let deploy;
     let approvalRequired;
     let approvalDescription;
     let version;
@@ -312,6 +313,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         remote = getPropertyValue(firstArg, 'remote');
         mcp = getPropertyValue(firstArg, 'mcp');
         readonly_ = getPropertyValue(firstArg, 'readonly');
+        deploy = getPropertyValue(firstArg, 'deploy');
         approvalRequired = getPropertyValue(firstArg, 'approvalRequired');
         // Extract approvalDescription identifier reference
         for (const prop of firstArg.properties) {
@@ -583,6 +585,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         remote: remote || undefined,
         mcp: mcpEnabled || undefined,
         readonly: readonly_ || undefined,
+        deploy: deploy || undefined,
         approvalRequired: approvalRequired || undefined,
         approvalDescription: approvalDescription || undefined,
         version,

package/dist/add/add-workflow.d.ts

@@ -5,7 +5,7 @@ import type { WorkflowStepMeta } from '@pikku/core/workflow';
  */
 export declare function collectInvokedRPCs(steps: WorkflowStepMeta[], rpcs: Set<string>): void;
 /**
- * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
+ * Inspector for pikkuWorkflowFunc() and pikkuWorkflowComplexFunc() calls
  * Detects workflow registration and extracts metadata
  */
 export declare const addWorkflow: AddWiring;

package/dist/add/add-workflow.js

@@ -142,7 +142,7 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
     });
 }
 /**
- * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
+ * Inspector for pikkuWorkflowFunc() and pikkuWorkflowComplexFunc() calls
  * Detects workflow registration and extracts metadata
  */
 export const addWorkflow = (logger, node, checker, state) => {
@@ -160,7 +160,7 @@ export const addWorkflow = (logger, node, checker, state) => {
         wrapperType = 'dsl';
     }
     else if (expression.text === 'pikkuWorkflowComplexFunc') {
-        wrapperType = 'regular';
+        wrapperType = 'complex';
     }
     else {
         return;
@@ -220,7 +220,9 @@ export const addWorkflow = (logger, node, checker, state) => {
     let dsl = undefined;
     // Try DSL workflow extraction first
     // Pass the whole CallExpression node so findWorkflowFunction can find the arrow function
-    const result = extractDSLWorkflow(node, checker);
+    const result = extractDSLWorkflow(node, checker, {
+        allowInline: wrapperType === 'complex',
+    });
     if (result.status === 'ok' && result.steps) {
         // Extraction succeeded
         steps = result.steps;
@@ -252,7 +254,7 @@ export const addWorkflow = (logger, node, checker, state) => {
             // For pikkuWorkflowFunc, this is a critical error
             // But still track RPC invocations for function registration
             getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
-            logger.critical(ErrorCode.INVALID_DSL_WORKFLOW, `Workflow '${workflowName}' uses pikkuWorkflowFunc but does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`);
+            logger.critical(ErrorCode.INVALID_DSL_WORKFLOW, `Workflow '${workflowName}' does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`);
             return;
         }
         else {
@@ -261,12 +263,10 @@ export const addWorkflow = (logger, node, checker, state) => {
             dsl = false;
         }
     }
-    /**
-     * For non-dsl workflows or pikkuWorkflowComplexFunc, run basic extraction
-     * to ensure all RPC invocations are tracked for function registration.
-     * This catches RPCs in Promise.all callbacks and other patterns DSL can't extract.
-     */
-    if (!dsl || wrapperType === 'regular') {
+    // For pikkuWorkflowComplexFunc, also run basic extraction so RPCs in
+    // patterns the DSL extractor doesn't handle (array+push, nested Promise.all
+    // with identifier args, etc.) are still registered as invoked functions.
+    if (wrapperType === 'complex') {
         getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
     }
     state.workflows.meta[workflowName] = {

package/dist/utils/extract-node-value.js

@@ -20,6 +20,10 @@ export function extractStringLiteral(node, checker) {
         }
         return result;
     }
+    // Unwrap type assertions: `expr as Type` or `<Type>expr`
+    if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
+        return extractStringLiteral(node.expression, checker);
+    }
     // Try to evaluate constant identifiers
     if (ts.isIdentifier(node)) {
         const symbol = checker.getSymbolAtLocation(node);

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

@@ -1,7 +1,7 @@
 import * as ts from 'typescript';
 import type { WorkflowStepMeta, WorkflowContext } from '@pikku/core/workflow';
 /**
- * Result of simple workflow extraction
+ * Result of DSL workflow extraction
  */
 export interface ExtractionResult {
     status: 'ok' | 'error';
@@ -9,9 +9,10 @@ export interface ExtractionResult {
     /** Workflow context (top-level variables) */
     context?: WorkflowContext;
     reason?: string;
-    simple?: boolean;
 }
 /**
- * Extract simple workflow metadata from a function declaration
+ * Extract DSL workflow metadata from a function declaration
  */
-export declare function extractDSLWorkflow(funcNode: ts.Node, checker: ts.TypeChecker): ExtractionResult;
+export declare function extractDSLWorkflow(funcNode: ts.Node, checker: ts.TypeChecker, options?: {
+    allowInline?: boolean;
+}): ExtractionResult;

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

@@ -1,26 +1,11 @@
 import * as ts from 'typescript';
-import { isWorkflowDoCall, isWorkflowSleepCall, isThrowCancelException, extractCancelReason, isParallelFanout, isParallelGroup, isSequentialFanout, isArrayFilter, isArraySome, isArrayEvery, extractForOfVariable, isArrayType, getSourceText, } from './patterns.js';
+import { isWorkflowDoCall, isWorkflowSleepCall, isThrowCancelException, extractCancelReason, isParallelFanout, isParallelGroup, isSequentialFanout, isArrayFilter, isArraySome, isArrayEvery, extractForOfVariable, isArrayType, getSourceText, extractSourcePath, } from './patterns.js';
 import { validateNoDisallowedPatterns, validateAwaitedCalls, formatValidationErrors, } from './validation.js';
 import { extractStringLiteral, extractNumberLiteral, } from '../../extract-node-value.js';
 /**
- * Extract full source path from an expression (e.g., data.memberEmails)
+ * Extract DSL workflow metadata from a function declaration
  */
-function extractSourcePath(expr) {
-    if (ts.isIdentifier(expr)) {
-        return expr.text;
-    }
-    if (ts.isPropertyAccessExpression(expr)) {
-        const base = extractSourcePath(expr.expression);
-        if (base) {
-            return `${base}.${expr.name.text}`;
-        }
-    }
-    return null;
-}
-/**
- * Extract simple workflow metadata from a function declaration
- */
-export function extractDSLWorkflow(funcNode, checker) {
+export function extractDSLWorkflow(funcNode, checker, options) {
     try {
         // Find the async arrow function
         const arrowFunc = findWorkflowFunction(funcNode);
@@ -28,7 +13,6 @@ export function extractDSLWorkflow(funcNode, checker) {
             return {
                 status: 'error',
                 reason: 'Could not find async arrow function in workflow definition',
-                simple: false,
             };
         }
         // Extract input parameter name (second parameter)
@@ -37,7 +21,6 @@ export function extractDSLWorkflow(funcNode, checker) {
             return {
                 status: 'error',
                 reason: 'Could not determine input parameter name',
-                simple: false,
             };
         }
         // Initialize extraction context
@@ -53,12 +36,13 @@ export function extractDSLWorkflow(funcNode, checker) {
             depth: 0,
         };
         // Validate no disallowed patterns
-        const patternErrors = validateNoDisallowedPatterns(arrowFunc.body);
+        const patternErrors = validateNoDisallowedPatterns(arrowFunc.body, {
+            allowInline: options?.allowInline,
+        });
         if (patternErrors.length > 0) {
             return {
                 status: 'error',
                 reason: formatValidationErrors(patternErrors),
-                simple: false,
             };
         }
         // Validate all workflow calls are awaited
@@ -67,7 +51,6 @@ export function extractDSLWorkflow(funcNode, checker) {
             return {
                 status: 'error',
                 reason: formatValidationErrors(awaitErrors),
-                simple: false,
             };
         }
         // Extract steps from function body
@@ -77,7 +60,6 @@ export function extractDSLWorkflow(funcNode, checker) {
             return {
                 status: 'error',
                 reason: formatValidationErrors(context.errors),
-                simple: false,
             };
         }
         // Build workflow context from extracted context variables
@@ -92,14 +74,12 @@ export function extractDSLWorkflow(funcNode, checker) {
             status: 'ok',
             steps,
             context: Object.keys(workflowContext).length > 0 ? workflowContext : undefined,
-            simple: true,
         };
     }
     catch (error) {
         return {
             status: 'error',
             reason: error instanceof Error ? error.message : String(error),
-            simple: false,
         };
     }
 }
@@ -248,7 +228,9 @@ function extractVariableDeclaration(statement, context) {
     if (ts.isAwaitExpression(init) && ts.isCallExpression(init.expression)) {
         const call = init.expression;
         if (isWorkflowDoCall(call, context.checker)) {
-            const step = extractRpcStep(call, context, varName);
+            const step = isInlineDoCall(call)
+                ? extractInlineStep(call, context)
+                : extractRpcStep(call, context, varName);
             if (step) {
                 // Track output variable
                 const type = context.checker.getTypeAtLocation(decl);
@@ -335,7 +317,9 @@ function extractExpressionStatement(statement, context) {
     if (ts.isAwaitExpression(expr) && ts.isCallExpression(expr.expression)) {
         const call = expr.expression;
         if (isWorkflowDoCall(call, context.checker)) {
-            const step = extractRpcStep(call, context, outputVar);
+            const step = isInlineDoCall(call)
+                ? extractInlineStep(call, context)
+                : extractRpcStep(call, context, outputVar);
             // Track output variable if this is an assignment
             if (outputVar && step) {
                 const type = context.checker.getTypeAtLocation(expr);
@@ -394,6 +378,41 @@ function extractRpcStep(call, context, outputVar) {
         return null;
     }
 }
+/**
+ * Extract inline step from workflow.do() call with a function argument
+ */
+function extractInlineStep(call, context) {
+    const args = call.arguments;
+    if (args.length < 2)
+        return null;
+    try {
+        const stepName = extractStringLiteral(args[0], context.checker);
+        const optionsArg = args.length >= 3 ? args[args.length - 1] : undefined;
+        const options = optionsArg && ts.isObjectLiteralExpression(optionsArg)
+            ? extractStepOptions(optionsArg, context)
+            : undefined;
+        return {
+            type: 'inline',
+            stepName,
+            options,
+        };
+    }
+    catch (error) {
+        context.errors.push({
+            message: `Failed to extract inline step: ${error instanceof Error ? error.message : String(error)}`,
+            node: call,
+        });
+        return null;
+    }
+}
+/**
+ * Check if the second argument of a workflow.do() call is a function
+ */
+function isInlineDoCall(call) {
+    const secondArg = call.arguments[1];
+    return (!!secondArg &&
+        (ts.isArrowFunction(secondArg) || ts.isFunctionExpression(secondArg)));
+}
 /**
  * Extract step options from options object
  */

package/dist/utils/workflow/dsl/patterns.d.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 /**
- * Pattern detection helpers for simple workflow extraction
+ * Pattern detection helpers for DSL workflow extraction
  */
 /**
  * Check if a call expression is workflow.do()
@@ -43,6 +43,10 @@ export declare function isParallelGroup(node: ts.CallExpression): boolean;
  * Check if a for statement is a valid sequential fanout (for..of)
  */
 export declare function isSequentialFanout(node: ts.ForOfStatement): boolean;
+/**
+ * Extract full source path from an expression (e.g., data.memberEmails)
+ */
+export declare function extractSourcePath(expr: ts.Expression): string | null;
 /**
  * Extract the variable name from a for..of statement
  */

package/dist/utils/workflow/dsl/patterns.js

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 /**
- * Pattern detection helpers for simple workflow extraction
+ * Pattern detection helpers for DSL workflow extraction
  */
 /**
  * Check if a call expression is workflow.do()
@@ -162,7 +162,7 @@ export function isSequentialFanout(node) {
 /**
  * Extract full source path from an expression (e.g., data.memberEmails)
  */
-function extractSourcePath(expr) {
+export function extractSourcePath(expr) {
     if (ts.isIdentifier(expr)) {
         return expr.text;
     }

package/dist/utils/workflow/dsl/validation.d.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 /**
- * Validation rules for simple workflows
+ * Validation rules for DSL workflows
  */
 export interface ValidationError {
     message: string;
@@ -19,7 +19,9 @@ export interface ValidationError {
  * - ThrowStatement (for WorkflowCancelledException)
  * - Block (containers)
  */
-export declare function validateNoDisallowedPatterns(node: ts.Node): ValidationError[];
+export declare function validateNoDisallowedPatterns(node: ts.Node, options?: {
+    allowInline?: boolean;
+}): ValidationError[];
 /**
  * Validate that all workflow.do calls are awaited
  */

package/dist/utils/workflow/dsl/validation.js

@@ -12,7 +12,7 @@ import * as ts from 'typescript';
  * - ThrowStatement (for WorkflowCancelledException)
  * - Block (containers)
  */
-export function validateNoDisallowedPatterns(node) {
+export function validateNoDisallowedPatterns(node, options) {
     const errors = [];
     function visitBlock(block) {
         for (const statement of block.statements) {
@@ -30,7 +30,7 @@ export function validateNoDisallowedPatterns(node) {
                 // Unknown/disallowed statement type
                 const nodeType = ts.SyntaxKind[statement.kind];
                 errors.push({
-                    message: `Statement type '${nodeType}' is not allowed in simple workflows. Allowed: const/let, if/else, switch/case, for..of, return, throw, and workflow calls. If this should be supported, please report the node type: ${nodeType}`,
+                    message: `Statement type '${nodeType}' is not allowed in DSL workflows. Allowed: const/let, if/else, switch/case, for..of, return, throw, and workflow calls. If this should be supported, please report the node type: ${nodeType}`,
                     node: statement,
                 });
             }
@@ -40,7 +40,7 @@ export function validateNoDisallowedPatterns(node) {
         // Disallow while and do-while
         if (ts.isWhileStatement(node) || ts.isDoStatement(node)) {
             errors.push({
-                message: 'while and do-while loops are not allowed in simple workflows',
+                message: 'while and do-while loops are not allowed in DSL workflows',
                 node,
             });
             return;
@@ -48,13 +48,13 @@ export function validateNoDisallowedPatterns(node) {
         // Disallow for and for-in loops
         if (ts.isForInStatement(node) || ts.isForStatement(node)) {
             errors.push({
-                message: 'for and for-in loops are not allowed in simple workflows. Use for-of instead.',
+                message: 'for and for-in loops are not allowed in DSL workflows. Use for-of instead.',
                 node,
             });
             return;
         }
         // Check for inline workflow.do
-        if (ts.isCallExpression(node)) {
+        if (!options?.allowInline && ts.isCallExpression(node)) {
             if (ts.isPropertyAccessExpression(node.expression)) {
                 const propAccess = node.expression;
                 if (propAccess.name.text === 'do' &&
@@ -65,7 +65,7 @@ export function validateNoDisallowedPatterns(node) {
                         (ts.isArrowFunction(secondArg) ||
                             ts.isFunctionExpression(secondArg))) {
                         errors.push({
-                            message: 'Inline workflow.do with function argument is not allowed in simple workflows. Use RPC form instead.',
+                            message: 'Inline workflow.do with function argument is not allowed in DSL workflows. Use pikkuWorkflowComplexFunc instead.',
                             node,
                         });
                         return;
@@ -97,11 +97,19 @@ export function validateAwaitedCalls(node) {
             if (propAccess.name.text === 'all' &&
                 ts.isIdentifier(propAccess.expression) &&
                 propAccess.expression.text === 'Promise') {
-                // console.log('[DEBUG] Found Promise.all, setting insidePromiseAll=true')
-                // Visit children with insidePromiseAll = true
                 ts.forEachChild(node, (child) => visit(child, parentIsAwait, true));
                 return;
             }
+            // .push() on an array — workflow.do() inside is collecting promises
+            if (propAccess.name.text === 'push') {
+                ts.forEachChild(node, (child) => visit(child, parentIsAwait, true));
+                return;
+            }
+        }
+        // Array literal — workflow.do() inside is collecting promises
+        if (ts.isArrayLiteralExpression(node)) {
+            ts.forEachChild(node, (child) => visit(child, parentIsAwait, true));
+            return;
         }
         // Now check for workflow calls
         if (ts.isCallExpression(node)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.9",
+  "version": "0.12.10",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.16",
+    "@pikku/core": "^0.12.18",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",
     "tsx": "^4.21.0",

package/src/add/add-functions.ts

@@ -339,6 +339,7 @@ export const addFunctions: AddWiring = (
   let remote: boolean | undefined
   let mcp: boolean | undefined
   let readonly_: boolean | undefined
+  let deploy: 'serverless' | 'server' | 'auto' | undefined
   let approvalRequired: boolean | undefined
   let approvalDescription: string | undefined
   let version: number | undefined
@@ -422,6 +423,11 @@ export const addFunctions: AddWiring = (
     remote = getPropertyValue(firstArg, 'remote') as boolean | undefined
     mcp = getPropertyValue(firstArg, 'mcp') as boolean | undefined
     readonly_ = getPropertyValue(firstArg, 'readonly') as boolean | undefined
+    deploy = getPropertyValue(firstArg, 'deploy') as
+      | 'serverless'
+      | 'server'
+      | 'auto'
+      | undefined
     approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
       | boolean
       | undefined
@@ -783,6 +789,7 @@ export const addFunctions: AddWiring = (
     remote: remote || undefined,
     mcp: mcpEnabled || undefined,
     readonly: readonly_ || undefined,
+    deploy: deploy || undefined,
     approvalRequired: approvalRequired || undefined,
     approvalDescription: approvalDescription || undefined,
     version,
@@ -817,9 +824,7 @@ export const addFunctions: AddWiring = (
 
   if (mcpEnabled) {
     if (!description) {
-      logger.warn(
-        `MCP tool '${name}' is missing a description.`
-      )
+      logger.warn(`MCP tool '${name}' is missing a description.`)
     }
     state.mcpEndpoints.files.add(node.getSourceFile().fileName)
     state.mcpEndpoints.toolsMeta[name] = {

package/src/add/add-workflow.ts

@@ -155,7 +155,7 @@ function getWorkflowInvocations(
 }
 
 /**
- * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
+ * Inspector for pikkuWorkflowFunc() and pikkuWorkflowComplexFunc() calls
  * Detects workflow registration and extracts metadata
  */
 export const addWorkflow: AddWiring = (logger, node, checker, state) => {
@@ -171,11 +171,11 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
     return
   }
 
-  let wrapperType: 'dsl' | 'regular' | null = null
+  let wrapperType: 'dsl' | 'complex' | null = null
   if (expression.text === 'pikkuWorkflowFunc') {
     wrapperType = 'dsl'
   } else if (expression.text === 'pikkuWorkflowComplexFunc') {
-    wrapperType = 'regular'
+    wrapperType = 'complex'
   } else {
     return
   }
@@ -267,7 +267,9 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
 
   // Try DSL workflow extraction first
   // Pass the whole CallExpression node so findWorkflowFunction can find the arrow function
-  const result = extractDSLWorkflow(node, checker)
+  const result = extractDSLWorkflow(node, checker, {
+    allowInline: wrapperType === 'complex',
+  })
 
   if (result.status === 'ok' && result.steps) {
     // Extraction succeeded
@@ -305,7 +307,7 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
       getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps)
       logger.critical(
         ErrorCode.INVALID_DSL_WORKFLOW,
-        `Workflow '${workflowName}' uses pikkuWorkflowFunc but does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`
+        `Workflow '${workflowName}' does not conform to DSL workflow rules:\n${result.reason || 'Unknown error'}`
       )
       return
     } else {
@@ -317,12 +319,10 @@ export const addWorkflow: AddWiring = (logger, node, checker, state) => {
     }
   }
 
-  /**
-   * For non-dsl workflows or pikkuWorkflowComplexFunc, run basic extraction
-   * to ensure all RPC invocations are tracked for function registration.
-   * This catches RPCs in Promise.all callbacks and other patterns DSL can't extract.
-   */
-  if (!dsl || wrapperType === 'regular') {
+  // For pikkuWorkflowComplexFunc, also run basic extraction so RPCs in
+  // patterns the DSL extractor doesn't handle (array+push, nested Promise.all
+  // with identifier args, etc.) are still registered as invoked functions.
+  if (wrapperType === 'complex') {
     getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps)
   }
 

package/src/utils/extract-node-value.ts

@@ -27,6 +27,11 @@ export function extractStringLiteral(
     return result
   }
 
+  // Unwrap type assertions: `expr as Type` or `<Type>expr`
+  if (ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)) {
+    return extractStringLiteral(node.expression, checker)
+  }
+
   // Try to evaluate constant identifiers
   if (ts.isIdentifier(node)) {
     const symbol = checker.getSymbolAtLocation(node)