Skip to content

Commit bc438fc

Browse files
authored
fix(realtime): keep admin block locks out of write-role graph replaces (#10062)
* fix(realtime): keep admin block locks out of write-role graph replaces batch-add-blocks and replace-state (realtime) and every HTTP state-replace door wrote workflow_blocks.locked from the payload, so a write member could clear an admin-only lock and then edit or delete the block. A shared helper now keeps protected blocks, their incoming edges and loop config as stored during a full replace and writes every other block unlocked; batch-add skips protected blocks and blocks nested under a locked ancestor and never writes the lock flag. * fix(realtime): guard locked loop config and re-sync clients when locks win batch-add-blocks loops/parallels and subflow updates could rewrite a locked container's config. When persistence keeps lock-protected state over a payload, the room is told to reload instead of receiving the rejected payload. * fix(realtime): cascade orphaned locked children and keep preserved edge ids A replace that removes an unlocked container now removes its locked children too, matching a direct delete, instead of saving a dangling parentId. Preserved protected edges win by id, so a retargeted edge cannot duplicate one and abort the save. Skipped subflow updates re-sync the room like the other lock-reconciled writes. * fix(realtime): refuse whole pasted subtrees under a locked ancestor batch-add-blocks checks each added block against the graph as it will land, so a rejected container's new children and loop/parallel config are refused with it, and an edge refused for targeting a locked block re-syncs the room.
1 parent 473338a commit bc438fc

10 files changed

Lines changed: 742 additions & 127 deletions

File tree

Lines changed: 299 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,299 @@
1+
/** Real PostgreSQL coverage: realtime batch-add, subflow updates and replace-state never change what a block lock protects. */
2+
import { mkdir, writeFile } from 'node:fs/promises'
3+
import { dirname, resolve } from 'node:path'
4+
import { db } from '@sim/db'
5+
import {
6+
user,
7+
workflow,
8+
workflowBlocks,
9+
workflowEdges,
10+
workflowSubflows,
11+
workspace,
12+
} from '@sim/db/schema'
13+
import { deleteWorkspaceFixture, insertWorkspaceFixture } from '@sim/db/testing/workspace-fixtures'
14+
import {
15+
BLOCKS_OPERATIONS,
16+
OPERATION_TARGETS,
17+
SUBFLOW_OPERATIONS,
18+
WORKFLOW_OPERATIONS,
19+
} from '@sim/realtime-protocol/constants'
20+
import { getErrorMessage } from '@sim/utils/errors'
21+
import { generateId } from '@sim/utils/id'
22+
import { eq } from 'drizzle-orm'
23+
import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
24+
import { persistWorkflowOperation } from '@/database/operations'
25+
26+
const userId = generateId()
27+
const workspaceId = generateId()
28+
const workflowId = generateId()
29+
const ids = {
30+
locked: generateId(),
31+
container: generateId(),
32+
child: generateId(),
33+
free: generateId(),
34+
edgeIntoLocked: generateId(),
35+
unlockedParent: generateId(),
36+
lockedChild: generateId(),
37+
}
38+
const lockedLoopConfig = { id: ids.container, nodes: [ids.child], iterations: 3, loopType: 'for' }
39+
const checks: { name: string; status: 'passed' | 'failed'; durationMs: number; error?: string }[] =
40+
[]
41+
42+
/** Registers a test and records its status and duration in the suite report. */
43+
function check(name: string, run: () => Promise<void>) {
44+
it(name, async () => {
45+
const started = performance.now()
46+
try {
47+
await run()
48+
checks.push({ name, status: 'passed', durationMs: performance.now() - started })
49+
} catch (error) {
50+
checks.push({
51+
name,
52+
status: 'failed',
53+
durationMs: performance.now() - started,
54+
error: getErrorMessage(error),
55+
})
56+
throw error
57+
}
58+
})
59+
}
60+
61+
function blockRow(
62+
id: string,
63+
name: string,
64+
extra: Partial<typeof workflowBlocks.$inferInsert> = {}
65+
) {
66+
return {
67+
id,
68+
workflowId,
69+
type: 'function',
70+
name,
71+
positionX: '0',
72+
positionY: '0',
73+
...extra,
74+
}
75+
}
76+
77+
function payloadBlock(id: string, name: string, extra: Record<string, unknown> = {}) {
78+
return { id, type: 'function', name, position: { x: 10, y: 10 }, subBlocks: {}, ...extra }
79+
}
80+
81+
function persist(target: string, operation: string, payload: unknown) {
82+
return persistWorkflowOperation(workflowId, {
83+
target,
84+
operation,
85+
payload,
86+
timestamp: Date.now(),
87+
userId,
88+
})
89+
}
90+
91+
async function readBlocks() {
92+
const rows = await db
93+
.select()
94+
.from(workflowBlocks)
95+
.where(eq(workflowBlocks.workflowId, workflowId))
96+
return Object.fromEntries(rows.map((row) => [row.id, row]))
97+
}
98+
99+
async function readSubflows() {
100+
return db
101+
.select({ id: workflowSubflows.id, config: workflowSubflows.config })
102+
.from(workflowSubflows)
103+
.where(eq(workflowSubflows.workflowId, workflowId))
104+
}
105+
106+
describe('block locks against PostgreSQL', () => {
107+
beforeAll(async () => {
108+
const now = new Date()
109+
await db.insert(user).values({
110+
id: userId,
111+
name: 'Lock fixture',
112+
email: `${userId}@block-lock.test`,
113+
emailVerified: true,
114+
createdAt: now,
115+
updatedAt: now,
116+
})
117+
await insertWorkspaceFixture(db, {
118+
id: workspaceId,
119+
name: 'Lock target',
120+
ownerId: userId,
121+
billedAccountUserId: userId,
122+
})
123+
await db.insert(workflow).values({
124+
id: workflowId,
125+
userId,
126+
workspaceId,
127+
name: 'Locked blocks',
128+
lastSynced: now,
129+
createdAt: now,
130+
updatedAt: now,
131+
})
132+
})
133+
134+
beforeEach(async () => {
135+
await db.delete(workflowSubflows).where(eq(workflowSubflows.workflowId, workflowId))
136+
await db.delete(workflowBlocks).where(eq(workflowBlocks.workflowId, workflowId))
137+
await db.insert(workflowBlocks).values([
138+
blockRow(ids.locked, 'Locked', { locked: true }),
139+
blockRow(ids.container, 'Locked loop', { type: 'loop', locked: true }),
140+
blockRow(ids.child, 'Child', { data: { parentId: ids.container, extent: 'parent' } }),
141+
blockRow(ids.free, 'Free'),
142+
blockRow(ids.unlockedParent, 'Unlocked loop', { type: 'loop' }),
143+
blockRow(ids.lockedChild, 'Locked child', {
144+
locked: true,
145+
data: { parentId: ids.unlockedParent, extent: 'parent' },
146+
}),
147+
])
148+
await db.insert(workflowEdges).values({
149+
id: ids.edgeIntoLocked,
150+
workflowId,
151+
sourceBlockId: ids.free,
152+
targetBlockId: ids.locked,
153+
})
154+
await db.insert(workflowSubflows).values({
155+
id: ids.container,
156+
workflowId,
157+
type: 'loop',
158+
config: lockedLoopConfig,
159+
})
160+
})
161+
162+
afterAll(async () => {
163+
const reportPath =
164+
process.env.REALTIME_BLOCK_LOCK_REPORT_PATH ??
165+
resolve('test-results/realtime-block-lock.json')
166+
await mkdir(dirname(reportPath), { recursive: true })
167+
await writeFile(reportPath, JSON.stringify({ checks }, null, 2))
168+
await deleteWorkspaceFixture(db, eq(workspace.ownerId, userId))
169+
await db.delete(user).where(eq(user.id, userId))
170+
})
171+
172+
check('batch-add-blocks cannot unlock or overwrite a locked block', async () => {
173+
const result = await persist(OPERATION_TARGETS.BLOCKS, BLOCKS_OPERATIONS.BATCH_ADD_BLOCKS, {
174+
blocks: [
175+
payloadBlock(ids.locked, 'Hijacked', { locked: false }),
176+
payloadBlock(ids.child, 'Hijacked child'),
177+
],
178+
edges: [],
179+
loops: {},
180+
parallels: {},
181+
})
182+
183+
const blocks = await readBlocks()
184+
expect(blocks[ids.locked]).toMatchObject({ locked: true, name: 'Locked' })
185+
expect(blocks[ids.child]).toMatchObject({ name: 'Child' })
186+
expect(result).toEqual({ reconcile: true })
187+
})
188+
189+
check('batch-add-blocks and subflow updates cannot rewrite a locked loop config', async () => {
190+
const result = await persist(OPERATION_TARGETS.BLOCKS, BLOCKS_OPERATIONS.BATCH_ADD_BLOCKS, {
191+
blocks: [payloadBlock(generateId(), 'Throwaway')],
192+
edges: [],
193+
loops: { [ids.container]: { ...lockedLoopConfig, iterations: 99 } },
194+
parallels: {},
195+
})
196+
const updated = await persist(OPERATION_TARGETS.SUBFLOW, SUBFLOW_OPERATIONS.UPDATE, {
197+
id: ids.container,
198+
type: 'loop',
199+
config: { iterations: 42 },
200+
})
201+
202+
expect(await readSubflows()).toEqual([{ id: ids.container, config: lockedLoopConfig }])
203+
expect(result).toEqual({ reconcile: true })
204+
expect(updated).toEqual({ reconcile: true })
205+
})
206+
207+
check('an add that touches no lock keeps collaborators on the payload', async () => {
208+
const result = await persist(OPERATION_TARGETS.BLOCKS, BLOCKS_OPERATIONS.BATCH_ADD_BLOCKS, {
209+
blocks: [payloadBlock(generateId(), 'Plain')],
210+
edges: [],
211+
loops: {},
212+
parallels: {},
213+
})
214+
215+
expect(result).toEqual({ reconcile: false })
216+
})
217+
218+
check('an add whose only rejected part is an edge into a locked block re-syncs', async () => {
219+
const result = await persist(OPERATION_TARGETS.BLOCKS, BLOCKS_OPERATIONS.BATCH_ADD_BLOCKS, {
220+
blocks: [],
221+
edges: [{ id: generateId(), source: ids.free, target: ids.locked, sourceHandle: 'source' }],
222+
loops: {},
223+
parallels: {},
224+
})
225+
226+
expect(result).toEqual({ reconcile: true })
227+
})
228+
229+
check(
230+
'batch-add-blocks never takes the lock flag from the client nor nests under a locked ancestor',
231+
async () => {
232+
const lockedNew = generateId()
233+
const nestedNew = generateId()
234+
const nestedChild = generateId()
235+
await persist(OPERATION_TARGETS.BLOCKS, BLOCKS_OPERATIONS.BATCH_ADD_BLOCKS, {
236+
blocks: [
237+
payloadBlock(lockedNew, 'Self-locked', { locked: true }),
238+
payloadBlock(nestedNew, 'Nested loop', { type: 'loop', data: { parentId: ids.child } }),
239+
payloadBlock(nestedChild, 'Nested child', { data: { parentId: nestedNew } }),
240+
],
241+
edges: [],
242+
loops: { [nestedNew]: { id: nestedNew, nodes: [nestedChild], iterations: 2 } },
243+
parallels: {},
244+
})
245+
246+
const blocks = await readBlocks()
247+
expect(blocks[lockedNew]).toMatchObject({ locked: false })
248+
expect(blocks[nestedNew]).toBeUndefined()
249+
expect(blocks[nestedChild]).toBeUndefined()
250+
expect(await readSubflows()).toEqual([{ id: ids.container, config: lockedLoopConfig }])
251+
}
252+
)
253+
254+
check(
255+
'replace-state keeps protected blocks, their incoming edges and loop config as stored, and drops what a lock or a removed parent no longer allows',
256+
async () => {
257+
const added = generateId()
258+
const nestedNew = generateId()
259+
const result = await persist(OPERATION_TARGETS.WORKFLOW, WORKFLOW_OPERATIONS.REPLACE_STATE, {
260+
state: {
261+
blocks: {
262+
[ids.locked]: payloadBlock(ids.locked, 'Hijacked', { locked: false }),
263+
[ids.free]: payloadBlock(ids.free, 'Free renamed', { locked: true }),
264+
[added]: payloadBlock(added, 'Added'),
265+
[nestedNew]: payloadBlock(nestedNew, 'Nested', {
266+
data: { parentId: ids.container, extent: 'parent' },
267+
}),
268+
},
269+
edges: [
270+
{ id: generateId(), source: ids.free, target: nestedNew },
271+
// Retargets the protected edge under its own id.
272+
{ id: ids.edgeIntoLocked, source: ids.free, target: added },
273+
],
274+
loops: { [ids.container]: { ...lockedLoopConfig, iterations: 99 } },
275+
parallels: {},
276+
},
277+
})
278+
279+
const blocks = await readBlocks()
280+
expect(blocks[ids.locked]).toMatchObject({ locked: true, name: 'Locked' })
281+
expect(blocks[ids.container]).toMatchObject({ locked: true, name: 'Locked loop' })
282+
expect(blocks[ids.child]).toMatchObject({ name: 'Child' })
283+
expect(blocks[ids.free]).toMatchObject({ locked: false, name: 'Free renamed' })
284+
expect(blocks[added]).toMatchObject({ locked: false })
285+
expect(blocks[nestedNew]).toBeUndefined()
286+
// The replacement removed its unlocked parent, so the locked child goes with it.
287+
expect(blocks[ids.lockedChild]).toBeUndefined()
288+
289+
const edges = await db
290+
.select({ id: workflowEdges.id, target: workflowEdges.targetBlockId })
291+
.from(workflowEdges)
292+
.where(eq(workflowEdges.workflowId, workflowId))
293+
expect(edges).toEqual([{ id: ids.edgeIntoLocked, target: ids.locked }])
294+
295+
expect(await readSubflows()).toEqual([{ id: ids.container, config: lockedLoopConfig }])
296+
expect(result).toEqual({ reconcile: true })
297+
}
298+
)
299+
})

‎apps/realtime/src/database/operations.test.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -84,7 +84,7 @@ describe('search replacement persistence', () => {
8484
},
8585
]
8686

87-
await expect(replaceTools(stored)).resolves.toBeUndefined()
87+
await expect(replaceTools(stored)).resolves.toEqual({ reconcile: false })
8888
expect(mockSet).toHaveBeenLastCalledWith(
8989
expect.objectContaining({
9090
subBlocks: { tools: { id: 'tools', type: 'tool-input', value: replacement } },
@@ -138,7 +138,7 @@ describe('subblock update with canonical modes persistence', () => {
138138
}
139139

140140
it('writes the subblock value and replaces canonical modes in one block update', async () => {
141-
await expect(updateTools({})).resolves.toBeUndefined()
141+
await expect(updateTools({})).resolves.toEqual({ reconcile: false })
142142

143143
expect(mockSet).toHaveBeenCalledTimes(2)
144144
expect(mockSet).toHaveBeenLastCalledWith(

0 commit comments

Comments
 (0)