@svadmin/supabase 0.11.8 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/supabase",
-  "version": "0.11.8",
+  "version": "0.12.0",
   "description": "Supabase adapters — DataProvider, AuthProvider, LiveProvider, AuditHandler",
   "type": "module",
   "sideEffects": false,
@@ -24,8 +24,8 @@
     }
   },
   "peerDependencies": {
-    "@svadmin/core": "^0.34.2",
-    "@supabase/supabase-js": "^2.112.2",
+    "@svadmin/core": "^0.36.2",
+    "@supabase/supabase-js": "^2.112.3",
     "@refinedev/supabase": "^6.0.2",
     "@supacloud/js": "^0.21.1"
   },
@@ -33,12 +33,12 @@
   "author": "zuohuadong",
   "repository": {
     "type": "git",
-    "url": "https://github.com/zuohuadong/svadmin.git",
+    "url": "https://github.com/vibeunion/svadmin.git",
     "directory": "packages/supabase"
   },
-  "homepage": "https://github.com/zuohuadong/svadmin#readme",
+  "homepage": "https://github.com/vibeunion/svadmin#readme",
   "bugs": {
-    "url": "https://github.com/zuohuadong/svadmin/issues"
+    "url": "https://github.com/vibeunion/svadmin/issues"
   },
   "peerDependenciesMeta": {
     "@svadmin/core": {
@@ -55,9 +55,9 @@
     }
   },
   "dependencies": {
-    "@svadmin/refine-adapter": "^0.10.1"
+    "@svadmin/refine-adapter": "^0.10.2"
   },
   "devDependencies": {
-    "@supabase/supabase-js": "^2.112.2"
+    "@supabase/supabase-js": "^2.112.3"
   }
 }

package/src/data-provider.ts

@@ -1,17 +1,25 @@
-import type { DataProvider } from '@svadmin/core';
+import type { CustomParams, CustomResult, DataProvider } from '@svadmin/core';
 import { createRefineAdapter } from '@svadmin/refine-adapter';
+import type { SupabaseClient } from '@supabase/supabase-js';
 // Static import — dynamic import() gets dropped by Vite/Rollup in static SPA builds
 import { dataProvider as refineDataProvider } from '@refinedev/supabase';
 
+export interface CreateSupabaseDataProviderOptions {
+  /** Default schema for table and RPC operations */
+  schema?: string;
+}
+
 /**
- * Creates a supabase data provider using the official @refinedev/supabase package.
- * Requires `@refinedev/supabase` to be installed.
- * 
- * @param args Arguments required by @refinedev/supabase
- * @returns A fully compatible svadmin DataProvider
+ * Creates a supabase data provider using the official @refinedev/supabase package
+ * with full support for custom RPC calls, Edge Functions, and schema targeting.
+ *
+ * @param client SupabaseClient instance
+ * @param options Optional provider configuration
+ * @returns A fully compatible svadmin DataProvider with custom RPC support
  */
 export function createSupabaseDataProvider(
-  ...args: Parameters<typeof refineDataProvider>
+  client: SupabaseClient,
+  options: CreateSupabaseDataProviderOptions = {}
 ): DataProvider {
   if (typeof refineDataProvider !== 'function') {
     throw new Error(
@@ -19,6 +27,181 @@ export function createSupabaseDataProvider(
       'Ensure the package is installed correctly: bun add @refinedev/supabase'
     );
   }
-  const refineProvider = refineDataProvider(...args);
-  return createRefineAdapter(refineProvider);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const refineProvider = refineDataProvider(client as any);
+  const adapter = createRefineAdapter(refineProvider);
+
+  // Provide first-class custom implementation for Supabase
+  adapter.custom = async <TData = unknown, TVariables = unknown>({
+    url,
+    method = 'get',
+    payload,
+    query,
+    headers,
+    filters,
+    sorters,
+    meta,
+  }: CustomParams<TVariables>): Promise<CustomResult<TData>> => {
+    const targetSchema = (meta?.schema as string | undefined) ?? options.schema;
+    const targetClient = targetSchema ? client.schema(targetSchema) : client;
+
+    // 1. Edge Function invocation
+    const isEdgeFunction =
+      meta?.function === true ||
+      meta?.edgeFunction === true ||
+      url.startsWith('functions/') ||
+      url.startsWith('functions:');
+
+    if (isEdgeFunction) {
+      const functionName = url.replace(/^functions[/:]/, '');
+      const { data, error } = await client.functions.invoke(functionName, {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        body: payload as any,
+        headers: headers as Record<string, string>,
+      });
+
+      if (error) {
+        throw new Error(
+          `[svadmin/supabase] Edge Function "${functionName}" failed: ${error.message}`
+        );
+      }
+
+      return { data: data as TData };
+    }
+
+    // 2. PostgreSQL Stored Procedure / RPC
+    const isExplicitRpc =
+      meta?.rpc === true ||
+      url.startsWith('rpc/') ||
+      url.startsWith('rpc:');
+    const isImplicitRpc =
+      !isExplicitRpc &&
+      meta?.rpc !== false &&
+      !url.startsWith('http://') &&
+      !url.startsWith('https://') &&
+      !url.includes('/') &&
+      (method === 'post' || meta?.rpc === true);
+
+    if (isExplicitRpc || (isImplicitRpc && meta?.rpc === true)) {
+      const functionName = url.replace(/^rpc[/:]/, '');
+      const rpcArgs = (payload ?? query ?? {}) as Record<string, unknown>;
+      const rpcOptions: { head?: boolean; count?: 'exact' | 'planned' | 'estimated'; get?: boolean } = {};
+      if (meta?.head) rpcOptions.head = Boolean(meta.head);
+      if (meta?.count) rpcOptions.count = meta.count as 'exact' | 'planned' | 'estimated';
+      if (meta?.get) rpcOptions.get = Boolean(meta.get);
+
+      const { data, error } = await targetClient.rpc(functionName, rpcArgs, rpcOptions);
+
+      if (error) {
+        throw new Error(
+          `[svadmin/supabase] RPC function "${functionName}" failed: ${error.message}`
+        );
+      }
+
+      return { data: data as TData };
+    }
+
+    // 3. Direct Table / View Query via PostgREST client
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+      const dbQuery = targetClient.from(url);
+
+      if (method === 'get') {
+        let selectQuery = dbQuery.select((meta?.select as string) ?? '*');
+        if (query) {
+          for (const [key, value] of Object.entries(query)) {
+            if (value !== undefined && value !== null) {
+              selectQuery = selectQuery.eq(key, value);
+            }
+          }
+        }
+        if (filters && Array.isArray(filters)) {
+          for (const filter of filters) {
+            if ('field' in filter && 'value' in filter) {
+              selectQuery = selectQuery.eq(filter.field, filter.value);
+            }
+          }
+        }
+        if (sorters && Array.isArray(sorters)) {
+          for (const sorter of sorters) {
+            selectQuery = selectQuery.order(sorter.field, {
+              ascending: sorter.order === 'asc',
+            });
+          }
+        }
+        const { data, error } = await selectQuery;
+        if (error) {
+          throw new Error(`[svadmin/supabase] Query "${url}" failed: ${error.message}`);
+        }
+        return { data: data as TData };
+      }
+
+      if (method === 'post') {
+        const { data, error } = await dbQuery
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          .insert(payload as any)
+          .select((meta?.select as string) ?? '*');
+        if (error) {
+          throw new Error(`[svadmin/supabase] Insert into "${url}" failed: ${error.message}`);
+        }
+        return { data: (Array.isArray(data) ? data[0] : data) as TData };
+      }
+
+      if (method === 'put' || method === 'patch') {
+        let updateQuery = dbQuery
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          .update(payload as any);
+        if (query) {
+          for (const [key, value] of Object.entries(query)) {
+            if (value !== undefined && value !== null) {
+              updateQuery = updateQuery.eq(key, value);
+            }
+          }
+        }
+        const { data, error } = await updateQuery.select((meta?.select as string) ?? '*');
+        if (error) {
+          throw new Error(`[svadmin/supabase] Update "${url}" failed: ${error.message}`);
+        }
+        return { data: (Array.isArray(data) ? data[0] : data) as TData };
+      }
+
+      if (method === 'delete') {
+        let deleteQuery = dbQuery.delete();
+        if (query) {
+          for (const [key, value] of Object.entries(query)) {
+            if (value !== undefined && value !== null) {
+              deleteQuery = deleteQuery.eq(key, value);
+            }
+          }
+        }
+        const { data, error } = await deleteQuery.select((meta?.select as string) ?? '*');
+        if (error) {
+          throw new Error(`[svadmin/supabase] Delete from "${url}" failed: ${error.message}`);
+        }
+        return { data: data as TData };
+      }
+    }
+
+    // 4. Fallback to standard HTTP fetch for absolute URLs
+    const fetchHeaders: Record<string, string> = {
+      'Content-Type': 'application/json',
+      ...(headers ?? {}),
+    };
+    const response = await fetch(url, {
+      method: method.toUpperCase(),
+      headers: fetchHeaders,
+      body: payload ? JSON.stringify(payload) : undefined,
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `[svadmin/supabase] Custom request to "${url}" failed with status ${response.status}`
+      );
+    }
+
+    const data = await response.json();
+    return { data: data as TData };
+  };
+
+  return adapter;
 }

package/src/index.ts

@@ -1,6 +1,7 @@
 // @svadmin/supabase — Supabase adapters
 
 export { createSupabaseDataProvider } from './data-provider';
+export type { CreateSupabaseDataProviderOptions } from './data-provider';
 export { createSupabaseAuthProvider } from './auth-provider';
 export type {
   SupabaseAuthProviderOptions,
@@ -9,6 +10,11 @@ export type {
 } from './auth-provider';
 export { createSupabaseLiveProvider } from './live-provider';
 export { createSupabaseAuditHandler } from './audit-handler';
+export { createSupabaseRpc } from './rpc';
+export type {
+  SupabaseRpcClient,
+  SupabaseRpcOptions,
+} from './rpc';
 export {
   createSupaCloudTaskProvider,
   createSupaCloudTaskLiveProvider,

package/src/rpc.ts

@@ -0,0 +1,69 @@
+// Supabase RPC Helper — Type-safe and Ergonomic PostgreSQL Function Execution
+import type { SupabaseClient } from '@supabase/supabase-js';
+
+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) */
+  head?: boolean;
+  /** Count algorithm to use */
+  count?: 'exact' | 'planned' | 'estimated';
+  /** Use GET HTTP method for read-only RPCs (enables HTTP caching) */
+  get?: boolean;
+}
+
+export interface SupabaseRpcClient {
+  /**
+   * Invoke a Postgres stored procedure / function via Supabase RPC.
+   *
+   * @param functionName Name of the PostgreSQL stored procedure
+   * @param args Arguments to pass to the procedure
+   * @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>>(
+    functionName: string,
+    args?: TArgs,
+    options?: SupabaseRpcOptions
+  ) => Promise<TResult>;
+}
+
+/**
+ * Creates a dedicated Supabase RPC helper for executing PostgreSQL stored procedures.
+ *
+ * @param client SupabaseClient instance
+ * @param defaultOptions Default options applied to all RPC calls
+ */
+export function createSupabaseRpc(
+  client: SupabaseClient,
+  defaultOptions: SupabaseRpcOptions = {}
+): SupabaseRpcClient {
+  return {
+    async call<TResult = unknown, TArgs extends Record<string, unknown> = Record<string, unknown>>(
+      functionName: string,
+      args?: TArgs,
+      options: SupabaseRpcOptions = {}
+    ): Promise<TResult> {
+      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;
+    },
+  };
+}