@opensaas/stack-core 0.32.0 → 0.34.0

package/tests/resolve-chain.test.ts

@@ -0,0 +1,394 @@
+import { describe, it, expect, vi } from 'vitest'
+import { getContext } from '../src/context/index.js'
+import { virtual, text, relationship } from '../src/fields/index.js'
+import { ResolveOutputCycleError } from '../src/access/index.js'
+import { RESOLVE_CHAIN_MAX_LENGTH } from '../src/access/depth-limits.js'
+import type { OpenSaasConfig } from '../src/config/types.js'
+
+/**
+ * Regression coverage for issue #844 / ADR-0023: a `resolveOutput` hook that
+ * issues its own read used to be able to recurse without bound, because the
+ * only guard was a boolean read of a mutable counter shared by the whole
+ * request. The fix is a resolve chain — an ordered list of `(list, field)`
+ * pairs, extended by deriving a NEW context per hook invocation rather than
+ * mutating one shared value — with a cycle guard that refuses to re-enter a
+ * pair already on the chain, and a separate, non-fatal cost cap.
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function makeModel(): any {
+  return { findMany: vi.fn(), findFirst: vi.fn(), findUnique: vi.fn(), count: vi.fn() }
+}
+
+describe('resolve chain — cycle guard terminates hook-issued reads (#844)', () => {
+  it('two lists with no relationship fields, whose virtual hooks read each other, throw the cycle error instead of recursing', async () => {
+    const config: OpenSaasConfig = {
+      db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
+      lists: {
+        Ping: {
+          fields: {
+            label: virtual({
+              type: 'string',
+              hooks: {
+                resolveOutput: async ({ context }) => {
+                  await context.db.pong.findMany({})
+                  return 'ping'
+                },
+              },
+            }),
+          },
+          access: { operation: { query: () => true } },
+        },
+        Pong: {
+          fields: {
+            label: virtual({
+              type: 'string',
+              hooks: {
+                resolveOutput: async ({ context }) => {
+                  await context.db.ping.findMany({})
+                  return 'pong'
+                },
+              },
+            }),
+          },
+          access: { operation: { query: () => true } },
+        },
+      },
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const prisma: any = { ping: makeModel(), pong: makeModel() }
+    prisma.ping.findMany.mockResolvedValue([{ id: 'p1' }])
+    prisma.pong.findMany.mockResolvedValue([{ id: 'q1' }])
+
+    const context = await getContext(config, prisma, null)
+
+    await expect(context.db.ping.findMany({})).rejects.toThrow(ResolveOutputCycleError)
+
+    // The cycle must be caught within a handful of hops, never left to grow
+    // toward the hundreds of queries the un-bounded chain produced (#844).
+    const totalCalls =
+      prisma.ping.findMany.mock.calls.length + prisma.pong.findMany.mock.calls.length
+    expect(totalCalls).toBeLessThan(10)
+  })
+
+  it('names every (list, field) pair on the chain in order, including the repeat', async () => {
+    const config: OpenSaasConfig = {
+      db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
+      lists: {
+        Ping: {
+          fields: {
+            label: virtual({
+              type: 'string',
+              hooks: {
+                resolveOutput: async ({ context }) => {
+                  await context.db.pong.findMany({})
+                  return 'ping'
+                },
+              },
+            }),
+          },
+          access: { operation: { query: () => true } },
+        },
+        Pong: {
+          fields: {
+            label: virtual({
+              type: 'string',
+              hooks: {
+                resolveOutput: async ({ context }) => {
+                  await context.db.ping.findMany({})
+                  return 'pong'
+                },
+              },
+            }),
+          },
+          access: { operation: { query: () => true } },
+        },
+      },
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const prisma: any = { ping: makeModel(), pong: makeModel() }
+    prisma.ping.findMany.mockResolvedValue([{ id: 'p1' }])
+    prisma.pong.findMany.mockResolvedValue([{ id: 'q1' }])
+
+    const context = await getContext(config, prisma, null)
+
+    let caught: unknown
+    try {
+      await context.db.ping.findMany({})
+    } catch (err) {
+      caught = err
+    }
+
+    expect(caught).toBeInstanceOf(ResolveOutputCycleError)
+    const err = caught as ResolveOutputCycleError
+    expect(err.chain).toEqual([
+      { listKey: 'Ping', fieldKey: 'label' },
+      { listKey: 'Pong', fieldKey: 'label' },
+      { listKey: 'Ping', fieldKey: 'label' },
+    ])
+    expect(err.message).toBe(
+      'resolveOutput cycle detected: Ping.label → Pong.label → Ping.label. A hook that ' +
+        're-enters a (list, field) pair already on its own resolve chain cannot terminate, so ' +
+        'the read is refused rather than left to recurse until the process runs out of memory. ' +
+        'Restructure the hooks so the read does not loop back into itself.',
+    )
+  })
+
+  it("reproduces the reporter's 3-list cyclic schema (User → Account → Student) within a bounded query budget", async () => {
+    // Sketch matches the issue's minimal reproduction: User.name reads
+    // Account, whose Student rows' own virtual field reads Account again.
+    const config: OpenSaasConfig = {
+      db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
+      lists: {
+        User: {
+          fields: {
+            accounts: relationship({ ref: 'Account.user', many: true }),
+            name: virtual({
+              type: 'string',
+              hooks: {
+                resolveOutput: async ({ item, context }) => {
+                  const [a] = await context.db.account.findMany({
+                    where: { userId: item.id },
+                    take: 1,
+                  })
+                  return `${(a as { firstName?: string } | undefined)?.firstName}`
+                },
+              },
+            }),
+          },
+          access: { operation: { query: () => true } },
+        },
+        Account: {
+          fields: {
+            firstName: text(),
+            user: relationship({ ref: 'User.accounts' }),
+            students: relationship({ ref: 'Student.account', many: true }),
+          },
+          access: { operation: { query: () => true } },
+        },
+        Student: {
+          fields: {
+            account: relationship({ ref: 'Account.students' }),
+            label: virtual({
+              type: 'string',
+              hooks: {
+                resolveOutput: async ({ item, context }) => {
+                  const a = await context.db.account.findUnique({
+                    where: { id: item.accountId },
+                  })
+                  return `${(a as { firstName?: string } | undefined)?.firstName}`
+                },
+              },
+            }),
+          },
+          access: { operation: { query: () => true } },
+        },
+      },
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const prisma: any = { user: makeModel(), account: makeModel(), student: makeModel() }
+    prisma.user.findMany.mockResolvedValue([{ id: 'u1' }])
+    // Account rows returned to a hook-issued read embed their (row-scoped,
+    // one-level) relations directly — deliberately WITHOUT `user`, so the
+    // walk goes through `students` → `Student.label`, matching the trace in
+    // the issue rather than short-circuiting through the `user` back-edge.
+    prisma.account.findMany.mockResolvedValue([
+      { id: 'a1', firstName: 'Ann', students: [{ id: 's1', accountId: 'a1' }] },
+    ])
+    // `context.db.<list>.findUnique` is implemented via the Prisma model's
+    // `findFirst` (see `createFindUnique` in `context/index.ts`), not its
+    // `findUnique` — mock the method actually called.
+    prisma.account.findFirst.mockResolvedValue({
+      id: 'a1',
+      firstName: 'Ann',
+      students: [{ id: 's1', accountId: 'a1' }],
+    })
+
+    const context = await getContext(config, prisma, null)
+
+    // Must settle (not hang), and must not have driven an unbounded number of
+    // queries before doing so — this is the actual OOM mechanism from #844.
+    await expect(context.db.user.findMany({})).rejects.toThrow(ResolveOutputCycleError)
+
+    const totalCalls =
+      prisma.user.findMany.mock.calls.length +
+      prisma.account.findMany.mock.calls.length +
+      prisma.account.findFirst.mock.calls.length
+    expect(totalCalls).toBeLessThan(20)
+  })
+})
+
+describe('resolve chain — cost cap is a warning, not a denial (#844)', () => {
+  it('an acyclic chain longer than RESOLVE_CHAIN_MAX_LENGTH omits the field and warns once, without throwing', async () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    // A straight-line chain of distinct lists L0 → L1 → … so no (list, field)
+    // pair ever repeats — this chain is acyclic and would terminate on its
+    // own; it only needs to be capped as a cost limit.
+    const listCount = RESOLVE_CHAIN_MAX_LENGTH + 3
+    const lists: OpenSaasConfig['lists'] = {}
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const prisma: any = {}
+    for (let i = 0; i < listCount; i++) {
+      const listKey = `L${i}`
+      const dbKey = `l${i}`
+      const nextDbKey = `l${i + 1}`
+      lists[listKey] = {
+        fields: {
+          next: virtual({
+            type: 'string',
+            hooks: {
+              resolveOutput:
+                i < listCount - 1
+                  ? async ({ context }) => {
+                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      await (context.db as any)[nextDbKey].findMany({})
+                      return 'ok'
+                    }
+                  : () => 'leaf',
+            },
+          }),
+        },
+        access: { operation: { query: () => true } },
+      }
+      prisma[dbKey] = makeModel()
+      prisma[dbKey].findMany.mockResolvedValue([{ id: `${dbKey}-row` }])
+    }
+
+    const config: OpenSaasConfig = {
+      db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
+      lists,
+    }
+
+    const context = await getContext(config, prisma, null)
+
+    // Does NOT throw — a cap hit is a cost limit, never a correctness denial.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const result = await (context.db as any).l0.findMany({})
+    expect(result).toBeTruthy()
+
+    expect(warnSpy).toHaveBeenCalledTimes(1)
+    expect(warnSpy.mock.calls[0][0]).toContain('RESOLVE_CHAIN_MAX_LENGTH')
+
+    // Nothing past the cap is ever queried — the chain simply stops growing.
+    for (let i = RESOLVE_CHAIN_MAX_LENGTH + 1; i < listCount; i++) {
+      expect(prisma[`l${i}`].findMany).not.toHaveBeenCalled()
+    }
+
+    warnSpy.mockRestore()
+  })
+})
+
+describe('resolve chain — concurrent hook invocations are isolated (#844)', () => {
+  it('sibling rows in a to-many read each observe their own chain of length 1, not a racing shared counter', async () => {
+    const observedLengths: number[] = []
+
+    const config: OpenSaasConfig = {
+      db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
+      lists: {
+        Widget: {
+          fields: {
+            tag: virtual({
+              type: 'string',
+              hooks: {
+                resolveOutput: async ({ context }) => {
+                  // Stagger completion so the three hook invocations
+                  // genuinely interleave rather than running back-to-back.
+                  await new Promise((resolve) => setTimeout(resolve, Math.random() * 5))
+                  observedLengths.push(context._resolveOutputChain.length)
+                  return 'tag'
+                },
+              },
+            }),
+          },
+          access: { operation: { query: () => true } },
+        },
+      },
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const prisma: any = { widget: makeModel() }
+    prisma.widget.findMany.mockResolvedValue([{ id: 'w1' }, { id: 'w2' }, { id: 'w3' }])
+
+    const context = await getContext(config, prisma, null)
+    await context.db.widget.findMany({})
+
+    expect(observedLengths.sort()).toEqual([1, 1, 1])
+  })
+
+  it('an unrelated top-level read in flight alongside a hook still gets its full nested auto-include', async () => {
+    let releaseSlowHook: () => void = () => {}
+
+    const config: OpenSaasConfig = {
+      db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
+      lists: {
+        Slow: {
+          fields: {
+            tag: virtual({
+              type: 'string',
+              hooks: {
+                resolveOutput: async () => {
+                  await new Promise<void>((resolve) => {
+                    releaseSlowHook = resolve
+                  })
+                  return 'tag'
+                },
+              },
+            }),
+          },
+          access: { operation: { query: () => true } },
+        },
+        Fast: {
+          fields: {
+            name: text(),
+            child: relationship({ ref: 'FastChild' }),
+          },
+          access: { operation: { query: () => true } },
+        },
+        FastChild: {
+          fields: {
+            label: text(),
+            grandchild: relationship({ ref: 'FastGrandchild' }),
+          },
+          access: { operation: { query: () => true } },
+        },
+        FastGrandchild: {
+          fields: { value: text() },
+          access: { operation: { query: () => true } },
+        },
+      },
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const prisma: any = { slow: makeModel(), fast: makeModel() }
+    prisma.slow.findMany.mockResolvedValue([{ id: 'sl1' }])
+    prisma.fast.findMany.mockResolvedValue([{ id: 'f1' }])
+
+    const context = await getContext(config, prisma, null)
+
+    // Start the slow read — it blocks inside Slow.tag's hook until released.
+    const slowPromise = context.db.slow.findMany({})
+
+    // Let the slow hook actually start (and derive its context) before racing
+    // the unrelated read against it.
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    // While the slow hook is still in flight, issue a plain top-level read
+    // that has nothing to do with it.
+    const fastPromise = context.db.fast.findMany({})
+
+    await fastPromise
+    releaseSlowHook()
+    await slowPromise
+
+    // The unrelated read's auto-include must still descend two levels deep
+    // (child → grandchild), not collapse to a bare `{ child: true }` because
+    // it happened to run while a totally different read's hook was active.
+    expect(prisma.fast.findMany.mock.calls[0][0].include).toEqual({
+      child: { include: { grandchild: true } },
+    })
+  })
+})

package/tests/transaction-boundary-hooks.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { getContext } from '../src/context/index.js'
 import { config, list } from '../src/config/index.js'
 import { text, relationship } from '../src/fields/index.js'
+import { enumerateInvolvedLists } from '../src/context/transaction-boundary.js'
 
 /**
  * #590 / ADR-0010: transaction-boundary hooks (`beforeTransaction` /
@@ -17,12 +18,13 @@ import { text, relationship } from '../src/fields/index.js'
  * that sudo does not affect these hooks.
  */
 
-function createTxPrisma() {
+function createTxPrisma(extraTables: string[] = []) {
   const tables: Record<string, Map<string, Record<string, unknown>>> = {
     post: new Map(),
     user: new Map(),
     comment: new Map(),
   }
+  for (const table of extraTables) tables[table] = new Map()
   let idCounter = 0
   const nextId = () => `id-${++idCounter}`
 
@@ -111,6 +113,7 @@ function createTxPrisma() {
     user: makeModel('user'),
     comment: makeModel('comment'),
   }
+  for (const table of extraTables) client[table] = makeModel(table)
 
   client.$transaction = async (fn: (tx: unknown) => Promise<unknown>) => {
     const snapshot: Record<string, Map<string, Record<string, unknown>>> = {}
@@ -463,3 +466,245 @@ describe('#590 transaction-boundary hooks', () => {
     expect(after).not.toHaveBeenCalled()
   })
 })
+
+/**
+ * #835: `enumerateInvolvedLists`'s walk used to stop at a fixed depth cap
+ * (`MAX_DEPTH = 5`), so lists reachable only past it never entered the
+ * involved-list set and their transaction-boundary hooks silently never fired.
+ * The fix replaces the depth cap with a saturation bound computed from the
+ * CONFIG's relationship graph reachable from the top-level list: the walk
+ * stops once every (list, operation) pair it could ever find has been
+ * recorded, regardless of how deep the payload nests.
+ */
+describe('#835 enumerateInvolvedLists — saturation-bound enumeration walk', () => {
+  function chainConfigLists(length: number) {
+    const lists: Record<string, ReturnType<typeof list>> = {}
+    for (let i = 1; i <= length; i++) {
+      const name = `L${i}`
+      const fields: Record<string, ReturnType<typeof text> | ReturnType<typeof relationship>> = {
+        name: text(),
+      }
+      if (i < length) {
+        fields[`l${i + 1}`] = relationship({ ref: `L${i + 1}` })
+      }
+      lists[name] = list({ fields })
+    }
+    return lists
+  }
+
+  function chainInputData(length: number): Record<string, unknown> {
+    let payload: Record<string, unknown> = { name: `r${length}` }
+    for (let i = length - 1; i >= 1; i--) {
+      payload = { name: `r${i}`, [`l${i + 1}`]: { create: payload } }
+    }
+    return payload
+  }
+
+  it('enumerates every list in an 8-list chain, deeper than the old fixed depth cap of 5', async () => {
+    const resolvedConfig = await config({
+      db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
+      lists: chainConfigLists(8),
+    })
+
+    const involved = enumerateInvolvedLists({
+      listName: 'L1',
+      listConfig: resolvedConfig.lists.L1,
+      operation: 'create',
+      inputData: chainInputData(8),
+      topLevelOriginalItem: undefined,
+      config: resolvedConfig,
+    })
+
+    expect(involved.map((i) => i.listKey)).toEqual(['L1', 'L2', 'L3', 'L4', 'L5', 'L6', 'L7', 'L8'])
+    expect(involved.map((i) => i.operation)).toEqual(Array(8).fill('create'))
+    // The top-level list is first and is the only one marked isTopLevel.
+    expect(involved[0].isTopLevel).toBe(true)
+    expect(involved.slice(1).every((i) => !i.isTopLevel)).toBe(true)
+  })
+
+  it('dedupes by (list, operation) when a list is nested many times in one payload', async () => {
+    const resolvedConfig = await config({
+      db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
+      lists: {
+        Parent: list({
+          fields: { name: text(), children: relationship({ ref: 'Child', many: true }) },
+        }),
+        Child: list({ fields: { name: text() } }),
+      },
+    })
+
+    const involved = enumerateInvolvedLists({
+      listName: 'Parent',
+      listConfig: resolvedConfig.lists.Parent,
+      operation: 'create',
+      inputData: {
+        name: 'p',
+        children: { create: [{ name: 'c1' }, { name: 'c2' }, { name: 'c3' }] },
+      },
+      topLevelOriginalItem: undefined,
+      config: resolvedConfig,
+    })
+
+    // Three nested Child creates collapse into a single involvement — the
+    // hooks are a per-LIST compensation bracket, not per-record.
+    expect(involved.map((i) => `${i.listKey}:${i.operation}`)).toEqual([
+      'Parent:create',
+      'Child:create',
+    ])
+  })
+
+  it('stops descending once every reachable (list, operation) pair is recorded, without inspecting payload past that point', async () => {
+    // Node self-references, so the reachable closure from Node is just
+    // {Node} — the saturation bound is 1 list * 3 operations = 3 pairs.
+    // Extra1/Extra2 are unrelated lists in the same config: if the bound were
+    // ever computed from the WHOLE config instead of the graph reachable
+    // from the write's own top-level list, the bound would be inflated to 9
+    // and this test's trap (below) would fire.
+    const resolvedConfig = await config({
+      db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
+      lists: {
+        Node: list({
+          fields: {
+            name: text(),
+            childrenA: relationship({ ref: 'Node', many: true }),
+            childrenB: relationship({ ref: 'Node', many: true }),
+          },
+        }),
+        Extra1: list({ fields: { name: text() } }),
+        Extra2: list({ fields: { name: text() } }),
+      },
+    })
+
+    // A payload entry that must NEVER be walked once the walk has saturated —
+    // reading its `childrenA` property throws, so any attempt to descend
+    // into it fails the test with a thrown error instead of relying on timing.
+    const trap: Record<string, unknown> = { name: 'trap' }
+    Object.defineProperty(trap, 'childrenA', {
+      enumerable: true,
+      get(): never {
+        throw new Error('walkNested must not descend past the saturation bound')
+      },
+    })
+
+    const involved = enumerateInvolvedLists({
+      listName: 'Node',
+      listConfig: resolvedConfig.lists.Node,
+      operation: 'create',
+      inputData: {
+        name: 'root',
+        // Completes the saturation bound: seed (Node:create) + Node:update +
+        // Node:delete = 3 pairs = the full reachable closure for Node.
+        childrenA: {
+          update: [{ where: { id: 'u1' }, data: { name: 'updated' } }],
+          delete: [{ id: 'd1' }],
+        },
+        // Processed after childrenA (insertion order) — by the time the walk
+        // reaches it, the bound is already saturated, so `trap` must never
+        // be descended into.
+        childrenB: { create: [trap] },
+      },
+      topLevelOriginalItem: undefined,
+      config: resolvedConfig,
+    })
+
+    expect(involved.map((i) => `${i.listKey}:${i.operation}`)).toEqual([
+      'Node:create',
+      'Node:update',
+      'Node:delete',
+    ])
+  })
+})
+
+/**
+ * #835 integration: the enumeration fix must not change the (separately
+ * verified, and unrelated) fact that nested writes stay access-checked at
+ * every depth — `processNestedOperations`'s own depth guard was already dead
+ * code before this fix (neither recursive call site nor the Write Pipeline
+ * ever passed a depth), so nested access control was never gated by depth and
+ * remains that way.
+ */
+describe('#835 deep nested writes remain access-checked at every depth', () => {
+  function chainLists(length: number, denyCreateAt?: number) {
+    const lists: Record<string, ReturnType<typeof list>> = {}
+    for (let i = 1; i <= length; i++) {
+      const name = `L${i}`
+      const fields: Record<string, ReturnType<typeof text> | ReturnType<typeof relationship>> = {
+        name: text(),
+      }
+      if (i < length) {
+        fields[`l${i + 1}`] = relationship({ ref: `L${i + 1}` })
+      }
+      lists[name] = list({
+        fields,
+        access: {
+          operation: {
+            query: () => true,
+            create: () => denyCreateAt !== i,
+            update: () => true,
+          },
+        },
+      })
+    }
+    return lists
+  }
+
+  function chainInputData(length: number): Record<string, unknown> {
+    let payload: Record<string, unknown> = { name: `r${length}` }
+    for (let i = length - 1; i >= 1; i--) {
+      payload = { name: `r${i}`, [`l${i + 1}`]: { create: payload } }
+    }
+    return payload
+  }
+
+  it('throws when a nested create 6 levels deep is denied, even though 6 is past the old enumeration depth cap', async () => {
+    const tables = Array.from({ length: 8 }, (_, i) => `l${i + 1}`)
+    const mock = createTxPrisma(tables)
+
+    const testConfig = config({
+      db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
+      lists: chainLists(8, 6),
+    })
+
+    const context = getContext(await testConfig, mock.client, { userId: '1' })
+
+    await expect(context.db.l1.create({ data: chainInputData(8) })).rejects.toThrow(
+      /access denied/i,
+    )
+
+    // Nothing was persisted — the whole write was aborted by the denial.
+    for (const table of tables) {
+      expect(mock.tables[table].size).toBe(0)
+    }
+  })
+
+  it('fires beforeTransaction/afterTransaction for every list in an 8-list chain, including the deepest', async () => {
+    const tables = Array.from({ length: 8 }, (_, i) => `l${i + 1}`)
+    const mock = createTxPrisma(tables)
+
+    const fired: string[] = []
+    const lists = chainLists(8)
+    for (const [name, listConfig] of Object.entries(lists)) {
+      listConfig.hooks = {
+        beforeTransaction: () => {
+          fired.push(`before:${name}`)
+        },
+        afterTransaction: () => {
+          fired.push(`after:${name}`)
+        },
+      }
+    }
+
+    const testConfig = config({
+      db: { provider: 'postgresql', url: 'postgresql://localhost:5432/test' },
+      lists,
+    })
+
+    const context = getContext(await testConfig, mock.client, { userId: '1' })
+    await context.db.l1.create({ data: chainInputData(8) })
+
+    for (let i = 1; i <= 8; i++) {
+      expect(fired).toContain(`before:L${i}`)
+      expect(fired).toContain(`after:L${i}`)
+    }
+  })
+})

package/tests/write-pipeline.test.ts

@@ -88,7 +88,7 @@ function makeContext(opts?: { isSudo?: boolean }): AccessContext {
     storage: {} as any,
     plugins: {},
     _isSudo: opts?.isSudo ?? false,
-    _resolveOutputCounter: { depth: 0 },
+    _resolveOutputChain: [],
   }
 }