@selvajs/supabase-provider 0.14.3 → 0.14.4-beta.1

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

@@ -1,78 +0,0 @@
-import { describe, beforeEach, it } from 'vitest';
-import { runAuthProviderConformance, runEmailLinkAuthConformance } from '@selvajs/platform/testing';
-import { SupabaseAuthProvider } from '../SupabaseAuthProvider.js';
-import { readEnv, resetAllData } from '../../data/__tests__/test-helpers.js';
-
-const envCtx = readEnv();
-
-if (!envCtx) {
-	describe.skip('SupabaseAuthProvider (skipped: no live stack)', () => {
-		it('populate packages/providers/supabase/.env.test with Supabase creds to run these tests', () => {});
-	});
-} else {
-	const ctx = envCtx; // non-null in this branch
-	// The auth conformance suite expects `verifyLogin('', adminPassword)` to
-	// succeed. Supabase requires a non-empty email, so we seed a deterministic
-	// admin email and have the suite use that via the `adminEmail` option.
-	const ADMIN_EMAIL = 'admin@conformance.test';
-	const ADMIN_PASSWORD = 'conformance-admin-password-1234';
-
-	async function ensureAdmin() {
-		const { data: existing } = await ctx.adminClient.auth.admin.listUsers({ perPage: 1000 });
-		const match = existing.users.find((u) => u.email === ADMIN_EMAIL);
-		if (match) return match.id;
-		const { data, error } = await ctx.adminClient.auth.admin.createUser({
-			email: ADMIN_EMAIL,
-			password: ADMIN_PASSWORD,
-			email_confirm: true
-		});
-		if (error) throw error;
-		return data.user.id;
-	}
-
-	async function makeProvider() {
-		const provider = new SupabaseAuthProvider({
-			supabaseUrl: ctx.url,
-			anonKey: ctx.anonKey,
-			serviceRoleKey: ctx.serviceRoleKey
-		});
-		// Ensure the admin account exists + has instance_admin.
-		const id = await ensureAdmin();
-		const { error: upError } = await ctx.adminClient
-			.from('user_profiles')
-			.update({ platform_permissions: ['instance_admin'] })
-			.eq('user_id', id);
-		if (upError) throw upError;
-		return { provider, adminPassword: ADMIN_PASSWORD };
-	}
-
-	describe('SupabaseAuthProvider', () => {
-		beforeEach(async () => {
-			await resetAllData(ctx);
-		});
-
-		runAuthProviderConformance({
-			name: 'SupabaseAuthProvider',
-			createProvider: async () => {
-				const { provider, adminPassword } = await makeProvider();
-				return { provider, adminPassword, adminEmail: ADMIN_EMAIL };
-			},
-			userManagement: true
-		});
-
-		runEmailLinkAuthConformance({
-			name: 'SupabaseEmailLinkAuth',
-			createAdapter: async () => {
-				const { provider } = await makeProvider();
-				return {
-					adapter: provider.emailLink,
-					// `validEmail` isn't used by the suite for live mail delivery;
-					// it just needs to look like a real address. The malformed
-					// case is what we actually assert on.
-					validEmail: 'real-looking@conformance.test',
-					invalidEmail: 'not-an-email-address'
-				};
-			}
-		});
-	});
-}

package/src/auth/index.ts

@@ -1,2 +0,0 @@
-export { SupabaseAuthProvider } from './SupabaseAuthProvider.js';
-export type { SupabaseAuthProviderConfig } from './SupabaseAuthProvider.js';

package/src/cli/sync-migrations.ts

@@ -1,133 +0,0 @@
-#!/usr/bin/env node
-// ============================================================================
-// sync-migrations — copy this package's Supabase migrations into a consuming
-// app's supabase/migrations/ directory.
-//
-// Migrations ship with deterministic timestamp-prefixed filenames
-// (<UTCtimestamp>_selva_<name>.sql) so they slot into a consuming app's own
-// migration timeline without colliding, and so every machine/CI produces a
-// byte-identical migration history. We copy verbatim — no rename at copy time,
-// which is what keeps the history stable.
-//
-// Usage:
-//   npx @selvajs/supabase-provider sync-migrations [--dir <path>] [--force]
-//
-//   --dir <path>   Target migrations dir (default: ./supabase/migrations)
-//   --force        Overwrite files that exist with differing content
-// ============================================================================
-
-import { fileURLToPath } from 'node:url';
-import { dirname, join, resolve } from 'node:path';
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
-
-const here = dirname(fileURLToPath(import.meta.url));
-
-// dist/cli/ -> package root is two levels up; migrations ship alongside src/dist.
-const packageRoot = resolve(here, '..', '..');
-const sourceDir = join(packageRoot, 'supabase', 'migrations');
-
-interface Options {
-	targetDir: string;
-	force: boolean;
-}
-
-function parseArgs(argv: string[]): Options {
-	let targetDir = resolve(process.cwd(), 'supabase', 'migrations');
-	let force = false;
-
-	for (let i = 0; i < argv.length; i++) {
-		const arg = argv[i];
-		if (arg === '--dir') {
-			const value = argv[++i];
-			if (!value) fail('--dir requires a path argument');
-			targetDir = resolve(process.cwd(), value);
-		} else if (arg === '--force') {
-			force = true;
-		} else if (arg === '--help' || arg === '-h') {
-			printHelp();
-			process.exit(0);
-		} else {
-			fail(`unknown argument: ${arg}`);
-		}
-	}
-
-	return { targetDir, force };
-}
-
-function printHelp(): void {
-	console.log(
-		[
-			'sync-migrations — copy @selvajs/supabase-provider migrations into your app.',
-			'',
-			'Usage:',
-			'  npx @selvajs/supabase-provider sync-migrations [--dir <path>] [--force]',
-			'',
-			'  --dir <path>   Target migrations dir (default: ./supabase/migrations)',
-			'  --force        Overwrite files that exist with differing content',
-			'',
-			'After syncing, apply with: npx supabase db push'
-		].join('\n')
-	);
-}
-
-function fail(message: string): never {
-	console.error(`error: ${message}`);
-	process.exit(1);
-}
-
-function main(): void {
-	const { targetDir, force } = parseArgs(process.argv.slice(2));
-
-	if (!existsSync(sourceDir)) {
-		fail(`could not locate packaged migrations at ${sourceDir}`);
-	}
-
-	const files = readdirSync(sourceDir)
-		.filter((name) => name.endsWith('.sql'))
-		.sort();
-
-	if (files.length === 0) {
-		fail(`no .sql migrations found in ${sourceDir}`);
-	}
-
-	mkdirSync(targetDir, { recursive: true });
-
-	let copied = 0;
-	let skipped = 0;
-	let conflicts = 0;
-
-	for (const name of files) {
-		const from = join(sourceDir, name);
-		const to = join(targetDir, name);
-		const contents = readFileSync(from);
-
-		if (existsSync(to)) {
-			const existing = readFileSync(to);
-			if (existing.equals(contents)) {
-				skipped++;
-				continue;
-			}
-			if (!force) {
-				console.warn(
-					`  conflict  ${name} exists with different content (use --force to overwrite)`
-				);
-				conflicts++;
-				continue;
-			}
-		}
-
-		writeFileSync(to, contents);
-		console.log(`  copied    ${name}`);
-		copied++;
-	}
-
-	console.log(`\n${copied} copied, ${skipped} unchanged, ${conflicts} conflict(s) -> ${targetDir}`);
-
-	if (conflicts > 0) {
-		process.exit(1);
-	}
-
-	console.log('\nNext: review the files, then run  npx supabase db push');
-}
-
-main();

package/src/data/SupabaseAuditQuery.ts

@@ -1,103 +0,0 @@
-import type {
-	AuditEventRow,
-	AuditQueryFilters,
-	AuditQueryResult,
-	DomainEvent,
-	IAuditQuery,
-	RequestContext
-} from '@selvajs/platform';
-import type { ClientBundle } from './client.js';
-
-const MAX_LIMIT = 200;
-const DEFAULT_LIMIT = 100;
-
-// Cursor values are interpolated into PostgREST filter strings — both formats
-// must be validated before any string concatenation reaches the query.
-const ISO_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
-const UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
-
-/**
- * Read-side for `audit_events`. Always uses the service-role client — RLS
- * blocks all read access by design, so the route layer is the single trust
- * boundary (callers must gate on `instance_admin`).
- *
- * Pagination is keyset on `(occurred_at desc, id desc)`. The `id` tie-breaker
- * prevents skipped rows when multiple events land in the same millisecond.
- */
-export class SupabaseAuditQuery implements IAuditQuery {
-	constructor(private readonly clients: ClientBundle) {}
-
-	async list(_ctx: RequestContext, filters: AuditQueryFilters): Promise<AuditQueryResult> {
-		const limit = clampLimit(filters.limit);
-
-		let q = this.clients.serviceClient
-			.from('audit_events')
-			.select('id, type, actor_id, occurred_at, data')
-			.order('occurred_at', { ascending: false })
-			.order('id', { ascending: false })
-			// Fetch one extra row to detect "has next page" without a count query.
-			.limit(limit + 1);
-
-		if (filters.types && filters.types.length > 0) {
-			q = q.in('type', [...filters.types]);
-		}
-		if (filters.actorId) {
-			q = q.eq('actor_id', filters.actorId);
-		}
-		if (filters.sinceIso) {
-			q = q.gte('occurred_at', filters.sinceIso);
-		}
-		if (filters.untilIso) {
-			q = q.lte('occurred_at', filters.untilIso);
-		}
-		if (filters.cursor) {
-			// `(occurred_at, id) < (cursorTs, cursorId)` expressed for PostgREST:
-			// strictly older OR same timestamp with a strictly smaller id.
-			//
-			// Both values are interpolated into a `.or()` filter string. Validate
-			// shape before interpolation — without these guards a malformed cursor
-			// (or a hand-crafted URL by a route caller) could break out of the
-			// filter and combine with arbitrary PostgREST operators.
-			const ts = filters.cursor.occurredAt;
-			const id = filters.cursor.id;
-			if (!ISO_RE.test(ts) || !UUID_RE.test(id)) {
-				throw new Error('audit_events query: malformed cursor');
-			}
-			q = q.or(`occurred_at.lt.${ts},and(occurred_at.eq.${ts},id.lt.${id})`);
-		}
-
-		const { data, error } = await q;
-		if (error) {
-			throw new Error(`audit_events query failed: ${error.message}`);
-		}
-
-		const fetched = (data ?? []) as Array<{
-			id: string;
-			type: string;
-			actor_id: string;
-			occurred_at: string;
-			data: DomainEvent;
-		}>;
-
-		const hasMore = fetched.length > limit;
-		const page = hasMore ? fetched.slice(0, limit) : fetched;
-		const last = page[page.length - 1];
-
-		return {
-			rows: page.map((r) => ({
-				id: r.id,
-				type: r.type as DomainEvent['type'],
-				actorId: r.actor_id,
-				occurredAt: r.occurred_at,
-				data: r.data
-			})) satisfies AuditEventRow[],
-			nextCursor: hasMore && last ? { occurredAt: last.occurred_at, id: last.id } : null
-		};
-	}
-}
-
-function clampLimit(requested: number | undefined): number {
-	if (!requested || requested <= 0) return DEFAULT_LIMIT;
-	if (requested > MAX_LIMIT) return MAX_LIMIT;
-	return Math.floor(requested);
-}

package/src/data/SupabaseComputeServerStore.ts

@@ -1,262 +0,0 @@
-import {
-	isOrgServer,
-	isPlatformServer,
-	type IComputeServerStore,
-	type ComputeConfig,
-	type ComputeServerConfig,
-	type RequestContext
-} from '@selvajs/platform';
-import { ProviderError } from '@selvajs/platform';
-import type { ClientBundle } from './client.js';
-
-/**
- * Compute-server config backed by three tables:
- *   - `compute_servers`: one row per server. `scope = 'platform' | 'org'`.
- *     Platform rows carry a `shared_with_all` flag + `compute_server_shares`
- *     allowlist; org rows carry `owner_org_id`.
- *   - `compute_server_shares`: many-to-many for platform servers shared
- *     with specific orgs (when `shared_with_all = false`).
- *   - `compute_server_org_defaults`: per-org `orgDefaults[orgId]` choice.
- *   - `compute_server_platform_default`: single-row sentinel for the global
- *     `defaultServerId`.
- *
- * `getConfig` returns the full doc; the visibility predicate is applied by
- * callers (resolver, page loaders) using helpers in `@selvajs/platform`.
- */
-export class SupabaseComputeServerStore implements IComputeServerStore {
-	constructor(private readonly clients: ClientBundle) {}
-
-	async getConfig(ctx: RequestContext): Promise<ComputeConfig> {
-		const client = this.clients.forRequest(ctx);
-
-		const [serversRes, sharesRes, orgDefRes, platDefRes] = await Promise.all([
-			client.from('compute_servers').select('*'),
-			client.from('compute_server_shares').select('*'),
-			client.from('compute_server_org_defaults').select('*'),
-			client
-				.from('compute_server_platform_default')
-				.select('default_server_id')
-				.eq('singleton', true)
-				.maybeSingle()
-		]);
-
-		if (serversRes.error) throw mapError(serversRes.error);
-		if (sharesRes.error) throw mapError(sharesRes.error);
-		if (orgDefRes.error) throw mapError(orgDefRes.error);
-		if (platDefRes.error) throw mapError(platDefRes.error);
-
-		// Build per-server `sharedWith` allowlists from the join table.
-		const sharedByServer = new Map<string, string[]>();
-		for (const row of sharesRes.data ?? []) {
-			const list = sharedByServer.get(row.server_id) ?? [];
-			list.push(row.org_id);
-			sharedByServer.set(row.server_id, list);
-		}
-
-		const servers = (serversRes.data ?? []).map((row) => rowToServer(row, sharedByServer));
-
-		const orgDefaults: Record<string, string> = {};
-		for (const row of orgDefRes.data ?? []) {
-			if (row.default_server_id) orgDefaults[row.org_id] = row.default_server_id;
-		}
-
-		return {
-			servers,
-			defaultServerId: platDefRes.data?.default_server_id ?? undefined,
-			orgDefaults
-		};
-	}
-
-	async savePlatformServers(
-		ctx: RequestContext,
-		servers: ComputeServerConfig[],
-		defaultServerId: string | undefined
-	): Promise<void> {
-		const client = this.clients.forRequest(ctx);
-		const platformOnly = servers.filter(isPlatformServer);
-
-		// Replace-all of platform rows.
-		const { error: delErr } = await client.from('compute_servers').delete().eq('scope', 'platform');
-		if (delErr) throw mapError(delErr);
-
-		if (platformOnly.length > 0) {
-			const { error: insErr } = await client
-				.from('compute_servers')
-				.insert(platformOnly.map(serverToRow));
-			if (insErr) throw mapError(insErr);
-
-			// Rebuild the share rows for any non-`all` platform servers.
-			const shareRows = platformOnly.flatMap((s) =>
-				s.sharedWith === 'all'
-					? []
-					: s.sharedWith.map((orgId) => ({ server_id: s.id, org_id: orgId }))
-			);
-			if (shareRows.length > 0) {
-				const { error: shErr } = await client.from('compute_server_shares').insert(shareRows);
-				if (shErr) throw mapError(shErr);
-			}
-		}
-
-		const { error: defErr } = await client
-			.from('compute_server_platform_default')
-			.update({ default_server_id: defaultServerId ?? null })
-			.eq('singleton', true);
-		if (defErr) throw mapError(defErr);
-	}
-
-	async saveOrgServers(
-		ctx: RequestContext,
-		orgId: string,
-		servers: ComputeServerConfig[],
-		defaultServerId?: string | null
-	): Promise<void> {
-		const client = this.clients.forRequest(ctx);
-		const orgOnly = servers.filter(isOrgServer).map((s) => ({ ...s, ownerOrgId: orgId }));
-
-		const { error: delErr } = await client
-			.from('compute_servers')
-			.delete()
-			.eq('scope', 'org')
-			.eq('owner_org_id', orgId);
-		if (delErr) throw mapError(delErr);
-
-		if (orgOnly.length > 0) {
-			const { error: insErr } = await client
-				.from('compute_servers')
-				.insert(orgOnly.map(serverToRow));
-			if (insErr) throw mapError(insErr);
-		}
-
-		if (defaultServerId === null) {
-			const { error } = await client
-				.from('compute_server_org_defaults')
-				.delete()
-				.eq('org_id', orgId);
-			if (error) throw mapError(error);
-		} else if (typeof defaultServerId === 'string') {
-			const { error } = await client
-				.from('compute_server_org_defaults')
-				.upsert({ org_id: orgId, default_server_id: defaultServerId });
-			if (error) throw mapError(error);
-		}
-	}
-
-	async setOrgDefault(ctx: RequestContext, orgId: string, serverId: string | null): Promise<void> {
-		const client = this.clients.forRequest(ctx);
-		if (serverId === null) {
-			const { error } = await client
-				.from('compute_server_org_defaults')
-				.delete()
-				.eq('org_id', orgId);
-			if (error) throw mapError(error);
-			return;
-		}
-		const { error } = await client
-			.from('compute_server_org_defaults')
-			.upsert({ org_id: orgId, default_server_id: serverId });
-		if (error) throw mapError(error);
-	}
-
-	async deleteByOrg(ctx: RequestContext, orgId: string): Promise<void> {
-		const client = this.clients.forRequest(ctx);
-
-		// orgDefaults entry — FK on org_id cascades from orgs(id), but org
-		// soft-delete doesn't trigger the cascade, so do it explicitly.
-		const { error: defErr } = await client
-			.from('compute_server_org_defaults')
-			.delete()
-			.eq('org_id', orgId);
-		if (defErr) throw mapError(defErr);
-
-		// Org-private servers owned by this org.
-		const { error: srvErr } = await client
-			.from('compute_servers')
-			.delete()
-			.eq('scope', 'org')
-			.eq('owner_org_id', orgId);
-		if (srvErr) throw mapError(srvErr);
-
-		// Strip this org from any platform server share allowlist.
-		const { error: shErr } = await client
-			.from('compute_server_shares')
-			.delete()
-			.eq('org_id', orgId);
-		if (shErr) throw mapError(shErr);
-	}
-}
-
-interface ServerRow {
-	id: string;
-	scope: 'platform' | 'org';
-	owner_org_id: string | null;
-	shared_with_all: boolean;
-	label: string;
-	server_url: string;
-	api_key: string | null;
-	timeout_ms: number | null;
-	retry_count: number | null;
-}
-
-function rowToServer(row: ServerRow, sharedByServer: Map<string, string[]>): ComputeServerConfig {
-	const common = {
-		id: row.id,
-		label: row.label,
-		serverUrl: row.server_url,
-		apiKey: row.api_key ?? undefined,
-		timeoutMs: row.timeout_ms ?? undefined,
-		retryCount: row.retry_count ?? undefined
-	};
-	if (row.scope === 'platform') {
-		return {
-			...common,
-			scope: 'platform',
-			sharedWith: row.shared_with_all ? 'all' : (sharedByServer.get(row.id) ?? [])
-		};
-	}
-	if (!row.owner_org_id) {
-		throw new Error(`compute_servers row ${row.id} has scope='org' but null owner_org_id`);
-	}
-	return { ...common, scope: 'org', ownerOrgId: row.owner_org_id };
-}
-
-function serverToRow(s: ComputeServerConfig): ServerRow {
-	const base = {
-		id: s.id,
-		label: s.label,
-		server_url: s.serverUrl,
-		api_key: s.apiKey ?? null,
-		timeout_ms: s.timeoutMs ?? null,
-		retry_count: s.retryCount ?? null
-	};
-	if (isPlatformServer(s)) {
-		return {
-			...base,
-			scope: 'platform',
-			owner_org_id: null,
-			shared_with_all: s.sharedWith === 'all'
-		};
-	}
-	return {
-		...base,
-		scope: 'org',
-		owner_org_id: s.ownerOrgId,
-		shared_with_all: false
-	};
-}
-
-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));
-}