@pikku/inspector 0.11.0 → 0.11.1

package/dist/add/add-workflow.js

@@ -1,20 +1,19 @@
 import * as ts from 'typescript';
-import { getPropertyValue, getPropertyTags, } from '../utils/get-property-value.js';
 import { extractFunctionName } from '../utils/extract-function-name.js';
-import { getPropertyAssignmentInitializer, resolveFunctionDeclaration, } from '../utils/type-utils.js';
-import { resolveMiddleware } from '../utils/middleware.js';
-import { extractWireNames } from '../utils/post-process.js';
+import { extractFunctionNode } from '../utils/extract-function-node.js';
 import { ErrorCode } from '../error-codes.js';
-import { extractStringLiteral, extractNumberLiteral, extractPropertyString, isStringLike, isFunctionLike, } from '../utils/extract-node-value.js';
+import { extractStringLiteral, isStringLike, isFunctionLike, extractDescription, extractDuration, } from '../utils/extract-node-value.js';
+import { extractSimpleWorkflow } from '../workflow/extract-simple-workflow.js';
+import { getCommonWireMetaData } from '../utils/get-property-value.js';
 /**
- * Scan for workflow.do() and workflow.sleep() calls to extract workflow steps
+ * Scan for workflow.do(), workflow.sleep(), and workflow.cancel() calls to extract workflow steps
  */
 function getWorkflowInvocations(node, checker, state, workflowName, steps) {
     // Look for property access expressions: workflow.do or workflow.sleep
     if (ts.isPropertyAccessExpression(node)) {
         const { name } = node;
         // Check if this is accessing 'do' or 'sleep' property
-        if (name.text === 'do' || name.text === 'sleep') {
+        if (name.text === 'do' || name.text === 'sleep' || name.text === 'cancel') {
             // Check if the parent is a call expression
             const parent = node.parent;
             if (ts.isCallExpression(parent) && parent.expression === node) {
@@ -34,7 +33,6 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
                             type: 'rpc',
                             stepName,
                             rpcName,
-                            description,
                         });
                         state.rpc.invokedFunctions.add(rpcName);
                     }
@@ -59,6 +57,12 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
                         duration: duration || '<dynamic>',
                     });
                 }
+                else if (name.text === 'cancel') {
+                    // workflow.cancel(reason?)
+                    steps.push({
+                        type: 'cancel',
+                    });
+                }
             }
         }
     }
@@ -73,80 +77,102 @@ function getWorkflowInvocations(node, checker, state, workflowName, steps) {
     });
 }
 /**
- * Extract description from options object
- */
-function extractDescription(optionsNode, checker) {
-    if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
-        return null;
-    }
-    return extractPropertyString(optionsNode, 'description', checker);
-}
-/**
- * Extract duration value (number or string)
- */
-function extractDuration(node, checker) {
-    const numValue = extractNumberLiteral(node);
-    if (numValue !== null) {
-        return numValue;
-    }
-    return extractStringLiteral(node, checker);
-}
-/**
- * Inspector for wireWorkflow() calls
+ * Inspector for pikkuWorkflow() and pikkuSimpleWorkflow() calls
  * Detects workflow registration and extracts metadata
  */
-export const addWorkflow = (logger, node, checker, state, options) => {
+export const addWorkflow = (logger, node, checker, state) => {
     if (!ts.isCallExpression(node)) {
         return;
     }
     const args = node.arguments;
     const firstArg = args[0];
     const expression = node.expression;
-    // Check if the call is to wireWorkflow
-    if (!ts.isIdentifier(expression) || expression.text !== 'wireWorkflow') {
+    if (!ts.isIdentifier(expression)) {
+        return;
+    }
+    let wrapperType = null;
+    if (expression.text === 'pikkuWorkflowFunc') {
+        wrapperType = 'regular';
+    }
+    else if (expression.text === 'pikkuSimpleWorkflowFunc') {
+        wrapperType = 'simple';
+    }
+    else {
         return;
     }
     if (!firstArg) {
         return;
     }
+    // Extract workflow name and metadata using same logic as add-functions
+    const { pikkuFuncName, name, exportedName } = extractFunctionName(node, checker, state.rootDir);
+    const workflowName = exportedName || name;
+    if (!workflowName) {
+        logger.critical(ErrorCode.MISSING_NAME, `Could not determine workflow name from export.`);
+        return;
+    }
+    // Extract the function node (either direct function or from config.func)
+    const { funcNode, resolvedFunc } = extractFunctionNode(firstArg, checker);
+    // Extract metadata if using object form
+    let tags;
+    let summary;
+    let description;
+    let errors;
     if (ts.isObjectLiteralExpression(firstArg)) {
-        const obj = firstArg;
-        const workflowName = getPropertyValue(obj, 'name');
-        const description = getPropertyValue(obj, 'description');
-        const docs = getPropertyValue(obj, 'docs') || undefined;
-        const tags = getPropertyTags(obj, 'Workflow', workflowName, logger);
-        // --- find the referenced function ---
-        const funcInitializer = getPropertyAssignmentInitializer(obj, 'func', true, checker);
-        if (!workflowName) {
-            logger.critical(ErrorCode.MISSING_NAME, `Wasn't able to determine 'name' property for workflow wiring.`);
-            return;
-        }
-        if (!funcInitializer) {
-            logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for workflow '${workflowName}'.`);
+        const metadata = getCommonWireMetaData(firstArg, 'Workflow', workflowName, logger);
+        tags = metadata.tags;
+        summary = metadata.summary;
+        description = metadata.description;
+        errors = metadata.errors;
+    }
+    // Validate that we got a valid function
+    if (ts.isObjectLiteralExpression(firstArg) &&
+        (!funcNode || funcNode === firstArg)) {
+        logger.critical(ErrorCode.MISSING_FUNC, `No valid 'func' property for workflow '${workflowName}'.`);
+        return;
+    }
+    if (!resolvedFunc) {
+        logger.critical(ErrorCode.MISSING_FUNC, `Could not resolve workflow function for '${workflowName}'.`);
+        return;
+    }
+    // Track workflow file for wiring generation
+    if (exportedName) {
+        state.workflows.files.set(pikkuFuncName, {
+            path: node.getSourceFile().fileName,
+            exportedName,
+        });
+    }
+    let steps = [];
+    let simple = undefined;
+    // Try simple workflow extraction first
+    // Pass the whole CallExpression node so findWorkflowFunction can find the arrow function
+    const result = extractSimpleWorkflow(node, checker);
+    if (result.status === 'ok' && result.steps) {
+        // Simple extraction succeeded
+        steps = result.steps;
+        simple = true;
+    }
+    else {
+        // Simple extraction failed
+        if (wrapperType === 'simple') {
+            // For pikkuSimpleWorkflowFunc, this is a critical error
+            logger.critical(ErrorCode.INVALID_SIMPLE_WORKFLOW, `Workflow '${workflowName}' uses pikkuSimpleWorkflowFunc but does not conform to simple workflow DSL:\n${result.reason || 'Unknown error'}`);
             return;
         }
-        const pikkuFuncName = extractFunctionName(funcInitializer, checker, state.rootDir).pikkuFuncName;
-        // --- resolve middleware ---
-        const middleware = resolveMiddleware(state, obj, tags, checker);
-        // --- track used functions/middleware for service aggregation ---
-        state.serviceAggregation.usedFunctions.add(pikkuFuncName);
-        extractWireNames(middleware).forEach((name) => state.serviceAggregation.usedMiddleware.add(name));
-        state.workflows.files.add(node.getSourceFile().fileName);
-        // Extract workflow steps from function body
-        // Resolve the identifier to the actual function declaration
-        const resolvedFunc = resolveFunctionDeclaration(funcInitializer, checker);
-        const steps = [];
-        if (resolvedFunc) {
-            getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
+        else {
+            // For pikkuWorkflowFunc, fall back to basic extraction
+            logger.debug(`Workflow '${workflowName}' could not be extracted as simple workflow: ${result.reason || 'Unknown error'}. Falling back to basic extraction.`);
+            simple = false;
         }
-        state.workflows.meta[workflowName] = {
-            pikkuFuncName,
-            workflowName,
-            description,
-            docs,
-            tags,
-            middleware,
-            steps,
-        };
     }
+    getWorkflowInvocations(resolvedFunc, checker, state, workflowName, steps);
+    state.workflows.meta[workflowName] = {
+        pikkuFuncName,
+        workflowName,
+        steps,
+        simple,
+        summary,
+        description,
+        errors,
+        tags,
+    };
 };

package/dist/error-codes.d.ts

@@ -19,6 +19,7 @@ export declare enum ErrorCode {
     CLI_CLIENTSIDE_RENDERER_HAS_SERVICES = "PKU672",
     DYNAMIC_STEP_NAME = "PKU529",
     WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED = "PKU600",
+    INVALID_SIMPLE_WORKFLOW = "PKU641",
     CONFIG_TYPE_NOT_FOUND = "PKU426",
     CONFIG_TYPE_UNDEFINED = "PKU427",
     SCHEMA_NO_ROOT = "PKU431",

package/dist/error-codes.js

@@ -21,6 +21,7 @@ export var ErrorCode;
     ErrorCode["CLI_CLIENTSIDE_RENDERER_HAS_SERVICES"] = "PKU672";
     ErrorCode["DYNAMIC_STEP_NAME"] = "PKU529";
     ErrorCode["WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED"] = "PKU600";
+    ErrorCode["INVALID_SIMPLE_WORKFLOW"] = "PKU641";
     // Configuration errors
     ErrorCode["CONFIG_TYPE_NOT_FOUND"] = "PKU426";
     ErrorCode["CONFIG_TYPE_UNDEFINED"] = "PKU427";

package/dist/index.d.ts

@@ -8,3 +8,5 @@ export { ErrorCode } from './error-codes.js';
 export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
 export type { SerializableInspectorState } from './utils/serialize-inspector-state.js';
 export { filterInspectorState } from './utils/filter-inspector-state.js';
+export { writeAllServiceMetadata } from './utils/write-service-metadata.js';
+export type { ServiceMetadata } from './utils/extract-service-metadata.js';

package/dist/index.js

@@ -3,3 +3,4 @@ export { getFilesAndMethods } from './utils/get-files-and-methods.js';
 export { ErrorCode } from './error-codes.js';
 export { serializeInspectorState, deserializeInspectorState, } from './utils/serialize-inspector-state.js';
 export { filterInspectorState } from './utils/filter-inspector-state.js';
+export { writeAllServiceMetadata } from './utils/write-service-metadata.js';

package/dist/inspector.js

@@ -4,7 +4,7 @@ import { visitSetup, visitRoutes } from './visit.js';
 import { TypesMap } from './types-map.js';
 import { getFilesAndMethods } from './utils/get-files-and-methods.js';
 import { findCommonAncestor } from './utils/find-root-dir.js';
-import { aggregateRequiredServices } from './utils/post-process.js';
+import { aggregateRequiredServices, extractServiceInterfaceMetadata, } from './utils/post-process.js';
 /**
  * Creates an initial/empty inspector state with all required properties initialized
  * @param rootDir - The root directory for the project
@@ -14,12 +14,12 @@ export function getInitialInspectorState(rootDir) {
     return {
         rootDir,
         singletonServicesTypeImportMap: new Map(),
-        sessionServicesTypeImportMap: new Map(),
+        wireServicesTypeImportMap: new Map(),
         userSessionTypeImportMap: new Map(),
         configTypeImportMap: new Map(),
         singletonServicesFactories: new Map(),
-        sessionServicesFactories: new Map(),
-        sessionServicesMeta: new Map(),
+        wireServicesFactories: new Map(),
+        wireServicesMeta: new Map(),
         configFactories: new Map(),
         filesAndMethods: {},
         filesAndMethodsErrors: new Map(),
@@ -58,7 +58,7 @@ export function getInitialInspectorState(rootDir) {
         },
         workflows: {
             meta: {},
-            files: new Set(),
+            files: new Map(),
         },
         rpc: {
             internalMeta: {},
@@ -94,8 +94,9 @@ export function getInitialInspectorState(rootDir) {
             usedMiddleware: new Set(),
             usedPermissions: new Set(),
             allSingletonServices: [],
-            allSessionServices: [],
+            allWireServices: [],
         },
+        serviceMetadata: [],
     };
 }
 export const inspect = (logger, routeFiles, options = {}) => {
@@ -144,6 +145,9 @@ export const inspect = (logger, routeFiles, options = {}) => {
         const startAggregate = performance.now();
         aggregateRequiredServices(state);
         logger.debug(`Aggregate required services completed in ${(performance.now() - startAggregate).toFixed(2)}ms`);
+        const startServiceMeta = performance.now();
+        extractServiceInterfaceMetadata(state, checker);
+        logger.debug(`Extract service metadata completed in ${(performance.now() - startServiceMeta).toFixed(2)}ms`);
     }
     return state;
 };

package/dist/types.d.ts

@@ -92,7 +92,7 @@ export type InspectorOptions = Partial<{
         configFileType: string;
         userSessionType: string;
         singletonServicesFactoryType: string;
-        sessionServicesFactoryType: string;
+        wireServicesFactoryType: string;
     }>;
 }>;
 export interface InspectorLogger {
@@ -111,7 +111,7 @@ export interface InspectorFilesAndMethods {
         type: string;
         typePath: string;
     };
-    sessionServicesType?: {
+    wireServicesType?: {
         file: string;
         variable: string;
         type: string;
@@ -141,7 +141,7 @@ export interface InspectorFilesAndMethods {
         type: string;
         typePath: string;
     };
-    sessionServicesFactory?: {
+    wireServicesFactory?: {
         file: string;
         variable: string;
         type: string;
@@ -151,12 +151,12 @@ export interface InspectorFilesAndMethods {
 export interface InspectorState {
     rootDir: string;
     singletonServicesTypeImportMap: PathToNameAndType;
-    sessionServicesTypeImportMap: PathToNameAndType;
+    wireServicesTypeImportMap: PathToNameAndType;
     userSessionTypeImportMap: PathToNameAndType;
     configTypeImportMap: PathToNameAndType;
     singletonServicesFactories: PathToNameAndType;
-    sessionServicesFactories: PathToNameAndType;
-    sessionServicesMeta: Map<string, string[]>;
+    wireServicesFactories: PathToNameAndType;
+    wireServicesMeta: Map<string, string[]>;
     configFactories: PathToNameAndType;
     filesAndMethods: InspectorFilesAndMethods;
     filesAndMethodsErrors: Map<string, PathToNameAndType>;
@@ -174,7 +174,10 @@ export interface InspectorState {
     };
     workflows: {
         meta: WorkflowsMeta;
-        files: Set<string>;
+        files: Map<string, {
+            path: string;
+            exportedName: string;
+        }>;
     };
     rpc: {
         internalMeta: Record<string, string>;
@@ -207,6 +210,16 @@ export interface InspectorState {
         usedMiddleware: Set<string>;
         usedPermissions: Set<string>;
         allSingletonServices: string[];
-        allSessionServices: string[];
+        allWireServices: string[];
     };
+    serviceMetadata: Array<{
+        name: string;
+        summary: string;
+        description: string;
+        package: string;
+        path: string;
+        version: string;
+        interface: string;
+        expandedProperties: Record<string, string>;
+    }>;
 }

package/dist/utils/extract-function-node.d.ts

@@ -0,0 +1,10 @@
+import * as ts from 'typescript';
+/**
+ * Extracts the actual function node from a pikkuFunc/pikkuWorkflowFunc call
+ * Handles both direct function form and config object form { func: ... }
+ */
+export declare function extractFunctionNode(firstArg: ts.Expression, checker: ts.TypeChecker): {
+    funcNode: ts.Node;
+    resolvedFunc: ts.Node | null;
+    isDirectFunction: boolean;
+};

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

@@ -0,0 +1,38 @@
+import * as ts from 'typescript';
+import { getPropertyAssignmentInitializer, resolveFunctionDeclaration, } from './type-utils.js';
+/**
+ * Extracts the actual function node from a pikkuFunc/pikkuWorkflowFunc call
+ * Handles both direct function form and config object form { func: ... }
+ */
+export function extractFunctionNode(firstArg, checker) {
+    let funcNode = firstArg;
+    let isDirectFunction = true;
+    // Check if first argument is a config object with 'func' property
+    if (ts.isObjectLiteralExpression(firstArg)) {
+        isDirectFunction = false;
+        const funcInitializer = getPropertyAssignmentInitializer(firstArg, 'func', true, checker);
+        if (funcInitializer) {
+            funcNode = funcInitializer;
+        }
+        else {
+            // Return the original node if no func property found
+            // Caller should handle validation
+            funcNode = firstArg;
+        }
+    }
+    // Resolve identifier to get the actual function node
+    if (ts.isIdentifier(funcNode)) {
+        const symbol = checker.getSymbolAtLocation(funcNode);
+        const decl = symbol?.valueDeclaration || symbol?.declarations?.[0];
+        if (decl && ts.isVariableDeclaration(decl) && decl.initializer) {
+            funcNode = decl.initializer;
+        }
+    }
+    // Resolve function declaration for deeper analysis
+    const resolvedFunc = resolveFunctionDeclaration(funcNode, checker);
+    return {
+        funcNode,
+        resolvedFunc,
+        isDirectFunction,
+    };
+}

package/dist/utils/extract-node-value.d.ts

@@ -22,3 +22,11 @@ export declare function extractNumberLiteral(node: ts.Node): number | null;
  * Returns the extracted value or null if not found/cannot extract
  */
 export declare function extractPropertyString(objNode: ts.ObjectLiteralExpression, propertyName: string, checker: ts.TypeChecker): string | null;
+/**
+ * Extract description from options object
+ */
+export declare function extractDescription(optionsNode: ts.Node | undefined, checker: ts.TypeChecker): string | null;
+/**
+ * Extract duration value (number or string)
+ */
+export declare function extractDuration(node: ts.Node, checker: ts.TypeChecker): string | number | null;

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

@@ -77,3 +77,27 @@ export function extractPropertyString(objNode, propertyName, checker) {
     }
     return null;
 }
+/**
+ * Extract description from options object
+ */
+export function extractDescription(optionsNode, checker) {
+    if (!optionsNode || !ts.isObjectLiteralExpression(optionsNode)) {
+        return null;
+    }
+    return extractPropertyString(optionsNode, 'description', checker);
+}
+/**
+ * Extract duration value (number or string)
+ */
+export function extractDuration(node, checker) {
+    const numValue = extractNumberLiteral(node);
+    if (numValue !== null) {
+        return numValue;
+    }
+    try {
+        return extractStringLiteral(node, checker);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/extract-service-metadata.d.ts

@@ -0,0 +1,19 @@
+import * as ts from 'typescript';
+export interface ServiceMetadata {
+    name: string;
+    summary: string;
+    description: string;
+    package: string;
+    path: string;
+    version: string;
+    interface: string;
+    expandedProperties: Record<string, string>;
+}
+/**
+ * Extract metadata for a service from its TypeScript declaration
+ */
+export declare function extractServiceMetadata(serviceName: string, type: ts.Type, checker: ts.TypeChecker, rootDir: string): ServiceMetadata | null;
+/**
+ * Extract metadata for all services in a type
+ */
+export declare function extractAllServiceMetadata(servicesType: ts.Type, checker: ts.TypeChecker, rootDir: string): ServiceMetadata[];