@selvajs/supabase-provider 0.11.0

package/src/userProfile/SupabaseUserProfileProvider.ts

@@ -0,0 +1,177 @@
+import type {
+	IUserProfileStore,
+	RecentRun,
+	RequestContext,
+	UserManagementResult,
+	UserProfile
+} from '@selvajs/platform';
+import { ProviderError, hasPermission } from '@selvajs/platform';
+import type { ClientBundle } from '../data/client.js';
+
+/**
+ * User profile backed by `public.user_profiles` (one row per `auth.users.id`).
+ * The row is auto-seeded by the `handle_new_auth_user` trigger on signup, so
+ * the store never inserts — only reads/updates.
+ *
+ * Uses the service-role client throughout (RLS on `user_profiles` is
+ * coarse-grained — server-side flows like the hooks.server.ts profile load
+ * need access regardless of the caller's identity). The `assertCanAccess`
+ * check enforces "you can only see/modify your own profile" at the app layer
+ * to match the `IUserProfileStore` contract.
+ */
+const MAX_RECENT_RUNS = 20;
+
+export class SupabaseUserProfileProvider implements IUserProfileStore {
+	constructor(private readonly clients: ClientBundle) {}
+
+	private client() {
+		return this.clients.serviceClient;
+	}
+
+	async getProfile(ctx: RequestContext, userId: string): Promise<UserProfile | null> {
+		assertCanAccess(ctx, userId);
+		const { data, error } = await this.client()
+			.from('user_profiles')
+			.select('user_id, display_name, starred_definitions, recent_runs')
+			.eq('user_id', userId)
+			.maybeSingle();
+		if (error) throw mapError(error);
+		return data ? rowToProfile(data) : null;
+	}
+
+	async getProfiles(_ctx: RequestContext, userIds: readonly string[]): Promise<UserProfile[]> {
+		// Batch read serves display-name lookups across the UI; scoping to one
+		// user defeats the purpose. No assertCanAccess.
+		if (userIds.length === 0) return [];
+		const { data, error } = await this.client()
+			.from('user_profiles')
+			.select('user_id, display_name, starred_definitions, recent_runs')
+			.in('user_id', [...userIds]);
+		if (error) throw mapError(error);
+		return (data ?? []).map(rowToProfile);
+	}
+
+	async updateProfile(
+		ctx: RequestContext,
+		userId: string,
+		patch: { displayName?: string }
+	): Promise<UserManagementResult> {
+		assertCanAccess(ctx, userId);
+		const row: Record<string, unknown> = {};
+		if (patch.displayName !== undefined) row.display_name = patch.displayName;
+		if (Object.keys(row).length === 0) return 'ok';
+
+		const { data, error } = await this.client()
+			.from('user_profiles')
+			.update(row)
+			.eq('user_id', userId)
+			.select('user_id');
+		if (error) throw mapError(error);
+		return data && data.length > 0 ? 'ok' : 'not_found';
+	}
+
+	async starDefinition(
+		ctx: RequestContext,
+		userId: string,
+		definitionId: string
+	): Promise<UserManagementResult> {
+		assertCanAccess(ctx, userId);
+		// Read-modify-write is fine for the local scale here; if concurrent
+		// starring ever becomes a hotspot, a SECURITY DEFINER RPC using
+		// `array_append` + `array_distinct` closes the race.
+		const existing = await this.getProfile(ctx, userId);
+		if (!existing) return 'not_found';
+		if (existing.starredDefinitions.includes(definitionId)) return 'ok';
+
+		const next = [...existing.starredDefinitions, definitionId];
+		const { data, error } = await this.client()
+			.from('user_profiles')
+			.update({ starred_definitions: next })
+			.eq('user_id', userId)
+			.select('user_id');
+		if (error) throw mapError(error);
+		return data && data.length > 0 ? 'ok' : 'not_found';
+	}
+
+	async unstarDefinition(
+		ctx: RequestContext,
+		userId: string,
+		definitionId: string
+	): Promise<UserManagementResult> {
+		assertCanAccess(ctx, userId);
+		const existing = await this.getProfile(ctx, userId);
+		if (!existing) return 'not_found';
+		if (!existing.starredDefinitions.includes(definitionId)) return 'ok';
+
+		const next = existing.starredDefinitions.filter((id) => id !== definitionId);
+		const { data, error } = await this.client()
+			.from('user_profiles')
+			.update({ starred_definitions: next })
+			.eq('user_id', userId)
+			.select('user_id');
+		if (error) throw mapError(error);
+		return data && data.length > 0 ? 'ok' : 'not_found';
+	}
+
+	async recordRun(
+		ctx: RequestContext,
+		userId: string,
+		run: RecentRun
+	): Promise<UserManagementResult> {
+		assertCanAccess(ctx, userId);
+		const existing = await this.getProfile(ctx, userId);
+		if (!existing) return 'not_found';
+
+		// Prepend newest, de-dupe by definitionId, cap at MAX_RECENT_RUNS.
+		const filtered = existing.recentRuns.filter((r) => r.definitionId !== run.definitionId);
+		const next = [run, ...filtered].slice(0, MAX_RECENT_RUNS);
+
+		const { data, error } = await this.client()
+			.from('user_profiles')
+			.update({ recent_runs: next })
+			.eq('user_id', userId)
+			.select('user_id');
+		if (error) throw mapError(error);
+		return data && data.length > 0 ? 'ok' : 'not_found';
+	}
+}
+
+function assertCanAccess(ctx: RequestContext, userId: string): void {
+	if (ctx.system) return;
+	if (ctx.userId === userId) return;
+	if (hasPermission(ctx, 'instance_admin')) return;
+	throw new ProviderError('Forbidden: cannot access another user’s profile', 403);
+}
+
+interface ProfileRow {
+	user_id: string;
+	display_name: string | null;
+	starred_definitions: string[] | null;
+	recent_runs: RecentRun[] | null;
+}
+
+function rowToProfile(row: ProfileRow): UserProfile {
+	return {
+		userId: row.user_id,
+		displayName: row.display_name ?? undefined,
+		starredDefinitions: row.starred_definitions ?? [],
+		recentRuns: row.recent_runs ?? []
+	};
+}
+
+interface PostgrestError {
+	code?: string;
+	message?: string;
+}
+
+function mapError(e: unknown): Error {
+	const pg = e as PostgrestError;
+	if (pg?.code === '23505') return new ProviderError(pg.message ?? 'Duplicate record', 409);
+	if (pg?.code === '23503') return new ProviderError(pg.message ?? 'Foreign key violation', 409);
+	if (e instanceof Error) return e;
+	if (e && typeof e === 'object') {
+		const obj = e as { message?: string; code?: string };
+		return new Error(obj.code ? `[${obj.code}] ${obj.message ?? ''}` : (obj.message ?? String(e)));
+	}
+	return new Error(String(e));
+}

package/src/userProfile/__tests__/conformance.test.ts

@@ -0,0 +1,39 @@
+import { describe, beforeEach, it } from 'vitest';
+import { runUserProfileStoreConformance } from '@selvajs/platform/testing';
+import type { AuthUser } from '@selvajs/platform';
+import { SupabaseUserProfileProvider } from '../SupabaseUserProfileProvider.js';
+import { readEnv, resetAllData } from '../../data/__tests__/test-helpers.js';
+
+const envCtx = readEnv();
+
+if (!envCtx) {
+	describe.skip('SupabaseUserProfileProvider (skipped: no live stack)', () => {
+		it('populate packages/providers/supabase/.env.test with Supabase creds to run these tests', () => {});
+	});
+} else {
+	describe('SupabaseUserProfileProvider', () => {
+		beforeEach(async () => {
+			await resetAllData(envCtx);
+		});
+
+		runUserProfileStoreConformance({
+			name: 'SupabaseUserProfileProvider',
+			createStore: async () => {
+				const store = new SupabaseUserProfileProvider(envCtx.bundle);
+				const seedUser = async (email: string): Promise<AuthUser> => {
+					const { data, error } = await envCtx.adminClient.auth.admin.createUser({
+						email,
+						password: 'conformance-test-password-1234',
+						email_confirm: true
+					});
+					if (error) throw error;
+					return {
+						id: data.user.id,
+						email: data.user.email
+					};
+				};
+				return { store, seedUser };
+			}
+		});
+	});
+}

package/src/userProfile/index.ts

@@ -0,0 +1 @@
+export { SupabaseUserProfileProvider } from './SupabaseUserProfileProvider.js';

package/supabase/.branches/_current_branch

@@ -0,0 +1 @@
+main

package/supabase/.temp/cli-latest

@@ -0,0 +1 @@
+v2.95.4

package/supabase/config.toml

@@ -0,0 +1,68 @@
+# Supabase local stack for @selvajs/supabase-provider.
+# Run from the package root: `npx supabase start` (Docker Desktop required).
+# The output prints SUPABASE_URL, SUPABASE_ANON_KEY, and SUPABASE_SERVICE_ROLE_KEY
+# — copy those into `.env.test` for the conformance tests.
+
+project_id = "selva-supabase-provider"
+
+[api]
+enabled = true
+port = 54321
+# Exposed REST schemas. `public` is where all Selva tables live; `storage`
+# stays private (only the storage-js client reaches it via the dedicated path).
+schemas = ["public", "graphql_public"]
+extra_search_path = ["public", "extensions"]
+max_rows = 1000
+
+[db]
+port = 54322
+shadow_port = 54320
+major_version = 15
+
+[db.pooler]
+enabled = false
+
+[db.seed]
+enabled = true
+sql_paths = ["./seed.sql"]
+
+[studio]
+enabled = true
+port = 54323
+
+[inbucket]
+enabled = true
+port = 54324
+
+[storage]
+enabled = true
+file_size_limit = "50MiB"
+
+[auth]
+enabled = true
+site_url = "http://127.0.0.1:54321"
+additional_redirect_urls = ["http://127.0.0.1:5173"]
+jwt_expiry = 3600
+enable_signup = true
+enable_anonymous_sign_ins = false
+enable_manual_linking = false
+minimum_password_length = 8
+
+[auth.email]
+enable_signup = true
+double_confirm_changes = false
+enable_confirmations = false
+secure_password_change = false
+max_frequency = "1s"
+
+[auth.sms]
+enable_signup = false
+enable_confirmations = false
+
+[edge_runtime]
+enabled = false
+
+[analytics]
+enabled = false
+
+[experimental]