@selvajs/supabase-provider 0.14.4-beta.0 → 0.15.0-beta.2

package/src/data/__tests__/solve-metric-sink-conformance.test.ts

@@ -1,59 +0,0 @@
-import { describe, beforeEach, it } from 'vitest';
-import { runSolveMetricSinkConformance, type RecordedSolveMetric } from '@selvajs/platform/testing';
-import { SupabaseSolveMetricSink } from '../SupabaseSolveMetricSink.js';
-import { buildClientBundle } from '../client.js';
-import { readEnv, resetAllData } from './test-helpers.js';
-
-const envCtx = readEnv();
-
-if (!envCtx) {
-	describe.skip('SupabaseSolveMetricSink (skipped: no live stack)', () => {
-		it('populate packages/providers/supabase/.env.test with Supabase creds to run these tests', () => {});
-	});
-} else {
-	const ctx = envCtx;
-	describe('SupabaseSolveMetricSink', () => {
-		beforeEach(async () => {
-			await resetAllData(ctx);
-		});
-
-		runSolveMetricSinkConformance({
-			name: 'SupabaseSolveMetricSink',
-			createSink: () => new SupabaseSolveMetricSink(ctx.bundle),
-			readRows: async () => {
-				const { data, error } = await ctx.adminClient
-					.from('solve_metrics')
-					.select(
-						'actor_id, definition_url, definition_id, version_id, channel, org_id, duration_ms, ok, failure_kind, error_count, warning_count'
-					)
-					.order('occurred_at', { ascending: true });
-				if (error) throw new Error(`solve_metrics read failed: ${error.message}`);
-				return (data ?? []).map(
-					(r): RecordedSolveMetric => ({
-						actorId: r.actor_id,
-						definitionUrl: r.definition_url,
-						definitionId: r.definition_id,
-						versionId: r.version_id,
-						channel: r.channel,
-						orgId: r.org_id,
-						durationMs: r.duration_ms,
-						ok: r.ok,
-						failureKind: r.failure_kind,
-						errorCount: r.error_count,
-						warningCount: r.warning_count
-					})
-				);
-			},
-			// Point the sink at a bundle whose service key is bogus, so the insert
-			// fails. record() must still resolve (contract: never throw).
-			createFailingSink: () =>
-				new SupabaseSolveMetricSink(
-					buildClientBundle({
-						supabaseUrl: ctx.url,
-						anonKey: ctx.anonKey,
-						serviceRoleKey: 'invalid-service-role-key'
-					})
-				)
-		});
-	});
-}

package/src/data/__tests__/test-helpers.ts

@@ -1,188 +0,0 @@
-/**
- * Shared test helpers for Supabase data conformance tests.
- *
- * Every suite starts with a fully wiped DB so tests are isolated. We use the
- * service-role client for both — seeding users in `auth.users` and wiping
- * every relevant table.
- */
-
-import { createClient } from '@supabase/supabase-js';
-import { buildClientBundle, type ClientBundle, type SelvaSchemaClient } from '../client.js';
-
-export interface TestContext {
-	url: string;
-	anonKey: string;
-	serviceRoleKey: string;
-	adminClient: SelvaSchemaClient;
-	bundle: ClientBundle;
-}
-
-export function readEnv(): TestContext | null {
-	const url = process.env.SUPABASE_URL;
-	const anonKey = process.env.SUPABASE_ANON_KEY;
-	const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
-	if (!url || !anonKey || !serviceRoleKey) return null;
-	// `.env.test` is checked in with local-Supabase defaults so contributors can
-	// `npx supabase start` and run the suite. But `createClient` transitively
-	// loads `@supabase/realtime-js`, which on Node < 22 throws at construction
-	// without a native WebSocket. Swallow that so the suite cleanly skips
-	// instead of crashing test collection.
-	let adminClient: SelvaSchemaClient;
-	try {
-		adminClient = createClient(url, serviceRoleKey, {
-			db: { schema: 'selva' },
-			auth: { persistSession: false, autoRefreshToken: false }
-		});
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		if (msg.includes('WebSocket')) return null;
-		throw err;
-	}
-	const bundle = buildClientBundle({ supabaseUrl: url, anonKey, serviceRoleKey });
-	return { url, anonKey, serviceRoleKey, adminClient, bundle };
-}
-
-/**
- * Reset every data table this adapter owns. Leaves Supabase-managed tables
- * (`auth.users`, etc.) alone except via `deleteAllAuthUsers` below.
- *
- * Order-sensitive because some FKs don't cascade: we go bottom up from
- * dependents to parents.
- */
-export async function resetAllData(ctx: TestContext): Promise<void> {
-	await truncate(ctx, 'solve_metrics');
-	await truncate(ctx, 'share_links');
-	await truncate(ctx, 'invites');
-	// Versions FK to definitions ON DELETE CASCADE, but `definitions` can't
-	// be wiped while live/draft pointers reference versions (ON DELETE
-	// RESTRICT, spec §6). Null the pointers, drop versions, then drop defs.
-	await ctx.adminClient
-		.from('definitions')
-		.update({ live_version_id: null, draft_version_id: null })
-		.not('guid', 'is', null);
-	await truncate(ctx, 'definition_versions');
-	await truncate(ctx, 'definitions');
-	await truncate(ctx, 'project_members');
-	// compute defaults have a platform_default sibling — reset all three.
-	await truncate(ctx, 'compute_server_org_defaults');
-	await truncate(ctx, 'compute_server_shares');
-	await resetComputePlatformDefault(ctx);
-	await truncate(ctx, 'compute_servers');
-	await truncate(ctx, 'org_members');
-	await truncate(ctx, 'orgs');
-	await truncate(ctx, 'user_profiles');
-	await deleteAllAuthUsers(ctx);
-}
-
-async function resetComputePlatformDefault(ctx: TestContext): Promise<void> {
-	// Singleton row — clear `default_server_id` rather than deleting.
-	const { error } = await ctx.adminClient
-		.from('compute_server_platform_default')
-		.update({ default_server_id: null })
-		.eq('singleton', true);
-	if (error) throw error;
-}
-
-async function truncate(ctx: TestContext, table: string): Promise<void> {
-	const { error } = await ctx.adminClient
-		.from(table)
-		.delete()
-		.neq(columnForDeleteAll(table), '00000000-0000-0000-0000-000000000000');
-	if (error) throw error;
-}
-
-function columnForDeleteAll(table: string): string {
-	if (table === 'org_members') return 'user_id';
-	if (table === 'project_members') return 'user_id';
-	if (table === 'user_profiles') return 'user_id';
-	if (table === 'definitions') return 'guid';
-	if (table === 'definition_versions') return 'id';
-	if (table === 'compute_server_org_defaults') return 'org_id';
-	if (table === 'compute_server_shares') return 'server_id';
-	return 'id';
-}
-
-async function deleteAllAuthUsers(ctx: TestContext): Promise<void> {
-	const { data, error } = await ctx.adminClient.auth.admin.listUsers({ perPage: 1000 });
-	if (error) throw error;
-	for (const user of data.users) {
-		const { error: delError } = await ctx.adminClient.auth.admin.deleteUser(user.id);
-		if (delError) throw delError;
-	}
-}
-
-/**
- * Seed an `auth.users` row, mark the user as `instance_admin`, sign in, and
- * return the real id + access token. `auth.admin.createUser` doesn't accept a
- * caller-supplied id — Supabase generates one. The conformance suite calls us
- * with a *suggested* id (for adapters that honor it); we ignore it and return
- * GoTrue's real id.
- *
- * The instance_admin grant is what makes RLS open up for the conformance
- * tests: every policy in the schema accepts `is_instance_admin()` as a
- * universal pass, mirroring the `instance_admin` default in `makeCtx`.
- *
- * The session token is what makes RLS *see* the user at all. Without it, the
- * Supabase client falls back to the anon role and every write fails.
- */
-export async function seedUser(
-	ctx: TestContext,
-	suggestedId: string
-): Promise<{ userId: string; sessionToken: string }> {
-	return seedUserCore(ctx, suggestedId, { promoteToInstanceAdmin: true });
-}
-
-/**
- * Variant of `seedUser` that leaves `platform_permissions` empty. Use this
- * when a test specifically asserts on a fresh user's permission state (e.g.
- * the platform-permission store conformance suite).
- */
-export async function seedPlainUser(
-	ctx: TestContext,
-	suggestedId: string
-): Promise<{ userId: string; sessionToken: string }> {
-	return seedUserCore(ctx, suggestedId, { promoteToInstanceAdmin: false });
-}
-
-async function seedUserCore(
-	ctx: TestContext,
-	_suggestedId: string,
-	opts: { promoteToInstanceAdmin: boolean }
-): Promise<{ userId: string; sessionToken: string }> {
-	// Unique email per seed so repeated calls don't collide. GoTrue requires
-	// an email even for password-less users.
-	const email = `conformance-${crypto.randomUUID()}@conformance.test`;
-	const password = 'conformance-test-password-1234';
-	const { data, error } = await ctx.adminClient.auth.admin.createUser({
-		email,
-		password,
-		email_confirm: true
-	});
-	if (error) throw error;
-	const userId = data.user.id;
-
-	if (opts.promoteToInstanceAdmin) {
-		// Trigger auto-created the user_profiles row; promote to instance_admin
-		// so every RLS policy treats this user as fully authorized. Mirrors the
-		// `instance_admin` default in `makeCtx`.
-		const { error: promoteError } = await ctx.adminClient
-			.from('user_profiles')
-			.update({ platform_permissions: ['instance_admin'] })
-			.eq('user_id', userId);
-		if (promoteError) throw promoteError;
-	}
-
-	// Sign in to get an access token. The conformance suite stuffs this into
-	// `adapterContext.sessionToken` and our client.ts uses it to scope the
-	// request to this user instead of falling back to anon.
-	const signInClient = createClient(ctx.url, ctx.anonKey, {
-		auth: { persistSession: false, autoRefreshToken: false }
-	});
-	const { data: session, error: signInError } = await signInClient.auth.signInWithPassword({
-		email,
-		password
-	});
-	if (signInError) throw signInError;
-	if (!session.session) throw new Error('seedUser: signInWithPassword returned no session');
-	return { userId, sessionToken: session.session.access_token };
-}

package/src/data/client.ts

@@ -1,173 +0,0 @@
-import { createClient, type SupabaseClient } from '@supabase/supabase-js';
-import type { RequestContext } from '@selvajs/platform';
-
-/**
- * All engine tables live in the `selva` schema (not `public`) so a consuming
- * app keeps `public` for its own tables. Every data client targets `selva` via
- * `db: { schema: 'selva' }`, which the supabase-js type system surfaces as the
- * client's schema generic — hence this alias rather than the bare default
- * `SupabaseClient` (which is pinned to `'public'`).
- */
-export type SelvaSchemaClient = SupabaseClient<any, 'public', 'selva'>;
-
-/** Default schema every engine store targets. */
-export const DEFAULT_SCHEMA = 'selva' as const;
-
-/**
- * A client pinned to a caller-chosen schema. When the schema is `'selva'` this
- * is the narrow `SelvaSchemaClient`; for an app-owned schema (e.g. `'public'`)
- * the schema generic is opaque — the store surface (`.from` / `.rpc`) is the
- * same either way.
- */
-export type SchemaClient = SupabaseClient<any, string, any>;
-
-export interface ForRequestOptions {
-	/**
-	 * Postgres schema this client targets. Defaults to `'selva'` (the engine's
-	 * tables). Pass `'public'` (or another app schema) to build stores on the
-	 * consuming app's own tables while keeping the same fail-closed RLS
-	 * dispatch as the engine stores.
-	 */
-	schema?: string;
-}
-
-/**
- * Build a Supabase client for a given `RequestContext`.
- *
- * Three modes — fail-closed:
- *  - **Service-role** ONLY when `ctx.system === true`. Bypasses RLS. Used for
- *    admin paths, janitors, bootstrap, and any explicitly-trusted server
- *    flow. The system flag must never be derived from a user session.
- *  - **User-scoped** when `ctx.adapterContext.sessionToken` is a JWT: runs
- *    under `authenticated` role with `auth.uid()` from the token. RLS
- *    policies enforce per-user visibility.
- *  - **Anonymous** otherwise: runs under the `anon` role. RLS is active and
- *    will scope reads/writes accordingly. This is the safety net — any code
- *    that constructs a context without forwarding the session token AND
- *    without setting `system: true` is treated as untrusted.
- *
- * Previous versions fell back to service-role when the session token was
- * absent — a fail-OPEN footgun: any synthetic ctx (e.g. share-token resolve)
- * silently bypassed RLS. The current contract is explicit: opt into
- * service-role with `system: true`, or you get RLS.
- *
- * Per-request WeakMap caching keeps a single client alive for the lifetime
- * of a RequestContext — multiple store calls in one HTTP handler share one
- * fetch connection without leaking auth across requests.
- */
-export interface ClientBundle {
-	/** Long-lived service-role client, pinned to the `'selva'` schema. Bypasses RLS. */
-	serviceClient: SelvaSchemaClient;
-	/**
-	 * Produce (or reuse) a client scoped to this request's identity, targeting
-	 * `opts.schema` (default `'selva'`).
-	 *  - `ctx.system === true` → service-role (RLS bypassed).
-	 *  - `ctx.adapterContext.sessionToken` set → user-scoped (RLS active).
-	 *  - neither → anon client (RLS active, no `auth.uid()`).
-	 *
-	 * The schema pin and the RLS dispatch travel together: an app building
-	 * stores on its own `'public'` tables gets the same fail-closed behavior as
-	 * engine stores, just aimed at a different schema.
-	 */
-	forRequest(ctx: RequestContext, opts?: ForRequestOptions): SchemaClient;
-}
-
-export interface BuildClientOptions {
-	supabaseUrl: string;
-	anonKey: string;
-	serviceRoleKey: string;
-}
-
-export function buildClientBundle(opts: BuildClientOptions): ClientBundle {
-	// Long-lived service-role + anon clients, one per schema. Both are stateless
-	// w.r.t. request identity, so a single instance is safe to share across all
-	// requests targeting the same schema.
-	const serviceBySchema = new Map<string, SchemaClient>();
-	const anonBySchema = new Map<string, SchemaClient>();
-
-	function serviceFor(schema: string): SchemaClient {
-		let client = serviceBySchema.get(schema);
-		if (!client) {
-			client = createClient(opts.supabaseUrl, opts.serviceRoleKey, {
-				db: { schema },
-				auth: { persistSession: false, autoRefreshToken: false }
-			});
-			serviceBySchema.set(schema, client);
-		}
-		return client;
-	}
-
-	function anonFor(schema: string): SchemaClient {
-		let client = anonBySchema.get(schema);
-		if (!client) {
-			client = createClient(opts.supabaseUrl, opts.anonKey, {
-				db: { schema },
-				auth: { persistSession: false, autoRefreshToken: false }
-			});
-			anonBySchema.set(schema, client);
-		}
-		return client;
-	}
-
-	// The `'selva'`-pinned service client is exposed directly on the bundle for
-	// engine code that reaches for RLS-bypassing reads without a request context.
-	const serviceClient = serviceFor(DEFAULT_SCHEMA) as SelvaSchemaClient;
-
-	// Per-request user-scoped clients, keyed first by context then by schema so
-	// a handler that touches both `'selva'` and an app schema reuses one client
-	// per (request, schema) without leaking auth across requests.
-	const perRequestCache = new WeakMap<RequestContext, Map<string, SchemaClient>>();
-
-	return {
-		serviceClient,
-		forRequest(ctx: RequestContext, forOpts?: ForRequestOptions): SchemaClient {
-			const schema = forOpts?.schema ?? DEFAULT_SCHEMA;
-			if (ctx.system) return serviceFor(schema);
-
-			const token = extractSessionToken(ctx.adapterContext);
-			if (!token) return anonFor(schema);
-
-			let bySchema = perRequestCache.get(ctx);
-			if (!bySchema) {
-				bySchema = new Map();
-				perRequestCache.set(ctx, bySchema);
-			}
-			const cached = bySchema.get(schema);
-			if (cached) return cached;
-
-			const client = createClient(opts.supabaseUrl, opts.anonKey, {
-				db: { schema },
-				auth: { persistSession: false, autoRefreshToken: false },
-				global: {
-					headers: { Authorization: `Bearer ${token}` }
-				}
-			});
-			bySchema.set(schema, client);
-			return client;
-		}
-	};
-}
-
-/**
- * Build a `ClientBundle` straight from environment variables — the
- * `SUPABASE_URL` / `SUPABASE_ANON_KEY` / `SUPABASE_SERVICE_ROLE_KEY` triple,
- * nothing else. Deliberately does NOT require `SELVA_AT_REST_KEY`: that key
- * only matters for compute-server secret encryption, which a consuming app
- * building its own `'public'` stores never touches. `SupabaseDataProvider.fromEnv`
- * layers the at-rest-key requirement on top of this.
- */
-export function clientBundleFromEnv(env: Record<string, string | undefined>): ClientBundle {
-	const supabaseUrl = env.SUPABASE_URL;
-	const anonKey = env.SUPABASE_ANON_KEY;
-	const serviceRoleKey = env.SUPABASE_SERVICE_ROLE_KEY;
-	if (!supabaseUrl) throw new Error('Missing required env var: SUPABASE_URL');
-	if (!anonKey) throw new Error('Missing required env var: SUPABASE_ANON_KEY');
-	if (!serviceRoleKey) throw new Error('Missing required env var: SUPABASE_SERVICE_ROLE_KEY');
-	return buildClientBundle({ supabaseUrl, anonKey, serviceRoleKey });
-}
-
-function extractSessionToken(adapterContext: unknown): string | undefined {
-	if (!adapterContext || typeof adapterContext !== 'object') return undefined;
-	const maybe = (adapterContext as { sessionToken?: unknown }).sessionToken;
-	return typeof maybe === 'string' && maybe.length > 0 ? maybe : undefined;
-}

package/src/data/errors.ts

@@ -1,45 +0,0 @@
-import { ProviderError } from '@selvajs/platform';
-
-/**
- * Canonical PostgREST/Postgres error translation shared by every Supabase
- * store. Replaces the six near-identical private `mapError` copies that had
- * drifted into two variants (a "full" one preserving `details`/`hint`, and a
- * slimmer message-only one) and none of which handled `PGRST116`.
- *
- * Mapping:
- *  - `PGRST116` (single-row selector matched zero rows) → 404. PostgREST
- *    raises this when `.single()` finds nothing; treating it as "not found"
- *    is almost always what a store's caller wants.
- *  - `23505` (unique violation) / `23503` (foreign-key violation) → 409.
- *  - Anything else → a plain `Error` (500 downstream via `api-errors`), with
- *    `details`/`hint`/`code` preserved on the error object for logs.
- */
-
-/** The subset of a `PostgrestError` this mapper inspects. */
-interface PostgrestErrorShape {
-	code?: string;
-	message?: string;
-	details?: string;
-	hint?: string;
-}
-
-export function mapPostgrestError(e: unknown): Error {
-	const pg = e as PostgrestErrorShape;
-	switch (pg?.code) {
-		case 'PGRST116':
-			return new ProviderError(pg.message ?? 'Not found', 404);
-		case '23505':
-			return new ProviderError(pg.message ?? 'Duplicate record', 409);
-		case '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 PostgrestErrorShape;
-		const msg = obj.message ?? obj.details ?? obj.hint ?? 'Unknown Postgres error';
-		const err = new Error(obj.code ? `[${obj.code}] ${msg}` : msg);
-		Object.assign(err, obj);
-		return err;
-	}
-	return new Error(String(e));
-}

package/src/data/index.ts

@@ -1,29 +0,0 @@
-export { SupabaseOrgStore } from './SupabaseOrgStore.js';
-export { SupabaseProjectStore } from './SupabaseProjectStore.js';
-export { SupabaseDefinitionStore } from './SupabaseDefinitionStore.js';
-export { SupabaseInviteStore } from './SupabaseInviteStore.js';
-export { SupabaseComputeServerStore } from './SupabaseComputeServerStore.js';
-export { SupabaseShareLinkStore } from './SupabaseShareLinkStore.js';
-export { SupabaseDataProvider } from './SupabaseDataProvider.js';
-export { SupabaseEventSink } from './SupabaseEventSink.js';
-export { SupabaseSolveMetricSink } from './SupabaseSolveMetricSink.js';
-export { SupabaseAuditQuery } from './SupabaseAuditQuery.js';
-export { buildClientBundle, clientBundleFromEnv, DEFAULT_SCHEMA } from './client.js';
-export type {
-	ClientBundle,
-	BuildClientOptions,
-	ForRequestOptions,
-	SchemaClient,
-	SelvaSchemaClient
-} from './client.js';
-export { mapPostgrestError } from './errors.js';
-export { stampUpdate, stampSoftDelete } from './rowStamp.js';
-export { notDeleted } from './query.js';
-export {
-	toRange,
-	orderColumn,
-	nextCursorFromRange,
-	encodeCursor,
-	decodeCursor
-} from './pagination.js';
-export type { RangeSpec } from './pagination.js';

package/src/data/pagination.ts

@@ -1,68 +0,0 @@
-/**
- * Pagination helpers shared across Supabase stores.
- *
- * The platform contract specifies cursor pagination (`ListOptions.cursor`).
- * Because Supabase/Postgres has no built-in opaque cursor format, we encode
- * an offset as the cursor — simple, correct for stable sorts, and good
- * enough for the volumes Selva deals with (admin/definition lists are
- * bounded; nothing is infinite scroll over millions of rows).
- *
- * Keyset pagination would be faster at scale if it ever matters.
- */
-
-import { DEFAULT_PAGE_LIMIT, MAX_PAGE_LIMIT } from '@selvajs/platform';
-import type { ListOptions } from '@selvajs/platform';
-
-export interface RangeSpec {
-	from: number;
-	to: number;
-	limit: number;
-}
-
-/** Decode an opaque cursor string. Returns 0 for missing/invalid cursors. */
-export function decodeCursor(cursor: string | undefined): number {
-	if (!cursor) return 0;
-	const n = parseInt(cursor, 10);
-	return Number.isFinite(n) && n >= 0 ? n : 0;
-}
-
-export function encodeCursor(offset: number): string {
-	return String(offset);
-}
-
-/** Clamp limit + compute the PostgREST `range(from, to)` bounds. */
-export function toRange(opts: Pick<ListOptions, 'limit' | 'cursor'> | undefined): RangeSpec {
-	const limit = Math.min(Math.max(opts?.limit ?? DEFAULT_PAGE_LIMIT, 1), MAX_PAGE_LIMIT);
-	const from = decodeCursor(opts?.cursor);
-	return { from, to: from + limit - 1, limit };
-}
-
-/**
- * Build the `nextCursor` from the count returned by PostgREST. Returns
- * undefined when there is no next page.
- */
-export function nextCursorFromRange(
-	range: RangeSpec,
-	returnedCount: number,
-	totalCount: number | null | undefined
-): string | undefined {
-	const consumed = range.from + returnedCount;
-	if (totalCount != null) {
-		return consumed < totalCount ? encodeCursor(consumed) : undefined;
-	}
-	// Without total, we can only infer "there might be more" if we got a full page.
-	return returnedCount >= range.limit ? encodeCursor(consumed) : undefined;
-}
-
-/** Map `ListOptions.orderBy` to a Postgres column name. */
-export function orderColumn(orderBy: ListOptions['orderBy'] | undefined): string {
-	switch (orderBy) {
-		case 'name':
-			return 'name';
-		case 'updatedAt':
-			return 'updated_at';
-		case 'createdAt':
-		default:
-			return 'created_at';
-	}
-}

package/src/data/query.ts

@@ -1,22 +0,0 @@
-/**
- * Small query-builder helpers shared across Supabase stores.
- */
-
-/**
- * The slice of a PostgREST filter builder these helpers touch: an `.is()`
- * method that returns the same builder for chaining. Generic over the builder
- * type so the caller's concrete builder (and its row generic) flows through.
- */
-interface DeletableQuery {
-	is(column: string, value: null): this;
-}
-
-/**
- * Apply the soft-delete filter `deleted_at IS NULL`. The `.is('deleted_at', null)`
- * idiom is repeated across every store that soft-deletes; this names it.
- *
- *   let q = notDeleted(client.from('projects').select(COLS));
- */
-export function notDeleted<Q extends DeletableQuery>(query: Q): Q {
-	return query.is('deleted_at', null);
-}

package/src/data/rowStamp.ts

@@ -1,48 +0,0 @@
-import type { RequestContext } from '@selvajs/platform';
-import { auditSoftDelete } from '@selvajs/platform';
-
-/**
- * Row-level (snake_case) audit-stamp helpers for Supabase stores.
- *
- * Platform's `auditUpdate` / `auditSoftDelete` emit camelCase *domain* fields
- * (`updatedAt` / `updatedBy`), but Postgres rows are snake_case, so every store
- * hand-translated them. These helpers own that translation once. Row-column
- * naming is a provider concern, so they live here rather than in platform.
- *
- * Two deliberate rules, matched to how the engine's stores already write rows:
- *  - `updated_by` is written ONLY when `ctx.userId` is set. On system contexts
- *    it's the empty string, and the column FKs `auth.users(id)` with
- *    `ON DELETE SET NULL` — writing `''` would violate the FK, so it's omitted
- *    and the existing value is left untouched.
- *  - Plain updates DON'T stamp `updated_at`: a per-table `updated_at` trigger
- *    already sets it. Only the soft-delete stamp writes `updated_at` explicitly,
- *    so it matches `deleted_at` (a single timestamp for the deletion event).
- */
-
-/**
- * Stamp for a plain UPDATE: `{ updated_by }` when the context carries a user,
- * `{}` otherwise (the DB trigger handles `updated_at`). Spread into the row:
- * `const row = { ...patch, ...stampUpdate(ctx) }`.
- */
-export function stampUpdate(ctx: RequestContext): { updated_by?: string } {
-	return ctx.userId ? { updated_by: ctx.userId } : {};
-}
-
-/**
- * Stamp for a soft-delete: `{ deleted_at, updated_at, updated_by? }`. `updated_at`
- * is set explicitly to equal `deleted_at`; `updated_by` follows the same
- * omit-when-empty rule as {@link stampUpdate}. `fallbackActor` defaults to
- * `ctx.userId` (matching the engine stores' `auditSoftDelete(ctx, ctx.userId)`).
- */
-export function stampSoftDelete(
-	ctx: RequestContext,
-	fallbackActor: string | null | undefined = ctx.userId
-): { deleted_at: string; updated_at: string; updated_by?: string } {
-	const stamp = auditSoftDelete(ctx, fallbackActor);
-	const row: { deleted_at: string; updated_at: string; updated_by?: string } = {
-		deleted_at: stamp.deletedAt,
-		updated_at: stamp.updatedAt
-	};
-	if (stamp.updatedBy) row.updated_by = stamp.updatedBy;
-	return row;
-}

package/src/index.ts

@@ -1,42 +0,0 @@
-export { SupabaseStorageProvider } from './storage/SupabaseStorageProvider.js';
-export type { SupabaseStorageProviderConfig } from './storage/SupabaseStorageProvider.js';
-
-export {
-	SupabaseOrgStore,
-	SupabaseProjectStore,
-	SupabaseDefinitionStore,
-	SupabaseInviteStore,
-	SupabaseComputeServerStore,
-	SupabaseShareLinkStore,
-	SupabaseDataProvider,
-	SupabaseEventSink,
-	SupabaseSolveMetricSink,
-	SupabaseAuditQuery,
-	buildClientBundle,
-	clientBundleFromEnv,
-	DEFAULT_SCHEMA,
-	mapPostgrestError,
-	stampUpdate,
-	stampSoftDelete,
-	notDeleted,
-	toRange,
-	orderColumn,
-	nextCursorFromRange,
-	encodeCursor,
-	decodeCursor
-} from './data/index.js';
-export type {
-	ClientBundle,
-	BuildClientOptions,
-	ForRequestOptions,
-	SchemaClient,
-	SelvaSchemaClient,
-	RangeSpec
-} from './data/index.js';
-
-export { SupabaseUserProfileProvider } from './userProfile/index.js';
-
-export { SupabaseAuthProvider } from './auth/index.js';
-export type { SupabaseAuthProviderConfig } from './auth/index.js';
-
-export { SupabasePlatformPermissionStore } from './permissions/index.js';