@pikku/inspector 0.12.41 → 0.12.42

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.12.42
+
+### Patch Changes
+
+- 854c342: Fix workspace addon integration: exclude nested pikku projects from inspection (prevents "More than one CoreUserSession/CoreConfig found" when a workspace addon is linked), widen the generated addon service `call()` data param to `unknown` so schema-less function inputs compile, and add `@pikku/inspector` + `@standard-schema/spec` to the generated addon devDependencies so its `.pikku` gen files typecheck.
+
 ## 0.12.41
 
 ### Patch Changes

package/dist/inspector.js

@@ -5,6 +5,7 @@ import { visitSetup, visitFunctions, 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 { createNestedProjectFilter } from './utils/nested-project-filter.js';
 import { aggregateRequiredServices, stampAuthHandlerServices, validateAgentModels, validateSecretOverrides, validateVariableOverrides, validateCredentialOverrides, computeResolvedIOTypes, computeMiddlewareGroupsMeta, computePermissionsGroupsMeta, computeRequiredSchemas, computeDiagnostics, validateSchemaWiringSeparation, } from './utils/post-process.js';
 import { generateOpenAPISpec } from './utils/serialize-openapi-json.js';
 import { pikkuState } from '@pikku/core/internal';
@@ -225,17 +226,22 @@ export const inspect = async (logger, routeFiles, options = {}) => {
     const startSourceFiles = performance.now();
     // node_modules under rootDir (e.g. a locally-installed addon) is a
     // dependency, not project source — scanning it double-counts the addon's
-    // own application types (CoreConfig/Services/SingletonServices).
+    // own application types (CoreConfig/Services/SingletonServices). Nested
+    // pikku projects (a workspace addon at packages/<addon>) are the same case:
+    // TS resolves the node_modules symlink to its realpath under rootDir, so
+    // the node_modules check alone misses them.
     // Sort by file name so the sweeps populate state in a stable order. The
     // program's own file order depends on glob + import-graph resolution, which
     // varies run to run — leaving generated meta keys (and anything serialized
     // in insertion order) non-reproducible across identical `pikku all` runs.
     // Safe because function registration is a dedicated pass (visitFunctions)
     // that completes before any order-sensitive wiring resolution in visitRoutes.
+    const isNestedProjectFile = createNestedProjectFilter(rootDir);
     const sourceFiles = program
         .getSourceFiles()
         .filter((sf) => sf.fileName.startsWith(rootDir) &&
-        !sf.fileName.includes('/node_modules/'))
+        !sf.fileName.includes('/node_modules/') &&
+        !isNestedProjectFile(sf.fileName))
         .sort((a, b) => a.fileName < b.fileName ? -1 : a.fileName > b.fileName ? 1 : 0);
     logger.debug(`Got source files in ${(performance.now() - startSourceFiles).toFixed(2)}ms`);
     const state = getInitialInspectorState(rootDir);

package/dist/utils/nested-project-filter.d.ts

@@ -0,0 +1 @@
+export declare const createNestedProjectFilter: (rootDir: string) => (fileName: string) => boolean;

package/dist/utils/nested-project-filter.js

@@ -0,0 +1,29 @@
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+export const createNestedProjectFilter = (rootDir) => {
+    const cache = new Map();
+    return (fileName) => {
+        const pending = [];
+        let dir = dirname(fileName);
+        let nested = false;
+        while (dir.startsWith(rootDir) && dir !== rootDir) {
+            const cached = cache.get(dir);
+            if (cached !== undefined) {
+                nested = cached;
+                break;
+            }
+            pending.push(dir);
+            if (existsSync(join(dir, 'pikku.config.json'))) {
+                nested = true;
+                break;
+            }
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        for (const d of pending)
+            cache.set(d, nested);
+        return nested;
+    };
+};

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

@@ -2,6 +2,12 @@ import * as ts from 'typescript';
 /**
  * Pattern detection helpers for DSL workflow extraction
  */
+/**
+ * The wire object handed to a DSL func is named `workflow` in a workflow and
+ * `scenario` in a scenario — both carry the same `do`/`sleep`/`suspend` DSL, so
+ * step extraction accepts either identifier.
+ */
+export declare function isWorkflowWireIdentifier(expr: ts.Expression): boolean;
 /**
  * Check if a call expression is workflow.do() or workflow.expectEventually()
  * (both are RPC steps; expectEventually is the polling variant used by scenarios)

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

@@ -2,6 +2,15 @@ import * as ts from 'typescript';
 /**
  * Pattern detection helpers for DSL workflow extraction
  */
+/**
+ * The wire object handed to a DSL func is named `workflow` in a workflow and
+ * `scenario` in a scenario — both carry the same `do`/`sleep`/`suspend` DSL, so
+ * step extraction accepts either identifier.
+ */
+export function isWorkflowWireIdentifier(expr) {
+    return (ts.isIdentifier(expr) &&
+        (expr.text === 'workflow' || expr.text === 'scenario'));
+}
 /**
  * Check if a call expression is workflow.do() or workflow.expectEventually()
  * (both are RPC steps; expectEventually is the polling variant used by scenarios)
@@ -13,8 +22,7 @@ export function isWorkflowDoCall(node, checker) {
     const propAccess = node.expression;
     return ((propAccess.name.text === 'do' ||
         propAccess.name.text === 'expectEventually') &&
-        ts.isIdentifier(propAccess.expression) &&
-        propAccess.expression.text === 'workflow');
+        isWorkflowWireIdentifier(propAccess.expression));
 }
 /**
  * Check if a call expression is workflow.expectEventually()
@@ -22,8 +30,7 @@ export function isWorkflowDoCall(node, checker) {
 export function isWorkflowExpectEventuallyCall(node) {
     return (ts.isPropertyAccessExpression(node.expression) &&
         node.expression.name.text === 'expectEventually' &&
-        ts.isIdentifier(node.expression.expression) &&
-        node.expression.expression.text === 'workflow');
+        isWorkflowWireIdentifier(node.expression.expression));
 }
 /**
  * Extract the actor NAME from a step options object literal:
@@ -58,8 +65,7 @@ export function isWorkflowSleepCall(node, checker) {
     }
     const propAccess = node.expression;
     return (propAccess.name.text === 'sleep' &&
-        ts.isIdentifier(propAccess.expression) &&
-        propAccess.expression.text === 'workflow');
+        isWorkflowWireIdentifier(propAccess.expression));
 }
 /**
  * Check if a call expression is workflow.suspend()
@@ -70,8 +76,7 @@ export function isWorkflowSuspendCall(node, _checker) {
     }
     const propAccess = node.expression;
     return (propAccess.name.text === 'suspend' &&
-        ts.isIdentifier(propAccess.expression) &&
-        propAccess.expression.text === 'workflow');
+        isWorkflowWireIdentifier(propAccess.expression));
 }
 /**
  * Check if a throw statement throws WorkflowCancelledException

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

@@ -1,4 +1,5 @@
 import * as ts from 'typescript';
+import { isWorkflowWireIdentifier } from './patterns.js';
 /**
  * Check if a node contains only allowed patterns
  *
@@ -58,8 +59,7 @@ export function validateNoDisallowedPatterns(node, options) {
             if (ts.isPropertyAccessExpression(node.expression)) {
                 const propAccess = node.expression;
                 if (propAccess.name.text === 'do' &&
-                    ts.isIdentifier(propAccess.expression) &&
-                    propAccess.expression.text === 'workflow') {
+                    isWorkflowWireIdentifier(propAccess.expression)) {
                     const secondArg = node.arguments[1];
                     if (secondArg &&
                         (ts.isArrowFunction(secondArg) ||
@@ -116,8 +116,7 @@ export function validateAwaitedCalls(node) {
             if (ts.isPropertyAccessExpression(node.expression)) {
                 const propAccess = node.expression;
                 if ((propAccess.name.text === 'do' || propAccess.name.text === 'sleep') &&
-                    ts.isIdentifier(propAccess.expression) &&
-                    propAccess.expression.text === 'workflow') {
+                    isWorkflowWireIdentifier(propAccess.expression)) {
                     if (!parentIsAwait && !insidePromiseAll) {
                         errors.push({
                             message: `workflow.${propAccess.name.text}() must be awaited`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.41",
+  "version": "0.12.42",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",

package/src/inspector.ts

@@ -10,6 +10,7 @@ import type {
 } from './types.js'
 import { getFilesAndMethods } from './utils/get-files-and-methods.js'
 import { findCommonAncestor } from './utils/find-root-dir.js'
+import { createNestedProjectFilter } from './utils/nested-project-filter.js'
 import {
   aggregateRequiredServices,
   stampAuthHandlerServices,
@@ -272,19 +273,24 @@ export const inspect = async (
   const startSourceFiles = performance.now()
   // node_modules under rootDir (e.g. a locally-installed addon) is a
   // dependency, not project source — scanning it double-counts the addon's
-  // own application types (CoreConfig/Services/SingletonServices).
+  // own application types (CoreConfig/Services/SingletonServices). Nested
+  // pikku projects (a workspace addon at packages/<addon>) are the same case:
+  // TS resolves the node_modules symlink to its realpath under rootDir, so
+  // the node_modules check alone misses them.
   // Sort by file name so the sweeps populate state in a stable order. The
   // program's own file order depends on glob + import-graph resolution, which
   // varies run to run — leaving generated meta keys (and anything serialized
   // in insertion order) non-reproducible across identical `pikku all` runs.
   // Safe because function registration is a dedicated pass (visitFunctions)
   // that completes before any order-sensitive wiring resolution in visitRoutes.
+  const isNestedProjectFile = createNestedProjectFilter(rootDir)
   const sourceFiles = program
     .getSourceFiles()
     .filter(
       (sf) =>
         sf.fileName.startsWith(rootDir) &&
-        !sf.fileName.includes('/node_modules/')
+        !sf.fileName.includes('/node_modules/') &&
+        !isNestedProjectFile(sf.fileName)
     )
     .sort((a, b) =>
       a.fileName < b.fileName ? -1 : a.fileName > b.fileName ? 1 : 0

package/src/utils/nested-project-filter.test.ts

@@ -0,0 +1,53 @@
+import { test } from 'node:test'
+import * as assert from 'node:assert'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { createNestedProjectFilter } from './nested-project-filter.js'
+
+test('createNestedProjectFilter', async (t) => {
+  const root = mkdtempSync(join(tmpdir(), 'pikku-nested-'))
+  t.after(() => rmSync(root, { recursive: true, force: true }))
+
+  writeFileSync(join(root, 'pikku.config.json'), '{}')
+  mkdirSync(join(root, 'packages/functions/src'), { recursive: true })
+  mkdirSync(join(root, 'packages/addon/src'), { recursive: true })
+  mkdirSync(join(root, 'packages/addon/types'), { recursive: true })
+  writeFileSync(join(root, 'packages/addon/pikku.config.json'), '{}')
+
+  const isNested = createNestedProjectFilter(root)
+
+  await t.test('keeps project source files', () => {
+    assert.strictEqual(
+      isNested(join(root, 'packages/functions/src/auth.ts')),
+      false
+    )
+  })
+
+  await t.test('keeps files directly under rootDir', () => {
+    assert.strictEqual(isNested(join(root, 'services.ts')), false)
+  })
+
+  await t.test('excludes files inside a nested pikku project', () => {
+    assert.strictEqual(
+      isNested(join(root, 'packages/addon/types/application-types.d.ts')),
+      true
+    )
+    assert.strictEqual(
+      isNested(join(root, 'packages/addon/src/index.ts')),
+      true
+    )
+  })
+
+  await t.test('keeps files outside rootDir untouched', () => {
+    assert.strictEqual(isNested('/somewhere/else/file.ts'), false)
+  })
+
+  await t.test('rootDir itself is not treated as nested', () => {
+    const addonScoped = createNestedProjectFilter(join(root, 'packages/addon'))
+    assert.strictEqual(
+      addonScoped(join(root, 'packages/addon/src/index.ts')),
+      false
+    )
+  })
+})

package/src/utils/nested-project-filter.ts

@@ -0,0 +1,28 @@
+import { existsSync } from 'fs'
+import { dirname, join } from 'path'
+
+export const createNestedProjectFilter = (rootDir: string) => {
+  const cache = new Map<string, boolean>()
+  return (fileName: string): boolean => {
+    const pending: string[] = []
+    let dir = dirname(fileName)
+    let nested = false
+    while (dir.startsWith(rootDir) && dir !== rootDir) {
+      const cached = cache.get(dir)
+      if (cached !== undefined) {
+        nested = cached
+        break
+      }
+      pending.push(dir)
+      if (existsSync(join(dir, 'pikku.config.json'))) {
+        nested = true
+        break
+      }
+      const parent = dirname(dir)
+      if (parent === dir) break
+      dir = parent
+    }
+    for (const d of pending) cache.set(d, nested)
+    return nested
+  }
+}

package/src/utils/workflow/dsl/patterns.ts

@@ -4,6 +4,18 @@ import * as ts from 'typescript'
  * Pattern detection helpers for DSL workflow extraction
  */
 
+/**
+ * The wire object handed to a DSL func is named `workflow` in a workflow and
+ * `scenario` in a scenario — both carry the same `do`/`sleep`/`suspend` DSL, so
+ * step extraction accepts either identifier.
+ */
+export function isWorkflowWireIdentifier(expr: ts.Expression): boolean {
+  return (
+    ts.isIdentifier(expr) &&
+    (expr.text === 'workflow' || expr.text === 'scenario')
+  )
+}
+
 /**
  * Check if a call expression is workflow.do() or workflow.expectEventually()
  * (both are RPC steps; expectEventually is the polling variant used by scenarios)
@@ -20,8 +32,7 @@ export function isWorkflowDoCall(
   return (
     (propAccess.name.text === 'do' ||
       propAccess.name.text === 'expectEventually') &&
-    ts.isIdentifier(propAccess.expression) &&
-    propAccess.expression.text === 'workflow'
+    isWorkflowWireIdentifier(propAccess.expression)
   )
 }
 
@@ -34,8 +45,7 @@ export function isWorkflowExpectEventuallyCall(
   return (
     ts.isPropertyAccessExpression(node.expression) &&
     node.expression.name.text === 'expectEventually' &&
-    ts.isIdentifier(node.expression.expression) &&
-    node.expression.expression.text === 'workflow'
+    isWorkflowWireIdentifier(node.expression.expression)
   )
 }
 
@@ -83,8 +93,7 @@ export function isWorkflowSleepCall(
   const propAccess = node.expression
   return (
     propAccess.name.text === 'sleep' &&
-    ts.isIdentifier(propAccess.expression) &&
-    propAccess.expression.text === 'workflow'
+    isWorkflowWireIdentifier(propAccess.expression)
   )
 }
 
@@ -102,8 +111,7 @@ export function isWorkflowSuspendCall(
   const propAccess = node.expression
   return (
     propAccess.name.text === 'suspend' &&
-    ts.isIdentifier(propAccess.expression) &&
-    propAccess.expression.text === 'workflow'
+    isWorkflowWireIdentifier(propAccess.expression)
   )
 }
 

package/src/utils/workflow/dsl/validation.ts

@@ -1,4 +1,5 @@
 import * as ts from 'typescript'
+import { isWorkflowWireIdentifier } from './patterns.js'
 
 /**
  * Validation rules for DSL workflows
@@ -78,8 +79,7 @@ export function validateNoDisallowedPatterns(
         const propAccess = node.expression
         if (
           propAccess.name.text === 'do' &&
-          ts.isIdentifier(propAccess.expression) &&
-          propAccess.expression.text === 'workflow'
+          isWorkflowWireIdentifier(propAccess.expression)
         ) {
           const secondArg = node.arguments[1]
           if (
@@ -154,8 +154,7 @@ export function validateAwaitedCalls(node: ts.Node): ValidationError[] {
         const propAccess = node.expression
         if (
           (propAccess.name.text === 'do' || propAccess.name.text === 'sleep') &&
-          ts.isIdentifier(propAccess.expression) &&
-          propAccess.expression.text === 'workflow'
+          isWorkflowWireIdentifier(propAccess.expression)
         ) {
           if (!parentIsAwait && !insidePromiseAll) {
             errors.push({