@selvajs/server 0.2.0-beta.3 → 0.2.0-beta.4

package/src/definitions/__tests__/definition-service.test.ts

@@ -1,131 +0,0 @@
-/**
- * Tests for `DefinitionService.uploadVersion` version-number allocation (caching
- * Phase 1.5). The root-cause fix: the next version number comes from the store's
- * monotonic `reserveNextVersionNumber` counter — NOT max(existing)+1, which
- * reused a number (and its `fileKey`) after delete-latest and let a stale storage
- * blob serve the old version's bytes for new content.
- *
- * These run against fakes that record the store/storage calls, so they pin the
- * SERVICE's contract (reserve → derive fileKey from the reserved number). That a
- * real provider's counter is truly monotonic across delete-then-reupload is
- * covered by the definition-store conformance suite (both providers).
- */
-
-import { describe, it, expect } from 'vitest';
-import type {
-	IDataProvider,
-	IStorageProvider,
-	RequestContext,
-	DefinitionRecord,
-	DefinitionVersion,
-	UISchema
-} from '@selvajs/platform';
-import { DefinitionService } from '../definition-service.js';
-
-const CTX = { userId: 'u-1' } as RequestContext;
-const SCHEMA = {} as UISchema;
-
-function fakeRecord(guid: string, nextVersionNumber: number): DefinitionRecord {
-	const now = new Date().toISOString();
-	return {
-		guid,
-		projectId: 'p-1',
-		ownerId: 'u-1',
-		createdBy: 'u-1',
-		updatedBy: 'u-1',
-		displayName: 'Def',
-		status: 'draft',
-		solveCount: 0,
-		nextVersionNumber,
-		liveVersionId: 'v-existing',
-		draftVersionId: 'v-existing',
-		createdAt: now,
-		updatedAt: now,
-		deletedAt: null
-	};
-}
-
-/**
- * A minimal data provider whose `definitions` store hands out the reserved
- * number and records the version row it was told to create. Only the methods
- * `uploadVersion` touches are implemented.
- */
-function fakeDeps(record: DefinitionRecord) {
-	let counter = record.nextVersionNumber;
-	const created: DefinitionVersion[] = [];
-	const puts: string[] = [];
-
-	const data = {
-		definitions: {
-			get: async () => record,
-			reserveNextVersionNumber: async () => counter++, // monotonic, never reused
-			createVersion: async (_ctx: RequestContext, v: DefinitionVersion) => {
-				created.push(v);
-			},
-			setDraftVersion: async () => {}
-		}
-	} as unknown as IDataProvider;
-
-	const storage = {
-		put: async (key: string) => {
-			puts.push(key);
-		}
-	} as unknown as IStorageProvider;
-
-	return { data, storage, created, puts };
-}
-
-describe('DefinitionService.uploadVersion — version-number allocation', () => {
-	it('reserves the next number from the record counter and derives the fileKey from it', async () => {
-		const record = fakeRecord('11111111-1111-1111-1111-111111111111', 3);
-		const { data, storage, created, puts } = fakeDeps(record);
-		const svc = new DefinitionService(data, storage);
-
-		const version = await svc.uploadVersion(
-			CTX,
-			record.guid,
-			new Uint8Array([1, 2, 3]),
-			'gh',
-			'model.gh',
-			SCHEMA
-		);
-
-		expect(version.versionNumber).toBe(3);
-		// fileKey encodes the reserved number — so a fresh number ⇒ fresh key.
-		expect(version.fileKey).toContain('v3');
-		expect(puts).toEqual([version.fileKey]);
-		expect(created).toHaveLength(1);
-		expect(created[0].versionNumber).toBe(3);
-	});
-
-	it('two consecutive uploads mint distinct numbers and distinct fileKeys', async () => {
-		const record = fakeRecord('22222222-2222-2222-2222-222222222222', 5);
-		const { data, storage } = fakeDeps(record);
-		const svc = new DefinitionService(data, storage);
-
-		const a = await svc.uploadVersion(CTX, record.guid, new Uint8Array([1]), 'gh', 'a.gh', SCHEMA);
-		const b = await svc.uploadVersion(CTX, record.guid, new Uint8Array([2]), 'gh', 'b.gh', SCHEMA);
-
-		expect(a.versionNumber).toBe(5);
-		expect(b.versionNumber).toBe(6);
-		expect(a.fileKey).not.toBe(b.fileKey);
-	});
-
-	it('does NOT derive the number from the version list (no listVersions call)', async () => {
-		// The old bug read the version list; the fix must not. A deps object with no
-		// listVersions still works — reserveNextVersionNumber is the only source.
-		const record = fakeRecord('33333333-3333-3333-3333-333333333333', 9);
-		const { data, storage } = fakeDeps(record);
-		const svc = new DefinitionService(data, storage);
-
-		const version = await svc.uploadVersion(
-			CTX,
-			record.guid,
-			new Uint8Array([1]),
-			'gh',
-			'a.gh',
-			SCHEMA
-		);
-		expect(version.versionNumber).toBe(9);
-	});
-});

package/src/definitions/__tests__/load-for-render.test.ts

@@ -1,244 +0,0 @@
-/**
- * Tests for `createDefinitionLoader` (K4) — version resolution, error
- * classification, and the ADR 0005 schema-staleness behavior: a cached schema
- * is used only at the app's current format version; anything else re-extracts
- * from compute and persists back (best-effort, current-version only).
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { UI_SCHEMA_VERSION, type UISchema } from '@selvajs/schemas';
-import type {
-	ComputeServerConfig,
-	DefinitionRecord,
-	DefinitionVersion,
-	RequestContext
-} from '@selvajs/platform';
-import { createDefinitionLoader, DefinitionLoadError } from '../load-for-render.js';
-
-const ctx = { userId: 'user-1' } as RequestContext;
-
-function uiSchema(version: string, inputs: unknown[] = []): UISchema {
-	return {
-		id: 'schema-1',
-		name: 'Test',
-		schemaVersion: version,
-		inputs,
-		outputs: [],
-		layout: { type: 'tabbed', tabs: [] }
-	} as unknown as UISchema;
-}
-
-const record = {
-	guid: 'def-1',
-	projectId: 'proj-1',
-	computeServerId: null,
-	liveVersionId: 'v-live',
-	draftVersionId: 'v-draft'
-} as unknown as DefinitionRecord;
-
-function version(overrides: Partial<DefinitionVersion> = {}): DefinitionVersion {
-	return {
-		id: 'v-live',
-		definitionId: 'def-1',
-		versionNumber: 1,
-		fileExt: 'gh',
-		fileKey: 'definitions/def-1/versions/v1.gh',
-		uploadedBy: 'user-1',
-		uploadedAt: '2026-07-01T00:00:00Z',
-		...overrides
-	} as DefinitionVersion;
-}
-
-const computeServer = { id: 'srv-1', serverUrl: 'http://c.example' } as ComputeServerConfig;
-
-function makeDeps(overrides: Record<string, unknown> = {}) {
-	const getIO = vi.fn(async () => ({ inputs: [{ id: 'a', default: 42 }], outputs: [] }));
-	const deps = {
-		storage: { get: vi.fn(async () => new Uint8Array([1, 2, 3])) },
-		definitions: {
-			getVersion: vi.fn(async () => version()),
-			setVersionSchema: vi.fn(async () => {})
-		},
-		projects: { getProject: vi.fn(async () => ({ id: 'proj-1', orgId: 'org-1' })) },
-		resolveServer: vi.fn(async () => computeServer),
-		getClient: vi.fn(async () => ({ client: { getIO, getRawIO: vi.fn() } })),
-		fetchSchema: vi.fn(async () => uiSchema(UI_SCHEMA_VERSION, [{ id: 'a' }])),
-		onWarn: vi.fn(),
-		...overrides
-	};
-	return {
-		deps: deps as never as Parameters<typeof createDefinitionLoader>[0],
-		mocks: deps,
-		getIO
-	};
-}
-
-async function flushMicrotasks() {
-	await new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-describe('schema cache staleness (ADR 0005)', () => {
-	it('uses the cached schema when its version matches, without re-extracting or persisting', async () => {
-		const cached = uiSchema(UI_SCHEMA_VERSION, [{ id: 'a' }]);
-		const { deps, mocks } = makeDeps();
-		mocks.definitions.getVersion.mockResolvedValue(version({ schema: cached }));
-
-		const result = await createDefinitionLoader(deps)(ctx, record, 'live');
-
-		expect(mocks.fetchSchema).not.toHaveBeenCalled();
-		expect(mocks.definitions.setVersionSchema).not.toHaveBeenCalled();
-		// Compute defaults are merged into the cached schema's inputs.
-		expect((result.schema.inputs[0] as { default?: unknown }).default).toBe(42);
-	});
-
-	it('re-extracts and persists when the cached schema is at an older format version', async () => {
-		const { deps, mocks } = makeDeps();
-		mocks.definitions.getVersion.mockResolvedValue(version({ schema: uiSchema('2.10.0') }));
-
-		await createDefinitionLoader(deps)(ctx, record, 'live');
-		await flushMicrotasks();
-
-		expect(mocks.fetchSchema).toHaveBeenCalledTimes(1);
-		expect(mocks.definitions.setVersionSchema).toHaveBeenCalledWith(
-			ctx,
-			'v-live',
-			expect.objectContaining({ schemaVersion: UI_SCHEMA_VERSION })
-		);
-	});
-
-	it('re-extracts and persists when no schema is cached (pre-caching row)', async () => {
-		const { deps, mocks } = makeDeps();
-		mocks.definitions.getVersion.mockResolvedValue(version({ schema: undefined }));
-
-		await createDefinitionLoader(deps)(ctx, record, 'live');
-		await flushMicrotasks();
-
-		expect(mocks.fetchSchema).toHaveBeenCalledTimes(1);
-		expect(mocks.definitions.setVersionSchema).toHaveBeenCalledTimes(1);
-	});
-
-	it('does NOT persist a re-extracted schema that is still not at the current version', async () => {
-		// Compute plugin behind the app: re-extraction yields an older format.
-		const { deps, mocks } = makeDeps({
-			fetchSchema: vi.fn(async () => uiSchema('2.10.0'))
-		});
-		mocks.definitions.getVersion.mockResolvedValue(version({ schema: undefined }));
-
-		const result = await createDefinitionLoader(deps)(ctx, record, 'live');
-		await flushMicrotasks();
-
-		expect(mocks.definitions.setVersionSchema).not.toHaveBeenCalled();
-		// The older schema still renders (older shapes only lack optional additions).
-		expect(result.schema.schemaVersion).toBe('2.10.0');
-	});
-
-	it('a failed persist warns but does not fail the render', async () => {
-		const { deps, mocks } = makeDeps();
-		mocks.definitions.getVersion.mockResolvedValue(version({ schema: undefined }));
-		mocks.definitions.setVersionSchema.mockRejectedValue(new Error('RLS: not allowed'));
-
-		const result = await createDefinitionLoader(deps)(ctx, record, 'live');
-		await flushMicrotasks();
-
-		expect(result.schema.schemaVersion).toBe(UI_SCHEMA_VERSION);
-		expect(mocks.onWarn).toHaveBeenCalledWith(expect.stringContaining('cache refresh failed'));
-	});
-});
-
-describe('version resolution', () => {
-	it('resolves the draft pointer for the draft channel', async () => {
-		const { deps, mocks } = makeDeps();
-		mocks.definitions.getVersion.mockResolvedValue(version({ id: 'v-draft' }));
-
-		await createDefinitionLoader(deps)(ctx, record, 'draft');
-		expect(mocks.definitions.getVersion).toHaveBeenCalledWith(ctx, 'v-draft');
-	});
-
-	it('an explicit versionId wins over the channel pointer', async () => {
-		const { deps, mocks } = makeDeps();
-		mocks.definitions.getVersion.mockResolvedValue(version({ id: 'v-7' }));
-
-		await createDefinitionLoader(deps)(ctx, record, 'live', 'v-7');
-		expect(mocks.definitions.getVersion).toHaveBeenCalledWith(ctx, 'v-7');
-	});
-
-	it("rejects a version that belongs to another definition ('data')", async () => {
-		const { deps, mocks } = makeDeps();
-		mocks.definitions.getVersion.mockResolvedValue(version({ definitionId: 'other-def' }));
-
-		await expect(createDefinitionLoader(deps)(ctx, record, 'live')).rejects.toMatchObject({
-			name: 'DefinitionLoadError',
-			kind: 'data'
-		});
-	});
-});
-
-describe('error classification', () => {
-	it("no pointer for the channel → 'data'", async () => {
-		const { deps } = makeDeps();
-		const bare = { ...record, liveVersionId: null } as unknown as DefinitionRecord;
-		await expect(createDefinitionLoader(deps)(ctx, bare, 'live')).rejects.toMatchObject({
-			kind: 'data'
-		});
-	});
-
-	it("missing blob → 'data'", async () => {
-		const { deps, mocks } = makeDeps();
-		mocks.storage.get.mockResolvedValue(null as never);
-		await expect(createDefinitionLoader(deps)(ctx, record, 'live')).rejects.toMatchObject({
-			kind: 'data'
-		});
-	});
-
-	it("unresolvable compute server → 'missing-config'", async () => {
-		const { deps, mocks } = makeDeps();
-		mocks.resolveServer.mockRejectedValue(new Error('none visible'));
-		await expect(createDefinitionLoader(deps)(ctx, record, 'live')).rejects.toMatchObject({
-			kind: 'missing-config'
-		});
-	});
-
-	it("client connect failure → 'connect'", async () => {
-		const { deps, mocks } = makeDeps();
-		mocks.getClient.mockRejectedValue(new Error('ECONNREFUSED'));
-		await expect(createDefinitionLoader(deps)(ctx, record, 'live')).rejects.toMatchObject({
-			kind: 'connect'
-		});
-	});
-
-	it("IO/schema phase failure → 'schema'", async () => {
-		const { deps, mocks } = makeDeps({
-			fetchSchema: vi.fn(async () => {
-				throw new Error('no Schema output');
-			})
-		});
-		mocks.definitions.getVersion.mockResolvedValue(version({ schema: undefined }));
-		const err = await createDefinitionLoader(deps)(ctx, record, 'live').catch((e) => e);
-		expect(err).toBeInstanceOf(DefinitionLoadError);
-		expect(err.kind).toBe('schema');
-	});
-});
-
-describe('compute default merging', () => {
-	beforeEach(() => vi.clearAllMocks());
-
-	it('converts Color defaults to hex', async () => {
-		const { deps, mocks } = makeDeps({
-			getClient: vi.fn(async () => ({
-				client: {
-					getIO: vi.fn(async () => ({
-						inputs: [{ id: 'col', paramType: 'Color', default: '255,128,0' }],
-						outputs: []
-					})),
-					getRawIO: vi.fn()
-				}
-			}))
-		});
-		mocks.definitions.getVersion.mockResolvedValue(
-			version({ schema: uiSchema(UI_SCHEMA_VERSION, [{ id: 'col' }]) })
-		);
-
-		const result = await createDefinitionLoader(deps)(ctx, record, 'live');
-		expect((result.schema.inputs[0] as { default?: unknown }).default).toBe('#ff8000');
-	});
-});

package/src/definitions/__tests__/schema-extraction.test.ts

@@ -1,137 +0,0 @@
-/**
- * Tests for the compute-schema extraction gate (K4 / ADR 0005).
- *
- * `fetch` is stubbed per test to script the compute `/grasshopper/schema`
- * response. The version-compat gate (`assertSupportedSchemaVersion`) is also
- * exercised directly: newer-than-supported must throw 'unsupported', while
- * older / missing versions pass (compute's C# migrator emits its own current
- * version; older shapes only lack optional additions).
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { UI_SCHEMA_VERSION, type UISchema } from '@selvajs/schemas';
-import type { ComputeServerConfig } from '@selvajs/platform';
-import {
-	fetchSchemaFromCompute,
-	assertSupportedSchemaVersion,
-	SchemaExtractionError
-} from '../schema-extraction.js';
-
-function schema(version?: string): UISchema {
-	return {
-		id: 'schema-1',
-		name: 'Test',
-		...(version !== undefined && { schemaVersion: version }),
-		inputs: [],
-		outputs: [],
-		layout: { type: 'tabbed', tabs: [] }
-	} as unknown as UISchema;
-}
-
-function bump(version: string, part: 0 | 1 | 2): string {
-	const nums = version.split('.').map(Number);
-	nums[part] += 1;
-	return nums.join('.');
-}
-
-const server: ComputeServerConfig = {
-	id: 'srv-1',
-	serverUrl: 'http://compute.example.com',
-	apiKey: 'secret'
-} as ComputeServerConfig;
-
-describe('assertSupportedSchemaVersion', () => {
-	it('passes the current version', () => {
-		expect(() => assertSupportedSchemaVersion(schema(UI_SCHEMA_VERSION))).not.toThrow();
-	});
-
-	it('passes older versions (older shapes only lack optional additions)', () => {
-		expect(() => assertSupportedSchemaVersion(schema('1.0.0'))).not.toThrow();
-		expect(() => assertSupportedSchemaVersion(schema('2.0.0'))).not.toThrow();
-	});
-
-	it('passes a schema without a version (pre-2.12.0 plugin)', () => {
-		expect(() => assertSupportedSchemaVersion(schema())).not.toThrow();
-	});
-
-	it.each([
-		['major', 0],
-		['minor', 1],
-		['patch', 2]
-	] as const)('throws unsupported for a newer %s version', (_label, part) => {
-		const newer = bump(UI_SCHEMA_VERSION, part);
-		try {
-			assertSupportedSchemaVersion(schema(newer));
-			expect.unreachable('should have thrown');
-		} catch (err) {
-			expect(err).toBeInstanceOf(SchemaExtractionError);
-			expect((err as SchemaExtractionError).kind).toBe('unsupported');
-			expect((err as SchemaExtractionError).message).toContain(newer);
-			expect((err as SchemaExtractionError).message).toContain(UI_SCHEMA_VERSION);
-		}
-	});
-
-	it('passes an unparseable version string (fail open — invalid is not "newer")', () => {
-		expect(() => assertSupportedSchemaVersion(schema('abc'))).not.toThrow();
-	});
-});
-
-describe('fetchSchemaFromCompute', () => {
-	let fetchMock: ReturnType<typeof vi.fn>;
-
-	beforeEach(() => {
-		fetchMock = vi.fn();
-		vi.stubGlobal('fetch', fetchMock);
-	});
-
-	afterEach(() => {
-		vi.unstubAllGlobals();
-	});
-
-	function computeResponse(schemas: unknown[]): Response {
-		// Compute wraps results with PascalCase keys.
-		return new Response(JSON.stringify([{ FileName: 'definition.gh', Schemas: schemas }]), {
-			status: 200,
-			headers: { 'content-type': 'application/json' }
-		});
-	}
-
-	it('extracts the first schema and sends the API key header', async () => {
-		fetchMock.mockResolvedValue(computeResponse([schema(UI_SCHEMA_VERSION)]));
-		const result = await fetchSchemaFromCompute(new Uint8Array([1]), server);
-		expect(result.id).toBe('schema-1');
-
-		const [url, init] = fetchMock.mock.calls[0];
-		expect(url).toBe('http://compute.example.com/grasshopper/schema');
-		expect((init.headers as Record<string, string>)['RhinoComputeKey']).toBe('secret');
-	});
-
-	it('throws unreachable when the network request fails', async () => {
-		fetchMock.mockRejectedValue(new Error('ECONNREFUSED'));
-		await expect(fetchSchemaFromCompute(new Uint8Array([1]), server)).rejects.toMatchObject({
-			name: 'SchemaExtractionError',
-			kind: 'unreachable'
-		});
-	});
-
-	it('throws unreachable on a non-OK status', async () => {
-		fetchMock.mockResolvedValue(new Response('nope', { status: 500 }));
-		await expect(fetchSchemaFromCompute(new Uint8Array([1]), server)).rejects.toMatchObject({
-			kind: 'unreachable'
-		});
-	});
-
-	it('throws invalid when the definition yields no schemas', async () => {
-		fetchMock.mockResolvedValue(computeResponse([]));
-		await expect(fetchSchemaFromCompute(new Uint8Array([1]), server)).rejects.toMatchObject({
-			kind: 'invalid'
-		});
-	});
-
-	it('applies the version gate to the extracted schema', async () => {
-		fetchMock.mockResolvedValue(computeResponse([schema(bump(UI_SCHEMA_VERSION, 1))]));
-		await expect(fetchSchemaFromCompute(new Uint8Array([1]), server)).rejects.toMatchObject({
-			kind: 'unsupported'
-		});
-	});
-});