@svadmin/supabase 0.13.8 → 0.15.0

package/src/permission-adapter.ts

@@ -0,0 +1,28 @@
+import {
+  createPermissionAccessControlProvider,
+  setAccessControlProvider,
+  type AccessControlProvider,
+  type PermissionProjectionOptions,
+  type PermissionSnapshot,
+} from '@svadmin/core';
+
+export type SupabasePermissionSnapshot = PermissionSnapshot;
+export type SupabasePermissionAdapterOptions = PermissionProjectionOptions;
+
+/** Convert a backend-verified Supabase/SupAuth snapshot into the UI hint provider. */
+export function createSupabasePermissionAccessControlProvider(
+  snapshot: unknown,
+  options: SupabasePermissionAdapterOptions = {},
+): AccessControlProvider {
+  return createPermissionAccessControlProvider(snapshot, options);
+}
+
+/** Register the adapter in one step; the result remains a UI-only projection. */
+export function registerSupabasePermissionAccessControl(
+  snapshot: unknown,
+  options: SupabasePermissionAdapterOptions = {},
+): AccessControlProvider {
+  const provider = createSupabasePermissionAccessControlProvider(snapshot, options);
+  setAccessControlProvider(provider);
+  return provider;
+}

package/src/rpc.ts

@@ -1,10 +1,9 @@
-// Supabase RPC Helper — Type-safe and Ergonomic PostgreSQL Function Execution
-import type { SupabaseClient } from '@supabase/supabase-js';
+import { executeSupabaseRpc, inputObject } from './sdk-boundary';
 
 export interface SupabaseRpcOptions {
   /** Database schema where the RPC function resides (defaults to client schema or 'public') */
   schema?: string;
-  /** When true, do not return result rows (sets Prefer: return=minimal) */
+  /** Use HEAD and omit result rows. */
   head?: boolean;
   /** Count algorithm to use */
   count?: 'exact' | 'planned' | 'estimated';
@@ -21,11 +20,11 @@ export interface SupabaseRpcClient {
    * @param options Additional Supabase RPC options (schema, head, count, get)
    * @returns The returned data from the RPC call
    */
-  call: <TResult = unknown, TArgs extends Record<string, unknown> = Record<string, unknown>>(
+  call: (
     functionName: string,
-    args?: TArgs,
+    args?: Record<string, unknown>,
     options?: SupabaseRpcOptions
-  ) => Promise<TResult>;
+  ) => Promise<unknown>;
 }
 
 /**
@@ -35,35 +34,18 @@ export interface SupabaseRpcClient {
  * @param defaultOptions Default options applied to all RPC calls
  */
 export function createSupabaseRpc(
-  client: SupabaseClient,
+  client: unknown,
   defaultOptions: SupabaseRpcOptions = {}
 ): SupabaseRpcClient {
+  inputObject(client, 'Supabase client');
   return {
-    async call<TResult = unknown, TArgs extends Record<string, unknown> = Record<string, unknown>>(
+    async call(
       functionName: string,
-      args?: TArgs,
+      args?: Record<string, unknown>,
       options: SupabaseRpcOptions = {}
-    ): Promise<TResult> {
+    ): Promise<unknown> {
       const mergedOptions = { ...defaultOptions, ...options };
-      const targetClient = mergedOptions.schema ? client.schema(mergedOptions.schema) : client;
-
-      const { data, error } = await targetClient.rpc(
-        functionName,
-        args ?? ({} as TArgs),
-        {
-          head: mergedOptions.head,
-          count: mergedOptions.count,
-          get: mergedOptions.get,
-        }
-      );
-
-      if (error) {
-        throw new Error(
-          `[svadmin/supabase] RPC function "${functionName}" failed: ${error.message}`
-        );
-      }
-
-      return data as TResult;
+      return executeSupabaseRpc(client, functionName, args === undefined ? {} : args, mergedOptions);
     },
   };
 }

package/src/sdk-boundary.ts

@@ -0,0 +1,79 @@
+import { definedOptions } from '@svadmin/core/options';
+import { decodeCustomResult, rejectProviderResponse } from '@svadmin/core/schema';
+
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function inputObject(value: unknown, label: string): Record<string, unknown> {
+  if (!isObject(value)) throw new TypeError(`${label} must be an object`);
+  return value;
+}
+
+export function inputRecord(value: unknown, label: string): Record<string, unknown> {
+  const record = inputObject(value, label);
+  const prototype: unknown = Object.getPrototypeOf(record);
+  if (prototype !== null && prototype !== Object.prototype) throw new TypeError(`${label} must be a plain record`);
+  return record;
+}
+
+function metadataValue(meta: object | undefined, key: string): unknown {
+  return meta === undefined ? undefined : Reflect.get(meta, key);
+}
+
+export function optionalString(meta: object | undefined, key: string): string | undefined {
+  const value = metadataValue(meta, key);
+  if (value === undefined) return undefined;
+  if (typeof value !== 'string' || !value.trim()) throw new TypeError(`Supabase ${key} must be a nonempty string`);
+  return value;
+}
+
+export function optionalBoolean(meta: object | undefined, key: string): boolean | undefined {
+  const value = metadataValue(meta, key);
+  if (value === undefined) return undefined;
+  if (typeof value !== 'boolean') throw new TypeError(`Supabase ${key} must be a boolean`);
+  return value;
+}
+
+export function optionalCount(meta: object | undefined): 'exact' | 'planned' | 'estimated' | undefined {
+  const value = metadataValue(meta, 'count');
+  if (value === undefined || value === 'exact' || value === 'planned' || value === 'estimated') return value;
+  throw new TypeError('Supabase count must be exact, planned, or estimated');
+}
+
+type SdkMethod = 'schema' | 'from' | 'rpc' | 'invoke' | 'select' | 'insert' | 'update' | 'delete' | 'eq' | 'order';
+
+/** Dynamic SDK calls remain unknown until their response envelope is checked. */
+export function callSdk(target: unknown, name: SdkMethod, args: readonly unknown[]): unknown {
+  if (!isObject(target)) throw new TypeError('Invalid Supabase client or query builder');
+  const method = target[name];
+  if (typeof method !== 'function') throw new TypeError(`Supabase SDK method ${name} is unavailable`);
+  return Reflect.apply(method, target, args);
+}
+
+export async function sdkData(request: unknown, operation: string, write: boolean): Promise<unknown> {
+  const result: unknown = await request;
+  if (!isObject(result) || !Object.hasOwn(result, 'error')) return rejectProviderResponse(write);
+  const error = result['error'];
+  if (error !== null) {
+    if (!isObject(error) || typeof error['message'] !== 'string') return rejectProviderResponse(write);
+    throw new Error(`[svadmin/supabase] ${operation} failed: ${error['message']}`);
+  }
+  return decodeCustomResult(result, write).data;
+}
+
+export async function executeSupabaseRpc(
+  client: unknown, functionName: string, args: unknown, options: object,
+): Promise<unknown> {
+  if (typeof functionName !== 'string' || !functionName.trim()) throw new TypeError('Supabase RPC name cannot be empty');
+  const schema = optionalString(options, 'schema');
+  const rpcOptions = definedOptions({
+    head: optionalBoolean(options, 'head'),
+    get: optionalBoolean(options, 'get'),
+    count: optionalCount(options),
+  });
+  const variables = inputRecord(args, 'Supabase RPC arguments');
+  const target = schema ? callSdk(client, 'schema', [schema]) : client;
+  return sdkData(callSdk(target, 'rpc', [functionName, variables, rpcOptions]),
+    `RPC function "${functionName}"`, !(rpcOptions.get || rpcOptions.head));
+}