@selvajs/local-provider 0.11.0

package/src/userProfile/LocalUserProfileProvider.ts

@@ -0,0 +1,135 @@
+import * as path from 'node:path';
+import type {
+	IUserProfileStore,
+	RecentRun,
+	RequestContext,
+	UserManagementResult,
+	UserProfile
+} from '@selvajs/platform';
+import { ProviderError, hasPermission } from '@selvajs/platform';
+import {
+	createLocalUserDataStore,
+	type LocalUserDataStore,
+	type StoredUserData
+} from '../data/userData.js';
+
+function toProfile(u: StoredUserData): UserProfile {
+	return {
+		userId: u.userId,
+		displayName: u.displayName,
+		starredDefinitions: u.starredDefinitions ?? [],
+		recentRuns: u.recentRuns ?? []
+	};
+}
+
+/**
+ * Filesystem-backed user-profile store. Reads and writes `user-data.json`,
+ * shared with `LocalPlatformPermissionStore`. Identity (email, password
+ * hash) lives separately on the auth provider — this store keys exclusively
+ * by user ID.
+ *
+ * `IDataProvider.ensureUser` (called from `hooks.server.ts`) seeds an empty
+ * row for every authed user, mirroring Supabase's `handle_new_auth_user`
+ * trigger.
+ */
+export class LocalUserProfileProvider implements IUserProfileStore {
+	private readonly data: LocalUserDataStore;
+
+	constructor(userDataFilePath: string) {
+		this.data = createLocalUserDataStore(userDataFilePath);
+	}
+
+	static fromEnv(env: Record<string, string | undefined>): LocalUserProfileProvider {
+		if (!env.DATA_PATH) throw new Error('Missing required env var: DATA_PATH');
+		return new LocalUserProfileProvider(path.join(env.DATA_PATH, 'user-data.json'));
+	}
+
+	async getProfile(ctx: RequestContext, userId: string): Promise<UserProfile | null> {
+		assertCanAccess(ctx, userId);
+		const u = await this.data.findById(userId);
+		return u ? toProfile(u) : null;
+	}
+
+	async getProfiles(_ctx: RequestContext, userIds: readonly string[]): Promise<UserProfile[]> {
+		// Batch read is read-only and used for display name lookups across the UI;
+		// scoping to a single user defeats the purpose. Adapters with stricter
+		// requirements should override.
+		const all = await this.data.listAll();
+		const wanted = new Set(userIds);
+		return all.filter((u) => wanted.has(u.userId)).map(toProfile);
+	}
+
+	async updateProfile(
+		ctx: RequestContext,
+		userId: string,
+		patch: { displayName?: string }
+	): Promise<UserManagementResult> {
+		assertCanAccess(ctx, userId);
+		try {
+			if (patch.displayName !== undefined) {
+				await this.data.updateDisplayName(userId, patch.displayName);
+			}
+			return 'ok';
+		} catch (err) {
+			if (err instanceof ProviderError && err.statusCode === 404) return 'not_found';
+			throw err;
+		}
+	}
+
+	async starDefinition(
+		ctx: RequestContext,
+		userId: string,
+		definitionId: string
+	): Promise<UserManagementResult> {
+		assertCanAccess(ctx, userId);
+		try {
+			await this.data.starDefinition(userId, definitionId);
+			return 'ok';
+		} catch (err) {
+			if (err instanceof ProviderError && err.statusCode === 404) return 'not_found';
+			throw err;
+		}
+	}
+
+	async unstarDefinition(
+		ctx: RequestContext,
+		userId: string,
+		definitionId: string
+	): Promise<UserManagementResult> {
+		assertCanAccess(ctx, userId);
+		try {
+			await this.data.unstarDefinition(userId, definitionId);
+			return 'ok';
+		} catch (err) {
+			if (err instanceof ProviderError && err.statusCode === 404) return 'not_found';
+			throw err;
+		}
+	}
+
+	async recordRun(
+		ctx: RequestContext,
+		userId: string,
+		run: RecentRun
+	): Promise<UserManagementResult> {
+		assertCanAccess(ctx, userId);
+		try {
+			await this.data.recordRun(userId, run);
+			return 'ok';
+		} catch (err) {
+			if (err instanceof ProviderError && err.statusCode === 404) return 'not_found';
+			throw err;
+		}
+	}
+}
+
+/**
+ * Profile reads/writes are scoped to the user themselves. `instance_admin`
+ * bypasses for admin tooling. `system: true` (background jobs, signup
+ * auto-seed) also passes — those flows have already authorized.
+ */
+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);
+}

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

@@ -0,0 +1,43 @@
+import { describe, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { runUserProfileStoreConformance } from '@selvajs/platform/testing';
+import { LocalAuthProvider } from '../../auth/LocalAuthProvider.js';
+import { LocalUserProfileProvider } from '../LocalUserProfileProvider.js';
+import { createLocalUserDataStore } from '../../data/userData.js';
+
+describe('LocalUserProfileProvider', () => {
+	let tempDir: string;
+
+	beforeEach(async () => {
+		tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'selva-userprofile-test-'));
+	});
+
+	afterEach(async () => {
+		await fs.rm(tempDir, { recursive: true, force: true });
+	});
+
+	runUserProfileStoreConformance({
+		name: 'LocalUserProfileProvider',
+		createStore: async () => {
+			const auth = new LocalAuthProvider({
+				hmacSecret: 'test-secret',
+				usersFilePath: path.join(tempDir, 'auth-users.json')
+			});
+			const userDataPath = path.join(tempDir, 'user-data.json');
+			const userData = createLocalUserDataStore(userDataPath);
+			const store = new LocalUserProfileProvider(userDataPath);
+			return {
+				store,
+				seedUser: async (email: string) => {
+					// Real user creation: auth-users row + user-data row, mirroring
+					// what `hooks.server.ts` does in production via `ensureUser`.
+					const user = await auth.passwordAuth.createUserWithPassword(email, 'pw');
+					await userData.ensure(user.id);
+					return user;
+				}
+			};
+		}
+	});
+});

package/src/userProfile/index.ts

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