|
| 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 | +}) |
0 commit comments