@pikku/inspector 0.12.16 → 0.12.17

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.12.17
+
+### Patch Changes
+
+- 2cf67be: Add inline option to pikkuFunc/pikkuSessionlessFunc for workflow step dispatch
+
+  By default, workflow steps now run inline (no queue hop). Set inline: false on a function to force dispatch through the queue for that step.
+
+- Updated dependencies [2cf67be]
+  - @pikku/core@0.12.28
+
 ## 0.12.16
 
 ### Patch Changes

package/dist/add/add-functions.js

@@ -277,6 +277,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
     let deploy;
     let approvalRequired;
     let approvalDescription;
+    let inline;
     let version;
     let objectNode;
     let nodeDisplayName = null;
@@ -344,6 +345,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         readonly_ = getPropertyValue(firstArg, 'readonly');
         deploy = getPropertyValue(firstArg, 'deploy');
         approvalRequired = getPropertyValue(firstArg, 'approvalRequired');
+        inline = getPropertyValue(firstArg, 'inline');
         // Extract approvalDescription identifier reference
         for (const prop of firstArg.properties) {
             if (ts.isPropertyAssignment(prop) &&
@@ -716,6 +718,7 @@ export const addFunctions = (logger, node, checker, state, options) => {
         deploy: deploy || undefined,
         approvalRequired: approvalRequired || undefined,
         approvalDescription: approvalDescription || undefined,
+        inline: inline === false ? false : undefined,
         implementationHash,
         version,
         title,

package/dist/utils/custom-types-generator.js

@@ -7,6 +7,53 @@
 export function sanitizeTypeName(name) {
     return name.replace(/[^a-zA-Z0-9_$]/g, '_');
 }
+const CLASSIFICATION_WRAPPERS = new Set(['Private', 'Pii', 'Secret']);
+function findMatchingAngleBracket(type, startIndex) {
+    let depth = 0;
+    for (let i = startIndex; i < type.length; i += 1) {
+        const char = type[i];
+        if (char === '<') {
+            depth += 1;
+            continue;
+        }
+        if (char === '>' && (i === 0 || type[i - 1] !== '=')) {
+            depth -= 1;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function stripClassificationWrappers(type) {
+    let output = '';
+    let index = 0;
+    while (index < type.length) {
+        const char = type[index];
+        if (!/[A-Za-z_$]/.test(char)) {
+            output += char;
+            index += 1;
+            continue;
+        }
+        let end = index + 1;
+        while (end < type.length && /[A-Za-z0-9_$]/.test(type[end])) {
+            end += 1;
+        }
+        const identifier = type.slice(index, end);
+        if (CLASSIFICATION_WRAPPERS.has(identifier) && type[end] === '<') {
+            const closingIndex = findMatchingAngleBracket(type, end);
+            if (closingIndex !== -1) {
+                const inner = type.slice(end + 1, closingIndex);
+                output += stripClassificationWrappers(inner);
+                index = closingIndex + 1;
+                continue;
+            }
+        }
+        output += identifier;
+        index = end;
+    }
+    return output;
+}
 export function generateCustomTypes(typesMap, requiredTypes) {
     const typeDeclarations = Array.from(typesMap.customTypes.entries())
         .sort(([a], [b]) => a.localeCompare(b))
@@ -17,11 +64,13 @@ export function generateCustomTypes(typesMap, requiredTypes) {
         .map(([originalName, { type, references }]) => {
         const name = sanitizeTypeName(originalName);
         references.forEach((refName) => {
-            if (refName !== '__object' && !refName.startsWith('__object_')) {
+            if (refName !== '__object' &&
+                !refName.startsWith('__object_') &&
+                !CLASSIFICATION_WRAPPERS.has(refName)) {
                 requiredTypes.add(refName);
             }
         });
-        const typeString = type;
+        const typeString = stripClassificationWrappers(type);
         const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g;
         const potentialTypes = typeString.match(typeNameRegex) || [];
         potentialTypes.forEach((typeName) => {
@@ -46,12 +95,14 @@ export function generateCustomTypes(typesMap, requiredTypes) {
                 // Type not found in map (ambient/builtin type)
             }
         });
-        if (name === type)
+        if (name === typeString)
             return null;
-        return `export type ${name} = ${type}`;
+        return `export type ${name} = ${typeString}`;
     });
     const importsByPath = new Map();
     for (const typeName of requiredTypes) {
+        if (CLASSIFICATION_WRAPPERS.has(typeName))
+            continue;
         try {
             const typeMeta = typesMap.getTypeMeta(typeName);
             if (typeMeta.path) {

package/dist/utils/schema-generator.js

@@ -212,7 +212,9 @@ async function batchImportWithRegister(logger, sourceFiles) {
         return null;
     }
     finally {
-        await unregister?.();
+        void Promise.resolve(unregister?.()).catch((e) => {
+            logger.debug(`tsx unregister() failed: ${e.message}`);
+        });
     }
 }
 async function importWithRegister(sourceFile) {
@@ -221,7 +223,7 @@ async function importWithRegister(sourceFile) {
         return await import(sourceFile);
     }
     finally {
-        await unregister();
+        void Promise.resolve(unregister()).catch(() => { });
     }
 }
 function processZodSchema(schemaName, zodSchema, schemas, typesMap, auxiliaryTypeStore, printer, fakeSourceFile, logger) {

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

@@ -1040,6 +1040,29 @@ function extractReturn(statement, context) {
     if (!statement.expression) {
         return null;
     }
+    if (ts.isAwaitExpression(statement.expression) &&
+        ts.isCallExpression(statement.expression.expression)) {
+        const call = statement.expression.expression;
+        if (isWorkflowDoCall(call, context.checker)) {
+            return isInlineDoCall(call)
+                ? extractInlineStep(call, context)
+                : extractRpcStep(call, context);
+        }
+        if (isWorkflowSleepCall(call, context.checker)) {
+            return extractSleepStep(call, context);
+        }
+    }
+    if (ts.isCallExpression(statement.expression)) {
+        const call = statement.expression;
+        if (isWorkflowDoCall(call, context.checker)) {
+            return isInlineDoCall(call)
+                ? extractInlineStep(call, context)
+                : extractRpcStep(call, context);
+        }
+        if (isWorkflowSleepCall(call, context.checker)) {
+            return extractSleepStep(call, context);
+        }
+    }
     if (!ts.isObjectLiteralExpression(statement.expression)) {
         return null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.16",
+  "version": "0.12.17",
   "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.27",
+    "@pikku/core": "^0.12.28",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",
     "tsx": "^4.21.0",

package/src/add/add-functions.ts

@@ -392,6 +392,7 @@ export const addFunctions: AddWiring = (
   let deploy: 'serverless' | 'server' | 'auto' | undefined
   let approvalRequired: boolean | undefined
   let approvalDescription: string | undefined
+  let inline: boolean | undefined
   let version: number | undefined
   let objectNode: ts.ObjectLiteralExpression | undefined
   let nodeDisplayName: string | null = null
@@ -487,6 +488,7 @@ export const addFunctions: AddWiring = (
     approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
       | boolean
       | undefined
+    inline = getPropertyValue(firstArg, 'inline') as boolean | undefined
 
     // Extract approvalDescription identifier reference
     for (const prop of firstArg.properties) {
@@ -1004,6 +1006,7 @@ export const addFunctions: AddWiring = (
     deploy: deploy || undefined,
     approvalRequired: approvalRequired || undefined,
     approvalDescription: approvalDescription || undefined,
+    inline: inline === false ? false : undefined,
     implementationHash,
     version,
     title,

package/src/utils/custom-types-generator.test.ts

@@ -0,0 +1,99 @@
+import { test, describe } from 'node:test'
+import { strict as assert } from 'node:assert'
+import { generateCustomTypes } from './custom-types-generator.js'
+import { TypesMap } from '../types-map.js'
+
+function makeTypesMap(
+  entries: Record<string, { type: string; references: string[] }>
+): TypesMap {
+  const tm = new TypesMap()
+  for (const [name, { type, references }] of Object.entries(entries)) {
+    tm.addCustomType(name, type, references)
+  }
+  return tm
+}
+
+describe('generateCustomTypes — classification wrapper stripping', () => {
+  test('strips Private<T> wrapper from type alias', () => {
+    const tm = makeTypesMap({
+      UserEmail: { type: 'Private<string>', references: ['Private'] },
+    })
+    const result = generateCustomTypes(tm, new Set())
+    assert.match(result, /UserEmail/, 'should emit UserEmail alias')
+    assert.match(
+      result,
+      /= string/,
+      'Private<string> should be stripped to string'
+    )
+    assert.doesNotMatch(result, /Private/, 'Private wrapper must be removed')
+  })
+
+  test('strips Secret<T> wrapper from type alias', () => {
+    const tm = makeTypesMap({
+      HashedPw: { type: 'Secret<string>', references: ['Secret'] },
+    })
+    const result = generateCustomTypes(tm, new Set())
+    assert.match(result, /HashedPw/)
+    assert.match(
+      result,
+      /= string/,
+      'Secret<string> should be stripped to string'
+    )
+    assert.doesNotMatch(result, /Secret/, 'Secret wrapper must be removed')
+  })
+
+  test('strips Pii<T> wrapper from type alias', () => {
+    const tm = makeTypesMap({
+      UserPhone: { type: 'Pii<string>', references: ['Pii'] },
+    })
+    const result = generateCustomTypes(tm, new Set())
+    assert.match(result, /UserPhone/)
+    assert.match(result, /= string/, 'Pii<string> should be stripped to string')
+    assert.doesNotMatch(result, /Pii/, 'Pii wrapper must be removed')
+  })
+
+  test('strips nested classification wrappers', () => {
+    const tm = makeTypesMap({
+      Combo: {
+        type: 'Private<Secret<string>>',
+        references: ['Private', 'Secret'],
+      },
+    })
+    const result = generateCustomTypes(tm, new Set())
+    assert.match(result, /Combo/)
+    assert.match(
+      result,
+      /= string/,
+      'nested wrappers should resolve to inner type'
+    )
+    assert.doesNotMatch(
+      result,
+      /Private|Secret/,
+      'all wrappers must be removed'
+    )
+  })
+
+  test('does not strip non-classification type names', () => {
+    const tm = makeTypesMap({
+      MyType: { type: 'SomeOtherType', references: ['SomeOtherType'] },
+    })
+    const required = new Set<string>()
+    generateCustomTypes(tm, required)
+    assert.ok(
+      required.has('SomeOtherType'),
+      'non-classification references must remain in requiredTypes'
+    )
+  })
+
+  test('classification wrapper references are not added to requiredTypes', () => {
+    const tm = makeTypesMap({
+      SensitiveField: { type: 'Private<string>', references: ['Private'] },
+    })
+    const required = new Set<string>()
+    generateCustomTypes(tm, required)
+    assert.ok(
+      !required.has('Private'),
+      'Private must not be added to requiredTypes'
+    )
+  })
+})

package/src/utils/custom-types-generator.ts

@@ -11,6 +11,61 @@ export function sanitizeTypeName(name: string): string {
   return name.replace(/[^a-zA-Z0-9_$]/g, '_')
 }
 
+const CLASSIFICATION_WRAPPERS = new Set(['Private', 'Pii', 'Secret'])
+
+function findMatchingAngleBracket(type: string, startIndex: number): number {
+  let depth = 0
+  for (let i = startIndex; i < type.length; i += 1) {
+    const char = type[i]
+    if (char === '<') {
+      depth += 1
+      continue
+    }
+    if (char === '>' && (i === 0 || type[i - 1] !== '=')) {
+      depth -= 1
+      if (depth === 0) {
+        return i
+      }
+    }
+  }
+  return -1
+}
+
+function stripClassificationWrappers(type: string): string {
+  let output = ''
+  let index = 0
+
+  while (index < type.length) {
+    const char = type[index]
+    if (!/[A-Za-z_$]/.test(char)) {
+      output += char
+      index += 1
+      continue
+    }
+
+    let end = index + 1
+    while (end < type.length && /[A-Za-z0-9_$]/.test(type[end])) {
+      end += 1
+    }
+
+    const identifier = type.slice(index, end)
+    if (CLASSIFICATION_WRAPPERS.has(identifier) && type[end] === '<') {
+      const closingIndex = findMatchingAngleBracket(type, end)
+      if (closingIndex !== -1) {
+        const inner = type.slice(end + 1, closingIndex)
+        output += stripClassificationWrappers(inner)
+        index = closingIndex + 1
+        continue
+      }
+    }
+
+    output += identifier
+    index = end
+  }
+
+  return output
+}
+
 export function generateCustomTypes(
   typesMap: TypesMap,
   requiredTypes: Set<string>
@@ -25,12 +80,16 @@ export function generateCustomTypes(
     .map(([originalName, { type, references }]) => {
       const name = sanitizeTypeName(originalName)
       references.forEach((refName) => {
-        if (refName !== '__object' && !refName.startsWith('__object_')) {
+        if (
+          refName !== '__object' &&
+          !refName.startsWith('__object_') &&
+          !CLASSIFICATION_WRAPPERS.has(refName)
+        ) {
           requiredTypes.add(refName)
         }
       })
 
-      const typeString = type
+      const typeString = stripClassificationWrappers(type)
       const typeNameRegex = /\b[A-Z][a-zA-Z0-9]*\b/g
       const potentialTypes = typeString.match(typeNameRegex) || []
 
@@ -59,12 +118,13 @@ export function generateCustomTypes(
         }
       })
 
-      if (name === type) return null
-      return `export type ${name} = ${type}`
+      if (name === typeString) return null
+      return `export type ${name} = ${typeString}`
     })
 
   const importsByPath = new Map<string, Set<string>>()
   for (const typeName of requiredTypes) {
+    if (CLASSIFICATION_WRAPPERS.has(typeName)) continue
     try {
       const typeMeta = typesMap.getTypeMeta(typeName)
       if (typeMeta.path) {

package/src/utils/schema-generator.ts

@@ -297,7 +297,9 @@ async function batchImportWithRegister(
     logger.debug(`tsx register() batch import failed: ${(e as Error).message}`)
     return null
   } finally {
-    await unregister?.()
+    void Promise.resolve(unregister?.()).catch((e) => {
+      logger.debug(`tsx unregister() failed: ${(e as Error).message}`)
+    })
   }
 }
 
@@ -308,7 +310,7 @@ async function importWithRegister(
   try {
     return await import(sourceFile)
   } finally {
-    await unregister()
+    void Promise.resolve(unregister()).catch(() => {})
   }
 }
 

package/src/utils/workflow/dsl/extract-dsl-workflow.ts

@@ -6,7 +6,6 @@ import type {
   BranchStepMeta,
   ParallelGroupStepMeta,
   FanoutStepMeta,
-  ReturnStepMeta,
   CancelStepMeta,
   SetStepMeta,
   SwitchStepMeta,
@@ -1340,11 +1339,38 @@ function extractOutputBinding(
 function extractReturn(
   statement: ts.ReturnStatement,
   context: ExtractionContext
-): ReturnStepMeta | null {
+): WorkflowStepMeta | null {
   if (!statement.expression) {
     return null
   }
 
+  if (
+    ts.isAwaitExpression(statement.expression) &&
+    ts.isCallExpression(statement.expression.expression)
+  ) {
+    const call = statement.expression.expression
+    if (isWorkflowDoCall(call, context.checker)) {
+      return isInlineDoCall(call)
+        ? extractInlineStep(call, context)
+        : extractRpcStep(call, context)
+    }
+    if (isWorkflowSleepCall(call, context.checker)) {
+      return extractSleepStep(call, context)
+    }
+  }
+
+  if (ts.isCallExpression(statement.expression)) {
+    const call = statement.expression
+    if (isWorkflowDoCall(call, context.checker)) {
+      return isInlineDoCall(call)
+        ? extractInlineStep(call, context)
+        : extractRpcStep(call, context)
+    }
+    if (isWorkflowSleepCall(call, context.checker)) {
+      return extractSleepStep(call, context)
+    }
+  }
+
   if (!ts.isObjectLiteralExpression(statement.expression)) {
     return null
   }