← vibesdk

/**
 * CheckpointStore tests against a real DO `SqlStorage` (via the FsHarnessDO
 * harness, same pattern as the FileSystem contract tests).
 *
 * The checkpoint is the durability layer for UNCOMMITTED workspace writes: it
 * must survive a DO reset even when nothing was ever pushed to Artifacts
 * (the "files missing until first deploy" bug).
 */
import { describe, it, expect } from 'vitest';
import { env, runInDurableObject } from 'cloudflare:test';
import { CheckpointStore } from '../src/space/checkpoint';
import type {} from './test-env';

function uniqueStub(name: string) {
	const id = env.FsHarnessDO.idFromName(`ckpt-${name}-${Date.now()}-${Math.random()}`);
	return env.FsHarnessDO.get(id);
}

const encoder = new TextEncoder();

describe('CheckpointStore', () => {
	it('saves and loads file bytes', async () => {
		await runInDurableObject(uniqueStub('roundtrip'), async (_instance, state) => {
			const store = new CheckpointStore(state.storage);
			store.save('/a.ts', encoder.encode('aaa'));
			store.save('/dir/b.ts', encoder.encode('bbb'));

			const { files, tombstones } = store.load();
			expect(tombstones).toEqual([]);
			const map = new Map(files.map(([p, b]) => [p, new TextDecoder().decode(b)]));
			expect(map.get('/a.ts')).toBe('aaa');
			expect(map.get('/dir/b.ts')).toBe('bbb');
		});
	});

	it('overwrites a path with the latest bytes', async () => {
		await runInDurableObject(uniqueStub('overwrite'), async (_instance, state) => {
			const store = new CheckpointStore(state.storage);
			store.save('/a.ts', encoder.encode('v1'));
			store.save('/a.ts', encoder.encode('v2'));

			const { files } = store.load();
			expect(files).toHaveLength(1);
			expect(new TextDecoder().decode(files[0][1])).toBe('v2');
		});
	});

	it('tombstones a deletion and drops rows beneath it', async () => {
		await runInDurableObject(uniqueStub('tombstone'), async (_instance, state) => {
			const store = new CheckpointStore(state.storage);
			store.save('/keep.ts', encoder.encode('k'));
			store.save('/dir/a.ts', encoder.encode('a'));
			store.save('/dir/nested/b.ts', encoder.encode('b'));

			store.save('/dir', null);

			const { files, tombstones } = store.load();
			expect(files.map(([p]) => p)).toEqual(['/keep.ts']);
			expect(tombstones).toEqual(['/dir']);
		});
	});

	it('a re-save after a tombstone replaces the tombstone for that path', async () => {
		await runInDurableObject(uniqueStub('resave'), async (_instance, state) => {
			const store = new CheckpointStore(state.storage);
			store.save('/f.ts', encoder.encode('v1'));
			store.save('/f.ts', null);
			store.save('/f.ts', encoder.encode('v2'));

			const { files, tombstones } = store.load();
			expect(tombstones).toEqual([]);
			expect(files).toHaveLength(1);
			expect(new TextDecoder().decode(files[0][1])).toBe('v2');
		});
	});

	it('clear drops every row (post-push reset)', async () => {
		await runInDurableObject(uniqueStub('clear'), async (_instance, state) => {
			const store = new CheckpointStore(state.storage);
			store.save('/a.ts', encoder.encode('a'));
			store.save('/b.ts', null);
			store.clear();

			const { files, tombstones } = store.load();
			expect(files).toEqual([]);
			expect(tombstones).toEqual([]);
		});
	});

	it('persists across store instances bound to the same storage (cold start)', async () => {
		const stub = uniqueStub('persist');
		await runInDurableObject(stub, async (_instance, state) => {
			new CheckpointStore(state.storage).save('/survives.ts', encoder.encode('yes'));
		});
		// A "cold-started" DO constructs a fresh store over the same storage.
		await runInDurableObject(stub, async (_instance, state) => {
			const { files } = new CheckpointStore(state.storage).load();
			expect(files).toHaveLength(1);
			expect(files[0][0]).toBe('/survives.ts');
		});
	});
});