@pikku/inspector 0.12.75 → 0.12.82

package/src/add/add-workflow-on-error.test.ts

@@ -1,118 +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' }),",
-  '})',
-].join('\n')
-
-const WORKFLOW_BODY = [
-  "  await workflow.do('Charge', 'chargeCard', { id: data.id }, {",
-  '    retries: 3,',
-  "    onError: 'refundOrder',",
-  '  })',
-  '  return { ok: true }',
-].join('\n')
-
-async function inspectWorkflow(body: string): Promise<{
-  nodes: Record<string, any>
-  invoked: string[]
-  code: string
-}> {
-  const logger = {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: () => {},
-    critical: () => {},
-    hasCriticalErrors: () => false,
-  } as unknown as InspectorLogger
-
-  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-oe-'))
-  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
-    assert.ok(graph, 'a graph should have been produced')
-    return {
-      nodes: graph.nodes,
-      invoked: [...(state.rpc?.invokedFunctions ?? [])],
-      code: deserializeDslWorkflow(graph),
-    }
-  } finally {
-    await rm(rootDir, { recursive: true, force: true })
-  }
-}
-
-describe('DSL onError — compensation is part of the graph', () => {
-  test('the handler becomes a node the failing step points at', async () => {
-    const { nodes } = await inspectWorkflow(WORKFLOW_BODY)
-
-    const charge = Object.values(nodes).find(
-      (n: any) => n.rpcName === 'chargeCard'
-    ) as any
-    assert.ok(charge, 'the charging step should exist')
-    assert.ok(
-      charge.onError,
-      `the step must record its error route so the graph can render it, got: ${JSON.stringify(charge)}`
-    )
-
-    const handlerId = Array.isArray(charge.onError)
-      ? charge.onError[0]
-      : charge.onError
-    const handler = nodes[handlerId]
-    assert.ok(
-      handler,
-      `onError must point at a real node so an edge can be drawn, got id '${handlerId}' in ${JSON.stringify(Object.keys(nodes))}`
-    )
-    assert.equal(handler.rpcName, 'refundOrder')
-  })
-
-  test('the handler RPC is registered as invoked so it gets wired', async () => {
-    const { invoked } = await inspectWorkflow(WORKFLOW_BODY)
-
-    assert.ok(
-      invoked.includes('refundOrder'),
-      `the compensation RPC must be wired, got: ${JSON.stringify(invoked)}`
-    )
-  })
-
-  test('onError survives regeneration back to code', async () => {
-    const { code } = await inspectWorkflow(WORKFLOW_BODY)
-
-    assert.ok(
-      code.includes("onError: 'refundOrder'"),
-      `onError must round-trip as an rpc name, got:\n${code}`
-    )
-    assert.ok(
-      code.includes('retries: 3'),
-      'other options must still round-trip'
-    )
-  })
-})

package/src/add/add-workflow-return-switch.test.ts

@@ -1,121 +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'
-
-const STEP_FILE = [
-  "import { pikkuSessionlessFunc } from '@pikku/core'",
-  'export const ship = pikkuSessionlessFunc({',
-  "  func: async () => ({ id: 's', ok: true }),",
-  '})',
-].join('\n')
-
-async function inspectWorkflow(body: string): Promise<{
-  nodes: Record<string, any>
-  diags: string[]
-}> {
-  const diags: string[] = []
-  const logger = {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: (d: any) => diags.push(d?.message ?? String(d)),
-    critical: (d: any) => diags.push(d?.message ?? String(d)),
-    hasCriticalErrors: () => false,
-  } as unknown as InspectorLogger
-
-  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-rs-'))
-  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 }
-  } finally {
-    await rm(rootDir, { recursive: true, force: true })
-  }
-}
-
-describe('switch extraction — a fall-through case is a real case', () => {
-  test("case 'a': case 'b': records both values", async () => {
-    const { nodes } = await inspectWorkflow(
-      [
-        '  switch (data.kind) {',
-        "    case 'a':",
-        "    case 'b':",
-        "      await workflow.do('Ship', 'ship', {})",
-        '      break',
-        '  }',
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    const switchNode = Object.values(nodes).find(
-      (n: any) => n.flow === 'switch'
-    ) as any
-    assert.ok(switchNode, 'a switch node should exist')
-    const values = (switchNode.cases ?? []).map((c: any) => c.value)
-    assert.deepEqual(
-      values.sort(),
-      ['a', 'b'],
-      `a fall-through case must not be dropped, got: ${JSON.stringify(switchNode.cases)}`
-    )
-    const entries = new Set((switchNode.cases ?? []).map((c: any) => c.entry))
-    assert.equal(entries.size, 1, 'both cases should share the same entry')
-  })
-})
-
-describe('return extraction — a spread output is not silently dropped', () => {
-  test('return { ...r, extra } keeps the spread', async () => {
-    const { nodes } = await inspectWorkflow(
-      [
-        "  const r = await workflow.do('Ship', 'ship', {})",
-        '  return { ...r, extra: 1 }',
-      ].join('\n')
-    )
-
-    const returnNode = Object.values(nodes).find(
-      (n: any) => n.flow === 'return'
-    ) as any
-    assert.ok(returnNode, 'a return node should exist')
-    assert.deepEqual(
-      returnNode.spread,
-      ['r'],
-      `the spread source must be recorded, got: ${JSON.stringify(returnNode)}`
-    )
-  })
-
-  test('return r produces a return node', async () => {
-    const { nodes } = await inspectWorkflow(
-      ["  const r = await workflow.do('Ship', 'ship', {})", '  return r'].join(
-        '\n'
-      )
-    )
-
-    const returnNode = Object.values(nodes).find(
-      (n: any) => n.flow === 'return'
-    ) as any
-    assert.ok(
-      returnNode,
-      `returning a variable must still produce a return node, got: ${JSON.stringify(nodes)}`
-    )
-    assert.deepEqual(returnNode.spread, ['r'])
-  })
-})

package/src/add/add-workflow-silent-drops.test.ts

@@ -1,261 +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(diags: string[]): InspectorLogger {
-  return {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: ({ code, message }: any) => {
-      diags.push(`${code}: ${message}`)
-    },
-    critical: (code: any, message: string) => {
-      diags.push(`${code}: ${message}`)
-    },
-    hasCriticalErrors: () => false,
-  }
-}
-
-const STEP_FILE = [
-  "import { pikkuSessionlessFunc } from '@pikku/core'",
-  'export const listUsers = pikkuSessionlessFunc({',
-  "  func: async () => ({ users: [{ id: '1', email: 'a@b.c' }] }),",
-  '})',
-  'export const rpcA = pikkuSessionlessFunc({',
-  "  func: async () => ({ id: 'a' }),",
-  '})',
-  'export const rpcB = pikkuSessionlessFunc({',
-  "  func: async () => ({ id: 'b' }),",
-  '})',
-  'export const rpcC = pikkuSessionlessFunc({',
-  '  func: async () => ({ ok: true }),',
-  '})',
-].join('\n')
-
-async function inspectWorkflow(body: string) {
-  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-drops-'))
-  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')
-  )
-  const diags: string[] = []
-  try {
-    const state: any = await inspect(makeLogger(diags), [stepFile, wfFile], {
-      rootDir,
-    })
-    const metaMap = state.workflows.meta
-    const meta = (
-      metaMap instanceof Map ? [...metaMap.values()] : Object.values(metaMap)
-    )[0] as any
-    return {
-      invoked: [...state.rpc.invokedFunctions] as string[],
-      steps: (meta?.steps ?? []) as any[],
-      diags,
-    }
-  } finally {
-    await rm(rootDir, { recursive: true, force: true })
-  }
-}
-
-describe('DSL extraction — constructs that must not be silently dropped', () => {
-  test('a property access on the loop item (u.id) survives as an item input', async () => {
-    const { steps } = await inspectWorkflow(
-      [
-        "  const audience = await workflow.do('collect', 'listUsers', {})",
-        '  await Promise.all(',
-        '    audience.users.map(async (u) => {',
-        "      await workflow.do('send', 'rpcC', { userId: u.id, tag: 'x' })",
-        '    })',
-        '  )',
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    const fanout = steps.find((s) => s.type === 'fanout')
-    assert.ok(fanout, 'fanout step should be extracted')
-    const send = fanout.body?.[0]
-    assert.ok(send, 'the fanout body step should be extracted')
-    assert.deepEqual(
-      send.inputs?.userId,
-      { from: 'item', path: 'id' },
-      `u.id must map to the loop item, got: ${JSON.stringify(send.inputs)}`
-    )
-    assert.deepEqual(
-      send.inputs?.tag,
-      { from: 'literal', value: 'x' },
-      'sibling literal inputs must still survive'
-    )
-  })
-
-  test('array destructuring of a Promise.all group keeps both steps and binds each result', async () => {
-    const { invoked, steps } = await inspectWorkflow(
-      [
-        '  const [org, user] = await Promise.all([',
-        "    workflow.do('create org', 'rpcA', {}),",
-        "    workflow.do('create user', 'rpcB', {}),",
-        '  ])',
-        '  return { orgId: org.id, userId: user.id }',
-      ].join('\n')
-    )
-
-    assert.ok(invoked.includes('rpcA'), 'rpcA must not be dropped')
-    assert.ok(invoked.includes('rpcB'), 'rpcB must not be dropped')
-
-    const parallel = steps.find((s) => s.type === 'parallel')
-    assert.ok(parallel, 'a parallel step should be extracted')
-    assert.deepEqual(
-      parallel.children?.map((c: any) => c.outputVar),
-      ['org', 'user'],
-      'each destructured name should bind to its matching child step'
-    )
-
-    const ret = steps.find((s) => s.type === 'return')
-    assert.deepEqual(
-      ret?.outputs?.orgId,
-      { from: 'outputVar', name: 'org', path: 'id' },
-      'org.id must resolve to the bound step output, not degrade to a trigger input'
-    )
-  })
-
-  test('object destructuring of a step result reports a diagnostic instead of silently dropping', async () => {
-    const { invoked, diags } = await inspectWorkflow(
-      [
-        "  const { id } = await workflow.do('s', 'rpcA', {})",
-        '  return { id }',
-      ].join('\n')
-    )
-
-    const dropped = !invoked.includes('rpcA')
-    assert.ok(
-      !dropped || diags.length > 0,
-      'if the step is dropped the user must be told — silence is the bug'
-    )
-  })
-
-  test('a counting for-of (Array(n).keys()) hard-errors instead of silently dropping its step', async () => {
-    const { invoked, steps, diags } = await inspectWorkflow(
-      [
-        '  for (const i of [...Array(3).keys()]) {',
-        "    await workflow.do(`poll #${i}`, 'rpcA', {})",
-        '  }',
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    // The DSL extractor can't model a computed/counting iterable, so it must
-    // FAIL LOUDLY (INVALID_DSL_WORKFLOW), not swallow the loop and every
-    // workflow.do inside it — the silent drop is exactly what stranded
-    // checkSandboxHostCapacity out of invokedFunctions and bricked prod.
-    assert.ok(
-      diags.length > 0,
-      'a counting for-of must raise a diagnostic, not vanish silently'
-    )
-    assert.ok(
-      diags.some((d) => /for-of/i.test(d)),
-      `the diagnostic must name the offending for-of, got: ${JSON.stringify(diags)}`
-    )
-    // And it must NOT have quietly produced a fanout with zero body steps.
-    assert.ok(
-      !invoked.includes('rpcA') || diags.length > 0,
-      'if rpcA was dropped the user must be told'
-    )
-    const fanout = steps.find((s) => s.type === 'fanout')
-    assert.ok(
-      !fanout,
-      'a counting loop must not serialize as a fanout — it is not a data-array fanout'
-    )
-  })
-
-  /**
-   * The diagnostic used to blame the iterable in every case, including this one
-   * where the iterable is a perfectly good data array. That sent readers looking
-   * at `data.tagsToRemove` when the real obstacle was the `if` in the body, so
-   * the message has to distinguish the two causes.
-   */
-  test('a branch inside a fanout body hard-errors, and the diagnostic blames the branch not the iterable', async () => {
-    const { steps, diags } = await inspectWorkflow(
-      [
-        '  for (const tag of data.tags) {',
-        '    if (tag.length > 2) {',
-        "      await workflow.do('add', 'rpcA', { tag })",
-        '    }',
-        '  }',
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    assert.ok(
-      diags.length > 0,
-      'a branch inside a fanout body must raise a diagnostic, not vanish silently'
-    )
-    assert.ok(
-      diags.some((d) => /if\/switch/.test(d)),
-      `the diagnostic must name the branch as the cause, got: ${JSON.stringify(diags)}`
-    )
-    assert.ok(
-      !diags.some((d) => /iterable must be a data array/.test(d)),
-      `data.tags IS a data array — the diagnostic must not blame it, got: ${JSON.stringify(diags)}`
-    )
-    const fanout = steps.find((s) => s.type === 'fanout')
-    assert.ok(!fanout, 'a fanout whose body was dropped must not serialize')
-  })
-
-  /**
-   * The hazard the hard error exists for is a *dropped step*. A loop that only
-   * massages locals has no step to drop, so failing the build on it is a false
-   * positive — and it fired on real workflows that were doing nothing wrong.
-   */
-  test('a for-of that calls no workflow step is not an error — there is nothing to drop', async () => {
-    const { steps, diags } = await inspectWorkflow(
-      [
-        "  const first = await workflow.do('get', 'rpcA', {})",
-        '  const merged: Record<string, string> = {}',
-        '  for (const dup of data.duplicates) {',
-        '    if (dup.phone && !first.phone) {',
-        '      merged.phone = dup.phone',
-        '    }',
-        '  }',
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    assert.deepEqual(
-      diags,
-      [],
-      `a pure-computation loop must not fail the build, got: ${JSON.stringify(diags)}`
-    )
-    assert.ok(
-      steps.some((s) => s.type === 'rpc'),
-      'the surrounding steps must still be extracted'
-    )
-  })
-
-  test('a brace-less for-of body is still extracted as a sequential fanout', async () => {
-    const { invoked, steps } = await inspectWorkflow(
-      [
-        '  for (const email of data.emails)',
-        "    await workflow.do('invite', 'rpcA', { email })",
-        '  return { ok: true }',
-      ].join('\n')
-    )
-
-    assert.ok(invoked.includes('rpcA'), 'rpcA must not be dropped')
-    const fanout = steps.find((s) => s.type === 'fanout')
-    assert.ok(fanout, 'a brace-less for-of should still produce a fanout step')
-    assert.equal(fanout.mode, 'sequential')
-  })
-})

package/src/add/add-workflow-sleep-expression.test.ts

@@ -1,96 +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'
-
-const STEPS = [
-  "import { pikkuSessionlessFunc } from '@pikku/core'",
-  "export const notify = pikkuSessionlessFunc({ func: async () => ({ id: 'n' }) })",
-].join('\n')
-
-async function run(body: 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-sleep-'))
-  const stepFile = join(rootDir, 'w.steps.ts')
-  const wfFile = join(rootDir, 'w.workflow.ts')
-  await writeFile(stepFile, STEPS)
-  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]
-    return { graph: graph as any, diags }
-  } finally {
-    await rm(rootDir, { recursive: true, force: true })
-  }
-}
-
-describe('sleep with a duration that is not a literal', () => {
-  test('a variable duration inside a loop is kept, not rejected', async () => {
-    const { graph, diags } = await run(
-      [
-        '  for (const interval of data.intervals) {',
-        '    await workflow.sleep(`Wait ${interval}`, interval)',
-        "    await workflow.do('Notify', 'notify', {})",
-        '  }',
-        '  return { sent: true }',
-      ].join('\n')
-    )
-
-    assert.deepEqual(
-      diags.filter((d) => d.includes('sleep')),
-      [],
-      'a duration only known at runtime is legal — the closure evaluates it'
-    )
-
-    const sleepNode = Object.values(graph?.nodes ?? {}).find(
-      (n: any) => n.flow === 'sleep'
-    ) as any
-    assert.ok(sleepNode, 'the sleep must still appear in the graph')
-    assert.equal(
-      sleepNode.expression,
-      'interval',
-      'its source text is recorded so the graph can show what it waits on'
-    )
-  })
-
-  test('a literal duration still round-trips as a value', async () => {
-    const { graph, diags } = await run(
-      ["  await workflow.sleep('Wait', '5s')", '  return { sent: true }'].join(
-        '\n'
-      )
-    )
-
-    assert.deepEqual(diags, [])
-    const sleepNode = Object.values(graph?.nodes ?? {}).find(
-      (n: any) => n.flow === 'sleep'
-    ) as any
-    assert.equal(sleepNode?.duration, '5s')
-    assert.equal(
-      sleepNode?.expression,
-      undefined,
-      'a literal is a value, not an expression'
-    )
-  })
-})