@selvajs/supabase-provider 0.11.0 → 0.13.0

package/src/cli/sync-migrations.ts

@@ -0,0 +1,133 @@
+#!/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/SupabaseDefinitionStore.ts

@@ -9,7 +9,8 @@ import type {
 	RequestContext,
 	DefinitionListOptions,
 	ListOptions,
-	Page
+	Page,
+	UISchema
 } from '@selvajs/platform';
 import { ProviderError, auditSoftDelete, actorFrom, NoopEventSink } from '@selvajs/platform';
 import type { ClientBundle } from './client.js';
@@ -228,6 +229,15 @@ export class SupabaseDefinitionStore implements IDefinitionStore {
 		return data ? rowToVersion(data) : null;
 	}
 
+	async setVersionSchema(ctx: RequestContext, versionId: string, schema: UISchema): Promise<void> {
+		const { error } = await this.clients
+			.forRequest(ctx)
+			.from('definition_versions')
+			.update({ schema, schema_extracted_at: new Date().toISOString() })
+			.eq('id', versionId);
+		if (error) throw mapError(error);
+	}
+
 	async deleteVersion(ctx: RequestContext, versionId: string): Promise<void> {
 		// FK enforcement at the DB layer: live_version_id / draft_version_id
 		// are ON DELETE RESTRICT. If the version is referenced by either
@@ -377,6 +387,8 @@ interface DefinitionVersionRow {
 	uploaded_by: string;
 	uploaded_at: string;
 	change_note?: string | null;
+	schema?: UISchema | null;
+	schema_extracted_at?: string | null;
 }
 
 function rowToRecord(row: DefinitionRow): DefinitionRecord {
@@ -450,7 +462,9 @@ function rowToVersion(row: DefinitionVersionRow): DefinitionVersion {
 		originalFilename: row.original_filename ?? undefined,
 		uploadedBy: row.uploaded_by,
 		uploadedAt: row.uploaded_at,
-		changeNote: row.change_note ?? undefined
+		changeNote: row.change_note ?? undefined,
+		schema: row.schema ?? undefined,
+		schemaExtractedAt: row.schema_extracted_at ?? undefined
 	};
 }
 
@@ -466,6 +480,8 @@ function versionToRow(v: DefinitionVersion): Record<string, unknown> {
 		uploaded_at: v.uploadedAt
 	};
 	if (v.changeNote !== undefined) row.change_note = v.changeNote;
+	if (v.schema !== undefined) row.schema = v.schema;
+	if (v.schemaExtractedAt !== undefined) row.schema_extracted_at = v.schemaExtractedAt;
 	return row;
 }
 

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

@@ -6,14 +6,14 @@
  * every relevant table.
  */
 
-import { createClient, type SupabaseClient } from '@supabase/supabase-js';
-import { buildClientBundle, type ClientBundle } from '../client.js';
+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: SupabaseClient;
+	adminClient: SelvaSchemaClient;
 	bundle: ClientBundle;
 }
 
@@ -27,9 +27,10 @@ export function readEnv(): TestContext | null {
 	// 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: SupabaseClient;
+	let adminClient: SelvaSchemaClient;
 	try {
 		adminClient = createClient(url, serviceRoleKey, {
+			db: { schema: 'selva' },
 			auth: { persistSession: false, autoRefreshToken: false }
 		});
 	} catch (err) {

package/src/data/client.ts

@@ -1,6 +1,15 @@
 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'>;
+
 /**
  * Build a Supabase client for a given `RequestContext`.
  *
@@ -27,14 +36,14 @@ import type { RequestContext } from '@selvajs/platform';
  */
 export interface ClientBundle {
 	/** Long-lived service-role client. Bypasses RLS. */
-	serviceClient: SupabaseClient;
+	serviceClient: SelvaSchemaClient;
 	/**
 	 * Produce (or reuse) a client scoped to this request's identity.
 	 *  - `ctx.system === true` → service-role (RLS bypassed).
 	 *  - `ctx.adapterContext.sessionToken` set → user-scoped (RLS active).
 	 *  - neither → anon client (RLS active, no `auth.uid()`).
 	 */
-	forRequest(ctx: RequestContext): SupabaseClient;
+	forRequest(ctx: RequestContext): SelvaSchemaClient;
 }
 
 export interface BuildClientOptions {
@@ -45,20 +54,22 @@ export interface BuildClientOptions {
 
 export function buildClientBundle(opts: BuildClientOptions): ClientBundle {
 	const serviceClient = createClient(opts.supabaseUrl, opts.serviceRoleKey, {
+		db: { schema: 'selva' },
 		auth: { persistSession: false, autoRefreshToken: false }
 	});
 
 	// Long-lived anon client — the fail-closed default for ctxes that aren't
 	// explicitly system and don't carry a session token.
 	const anonClient = createClient(opts.supabaseUrl, opts.anonKey, {
+		db: { schema: 'selva' },
 		auth: { persistSession: false, autoRefreshToken: false }
 	});
 
-	const perRequestCache = new WeakMap<RequestContext, SupabaseClient>();
+	const perRequestCache = new WeakMap<RequestContext, SelvaSchemaClient>();
 
 	return {
 		serviceClient,
-		forRequest(ctx: RequestContext): SupabaseClient {
+		forRequest(ctx: RequestContext): SelvaSchemaClient {
 			if (ctx.system) return serviceClient;
 
 			const token = extractSessionToken(ctx.adapterContext);
@@ -68,6 +79,7 @@ export function buildClientBundle(opts: BuildClientOptions): ClientBundle {
 			if (cached) return cached;
 
 			const client = createClient(opts.supabaseUrl, opts.anonKey, {
+				db: { schema: 'selva' },
 				auth: { persistSession: false, autoRefreshToken: false },
 				global: {
 					headers: { Authorization: `Bearer ${token}` }

package/supabase/config.toml

@@ -8,8 +8,13 @@ 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).
+# Exposed REST schemas. `selva` (where all Selva tables live, isolated from a
+# consuming app's `public`) is intentionally NOT listed here: PostgREST loads
+# this config at stack boot, *before* migrations run, so naming a not-yet-created
+# schema fails the health check and aborts `supabase start`. Instead the initial
+# migration exposes `selva` via `alter role authenticator set pgrst.db_schemas`
+# once the schema exists. A hosted project that boots from a snapshot already
+# containing `selva` may also add it here directly.
 schemas = ["public", "graphql_public"]
 extra_search_path = ["public", "extensions"]
 max_rows = 1000