@selvajs/platform 0.14.2 → 0.15.0-beta.1

package/src/testing/suites/eventSinkSuite.ts

@@ -1,379 +0,0 @@
-/**
- * Adapter conformance suite for the event-sink contract (Permissions spec §9).
- *
- * Verifies that each provider's stores emit the expected `DomainEvent` shape
- * after the corresponding mutation succeeds, and that emit happens AFTER the
- * write (so a failed write does not emit). Both reference providers run the
- * same suite — drift between Local and Supabase emission shape gets caught
- * immediately.
- *
- * Local stays on `NoopEventSink`; Supabase wires `SupabaseEventSink` so events
- * persist to `public.audit_events`. The suite guarantees the seam exists and
- * the shape is consistent so future webhook / audit / analytics consumers can
- * plug in by swapping the sink.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import type {
-	IDataProvider,
-	DomainEvent,
-	IEventSink,
-	Organization,
-	Project,
-	OrgMember,
-	DefinitionRecord,
-	DefinitionVersion,
-	ShareLink,
-	RequestContext
-} from '../../index.js';
-import { ALL_ORG_PERMISSIONS, ALL_PLATFORM_PERMISSIONS } from '../../index.js';
-import { makeUuid } from './helpers.js';
-
-/** Records every event for assertion. Resets per test via `clear()`. */
-export class RecordingEventSink implements IEventSink {
-	readonly events: DomainEvent[] = [];
-
-	async emit(event: DomainEvent): Promise<void> {
-		this.events.push(event);
-	}
-
-	clear(): void {
-		this.events.length = 0;
-	}
-
-	last(): DomainEvent | undefined {
-		return this.events[this.events.length - 1];
-	}
-
-	ofType<T extends DomainEvent['type']>(type: T): Extract<DomainEvent, { type: T }>[] {
-		return this.events.filter((e): e is Extract<DomainEvent, { type: T }> => e.type === type);
-	}
-}
-
-export interface EventSinkConformanceOptions {
-	name: string;
-	/**
-	 * Build a fresh data provider wired to the given sink. Adapters that need
-	 * to seed FK-related state (Supabase: `auth.users` rows) do it here.
-	 */
-	createProvider: (sink: RecordingEventSink) => Promise<IDataProvider> | IDataProvider;
-	/**
-	 * The actor user id that mutations will be performed as. The suite needs
-	 * this to be a real id in the adapter's auth backend (Supabase has FK).
-	 * Local can return any uuid.
-	 *
-	 * `sessionToken` is required for adapters with DB-side auth (Supabase RLS)
-	 * so the per-test `ctx` runs as that authenticated user. Local can omit.
-	 */
-	createActorId: () => Promise<{ userId: string; sessionToken?: string }>;
-	/**
-	 * Optional hook for cleaning up after the test (delete tempdir, truncate
-	 * Supabase tables, etc.). Called once at the end of each test.
-	 */
-	cleanup?: () => Promise<void> | void;
-}
-
-export function runEventSinkConformance(opts: EventSinkConformanceOptions): void {
-	const { name, createProvider, createActorId, cleanup } = opts;
-
-	describe(`IEventSink conformance: ${name}`, () => {
-		let sink: RecordingEventSink;
-		let provider: IDataProvider;
-		let actorId: string;
-		let ctx: RequestContext;
-
-		beforeEach(async () => {
-			sink = new RecordingEventSink();
-			provider = await createProvider(sink);
-			const seeded = await createActorId();
-			actorId = seeded.userId;
-			ctx = {
-				userId: actorId,
-				platformPermissions: [...ALL_PLATFORM_PERMISSIONS],
-				orgPermissions: [...ALL_ORG_PERMISSIONS],
-				adapterContext: seeded.sessionToken ? { sessionToken: seeded.sessionToken } : undefined
-			};
-		});
-
-		// Clean up after each test if the adapter supplies a hook. Always
-		// registered (calling an undefined cleanup is the no-op path).
-		afterEach(async () => {
-			if (cleanup) await cleanup();
-		});
-
-		it('createOrg emits org.created', async () => {
-			const orgId = makeUuid();
-			await provider.orgs.createOrg(ctx, makeOrg({ id: orgId, ownerId: actorId }));
-
-			const created = sink.ofType('org.created');
-			expect(created).toHaveLength(1);
-			expect(created[0]).toMatchObject({ orgId, actorId });
-		});
-
-		it('deleteOrg emits org.deleted', async () => {
-			const orgId = makeUuid();
-			await provider.orgs.createOrg(ctx, makeOrg({ id: orgId, ownerId: actorId }));
-			sink.clear();
-
-			await provider.orgs.deleteOrg(ctx, orgId);
-
-			expect(sink.ofType('org.deleted')).toMatchObject([{ orgId, actorId }]);
-		});
-
-		it('addOrgMember emits org_member.added', async () => {
-			const orgId = makeUuid();
-			const { userId: newMemberId } = await createActorId();
-			await provider.orgs.createOrg(ctx, makeOrg({ id: orgId, ownerId: actorId }));
-			sink.clear();
-
-			await provider.orgs.addOrgMember(ctx, makeOrgMember({ orgId, userId: newMemberId }));
-
-			expect(sink.ofType('org_member.added')).toMatchObject([
-				{ orgId, userId: newMemberId, actorId }
-			]);
-		});
-
-		it('removeOrgMember emits org_member.removed', async () => {
-			const orgId = makeUuid();
-			const { userId: newMemberId } = await createActorId();
-			await provider.orgs.createOrg(ctx, makeOrg({ id: orgId, ownerId: actorId }));
-			await provider.orgs.addOrgMember(ctx, makeOrgMember({ orgId, userId: newMemberId }));
-			sink.clear();
-
-			await provider.orgs.removeOrgMember(ctx, orgId, newMemberId);
-
-			expect(sink.ofType('org_member.removed')).toMatchObject([
-				{ orgId, userId: newMemberId, actorId }
-			]);
-		});
-
-		it('createProject emits project.created with the parent orgId', async () => {
-			const orgId = makeUuid();
-			const projectId = makeUuid();
-			await provider.orgs.createOrg(ctx, makeOrg({ id: orgId, ownerId: actorId }));
-			sink.clear();
-
-			await provider.projects.createProject(
-				ctx,
-				makeProject({ id: projectId, orgId, ownerId: actorId })
-			);
-
-			expect(sink.ofType('project.created')).toMatchObject([{ projectId, orgId, actorId }]);
-		});
-
-		it('deleteProject emits project.deleted', async () => {
-			const orgId = makeUuid();
-			const projectId = makeUuid();
-			await provider.orgs.createOrg(ctx, makeOrg({ id: orgId, ownerId: actorId }));
-			await provider.projects.createProject(
-				ctx,
-				makeProject({ id: projectId, orgId, ownerId: actorId })
-			);
-			sink.clear();
-
-			await provider.projects.deleteProject(ctx, projectId);
-
-			expect(sink.ofType('project.deleted')).toMatchObject([{ projectId, actorId }]);
-		});
-
-		it('createDefinition + setLiveVersion emit created + published', async () => {
-			const orgId = makeUuid();
-			const projectId = makeUuid();
-			const definitionId = makeUuid();
-			const versionId = makeUuid();
-
-			await provider.orgs.createOrg(ctx, makeOrg({ id: orgId, ownerId: actorId }));
-			await provider.projects.createProject(
-				ctx,
-				makeProject({ id: projectId, orgId, ownerId: actorId })
-			);
-			sink.clear();
-
-			await provider.definitions.create(
-				ctx,
-				makeDefinition({ guid: definitionId, projectId, ownerId: actorId })
-			);
-			await provider.definitions.createVersion(
-				ctx,
-				makeVersion({ id: versionId, definitionId, uploadedBy: actorId })
-			);
-			await provider.definitions.setLiveVersion(ctx, definitionId, versionId);
-
-			expect(sink.ofType('definition.created')).toMatchObject([
-				{ definitionId, projectId, actorId }
-			]);
-			expect(sink.ofType('definition_version.created')).toMatchObject([
-				{ versionId, definitionId, actorId }
-			]);
-			expect(sink.ofType('definition.published')).toMatchObject([
-				{ definitionId, versionId, actorId }
-			]);
-		});
-
-		it('share-link create + revoke emit minted + revoked', async () => {
-			const orgId = makeUuid();
-			const projectId = makeUuid();
-			const definitionId = makeUuid();
-			const linkId = makeUuid();
-
-			await provider.orgs.createOrg(ctx, makeOrg({ id: orgId, ownerId: actorId }));
-			await provider.projects.createProject(
-				ctx,
-				makeProject({ id: projectId, orgId, ownerId: actorId })
-			);
-			await provider.definitions.create(
-				ctx,
-				makeDefinition({ guid: definitionId, projectId, ownerId: actorId })
-			);
-			sink.clear();
-
-			await provider.shareLinks.create(
-				ctx,
-				makeShareLink({ id: linkId, definitionId, createdBy: actorId })
-			);
-			await provider.shareLinks.revoke(ctx, linkId);
-
-			expect(sink.ofType('share_link.minted')).toMatchObject([{ linkId, definitionId, actorId }]);
-			expect(sink.ofType('share_link.revoked')).toMatchObject([{ linkId, actorId }]);
-		});
-
-		it('failed write does not emit', async () => {
-			const orgId = makeUuid();
-			await provider.orgs.createOrg(ctx, makeOrg({ id: orgId, ownerId: actorId }));
-			sink.clear();
-			// Duplicate-id create must throw and must not emit.
-			await expect(
-				provider.orgs.createOrg(ctx, makeOrg({ id: orgId, ownerId: actorId }))
-			).rejects.toThrow();
-			expect(sink.ofType('org.created')).toHaveLength(0);
-		});
-
-		it('system-context mutations emit with actorId="system"', async () => {
-			const sysCtx: RequestContext = {
-				userId: '',
-				platformPermissions: [...ALL_PLATFORM_PERMISSIONS],
-				orgPermissions: [...ALL_ORG_PERMISSIONS],
-				system: true
-			};
-			const orgId = makeUuid();
-			await provider.orgs.createOrg(sysCtx, makeOrg({ id: orgId, ownerId: actorId }));
-
-			const created = sink.ofType('org.created');
-			expect(created).toHaveLength(1);
-			expect(created[0].actorId).toBe('system');
-		});
-	});
-}
-
-// ============================================================================
-// Test data helpers
-// ============================================================================
-function nowIso(): string {
-	return new Date().toISOString();
-}
-
-function makeOrg(overrides: { id: string; ownerId: string }): Organization {
-	const now = nowIso();
-	return {
-		id: overrides.id,
-		name: `Org ${overrides.id.slice(0, 6)}`,
-		slug: `org-${overrides.id.slice(0, 8)}`,
-		ownerId: overrides.ownerId,
-		createdBy: overrides.ownerId,
-		updatedBy: overrides.ownerId,
-		createdAt: now,
-		updatedAt: now,
-		deletedAt: null
-	};
-}
-
-function makeOrgMember(overrides: { orgId: string; userId: string }): OrgMember {
-	const now = nowIso();
-	return {
-		orgId: overrides.orgId,
-		userId: overrides.userId,
-		role: 'member',
-		permissions: [],
-		joinedAt: now,
-		updatedAt: now,
-		updatedBy: overrides.userId,
-		deletedAt: null
-	};
-}
-
-function makeProject(overrides: { id: string; orgId: string; ownerId: string }): Project {
-	const now = nowIso();
-	return {
-		id: overrides.id,
-		orgId: overrides.orgId,
-		name: `Project ${overrides.id.slice(0, 6)}`,
-		slug: `proj-${overrides.id.slice(0, 8)}`,
-		visibility: 'private',
-		autoJoinOnUpload: false,
-		ownerId: overrides.ownerId,
-		createdBy: overrides.ownerId,
-		updatedBy: overrides.ownerId,
-		createdAt: now,
-		updatedAt: now,
-		deletedAt: null
-	};
-}
-
-function makeDefinition(overrides: {
-	guid: string;
-	projectId: string;
-	ownerId: string;
-}): DefinitionRecord {
-	const now = nowIso();
-	return {
-		guid: overrides.guid,
-		projectId: overrides.projectId,
-		ownerId: overrides.ownerId,
-		createdBy: overrides.ownerId,
-		updatedBy: overrides.ownerId,
-		displayName: `Def ${overrides.guid.slice(0, 6)}`,
-		status: 'published',
-		solveCount: 0,
-		liveVersionId: null,
-		draftVersionId: null,
-		createdAt: now,
-		updatedAt: now,
-		deletedAt: null
-	};
-}
-
-function makeVersion(overrides: {
-	id: string;
-	definitionId: string;
-	uploadedBy: string;
-}): DefinitionVersion {
-	return {
-		id: overrides.id,
-		definitionId: overrides.definitionId,
-		versionNumber: 1,
-		fileExt: 'gh',
-		fileKey: `defs/${overrides.definitionId}/v/${overrides.id}/file.gh`,
-		uploadedBy: overrides.uploadedBy,
-		uploadedAt: nowIso()
-	};
-}
-
-function makeShareLink(overrides: {
-	id: string;
-	definitionId: string;
-	createdBy: string;
-}): ShareLink {
-	return {
-		id: overrides.id,
-		definitionId: overrides.definitionId,
-		channel: 'live',
-		tokenHash: `hash-${overrides.id}`,
-		createdBy: overrides.createdBy,
-		createdAt: nowIso(),
-		expiresAt: null,
-		revokedAt: null,
-		allowSolve: true,
-		maxSolves: null,
-		solveCount: 0
-	};
-}

package/src/testing/suites/helpers.ts

@@ -1,87 +0,0 @@
-import type { RequestContext } from '../../context.js';
-import { ALL_ORG_PERMISSIONS } from '../../organizations/schemas.js';
-
-/**
- * Build a test `RequestContext`. Defaults to a platform admin to keep existing
- * suites permissive; tests that verify permission gating should pass explicit
- * platform/org permission arrays.
- *
- * `sessionToken`, when supplied, is stuffed into `adapterContext.sessionToken`
- * so adapters that enforce auth at the DB layer (Supabase RLS) can run the
- * call as a real authenticated user. Local providers ignore it.
- */
-export function makeCtx(
-	userId: string,
-	opts: {
-		actingOrgId?: string;
-		platformPermissions?: RequestContext['platformPermissions'];
-		orgPermissions?: RequestContext['orgPermissions'];
-		sessionToken?: string;
-	} = {}
-): RequestContext {
-	return {
-		userId,
-		actingOrgId: opts.actingOrgId,
-		platformPermissions: opts.platformPermissions ?? ['instance_admin'],
-		orgPermissions: opts.orgPermissions ?? [...ALL_ORG_PERMISSIONS],
-		adapterContext: opts.sessionToken ? { sessionToken: opts.sessionToken } : undefined
-	};
-}
-
-export function makeUuid(): string {
-	return crypto.randomUUID();
-}
-
-/**
- * Optional hook adapters pass when their backend enforces referential
- * integrity on user ids (e.g. Supabase `auth.users`). Returns the id the
- * adapter actually stored AND, optionally, a session token the suite can
- * thread back into `makeCtx({ sessionToken })` so the resulting calls run
- * as that user.
- *
- * Adapters without user FKs (local JSON) return the suggested id as-is and
- * omit the token. Adapters with auth (Supabase) ignore the suggested id,
- * create a fresh user, sign in as them, and return the real id + access JWT.
- *
- * The conformance suite calls this to get a usable id *before* constructing
- * any record that references a user. It never assumes the suggested id is
- * the one used.
- */
-export type SeedUserResult = { userId: string; sessionToken?: string };
-export type SeedUserFn = (suggestedId: string) => Promise<SeedUserResult>;
-
-/** Default no-op for adapters that don't need to seed users. Echoes the id back, no token. */
-export const noopSeedUser: SeedUserFn = async (id) => ({ userId: id });
-
-/**
- * Wraps a `SeedUserFn` so suites can keep their existing `seed() → userId` and
- * `ctx(userId)` shape while transparently threading session tokens for adapters
- * that return them. Build one per test (Map is mutable & local).
- */
-export function makeSeedHelpers(seedUser: SeedUserFn) {
-	const tokens = new Map<string, string>();
-
-	async function seed(): Promise<string> {
-		const result = await seedUser(makeUuid());
-		if (result.sessionToken) tokens.set(result.userId, result.sessionToken);
-		return result.userId;
-	}
-
-	/** Register a token for a user that wasn't created via `seed()` (e.g. one returned by `createStore`). */
-	function registerToken(userId: string, sessionToken: string): void {
-		tokens.set(userId, sessionToken);
-	}
-
-	function ctx(
-		userId: string,
-		opts: {
-			actingOrgId?: string;
-			platformPermissions?: RequestContext['platformPermissions'];
-			orgPermissions?: RequestContext['orgPermissions'];
-		} = {}
-	): RequestContext {
-		return makeCtx(userId, { ...opts, sessionToken: tokens.get(userId) });
-	}
-
-	return { seed, ctx, registerToken, tokens };
-}

package/src/testing/suites/inviteStoreSuite.ts

@@ -1,143 +0,0 @@
-/**
- * Adapter conformance suite for IInviteStore.
- *
- * Invites are the handoff between "admin wants to add Alice" and "Alice has
- * an account + an org membership". The contract is small but there are a few
- * state-machine rules adapters must honor:
- *
- * - `getByTokenHash` returns null for missing, expired, or already-consumed
- *   invites. The store sees only HMAC digests; the route layer hashes raw
- *   tokens before lookup.
- * - `markAccepted` is idempotent (no-op if already accepted).
- * - `revoke` removes pending invites but must not un-consume accepted ones.
- */
-
-import { describe, it, expect } from 'vitest';
-import type { IInviteStore } from '../../invites/interface.js';
-import type { Invite } from '../../invites/types.js';
-import { SYSTEM_CONTEXT } from '../../context.js';
-import { makeSeedHelpers, makeUuid, noopSeedUser, type SeedUserFn } from './helpers.js';
-
-export interface InviteTestScope {
-	/** User that creates invites. Must be seeded + have `manage_org_members` in the org. */
-	adminId: string;
-	/**
-	 * Optional access token for `adminId`. Required for adapters with DB-side
-	 * auth (Supabase RLS); local providers ignore it.
-	 */
-	adminSessionToken?: string;
-	/** Org invites are issued for. Must be seeded with the admin as a member. */
-	orgId: string;
-}
-
-export interface InviteStoreConformanceOptions {
-	name: string;
-	createStore: () => Promise<IInviteStore> | IInviteStore;
-	createScope?: () => Promise<InviteTestScope> | InviteTestScope;
-	seedUser?: SeedUserFn;
-}
-
-function invite(scope: InviteTestScope, overrides: Partial<Invite> = {}): Invite {
-	const now = new Date();
-	return {
-		id: overrides.id ?? makeUuid(),
-		// Conformance treats `tokenHash` as opaque — the suite stores whatever
-		// the adapter receives and looks it up by the same value. The route
-		// layer is the one that mints raw tokens and HMACs them; the store
-		// contract is "lookup by stored digest".
-		tokenHash:
-			overrides.tokenHash ?? `hash-${makeUuid()}-${Math.random().toString(36).slice(2, 8)}`,
-		email: overrides.email ?? `invitee-${Math.random().toString(36).slice(2, 6)}@test.local`,
-		orgId: overrides.orgId ?? scope.orgId,
-		orgRole: overrides.orgRole ?? 'member',
-		orgPermissions: overrides.orgPermissions ?? [],
-		invitedBy: overrides.invitedBy ?? scope.adminId,
-		createdAt: overrides.createdAt ?? now.toISOString(),
-		expiresAt: overrides.expiresAt ?? new Date(now.getTime() + 24 * 60 * 60 * 1000).toISOString(),
-		acceptedAt: overrides.acceptedAt,
-		acceptedByUserId: overrides.acceptedByUserId
-	};
-}
-
-const DEFAULT_SCOPE: InviteTestScope = {
-	adminId: 'admin-1',
-	orgId: 'org-1'
-};
-
-export function runInviteStoreConformance(opts: InviteStoreConformanceOptions): void {
-	const { name, createStore, createScope, seedUser = noopSeedUser } = opts;
-	const { ctx, registerToken } = makeSeedHelpers(seedUser);
-	const scopeFor = async (): Promise<InviteTestScope> => {
-		const s = createScope ? await createScope() : DEFAULT_SCOPE;
-		if (s.adminSessionToken) registerToken(s.adminId, s.adminSessionToken);
-		return s;
-	};
-
-	describe(`IInviteStore conformance: ${name}`, () => {
-		it('create + getByTokenHash round-trips', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const inv = invite(scope);
-			await store.create(ctx(scope.adminId), inv);
-			const got = await store.getByTokenHash(SYSTEM_CONTEXT, inv.tokenHash);
-			expect(got?.id).toBe(inv.id);
-			expect(got?.email).toBe(inv.email);
-		});
-
-		it('getByTokenHash returns null for unknown hash', async () => {
-			const store = await createStore();
-			const got = await store.getByTokenHash(SYSTEM_CONTEXT, 'nope-' + makeUuid());
-			expect(got).toBeNull();
-		});
-
-		it('getByTokenHash returns null for expired invite', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const inv = invite(scope, {
-				expiresAt: new Date(Date.now() - 60_000).toISOString()
-			});
-			await store.create(ctx(scope.adminId), inv);
-			const got = await store.getByTokenHash(SYSTEM_CONTEXT, inv.tokenHash);
-			expect(got).toBeNull();
-		});
-
-		it('markAccepted sets acceptedAt + acceptedByUserId; getByTokenHash then returns null', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const { userId: acceptor } = await seedUser(makeUuid());
-			const inv = invite(scope);
-			await store.create(ctx(scope.adminId), inv);
-			await store.markAccepted(SYSTEM_CONTEXT, inv.id, acceptor);
-			const got = await store.getByTokenHash(SYSTEM_CONTEXT, inv.tokenHash);
-			expect(got).toBeNull();
-		});
-
-		it('markAccepted is idempotent (second call is a no-op)', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const { userId: acceptor } = await seedUser(makeUuid());
-			const inv = invite(scope);
-			await store.create(ctx(scope.adminId), inv);
-			await store.markAccepted(SYSTEM_CONTEXT, inv.id, acceptor);
-			await store.markAccepted(SYSTEM_CONTEXT, inv.id, acceptor);
-		});
-
-		it('listByOrg returns invites for the org', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			for (let i = 0; i < 3; i++) await store.create(ctx(scope.adminId), invite(scope));
-			const page = await store.listByOrg(ctx(scope.adminId), scope.orgId, { limit: 100 });
-			expect(page.items.length).toBeGreaterThanOrEqual(3);
-		});
-
-		it('revoke removes a pending invite', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const inv = invite(scope);
-			await store.create(ctx(scope.adminId), inv);
-			await store.revoke(ctx(scope.adminId), inv.id);
-			const got = await store.getByTokenHash(SYSTEM_CONTEXT, inv.tokenHash);
-			expect(got).toBeNull();
-		});
-	});
-}