@tldraw/store 3.16.0-canary.dfdf6b7de8c2 → 3.16.0-canary.e1d5c8aeb399

package/src/lib/RecordType.ts

@@ -116,23 +116,6 @@ export class RecordType<
 		return (this.typeName + ':' + (customUniquePart ?? uniqueId())) as IdOf<R>
 	}
 
-	/**
-	 * Create a new ID for this record type based on the given ID.
-	 *
-	 * @example
-	 *
-	 * ```ts
-	 * const id = recordType.createCustomId('myId')
-	 * ```
-	 *
-	 * @deprecated - Use `createId` instead.
-	 * @param id - The ID to base the new ID on.
-	 * @returns The new ID.
-	 */
-	createCustomId(id: string): IdOf<R> {
-		return (this.typeName + ':' + id) as IdOf<R>
-	}
-
 	/**
 	 * Takes an id like `user:123` and returns the part after the colon `123`
 	 *

package/src/lib/RecordsDiff.ts

@@ -42,15 +42,21 @@ export function isRecordsDiffEmpty<T extends UnknownRecord>(diff: RecordsDiff<T>
  * Squash a collection of diffs into a single diff.
  *
  * @param diffs - An array of diffs to squash.
+ * @param options - An optional object with a `mutateFirstDiff` property. If `mutateFirstDiff` is true, the first diff in the array will be mutated in-place.
  * @returns A single diff that represents the squashed diffs.
  * @public
  */
 export function squashRecordDiffs<T extends UnknownRecord>(
-	diffs: RecordsDiff<T>[]
+	diffs: RecordsDiff<T>[],
+	options?: {
+		mutateFirstDiff?: boolean
+	}
 ): RecordsDiff<T> {
-	const result = { added: {}, removed: {}, updated: {} } as RecordsDiff<T>
+	const result = options?.mutateFirstDiff
+		? diffs[0]
+		: ({ added: {}, removed: {}, updated: {} } as RecordsDiff<T>)
 
-	squashRecordDiffsMutable(result, diffs)
+	squashRecordDiffsMutable(result, options?.mutateFirstDiff ? diffs.slice(1) : diffs)
 	return result
 }
 

package/src/lib/Store.ts

@@ -501,21 +501,11 @@ export class Store<R extends UnknownRecord = UnknownRecord, Props = unknown> {
 		}
 	}
 
-	/**
-	 * @deprecated use `getSnapshot` from the 'tldraw' package instead.
-	 */
-	getSnapshot(scope: RecordScope | 'all' = 'document') {
-		console.warn(
-			'[tldraw] `Store.getSnapshot` is deprecated and will be removed in a future release. Use `getSnapshot` from the `tldraw` package instead.'
-		)
-		return this.getStoreSnapshot(scope)
-	}
-
 	/**
 	 * Migrate a serialized snapshot of the store and its schema.
 	 *
 	 * ```ts
-	 * const snapshot = store.getSnapshot()
+	 * const snapshot = store.getStoreSnapshot()
 	 * store.migrateSnapshot(snapshot)
 	 * ```
 	 *
@@ -566,17 +556,6 @@ export class Store<R extends UnknownRecord = UnknownRecord, Props = unknown> {
 		}
 	}
 
-	/**
-	 * @public
-	 * @deprecated use `loadSnapshot` from the 'tldraw' package instead.
-	 */
-	loadSnapshot(snapshot: StoreSnapshot<R>) {
-		console.warn(
-			"[tldraw] `Store.loadSnapshot` is deprecated and will be removed in a future release. Use `loadSnapshot` from the 'tldraw' package instead."
-		)
-		this.loadStoreSnapshot(snapshot)
-	}
-
 	/**
 	 * Get an array of all values in the store.
 	 *

package/src/lib/StoreSchema.ts

@@ -349,6 +349,7 @@ export class StoreSchema<R extends UnknownRecord, P = unknown> {
 
 	/**
 	 * @deprecated This is only here for legacy reasons, don't use it unless you have david's blessing!
+	 * @internal
 	 */
 	serializeEarliestVersion(): SerializedSchema {
 		return {

package/src/lib/migrate.ts

@@ -2,45 +2,6 @@ import { assert, objectMapEntries } from '@tldraw/utils'
 import { UnknownRecord } from './BaseRecord'
 import { SerializedStore } from './Store'
 
-let didWarn = false
-
-/**
- * @public
- * @deprecated use `createShapePropsMigrationSequence` instead. See [the docs](https://tldraw.dev/docs/persistence#Updating-legacy-shape-migrations-defineMigrations) for how to migrate.
- */
-export function defineMigrations(opts: {
-	firstVersion?: number
-	currentVersion?: number
-	migrators?: Record<number, LegacyMigration>
-	subTypeKey?: string
-	subTypeMigrations?: Record<string, LegacyBaseMigrationsInfo>
-}): LegacyMigrations {
-	const { currentVersion, firstVersion, migrators = {}, subTypeKey, subTypeMigrations } = opts
-	if (!didWarn) {
-		console.warn(
-			`The 'defineMigrations' function is deprecated and will be removed in a future release. Use the new migrations API instead. See the migration guide for more info: https://tldraw.dev/docs/persistence#Updating-legacy-shape-migrations-defineMigrations`
-		)
-		didWarn = true
-	}
-
-	// Some basic guards against impossible version combinations, some of which will be caught by TypeScript
-	if (typeof currentVersion === 'number' && typeof firstVersion === 'number') {
-		if ((currentVersion as number) === (firstVersion as number)) {
-			throw Error(`Current version is equal to initial version.`)
-		} else if (currentVersion < firstVersion) {
-			throw Error(`Current version is lower than initial version.`)
-		}
-	}
-
-	return {
-		firstVersion: (firstVersion as number) ?? 0, // defaults
-		currentVersion: (currentVersion as number) ?? 0, // defaults
-		migrators,
-		subTypeKey,
-		subTypeMigrations,
-	}
-}
-
 function squashDependsOn(sequence: Array<Migration | StandaloneDependsOn>): Migration[] {
 	const result: Migration[] = []
 	for (let i = sequence.length - 1; i >= 0; i--) {
@@ -199,38 +160,126 @@ export interface MigrationSequence {
 	sequence: Migration[]
 }
 
+/**
+ * Sorts migrations using a distance-minimizing topological sort.
+ *
+ * This function respects two types of dependencies:
+ * 1. Implicit sequence dependencies (foo/1 must come before foo/2)
+ * 2. Explicit dependencies via `dependsOn` property
+ *
+ * The algorithm minimizes the total distance between migrations and their explicit
+ * dependencies in the final ordering, while maintaining topological correctness.
+ * This means when migration A depends on migration B, A will be scheduled as close
+ * as possible to B (while respecting all constraints).
+ *
+ * Implementation uses Kahn's algorithm with priority scoring:
+ * - Builds dependency graph and calculates in-degrees
+ * - Uses priority queue that prioritizes migrations which unblock explicit dependencies
+ * - Processes migrations in urgency order while maintaining topological constraints
+ * - Detects cycles by ensuring all migrations are processed
+ *
+ * @param migrations - Array of migrations to sort
+ * @returns Sorted array of migrations in execution order
+ */
 export function sortMigrations(migrations: Migration[]): Migration[] {
-	// we do a topological sort using dependsOn and implicit dependencies between migrations in the same sequence
-	const byId = new Map(migrations.map((m) => [m.id, m]))
-	const isProcessing = new Set<MigrationId>()
+	if (migrations.length === 0) return []
 
-	const result: Migration[] = []
+	// Build dependency graph and calculate in-degrees
+	const byId = new Map(migrations.map((m) => [m.id, m]))
+	const dependents = new Map<MigrationId, Set<MigrationId>>() // who depends on this
+	const inDegree = new Map<MigrationId, number>()
+	const explicitDeps = new Map<MigrationId, Set<MigrationId>>() // explicit dependsOn relationships
 
-	function process(m: Migration) {
-		assert(!isProcessing.has(m.id), `Circular dependency in migrations: ${m.id}`)
-		isProcessing.add(m.id)
+	// Initialize
+	for (const m of migrations) {
+		inDegree.set(m.id, 0)
+		dependents.set(m.id, new Set())
+		explicitDeps.set(m.id, new Set())
+	}
 
+	// Add implicit sequence dependencies and explicit dependencies
+	for (const m of migrations) {
 		const { version, sequenceId } = parseMigrationId(m.id)
-		const parent = byId.get(`${sequenceId}/${version - 1}`)
-		if (parent) {
-			process(parent)
+
+		// Implicit dependency on previous in sequence
+		const prevId = `${sequenceId}/${version - 1}` as MigrationId
+		if (byId.has(prevId)) {
+			dependents.get(prevId)!.add(m.id)
+			inDegree.set(m.id, inDegree.get(m.id)! + 1)
 		}
 
+		// Explicit dependencies
 		if (m.dependsOn) {
-			for (const dep of m.dependsOn) {
-				const depMigration = byId.get(dep)
-				if (depMigration) {
-					process(depMigration)
+			for (const depId of m.dependsOn) {
+				if (byId.has(depId)) {
+					dependents.get(depId)!.add(m.id)
+					explicitDeps.get(m.id)!.add(depId)
+					inDegree.set(m.id, inDegree.get(m.id)! + 1)
+				}
+			}
+		}
+	}
+
+	// Priority queue: migrations ready to process (in-degree 0)
+	const ready = migrations.filter((m) => inDegree.get(m.id) === 0)
+	const result: Migration[] = []
+	const processed = new Set<MigrationId>()
+
+	while (ready.length > 0) {
+		// Calculate urgency scores for ready migrations and pick the best one
+		let bestCandidate: Migration | undefined
+		let bestCandidateScore = -Infinity
+
+		for (const m of ready) {
+			let urgencyScore = 0
+
+			for (const depId of dependents.get(m.id) || []) {
+				if (!processed.has(depId)) {
+					// Priority 1: Count all unprocessed dependents (to break ties)
+					urgencyScore += 1
+
+					// Priority 2: If this migration is explicitly depended on by others, boost priority
+					if (explicitDeps.get(depId)!.has(m.id)) {
+						urgencyScore += 100
+					}
 				}
 			}
+
+			if (
+				urgencyScore > bestCandidateScore ||
+				// Tiebreaker: prefer lower sequence/version
+				(urgencyScore === bestCandidateScore && m.id.localeCompare(bestCandidate?.id ?? '') < 0)
+			) {
+				bestCandidate = m
+				bestCandidateScore = urgencyScore
+			}
 		}
 
-		byId.delete(m.id)
-		result.push(m)
+		const nextMigration = bestCandidate!
+		ready.splice(ready.indexOf(nextMigration), 1)
+
+		// Cycle detection - if we have processed everything and still have items left, there's a cycle
+		// This is handled by Kahn's algorithm naturally - if we finish with items unprocessed, there's a cycle
+
+		// Process this migration
+		result.push(nextMigration)
+		processed.add(nextMigration.id)
+
+		// Update in-degrees and add newly ready migrations
+		for (const depId of dependents.get(nextMigration.id) || []) {
+			if (!processed.has(depId)) {
+				inDegree.set(depId, inDegree.get(depId)! - 1)
+				if (inDegree.get(depId) === 0) {
+					ready.push(byId.get(depId)!)
+				}
+			}
+		}
 	}
 
-	for (const m of byId.values()) {
-		process(m)
+	// Check for cycles - if we didn't process all migrations, there's a cycle
+	if (result.length !== migrations.length) {
+		const unprocessed = migrations.filter((m) => !processed.has(m.id))
+		assert(false, `Circular dependency in migrations: ${unprocessed[0].id}`)
 	}
 
 	return result

package/src/lib/test/AtomMap.test.ts

@@ -1,4 +1,5 @@
 import { react, transaction } from '@tldraw/state'
+import { vi } from 'vitest'
 import { AtomMap } from '../AtomMap'
 
 describe('AtomMap', () => {
@@ -11,7 +12,7 @@ describe('AtomMap', () => {
 	})
 
 	function testReactor(name: string, fn: () => any) {
-		const cb = jest.fn(fn)
+		const cb = vi.fn(fn)
 		const cleanup = react(name, cb)
 		cleanupFns.push(() => cleanup())
 		return cb

package/src/lib/test/dependsOn.test.ts

@@ -26,7 +26,7 @@ describe('dependsOn', () => {
 				}
 			)
 		}).toThrowErrorMatchingInlineSnapshot(
-			`"Migration 'foo/1' depends on missing migration 'bar/1'"`
+			`[Error: Migration 'foo/1' depends on missing migration 'bar/1']`
 		)
 	})
 
@@ -108,7 +108,7 @@ describe('standalone dependsOn', () => {
 				}
 			)
 		}).toThrowErrorMatchingInlineSnapshot(
-			`"Migration 'foo/1' depends on missing migration 'bar/1'"`
+			`[Error: Migration 'foo/1' depends on missing migration 'bar/1']`
 		)
 	})
 

package/src/lib/test/recordStore.test.ts

@@ -1,4 +1,5 @@
 import { Computed, react, RESET_VALUE, transact } from '@tldraw/state'
+import { vi } from 'vitest'
 import { BaseRecord, RecordId } from '../BaseRecord'
 import { createMigrationSequence } from '../migrate'
 import { RecordsDiff, reverseRecordsDiff } from '../RecordsDiff'
@@ -206,7 +207,7 @@ describe('Store', () => {
 
 	it('allows adding onAfterChange callbacks that see the final state of the world', () => {
 		/* ADDING */
-		const onAfterCreate = jest.fn((current) => {
+		const onAfterCreate = vi.fn((current) => {
 			expect(current).toEqual(
 				Author.create({ name: 'J.R.R Tolkein', id: Author.createId('tolkein') })
 			)
@@ -218,7 +219,7 @@ describe('Store', () => {
 		expect(onAfterCreate).toHaveBeenCalledTimes(1)
 
 		/* UPDATING */
-		const onAfterChange = jest.fn((prev, current) => {
+		const onAfterChange = vi.fn((prev, current) => {
 			expect(prev.name).toBe('J.R.R Tolkein')
 			expect(current.name).toBe('Butch Cassidy')
 
@@ -231,7 +232,7 @@ describe('Store', () => {
 		expect(onAfterChange).toHaveBeenCalledTimes(1)
 
 		/* REMOVING */
-		const onAfterDelete = jest.fn((prev) => {
+		const onAfterDelete = vi.fn((prev) => {
 			if (prev.typeName === 'author') {
 				expect(prev.name).toBe('Butch Cassidy')
 			}
@@ -309,7 +310,7 @@ describe('Store', () => {
 	})
 
 	it('supports listening for changes to the whole store', async () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener)
 
 		transact(() => {
@@ -336,7 +337,7 @@ describe('Store', () => {
 
 		await new Promise((resolve) => requestAnimationFrame(resolve))
 		expect(listener).toHaveBeenCalledTimes(1)
-		expect(listener.mock.lastCall[0]).toMatchInlineSnapshot(`
+		expect(listener.mock.lastCall?.[0]).toMatchInlineSnapshot(`
 		{
 		  "changes": {
 		    "added": {
@@ -391,7 +392,7 @@ describe('Store', () => {
 		await new Promise((resolve) => requestAnimationFrame(resolve))
 		expect(listener).toHaveBeenCalledTimes(2)
 
-		expect(listener.mock.lastCall[0]).toMatchInlineSnapshot(`
+		expect(listener.mock.lastCall?.[0]).toMatchInlineSnapshot(`
 		{
 		  "changes": {
 		    "added": {},
@@ -444,7 +445,7 @@ describe('Store', () => {
 		await new Promise((resolve) => requestAnimationFrame(resolve))
 		expect(listener).toHaveBeenCalledTimes(3)
 
-		expect(listener.mock.lastCall[0]).toMatchInlineSnapshot(`
+		expect(listener.mock.lastCall?.[0]).toMatchInlineSnapshot(`
 		{
 		  "changes": {
 		    "added": {},
@@ -480,7 +481,7 @@ describe('Store', () => {
 	})
 
 	it('supports filtering history by scope', () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener, {
 			scope: 'session',
 		})
@@ -521,7 +522,7 @@ describe('Store', () => {
 	})
 
 	it('supports filtering history by scope (2)', () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener, {
 			scope: 'document',
 		})
@@ -550,7 +551,7 @@ describe('Store', () => {
 	})
 
 	it('supports filtering history by source', () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener, {
 			source: 'remote',
 		})
@@ -600,7 +601,7 @@ describe('Store', () => {
 	})
 
 	it('supports filtering history by source (user)', () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener, {
 			source: 'user',
 		})
@@ -658,7 +659,7 @@ describe('Store', () => {
 			// @ts-expect-error
 			globalThis.__FORCE_RAF_IN_TESTS__ = true
 			store.put([Author.create({ name: 'J.R.R Tolkein', id: Author.createId('tolkein') })])
-			const firstListener = jest.fn()
+			const firstListener = vi.fn()
 			store.listen(firstListener)
 			expect(firstListener).toHaveBeenCalledTimes(0)
 
@@ -666,7 +667,7 @@ describe('Store', () => {
 
 			expect(firstListener).toHaveBeenCalledTimes(0)
 
-			const secondListener = jest.fn()
+			const secondListener = vi.fn()
 
 			store.listen(secondListener)
 
@@ -707,7 +708,7 @@ describe('Store', () => {
 		const id = Author.createId('tolkein')
 		store.put([Author.create({ name: 'J.R.R Tolkein', id })])
 
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener)
 
 		// Return the exact same value that came in
@@ -717,7 +718,7 @@ describe('Store', () => {
 	})
 
 	it('tells listeners the source of the changes so they can decide if they want to run or not', async () => {
-		const listener = jest.fn()
+		const listener = vi.fn()
 		store.listen(listener)
 
 		store.put([Author.create({ name: 'Jimmy Beans', id: Author.createId('jimmy') })])
@@ -824,7 +825,7 @@ describe('snapshots', () => {
 		expect(() => {
 			// @ts-expect-error
 			store2.loadStoreSnapshot(snapshot1)
-		}).toThrowErrorMatchingInlineSnapshot(`"Missing definition for record type author"`)
+		}).toThrowErrorMatchingInlineSnapshot(`[Error: Missing definition for record type author]`)
 	})
 
 	it('throws errors when loading a snapshot with a different schema', () => {
@@ -839,12 +840,12 @@ describe('snapshots', () => {
 
 		expect(() => {
 			store2.loadStoreSnapshot(snapshot1 as any)
-		}).toThrowErrorMatchingInlineSnapshot(`"Missing definition for record type author"`)
+		}).toThrowErrorMatchingInlineSnapshot(`[Error: Missing definition for record type author]`)
 	})
 
 	it('migrates the snapshot', () => {
 		const snapshot1 = store.getStoreSnapshot()
-		const up = jest.fn((s: any) => {
+		const up = vi.fn((s: any) => {
 			s['book:lotr'].numPages = 42
 		})
 
@@ -969,7 +970,7 @@ describe('diffs', () => {
 	})
 	it('produces diffs from `addHistoryInterceptor`', () => {
 		const diffs: any[] = []
-		const interceptor = jest.fn((diff) => diffs.push(diff))
+		const interceptor = vi.fn((diff) => diffs.push(diff))
 		store.addHistoryInterceptor(interceptor)
 
 		store.put([
@@ -1095,15 +1096,15 @@ describe('callbacks', () => {
 		numPages: 1,
 	})
 
-	let onAfterCreate: jest.Mock
-	let onAfterChange: jest.Mock
-	let onAfterDelete: jest.Mock
+	let onAfterCreate: ReturnType<typeof vi.fn>
+	let onAfterChange: ReturnType<typeof vi.fn>
+	let onAfterDelete: ReturnType<typeof vi.fn>
 
-	let onBeforeCreate: jest.Mock
-	let onBeforeChange: jest.Mock
-	let onBeforeDelete: jest.Mock
+	let onBeforeCreate: ReturnType<typeof vi.fn>
+	let onBeforeChange: ReturnType<typeof vi.fn>
+	let onBeforeDelete: ReturnType<typeof vi.fn>
 
-	let onOperationComplete: jest.Mock
+	let onOperationComplete: ReturnType<typeof vi.fn>
 
 	beforeEach(() => {
 		store = new Store({
@@ -1113,15 +1114,15 @@ describe('callbacks', () => {
 			}),
 		})
 
-		onAfterCreate = jest.fn((record) => callbacks.push({ type: 'create', record }))
-		onAfterChange = jest.fn((from, to) => callbacks.push({ type: 'change', from, to }))
-		onAfterDelete = jest.fn((record) => callbacks.push({ type: 'delete', record }))
+		onAfterCreate = vi.fn((record) => callbacks.push({ type: 'create', record }))
+		onAfterChange = vi.fn((from, to) => callbacks.push({ type: 'change', from, to }))
+		onAfterDelete = vi.fn((record) => callbacks.push({ type: 'delete', record }))
 
-		onBeforeCreate = jest.fn((record) => record)
-		onBeforeChange = jest.fn((_from, to) => to)
-		onBeforeDelete = jest.fn((_record) => {})
+		onBeforeCreate = vi.fn((record) => record)
+		onBeforeChange = vi.fn((_from, to) => to)
+		onBeforeDelete = vi.fn((_record) => {})
 
-		onOperationComplete = jest.fn(() => callbacks.push({ type: 'complete' }))
+		onOperationComplete = vi.fn(() => callbacks.push({ type: 'complete' }))
 		callbacks = []
 
 		store.sideEffects.registerAfterCreateHandler('book', onAfterCreate)
@@ -1161,12 +1162,12 @@ describe('callbacks', () => {
 
 	it('bails out if too many callbacks are fired', () => {
 		let limit = 10
-		onAfterCreate.mockImplementation((record) => {
+		onAfterCreate.mockImplementation((record: any) => {
 			if (record.numPages < limit) {
 				store.put([{ ...record, numPages: record.numPages + 1 }])
 			}
 		})
-		onAfterChange.mockImplementation((from, to) => {
+		onAfterChange.mockImplementation((from: any, to: any) => {
 			if (to.numPages < limit) {
 				store.put([{ ...to, numPages: to.numPages + 1 }])
 			}
@@ -1181,7 +1182,9 @@ describe('callbacks', () => {
 		store.clear()
 		expect(() => {
 			store.put([book2])
-		}).toThrowErrorMatchingInlineSnapshot(`"Maximum store update depth exceeded, bailing out"`)
+		}).toThrowErrorMatchingInlineSnapshot(
+			`[Error: Maximum store update depth exceeded, bailing out]`
+		)
 	})
 
 	it('keeps firing operation complete callbacks until all are cleared', () => {
@@ -1197,7 +1200,7 @@ describe('callbacks', () => {
 
 		store.put([book1])
 
-		onAfterChange.mockImplementation((prev, next) => {
+		onAfterChange.mockImplementation((prev: any, next: any) => {
 			if ([0, 1, 2, 5, 6].includes(step)) {
 				step++
 				store.put([{ ...next, numPages: next.numPages + 1 }])

package/src/lib/test/sortMigrations.test.ts

@@ -31,21 +31,53 @@ describe(sortMigrations, () => {
 		).toEqual(['bar/1', 'bar/2', 'foo/1', 'foo/2'])
 	})
 
+	it('should minimize distance between dependencies and dependents', () => {
+		// bar/3 depends on foo/1 - should process bar sequence immediately after foo/1
+		expect(
+			sort([m('foo/2'), m('bar/3', { dependsOn: ['foo/1'] }), m('foo/1'), m('bar/1'), m('bar/2')])
+		).toEqual(['foo/1', 'bar/1', 'bar/2', 'bar/3', 'foo/2'])
+	})
+
+	it('should minimize total distance for multiple explicit dependencies', () => {
+		// Both bar/2 and baz/1 depend on foo/1 - minimize total distance
+		expect(
+			sort([
+				m('foo/2'),
+				m('bar/2', { dependsOn: ['foo/1'] }),
+				m('foo/1'),
+				m('bar/1'),
+				m('baz/1', { dependsOn: ['foo/1'] }),
+			])
+		).toEqual(['foo/1', 'bar/1', 'bar/2', 'baz/1', 'foo/2'])
+	})
+
+	it('should handle chain of explicit dependencies optimally', () => {
+		// foo/1 -> bar/1 -> baz/1 chain should be consecutive
+		expect(
+			sort([
+				m('foo/2'),
+				m('bar/1', { dependsOn: ['foo/1'] }),
+				m('foo/1'),
+				m('baz/1', { dependsOn: ['bar/1'] }),
+			])
+		).toEqual(['foo/1', 'bar/1', 'baz/1', 'foo/2'])
+	})
+
 	it('should fail if a cycle is created', () => {
 		expect(() => {
 			sort([m('foo/1', { dependsOn: ['foo/1'] })])
-		}).toThrowErrorMatchingInlineSnapshot(`"Circular dependency in migrations: foo/1"`)
+		}).toThrowErrorMatchingInlineSnapshot(`[Error: Circular dependency in migrations: foo/1]`)
 
 		expect(() => {
 			sort([m('foo/1', { dependsOn: ['foo/2'] }), m('foo/2')])
-		}).toThrowErrorMatchingInlineSnapshot(`"Circular dependency in migrations: foo/1"`)
+		}).toThrowErrorMatchingInlineSnapshot(`[Error: Circular dependency in migrations: foo/1]`)
 
 		expect(() => {
 			sort([m('foo/1', { dependsOn: ['bar/1'] }), m('bar/1', { dependsOn: ['foo/1'] })])
-		}).toThrowErrorMatchingInlineSnapshot(`"Circular dependency in migrations: foo/1"`)
+		}).toThrowErrorMatchingInlineSnapshot(`[Error: Circular dependency in migrations: foo/1]`)
 
 		expect(() => {
 			sort([m('bar/1', { dependsOn: ['foo/1'] }), m('foo/1', { dependsOn: ['bar/1'] })])
-		}).toThrowErrorMatchingInlineSnapshot(`"Circular dependency in migrations: bar/1"`)
+		}).toThrowErrorMatchingInlineSnapshot(`[Error: Circular dependency in migrations: bar/1]`)
 	})
 })