@pikku/inspector 0.12.75 → 0.12.82

package/src/add/add-workflow-edge-cases.test.ts

@@ -1,201 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { InspectorLogger } from '../types.js'
-import { deserializeDslWorkflow } from '../utils/workflow/dsl/deserialize-dsl-workflow.js'
-
-const STEP_FILE = [
-  "import { pikkuSessionlessFunc } from '@pikku/core'",
-  'export const chargeCard = pikkuSessionlessFunc({',
-  "  func: async () => ({ id: 'c' }),",
-  '})',
-  'export const refundOrder = pikkuSessionlessFunc({',
-  "  func: async () => ({ id: 'r' }),",
-  '})',
-  'export const notify = pikkuSessionlessFunc({',
-  "  func: async () => ({ id: 'n' }),",
-  '})',
-  'export const audit = pikkuSessionlessFunc({',
-  "  func: async () => ({ id: 'a' }),",
-  '})',
-].join('\n')
-
-async function run(body: string): Promise<{
-  nodes: Record<string, any>
-  diags: string[]
-  code: string
-}> {
-  const diags: string[] = []
-  const logger = {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: (...a: any[]) => diags.push(a.map(String).join(' ')),
-    critical: (...a: any[]) => diags.push(a.map(String).join(' ')),
-    hasCriticalErrors: () => false,
-  } as unknown as InspectorLogger
-
-  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-edge-'))
-  const stepFile = join(rootDir, 'w.steps.ts')
-  const wfFile = join(rootDir, 'w.workflow.ts')
-  await writeFile(stepFile, STEP_FILE)
-  await writeFile(
-    wfFile,
-    [
-      "import { pikkuWorkflowFunc } from '@pikku/core/workflow'",
-      'export const wf = pikkuWorkflowFunc(async (_, data: any, { workflow }) => {',
-      body,
-      '})',
-    ].join('\n')
-  )
-  try {
-    const state: any = await inspect(logger, [stepFile, wfFile], { rootDir })
-    const gm = state.workflows.graphMeta
-    const graph = (
-      gm instanceof Map ? [...gm.values()] : Object.values(gm)
-    )[0] as any
-    return {
-      nodes: graph?.nodes ?? {},
-      diags,
-      code: graph ? deserializeDslWorkflow(graph) : '',
-    }
-  } finally {
-    await rm(rootDir, { recursive: true, force: true })
-  }
-}
-
-describe('onError — edge cases', () => {
-  test('the handler is not also emitted as a step that always runs', async () => {
-    const { code } = await run(
-      [
-        "  await workflow.do('Charge', 'chargeCard', {}, { onError: 'refundOrder' })",
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    const refundCalls = code.match(/'refundOrder'/g) ?? []
-    assert.equal(
-      refundCalls.length,
-      1,
-      `the handler must appear only as onError, never as its own sequential step, got:\n${code}`
-    )
-  })
-
-  test('a non-literal onError is reported, not silently ignored', async () => {
-    const { diags } = await run(
-      [
-        '  const target = data.handler',
-        "  await workflow.do('Charge', 'chargeCard', {}, { onError: target })",
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    assert.ok(
-      diags.some((d) => d.includes('onError')),
-      `a non-literal onError must be diagnosed, got: ${JSON.stringify(diags)}`
-    )
-  })
-
-  test('onError inside a branch still resolves', async () => {
-    const { nodes } = await run(
-      [
-        '  if (data.paid) {',
-        "    await workflow.do('Charge', 'chargeCard', {}, { onError: 'refundOrder' })",
-        '  }',
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    const charge = Object.values(nodes).find(
-      (n: any) => n.rpcName === 'chargeCard'
-    ) as any
-    assert.ok(
-      charge?.onError,
-      'a branch step should still carry its error route'
-    )
-    assert.equal((nodes[charge.onError] as any)?.rpcName, 'refundOrder')
-  })
-})
-
-describe('switch — fall-through to default', () => {
-  test('a trailing empty case routes to the default body', async () => {
-    const { nodes } = await run(
-      [
-        '  switch (data.kind) {',
-        "    case 'a':",
-        "      await workflow.do('Notify', 'notify', {})",
-        '      break',
-        "    case 'b':",
-        '    default:',
-        "      await workflow.do('Audit', 'audit', {})",
-        '  }',
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    const sw = Object.values(nodes).find((n: any) => n.flow === 'switch') as any
-    assert.ok(sw, 'a switch node should exist')
-    const caseB = (sw.cases ?? []).find((c: any) => c.value === 'b')
-    assert.ok(
-      caseB,
-      `a case falling through to default must not be dropped, got: ${JSON.stringify(sw.cases)}`
-    )
-    assert.equal(
-      caseB.entry,
-      sw.defaultEntry,
-      'it should route to the default body it falls into'
-    )
-  })
-})
-
-describe('options — numeric values keep their type', () => {
-  test('a numeric retryDelay is not quoted', async () => {
-    const { code } = await run(
-      [
-        "  await workflow.do('Charge', 'chargeCard', {}, { retries: 2, retryDelay: 500 })",
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    assert.ok(
-      code.includes('retryDelay: 500'),
-      `a numeric retryDelay must stay numeric, got:\n${code}`
-    )
-  })
-})
-
-describe('sequential fanout — for..of bodies', () => {
-  test('a multi-step for..of body keeps every step', async () => {
-    const { nodes } = await run(
-      [
-        '  for (const u of data.users) {',
-        "    const c = await workflow.do('Charge', 'chargeCard', { id: u.id })",
-        "    await workflow.do('Notify', 'notify', { id: c.id })",
-        '  }',
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    const fanout = Object.values(nodes).find(
-      (n: any) => n.flow === 'fanout'
-    ) as any
-    assert.ok(fanout, 'a for..of should produce a fanout node')
-    assert.notEqual(
-      fanout.nodeId,
-      fanout.childEntry,
-      'the loop and its body entry must not share an id'
-    )
-
-    const rpcs = Object.values(nodes)
-      .filter((n: any) => n.rpcName)
-      .map((n: any) => n.rpcName)
-    assert.ok(
-      rpcs.includes('chargeCard') && rpcs.includes('notify'),
-      `both body steps must survive, got: ${JSON.stringify(rpcs)}`
-    )
-  })
-})

package/src/add/add-workflow-fanout.test.ts

@@ -1,166 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { InspectorLogger } from '../types.js'
-
-function makeLogger(
-  criticals: Array<{ code: string; message: string }>
-): InspectorLogger {
-  return {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: ({ code, message }) => {
-      criticals.push({ code, message })
-    },
-    critical: (code: any, message: string) => {
-      criticals.push({ code, message })
-    },
-    hasCriticalErrors: () => criticals.length > 0,
-  }
-}
-
-const STEP_FILE = [
-  "import { pikkuSessionlessFunc } from '@pikku/core'",
-  'export const processEventLeadsStep = pikkuSessionlessFunc({',
-  '  func: async ({ logger }) => ({ persistedCount: 1 }),',
-  '})',
-].join('\n')
-
-describe('addWorkflow — Promise.all fanout RPC detection', () => {
-  test('registers fanout RPC when captured with `const x = await Promise.all(map(...))`', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-fanout-const-'))
-    const wfFile = join(rootDir, 'leads.workflow.ts')
-    const stepFile = join(rootDir, 'leads.steps.ts')
-
-    await writeFile(stepFile, STEP_FILE)
-    await writeFile(
-      wfFile,
-      [
-        "import { pikkuWorkflowFunc } from '@pikku/core/workflow'",
-        'export const extractLeadsWorkflow = pikkuWorkflowFunc(async (_, data, { workflow }) => {',
-        '  const events = [{ id: "a", name: "x" }]',
-        '  const processed = await Promise.all(',
-        '    events.map((event) =>',
-        "      workflow.do(`Enrich event ${event.id ?? event.name}`, 'processEventLeadsStep', { event })",
-        '    )',
-        '  )',
-        '  return { count: processed.length }',
-        '})',
-      ].join('\n')
-    )
-
-    const criticals: Array<{ code: string; message: string }> = []
-    try {
-      const state = await inspect(makeLogger(criticals), [stepFile, wfFile], {
-        rootDir,
-      })
-      assert.ok(
-        state.rpc.invokedFunctions.has('processEventLeadsStep'),
-        'processEventLeadsStep should be registered when fanout is captured with const'
-      )
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-
-  test('registers fanout RPC with string-concatenation (`+`) step name, same as template literal', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-fanout-concat-'))
-    const wfFile = join(rootDir, 'leads.workflow.ts')
-    const stepFile = join(rootDir, 'leads.steps.ts')
-
-    await writeFile(stepFile, STEP_FILE)
-    await writeFile(
-      wfFile,
-      [
-        "import { pikkuWorkflowFunc } from '@pikku/core/workflow'",
-        'export const extractLeadsWorkflow = pikkuWorkflowFunc(async (_, data, { workflow }) => {',
-        '  const events = [{ id: "a", name: "x" }]',
-        '  await Promise.all(',
-        '    events.map((event) =>',
-        "      workflow.do('Enrich event ' + (event.id ?? event.name), 'processEventLeadsStep', { event })",
-        '    )',
-        '  )',
-        '  return { ok: true }',
-        '})',
-      ].join('\n')
-    )
-
-    const criticals: Array<{ code: string; message: string }> = []
-    try {
-      const state = await inspect(makeLogger(criticals), [stepFile, wfFile], {
-        rootDir,
-      })
-      assert.ok(
-        state.rpc.invokedFunctions.has('processEventLeadsStep'),
-        'processEventLeadsStep should be registered even when the step name uses `+` concatenation with a non-static operand'
-      )
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-
-  test('registers every RPC in a multi-step map body, including a `const`-captured step feeding the next', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-fanout-multi-'))
-    const wfFile = join(rootDir, 'digest.workflow.ts')
-    const stepFile = join(rootDir, 'digest.steps.ts')
-
-    await writeFile(
-      stepFile,
-      [
-        "import { pikkuSessionlessFunc } from '@pikku/core'",
-        'export const getDigestData = pikkuSessionlessFunc({',
-        '  func: async ({ logger }) => ({ dealsByStage: {}, totalDealValue: 0 }),',
-        '})',
-        'export const sendDigestEmail = pikkuSessionlessFunc({',
-        '  func: async ({ logger }) => ({ sent: true }),',
-        '})',
-      ].join('\n')
-    )
-    await writeFile(
-      wfFile,
-      [
-        "import { pikkuWorkflowFunc } from '@pikku/core/workflow'",
-        'export const dailyDigestWorkflow = pikkuWorkflowFunc(async (_, data, { workflow }) => {',
-        '  const users = [{ id: "1", email: "a@b.c" }]',
-        '  await Promise.all(',
-        '    users.map(async (u) => {',
-        '      const digestData = await workflow.do(',
-        '        `Get pipeline for ${u.email}`,',
-        "        'getDigestData',",
-        '        { userId: u.id },',
-        '      )',
-        "      await workflow.do(`Send digest to ${u.email}`, 'sendDigestEmail', {",
-        '        email: u.email,',
-        '        dealsByStage: digestData.dealsByStage,',
-        '        totalDealValue: digestData.totalDealValue,',
-        '      })',
-        '    }),',
-        '  )',
-        '  return { sent: users.length }',
-        '})',
-      ].join('\n')
-    )
-
-    const criticals: Array<{ code: string; message: string }> = []
-    try {
-      const state = await inspect(makeLogger(criticals), [stepFile, wfFile], {
-        rootDir,
-      })
-      assert.ok(
-        state.rpc.invokedFunctions.has('sendDigestEmail'),
-        'sendDigestEmail should be registered'
-      )
-      assert.ok(
-        state.rpc.invokedFunctions.has('getDigestData'),
-        'getDigestData should be registered — a `const`-captured workflow.do inside the map body must not be dropped'
-      )
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-})

package/src/add/add-workflow-graph-foreach.test.ts

@@ -1,174 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { InspectorLogger } from '../types.js'
-
-function makeLogger(): InspectorLogger {
-  return {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: () => {},
-    critical: () => {},
-    hasCriticalErrors: () => false,
-  }
-}
-
-async function inspectGraph(graphSource: string[], graphName: string) {
-  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-graph-foreach-'))
-  const stepFile = join(rootDir, 'my.steps.ts')
-  const graphFile = join(rootDir, 'my.graph.ts')
-
-  await writeFile(
-    stepFile,
-    [
-      "import { pikkuSessionlessFunc } from '@pikku/core'",
-      'export const listRows = pikkuSessionlessFunc({ func: async () => ({ rows: [] }) })',
-      'export const postVideo = pikkuSessionlessFunc({ func: async () => ({ ok: true }) })',
-    ].join('\n')
-  )
-  await writeFile(graphFile, graphSource.join('\n'))
-
-  try {
-    const state = await inspect(makeLogger(), [stepFile, graphFile], {
-      rootDir,
-    })
-    const graph = state.workflows.graphMeta[graphName]
-    assert.ok(graph, `graph meta '${graphName}' should be registered`)
-    return graph
-  } finally {
-    await rm(rootDir, { recursive: true, force: true })
-  }
-}
-
-describe('addWorkflowGraph — forEach extraction', () => {
-  test('forEach node id and $item() lower into the serialized meta', async () => {
-    const graph = await inspectGraph(
-      [
-        "import { pikkuWorkflowGraph } from '@pikku/core/workflow'",
-        'export const myGraph = pikkuWorkflowGraph({',
-        "  name: 'foreach-graph',",
-        "  nodes: { listRows: 'listRows', postVideo: 'postVideo' },",
-        '  config: {',
-        "    listRows: { next: 'postVideo' },",
-        '    postVideo: {',
-        "      forEach: 'listRows',",
-        '      input: (ref, template, $item) => ({',
-        "        url: $item('URL VIDEO'),",
-        '        whole: $item(),',
-        "        listed: ref('listRows'),",
-        '      }),',
-        '    },',
-        '  },',
-        '})',
-      ],
-      'foreach-graph'
-    )
-
-    const node = graph.nodes['postVideo'] as any
-    assert.deepEqual(node.forEach, { $ref: 'listRows' })
-    assert.equal(node.mode, undefined)
-    assert.deepEqual(node.input, {
-      url: { $ref: '$item', path: 'URL VIDEO' },
-      whole: { $ref: '$item', path: undefined },
-      listed: { $ref: 'listRows', path: undefined },
-    })
-  })
-
-  test('forEach accepts a (ref) callback with a path, plus a sequential mode', async () => {
-    const graph = await inspectGraph(
-      [
-        "import { pikkuWorkflowGraph } from '@pikku/core/workflow'",
-        'export const myGraph = pikkuWorkflowGraph({',
-        "  name: 'foreach-callback-graph',",
-        "  nodes: { listRows: 'listRows', postVideo: 'postVideo' },",
-        '  config: {',
-        "    listRows: { next: 'postVideo' },",
-        '    postVideo: {',
-        "      forEach: (ref) => ref('listRows', 'rows'),",
-        "      mode: 'sequential',",
-        "      input: (ref, template, $item) => ({ url: $item('URL') }),",
-        '    },',
-        '  },',
-        '})',
-      ],
-      'foreach-callback-graph'
-    )
-
-    const node = graph.nodes['postVideo'] as any
-    assert.deepEqual(node.forEach, { $ref: 'listRows', path: 'rows' })
-    assert.equal(node.mode, 'sequential')
-  })
-
-  test('an existing (ref) => ... node keeps its exact input and gains no forEach', async () => {
-    const graph = await inspectGraph(
-      [
-        "import { pikkuWorkflowGraph } from '@pikku/core/workflow'",
-        "import { template } from '@pikku/core/workflow'",
-        'export const myGraph = pikkuWorkflowGraph({',
-        "  name: 'plain-graph',",
-        "  nodes: { listRows: 'listRows', postVideo: 'postVideo' },",
-        '  config: {',
-        "    listRows: { next: 'postVideo' },",
-        '    postVideo: {',
-        '      input: (ref) => ({',
-        "        rows: ref('listRows', 'rows'),",
-        "        label: template('rows: $0', [ref('listRows', 'rows')]),",
-        '      }),',
-        '    },',
-        '  },',
-        '})',
-      ],
-      'plain-graph'
-    )
-
-    const node = graph.nodes['postVideo'] as any
-    assert.equal(node.forEach, undefined)
-    assert.equal(node.mode, undefined)
-    assert.deepEqual(node.input, {
-      rows: { $ref: 'listRows', path: 'rows' },
-      label: {
-        $template: {
-          parts: ['rows: ', ''],
-          expressions: [{ $ref: 'listRows', path: 'rows' }],
-        },
-      },
-    })
-  })
-
-  test('an existing (ref, template) => ... node still resolves template from the 2nd param', async () => {
-    const graph = await inspectGraph(
-      [
-        "import { pikkuWorkflowGraph } from '@pikku/core/workflow'",
-        'export const myGraph = pikkuWorkflowGraph({',
-        "  name: 'two-param-graph',",
-        "  nodes: { listRows: 'listRows', postVideo: 'postVideo' },",
-        '  config: {',
-        "    listRows: { next: 'postVideo' },",
-        '    postVideo: {',
-        '      input: (ref, template) => ({',
-        "        label: template('rows: $0', [ref('listRows', 'rows')]),",
-        '      }),',
-        '    },',
-        '  },',
-        '})',
-      ],
-      'two-param-graph'
-    )
-
-    const node = graph.nodes['postVideo'] as any
-    assert.equal(node.forEach, undefined)
-    assert.deepEqual(node.input, {
-      label: {
-        $template: {
-          parts: ['rows: ', ''],
-          expressions: [{ $ref: 'listRows', path: 'rows' }],
-        },
-      },
-    })
-  })
-})

package/src/add/add-workflow-graph-input.test.ts

@@ -1,94 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { InspectorLogger } from '../types.js'
-
-function makeLogger(): InspectorLogger {
-  return {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: () => {},
-    critical: () => {},
-    hasCriticalErrors: () => false,
-  }
-}
-
-describe('addWorkflowGraph — node input extraction', () => {
-  test('`as const` and imported template() values survive into the serialized input', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-graph-input-'))
-    const stepFile = join(rootDir, 'my.steps.ts')
-    const graphFile = join(rootDir, 'my.graph.ts')
-
-    await writeFile(
-      stepFile,
-      [
-        "import { pikkuSessionlessFunc } from '@pikku/core'",
-        'export const edit = pikkuSessionlessFunc({ func: async () => ({ ok: true }) })',
-      ].join('\n')
-    )
-
-    await writeFile(
-      graphFile,
-      [
-        "import { pikkuWorkflowGraph } from '@pikku/core/workflow'",
-        "import { template } from '@pikku/core/workflow'",
-        'export const myGraph = pikkuWorkflowGraph({',
-        "  name: 'input-graph',",
-        "  nodes: { edit: 'edit' },",
-        '  config: {',
-        '    edit: {',
-        '      input: (ref) => ({',
-        "        method: 'GET' as const,",
-        '        operations: [',
-        "          { field: 'product', operation: 'set' as const, value: 'widget' },",
-        "          { field: 'email', operation: 'set' as const, value: ref('trigger', 'body.email') },",
-        "          { field: 'greeting', operation: 'set' as const, value: template('Hi $0', [ref('trigger', 'body.name')]) },",
-        '        ],',
-        '      }),',
-        '    },',
-        '  },',
-        '})',
-      ].join('\n')
-    )
-
-    try {
-      const state = await inspect(makeLogger(), [stepFile, graphFile], {
-        rootDir,
-      })
-      const graph = state.workflows.graphMeta['input-graph']
-      assert.ok(graph, 'graph meta should be registered')
-      const input = (graph.nodes['edit'] as { input?: any }).input
-      assert.ok(input, 'node input should be extracted')
-
-      // Bug 1 — top-level `X as const` must not be dropped.
-      assert.equal(input.method, 'GET', 'top-level `as const` value preserved')
-
-      // Bug 1 — nested `as const` inside an array element must not be dropped.
-      assert.equal(input.operations[0].operation, 'set')
-      assert.equal(input.operations[0].value, 'widget')
-      assert.equal(input.operations[1].operation, 'set')
-
-      // ref() still works alongside the fix.
-      assert.deepEqual(input.operations[1].value, {
-        $ref: 'trigger',
-        path: 'body.email',
-      })
-
-      // Bug 2 — imported template() (arrow has only `ref`, no 2nd param) preserved.
-      assert.equal(input.operations[2].operation, 'set')
-      assert.deepEqual(input.operations[2].value, {
-        $template: {
-          parts: ['Hi ', ''],
-          expressions: [{ $ref: 'trigger', path: 'body.name' }],
-        },
-      })
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-})