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

package/src/access/__tests__/project-access-input.test.ts

@@ -1,175 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import type {
-	Project,
-	ProjectAccessInput,
-	ProjectVisibility,
-	RequestContext
-} from '@selvajs/platform';
-import {
-	createProjectAccessInputBuilder,
-	type ProjectAccessFlags
-} from '../project-access-input.js';
-
-const CTX: RequestContext = {
-	userId: 'user-1',
-	actingOrgId: 'org-1',
-	platformPermissions: ['manage_compute'],
-	orgPermissions: ['manage_org_members']
-} as RequestContext;
-
-function project(visibility: ProjectVisibility): Project {
-	return {
-		id: 'proj-1',
-		orgId: 'org-1',
-		name: 'P',
-		slug: 'p',
-		visibility,
-		ownerId: 'user-9',
-		createdBy: 'user-9',
-		updatedBy: 'user-9',
-		autoJoinOnUpload: false,
-		createdAt: '2026-01-01T00:00:00Z',
-		updatedAt: '2026-01-01T00:00:00Z'
-	};
-}
-
-// Row identity is all the builder consumes — it passes rows through opaquely.
-const MEMBER = {
-	projectId: 'proj-1',
-	userId: 'user-1',
-	role: 'editor'
-} as unknown as NonNullable<ProjectAccessInput['member']>;
-const ORG_MEMBER = {
-	orgId: 'org-1',
-	userId: 'user-1',
-	role: 'member'
-} as unknown as NonNullable<ProjectAccessInput['orgMember']>;
-const GRANT = {
-	projectId: 'proj-1',
-	orgId: 'org-2',
-	canSolve: true
-} as unknown as ProjectAccessInput['platformGrants'][number];
-
-function makeDeps(flags: Partial<ProjectAccessFlags> = {}) {
-	return {
-		getProjectMember: vi.fn().mockResolvedValue(MEMBER),
-		getOrgMember: vi.fn().mockResolvedValue(ORG_MEMBER),
-		listPlatformGrants: vi.fn().mockResolvedValue([GRANT]),
-		flags: vi.fn().mockReturnValue({
-			allowCrossOrgPublic: false,
-			enablePlatformProjects: false,
-			...flags
-		})
-	};
-}
-
-describe('buildProjectAccessInput — per-visibility row fetching', () => {
-	it('private: fetches only the project member row', async () => {
-		const deps = makeDeps();
-		const builder = createProjectAccessInputBuilder(deps);
-		const input = await builder.buildProjectAccessInput(CTX, project('private'));
-
-		expect(input.member).toEqual(MEMBER);
-		expect(input.orgMember).toBeNull();
-		expect(input.platformGrants).toEqual([]);
-		expect(deps.getOrgMember).not.toHaveBeenCalled();
-		expect(deps.listPlatformGrants).not.toHaveBeenCalled();
-	});
-
-	it.each(['org', 'public'] as const)('%s: fetches project member + org member', async (vis) => {
-		const deps = makeDeps();
-		const builder = createProjectAccessInputBuilder(deps);
-		const input = await builder.buildProjectAccessInput(CTX, project(vis));
-
-		expect(input.member).toEqual(MEMBER);
-		expect(input.orgMember).toEqual(ORG_MEMBER);
-		expect(deps.getOrgMember).toHaveBeenCalledWith(CTX, 'org-1', 'user-1');
-	});
-
-	it('public + ALLOW_CROSS_ORG_PUBLIC: skips the org member row', async () => {
-		const deps = makeDeps({ allowCrossOrgPublic: true });
-		const builder = createProjectAccessInputBuilder(deps);
-		const input = await builder.buildProjectAccessInput(CTX, project('public'));
-
-		expect(input.member).toEqual(MEMBER);
-		expect(input.orgMember).toBeNull();
-		expect(deps.getOrgMember).not.toHaveBeenCalled();
-	});
-
-	it('org visibility still fetches the org row when cross-org public is on', async () => {
-		const deps = makeDeps({ allowCrossOrgPublic: true });
-		const builder = createProjectAccessInputBuilder(deps);
-		const input = await builder.buildProjectAccessInput(CTX, project('org'));
-		expect(input.orgMember).toEqual(ORG_MEMBER);
-	});
-
-	it('platform + flag on: fetches grants only', async () => {
-		const deps = makeDeps({ enablePlatformProjects: true });
-		const builder = createProjectAccessInputBuilder(deps);
-		const input = await builder.buildProjectAccessInput(CTX, project('platform'));
-
-		expect(input.platformGrants).toEqual([GRANT]);
-		expect(input.member).toBeNull();
-		expect(deps.getProjectMember).not.toHaveBeenCalled();
-		expect(deps.getOrgMember).not.toHaveBeenCalled();
-	});
-
-	it('platform + flag off: skips the grant lookup entirely (feature disabled stays cheap)', async () => {
-		const deps = makeDeps({ enablePlatformProjects: false });
-		const builder = createProjectAccessInputBuilder(deps);
-		const input = await builder.buildProjectAccessInput(CTX, project('platform'));
-
-		expect(input.platformGrants).toEqual([]);
-		expect(deps.listPlatformGrants).not.toHaveBeenCalled();
-	});
-
-	it('threads ctx fields and flags into the input, with overrides winning', async () => {
-		const deps = makeDeps({ allowCrossOrgPublic: true });
-		const builder = createProjectAccessInputBuilder(deps);
-		const input = await builder.buildProjectAccessInput(CTX, project('private'), {
-			member: null
-		});
-
-		expect(input.userId).toBe('user-1');
-		expect(input.actingOrgId).toBe('org-1');
-		expect(input.orgPermissions).toEqual(CTX.orgPermissions);
-		expect(input.platformPermissions).toEqual(CTX.platformPermissions);
-		expect(input.allowCrossOrgPublic).toBe(true);
-		expect(input.member).toBeNull(); // override beat the fetched row
-	});
-
-	it('reads flags per call, not at builder creation', async () => {
-		const deps = makeDeps();
-		const builder = createProjectAccessInputBuilder(deps);
-		await builder.buildProjectAccessInput(CTX, project('private'));
-		deps.flags.mockReturnValue({ allowCrossOrgPublic: true, enablePlatformProjects: true });
-		const input = await builder.buildProjectAccessInput(CTX, project('private'));
-		expect(input.enablePlatformProjects).toBe(true);
-	});
-});
-
-describe('projectAccessInputFromRows', () => {
-	it('assembles from caller rows with zero I/O', () => {
-		const deps = makeDeps();
-		const builder = createProjectAccessInputBuilder(deps);
-		const input = builder.projectAccessInputFromRows(CTX, project('org'), {
-			member: MEMBER,
-			orgMember: ORG_MEMBER
-		});
-
-		expect(input.member).toEqual(MEMBER);
-		expect(input.orgMember).toEqual(ORG_MEMBER);
-		expect(input.platformGrants).toEqual([]);
-		expect(deps.getProjectMember).not.toHaveBeenCalled();
-		expect(deps.getOrgMember).not.toHaveBeenCalled();
-		expect(deps.listPlatformGrants).not.toHaveBeenCalled();
-	});
-
-	it('defaults omitted rows to null/empty', () => {
-		const builder = createProjectAccessInputBuilder(makeDeps());
-		const input = builder.projectAccessInputFromRows(CTX, project('private'), {});
-		expect(input.member).toBeNull();
-		expect(input.orgMember).toBeNull();
-		expect(input.platformGrants).toEqual([]);
-	});
-});

package/src/access/index.ts

@@ -1,9 +0,0 @@
-// Access-rule input assembly — marshals providers + flags into what
-// platform's pure canView/canEdit/… rules consume.
-
-export {
-	createProjectAccessInputBuilder,
-	type ProjectAccessFlags,
-	type ProjectAccessInputBuilder,
-	type ProjectAccessInputDeps
-} from './project-access-input.js';

package/src/access/project-access-input.ts

@@ -1,145 +0,0 @@
-import type { Project, ProjectAccessInput, RequestContext } from '@selvajs/platform';
-
-/**
- * Assembly of `ProjectAccessInput` — the marshalling layer between an app's
- * providers and platform's pure access rules (`canView`/`canEdit`/`canSolve`/
- * `canManage`/…). The rules are pure functions over one input shape; the
- * knowledge captured here is **which rows each project visibility needs**, so
- * a consuming app doesn't reimplement (and mis-fetch) it:
- *
- * - `platform` → grants (skipped entirely while the feature flag is off)
- * - `private`  → caller's project member row
- * - `org` / `public` → caller's project member row (for canEdit/canManage) and
- *   org member row (for canView). Cross-org public skips the org row.
- *
- * Wiring is injected: row lookups as functions (so lazily-initialized
- * providers work unchanged) and flags read per call (so runtime flag flips
- * behave like the app's own `flag()` reads).
- */
-
-export interface ProjectAccessFlags {
-	/** `ALLOW_CROSS_ORG_PUBLIC` — public visibility spans orgs when true. */
-	allowCrossOrgPublic: boolean;
-	/** `ENABLE_PLATFORM_PROJECTS` — platform visibility is live when true. */
-	enablePlatformProjects: boolean;
-}
-
-export interface ProjectAccessInputDeps {
-	getProjectMember(
-		ctx: RequestContext,
-		projectId: string,
-		userId: string
-	): Promise<ProjectAccessInput['member']>;
-	getOrgMember(
-		ctx: RequestContext,
-		orgId: string,
-		userId: string
-	): Promise<ProjectAccessInput['orgMember']>;
-	listPlatformGrants(
-		ctx: RequestContext,
-		projectId: string
-	): Promise<ProjectAccessInput['platformGrants']>;
-	/** Read the two access-relevant feature flags. Called once per assembly. */
-	flags(): ProjectAccessFlags;
-}
-
-export interface ProjectAccessInputBuilder {
-	/**
-	 * Build the rule input for any project-scope rule, fetching exactly the
-	 * rows the rule will consult based on `project.visibility`. Other fields
-	 * default to safe values; pass `overrides` for the rare callers that
-	 * already loaded a row (e.g. tests, batched listing pages).
-	 */
-	buildProjectAccessInput(
-		ctx: RequestContext,
-		project: Project,
-		overrides?: Partial<ProjectAccessInput>
-	): Promise<ProjectAccessInput>;
-	/**
-	 * Build a `ProjectAccessInput` from caller-provided rows without any I/O.
-	 * Used by listing pages that have already batch-loaded membership for many
-	 * projects; the per-row predicate calls this instead of
-	 * `buildProjectAccessInput` to avoid an N+1 fetch.
-	 */
-	projectAccessInputFromRows(
-		ctx: RequestContext,
-		project: Project,
-		rows: {
-			member?: ProjectAccessInput['member'];
-			orgMember?: ProjectAccessInput['orgMember'];
-			platformGrants?: ProjectAccessInput['platformGrants'];
-		}
-	): ProjectAccessInput;
-}
-
-export function createProjectAccessInputBuilder(
-	deps: ProjectAccessInputDeps
-): ProjectAccessInputBuilder {
-	return {
-		async buildProjectAccessInput(
-			ctx: RequestContext,
-			project: Project,
-			overrides: Partial<ProjectAccessInput> = {}
-		): Promise<ProjectAccessInput> {
-			const { allowCrossOrgPublic, enablePlatformProjects } = deps.flags();
-
-			let member: ProjectAccessInput['member'] = null;
-			let orgMember: ProjectAccessInput['orgMember'] = null;
-			let platformGrants: ProjectAccessInput['platformGrants'] = [];
-
-			if (project.visibility === 'platform') {
-				// When the flag is off the rule short-circuits before reading grants —
-				// skip the lookup to keep "feature disabled" cheap.
-				if (enablePlatformProjects) {
-					platformGrants = await deps.listPlatformGrants(ctx, project.id);
-				}
-			} else if (project.visibility === 'private') {
-				member = await deps.getProjectMember(ctx, project.id, ctx.userId);
-			} else {
-				const skipOrgMember = project.visibility === 'public' && allowCrossOrgPublic;
-				[member, orgMember] = await Promise.all([
-					deps.getProjectMember(ctx, project.id, ctx.userId),
-					skipOrgMember ? Promise.resolve(null) : deps.getOrgMember(ctx, project.orgId, ctx.userId)
-				]);
-			}
-
-			return {
-				orgPermissions: ctx.orgPermissions,
-				platformPermissions: ctx.platformPermissions,
-				project,
-				member,
-				orgMember,
-				allowCrossOrgPublic,
-				enablePlatformProjects,
-				platformGrants,
-				actingOrgId: ctx.actingOrgId ?? null,
-				userId: ctx.userId,
-				...overrides
-			};
-		},
-
-		projectAccessInputFromRows(
-			ctx: RequestContext,
-			project: Project,
-			rows: {
-				member?: ProjectAccessInput['member'];
-				orgMember?: ProjectAccessInput['orgMember'];
-				platformGrants?: ProjectAccessInput['platformGrants'];
-			}
-		): ProjectAccessInput {
-			const { allowCrossOrgPublic, enablePlatformProjects } = deps.flags();
-			return {
-				orgPermissions: ctx.orgPermissions,
-				platformPermissions: ctx.platformPermissions,
-				project,
-				member: rows.member ?? null,
-				orgMember: rows.orgMember ?? null,
-				allowCrossOrgPublic,
-				enablePlatformProjects,
-				platformGrants: rows.platformGrants ?? [],
-				actingOrgId: ctx.actingOrgId ?? null,
-				userId: ctx.userId
-			};
-		}
-	};
-}

package/src/compute/__tests__/client-cache.test.ts

@@ -1,244 +0,0 @@
-/**
- * Tests for `createClientCache` — the per-server warm-client LRU.
- *
- * `@selvajs/compute`'s `GrasshopperClient.create` does a real network preflight,
- * so we mock the module: `create` records the config it was called with and
- * returns a fake client whose `createScheduler` returns a disposable stub. That
- * lets us assert the cache's own behavior (id-keying, LRU eviction, evict,
- * disposeAll, the `X-Selva-Definition` header) without a live compute server.
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-// --- Mock @selvajs/compute -------------------------------------------------
-const createdConfigs: any[] = [];
-const createdSchedulerOptions: any[] = [];
-const disposedSchedulers: any[] = [];
-
-vi.mock('@selvajs/compute', () => {
-	class GrasshopperClient {
-		static async create(config: any) {
-			createdConfigs.push(config);
-			return new GrasshopperClient(config);
-		}
-		constructor(public config: any) {}
-		createScheduler(options: any) {
-			createdSchedulerOptions.push(options);
-			const scheduler = {
-				disposed: false,
-				dispose() {
-					this.disposed = true;
-					disposedSchedulers.push(this);
-				}
-			};
-			return scheduler;
-		}
-	}
-	return { GrasshopperClient, enableDebugLogging: vi.fn() };
-});
-
-import { createClientCache, serverIdentity } from '../client-cache.js';
-
-function baseConfig() {
-	return {
-		maxSolveDurationMs: 30_000,
-		maxConcurrentSolves: 4,
-		maxQueueDepth: 0,
-		queueWaitMs: 0,
-		cachesolve: true,
-		cacheerroredsolves: false,
-		reuseServerDefinitionCache: true,
-		debug: false,
-		debugVerbose: false
-	};
-}
-
-const server = (id: string, over: Partial<{ serverUrl: string; apiKey: string }> = {}) => ({
-	id,
-	serverUrl: over.serverUrl ?? `http://compute-${id}:6500`,
-	apiKey: over.apiKey ?? `key-${id}`
-});
-
-beforeEach(() => {
-	createdConfigs.length = 0;
-	createdSchedulerOptions.length = 0;
-	disposedSchedulers.length = 0;
-});
-
-describe('createClientCache — keying', () => {
-	it('keys on id: two calls for the same id build one client', async () => {
-		const cache = createClientCache(baseConfig());
-		const a = await cache.getClient(server('s1'));
-		const b = await cache.getClient(server('s1'));
-		expect(a).toBe(b);
-		expect(createdConfigs).toHaveLength(1);
-	});
-
-	it('reuses the entry even when the URL/apiKey rotate under the same id', async () => {
-		// The whole point of ADR 0004 D1: identity is the id, so a rotated URL is
-		// the SAME entry (stale until evicted) — not a new client.
-		const cache = createClientCache(baseConfig());
-		const a = await cache.getClient(server('s1', { serverUrl: 'http://old:6500' }));
-		const b = await cache.getClient(server('s1', { serverUrl: 'http://new:6500' }));
-		expect(a).toBe(b);
-		expect(createdConfigs).toHaveLength(1);
-		// It kept the ORIGINAL connection details — proving eviction is required.
-		expect(createdConfigs[0].serverUrl).toBe('http://old:6500');
-	});
-
-	it('builds distinct clients for distinct ids', async () => {
-		const cache = createClientCache(baseConfig());
-		const a = await cache.getClient(server('s1'));
-		const b = await cache.getClient(server('s2'));
-		expect(a).not.toBe(b);
-		expect(createdConfigs).toHaveLength(2);
-	});
-});
-
-describe('createClientCache — LRU eviction', () => {
-	it('evicts the least-recently-used entry past capacity and disposes its scheduler', async () => {
-		const cache = createClientCache({ ...baseConfig(), maxCachedClients: 2 });
-		const s1 = await cache.getClient(server('s1'));
-		await cache.getClient(server('s2'));
-		// Touch s1 so s2 becomes the LRU.
-		await cache.getClient(server('s1'));
-		await cache.getClient(server('s3')); // over capacity → evict s2
-
-		expect(disposedSchedulers).toHaveLength(1);
-		// s1 still warm (same entry, no rebuild); s2 rebuilt on next access.
-		expect(await cache.getClient(server('s1'))).toBe(s1);
-		expect(createdConfigs.filter((c) => c.serverUrl.includes('s2'))).toHaveLength(1);
-		await cache.getClient(server('s2'));
-		expect(createdConfigs.filter((c) => c.serverUrl.includes('s2'))).toHaveLength(2);
-	});
-});
-
-describe('createClientCache — explicit invalidation', () => {
-	it('evict(id) disposes the scheduler and forces a rebuild (config-write hook)', async () => {
-		const cache = createClientCache(baseConfig());
-		await cache.getClient(server('s1'));
-		cache.evict('s1');
-		expect(disposedSchedulers).toHaveLength(1);
-		await cache.getClient(server('s1'));
-		expect(createdConfigs).toHaveLength(2);
-	});
-
-	it('evict accepts a ServerIdentity', async () => {
-		const cache = createClientCache(baseConfig());
-		await cache.getClient(server('s1'));
-		cache.evict(serverIdentity({ id: 's1' }));
-		expect(disposedSchedulers).toHaveLength(1);
-	});
-
-	it('evict on an unknown id is a no-op', async () => {
-		const cache = createClientCache(baseConfig());
-		await cache.getClient(server('s1'));
-		cache.evict('nope');
-		expect(disposedSchedulers).toHaveLength(0);
-	});
-
-	it('disposeAll disposes every warm scheduler and clears the cache', async () => {
-		const cache = createClientCache(baseConfig());
-		await cache.getClient(server('s1'));
-		await cache.getClient(server('s2'));
-		cache.disposeAll();
-		expect(disposedSchedulers).toHaveLength(2);
-		// Next access rebuilds.
-		await cache.getClient(server('s1'));
-		expect(createdConfigs).toHaveLength(3);
-	});
-});
-
-describe('createClientCache — X-Selva-Definition (ADR 0004 D2)', () => {
-	it('stamps the definition guid on the client headers when provided', async () => {
-		const cache = createClientCache(baseConfig());
-		await cache.getClient(server('s1'), { definitionGuid: 'guid-123' });
-		expect(createdConfigs[0].headers).toEqual({ 'X-Selva-Definition': 'guid-123' });
-	});
-
-	it('omits the header entirely when no guid is given', async () => {
-		const cache = createClientCache(baseConfig());
-		await cache.getClient(server('s1'));
-		expect(createdConfigs[0].headers).toBeUndefined();
-	});
-});
-
-describe('createClientCache — scheduler concurrency (audit B6)', () => {
-	it('forwards maxConcurrentSolves as the scheduler maxConcurrent in queue mode', async () => {
-		const cache = createClientCache({ ...baseConfig(), maxConcurrentSolves: 7 });
-		await cache.getClient(server('s1'));
-		expect(createdSchedulerOptions).toHaveLength(1);
-		// Queue mode with NO maxConcurrent defaults to 1 in the scheduler,
-		// serializing every solve on the server — the option must always be set.
-		expect(createdSchedulerOptions[0].mode).toBe('queue');
-		expect(createdSchedulerOptions[0].maxConcurrent).toBe(7);
-	});
-});
-
-describe('createClientCache — scheduler backpressure (audit B7)', () => {
-	it('forwards non-zero queue bounds to the scheduler', async () => {
-		const cache = createClientCache({ ...baseConfig(), maxQueueDepth: 12, queueWaitMs: 90_000 });
-		await cache.getClient(server('s1'));
-		expect(createdSchedulerOptions[0].maxQueueDepth).toBe(12);
-		expect(createdSchedulerOptions[0].queueWaitMs).toBe(90_000);
-	});
-
-	it('maps a 0 (disabled) queue bound to undefined so the scheduler stays unbounded', async () => {
-		// The scheduler treats undefined as unbounded/no-deadline; passing 0 would
-		// shed EVERY queued solve. Our `0 = off` convention must become undefined.
-		const cache = createClientCache({ ...baseConfig(), maxQueueDepth: 0, queueWaitMs: 0 });
-		await cache.getClient(server('s1'));
-		expect(createdSchedulerOptions[0].maxQueueDepth).toBeUndefined();
-		expect(createdSchedulerOptions[0].queueWaitMs).toBeUndefined();
-	});
-});
-
-describe('createClientCache — per-request telemetry sequence counters', () => {
-	it('onServerTiming bumps rhinoTiming.seq on every write', async () => {
-		const cache = createClientCache(baseConfig());
-		const entry = await cache.getClient(server('s1'));
-		expect(entry.rhinoTiming).toEqual({ last: null, seq: 0 });
-		createdConfigs[0].onServerTiming({ decode: 5, solve: 100, encode: 3 });
-		expect(entry.rhinoTiming.seq).toBe(1);
-		expect(entry.rhinoTiming.last).toEqual({ decode: 5, solve: 100, encode: 3 });
-		createdConfigs[0].onServerTiming({ decode: 1, solve: 2, encode: 3 });
-		expect(entry.rhinoTiming.seq).toBe(2);
-		expect(entry.rhinoTiming.last).toEqual({ decode: 1, solve: 2, encode: 3 });
-	});
-
-	it('onSettle bumps solveMeta.seq on every settle but writes last only on success', async () => {
-		const cache = createClientCache(baseConfig());
-		const entry = await cache.getClient(server('s1'));
-		const onSettle = createdSchedulerOptions[0].onSettle;
-		expect(entry.solveMeta).toEqual({ last: null, seq: 0 });
-
-		onSettle(
-			{ key: 'k' },
-			{
-				status: 'success',
-				fromCache: false,
-				definitionReuploaded: false,
-				durationMs: 10,
-				response: {}
-			}
-		);
-		expect(entry.solveMeta.seq).toBe(1);
-		expect(entry.solveMeta.last).toEqual({ fromCache: false, definitionReuploaded: false });
-
-		// An error settle must still count toward seq (the attribution guard in
-		// the pipeline needs to see ALL concurrent activity) without clobbering last.
-		onSettle({ key: 'k' }, { status: 'error', error: new Error('x'), durationMs: 5 });
-		expect(entry.solveMeta.seq).toBe(2);
-		expect(entry.solveMeta.last).toEqual({ fromCache: false, definitionReuploaded: false });
-
-		onSettle({ key: 'k' }, { status: 'success', fromCache: true, durationMs: 0, response: {} });
-		expect(entry.solveMeta.seq).toBe(3);
-		expect(entry.solveMeta.last).toEqual({ fromCache: true, definitionReuploaded: undefined });
-	});
-});
-
-describe('serverIdentity', () => {
-	it('derives identity from the id', () => {
-		expect(serverIdentity({ id: 'abc' })).toBe('abc');
-	});
-});