@svadmin/supabase 0.9.1 → 0.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/supabase",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Supabase adapters — DataProvider, AuthProvider, LiveProvider, AuditHandler",
   "type": "module",
   "sideEffects": false,
@@ -16,8 +16,10 @@
     }
   },
   "peerDependencies": {
-    "@svadmin/core": "^0.21.0",
-    "@supabase/supabase-js": "^2.0.0"
+    "@svadmin/core": "^0.21.2",
+    "@supabase/supabase-js": "^2.0.0",
+    "@refinedev/supabase": "^5.0.0",
+    "@svadmin/refine-adapter": "^0.9.3"
   },
   "license": "MIT",
   "author": "zuohuadong",

package/src/data-provider.ts

@@ -1,113 +1,16 @@
-// Supabase DataProvider
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type {
-  DataProvider, GetListParams, GetListResult, GetOneParams, GetOneResult,
-  CreateParams, CreateResult, UpdateParams, UpdateResult, DeleteParams, DeleteResult,
-  GetManyParams, GetManyResult, CreateManyParams, CreateManyResult,
-  UpdateManyParams, UpdateManyResult, DeleteManyParams, DeleteManyResult,
-  CustomParams, CustomResult, BaseRecord,
-} from '@svadmin/core';
-
-export function createSupabaseDataProvider(client: SupabaseClient, apiUrl?: string): DataProvider {
-  const resolvedApiUrl = apiUrl ?? '';
-
-  return {
-    getApiUrl: () => resolvedApiUrl,
-
-    async getList<TData extends BaseRecord = BaseRecord>({ resource, pagination, sorters, filters, meta }: GetListParams): Promise<GetListResult<TData>> {
-      const { current = 1, pageSize = 10 } = pagination ?? {};
-      const from = (current - 1) * pageSize;
-      const to = from + pageSize - 1;
-      const select = (meta?.select as string) ?? '*';
-
-      let query = client.from(resource).select(select, { count: 'exact' }).range(from, to);
-
-      if (sorters?.length) {
-        for (const sort of sorters) {
-          query = query.order(sort.field, { ascending: sort.order === 'asc' });
-        }
-      }
-
-      if (filters?.length) {
-        for (const filter of filters) {
-          switch (filter.operator) {
-            case 'eq': query = query.eq(filter.field, filter.value); break;
-            case 'ne': query = query.neq(filter.field, filter.value); break;
-            case 'lt': query = query.lt(filter.field, filter.value); break;
-            case 'gt': query = query.gt(filter.field, filter.value); break;
-            case 'lte': query = query.lte(filter.field, filter.value); break;
-            case 'gte': query = query.gte(filter.field, filter.value); break;
-            case 'contains': query = query.ilike(filter.field, `%${filter.value}%`); break;
-            case 'in': query = query.in(filter.field, filter.value as unknown[]); break;
-            case 'null': query = query.is(filter.field, null); break;
-          }
-        }
-      }
-
-      const { data, count, error } = await query;
-      if (error) throw error;
-      return { data: (data ?? []) as unknown as TData[], total: count ?? 0 };
-    },
-
-    async getOne<TData extends BaseRecord = BaseRecord>({ resource, id, meta }: GetOneParams): Promise<GetOneResult<TData>> {
-      const select = (meta?.select as string) ?? '*';
-      const { data, error } = await client.from(resource).select(select).eq('id', id).single();
-      if (error) throw error;
-      return { data: data as unknown as TData };
-    },
-
-    async create<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, variables }: CreateParams<TVariables>): Promise<CreateResult<TData>> {
-      const { data, error } = await client.from(resource).insert(variables).select().single();
-      if (error) throw error;
-      return { data: data as TData };
-    },
-
-    async update<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, id, variables }: UpdateParams<TVariables>): Promise<UpdateResult<TData>> {
-      const { data, error } = await client.from(resource).update(variables).eq('id', id).select().single();
-      if (error) throw error;
-      return { data: data as TData };
-    },
-
-    async deleteOne<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, id }: DeleteParams<TVariables>): Promise<DeleteResult<TData>> {
-      const { data, error } = await client.from(resource).delete().eq('id', id).select().single();
-      if (error) throw error;
-      return { data: data as TData };
-    },
-
-    async getMany<TData extends BaseRecord = BaseRecord>({ resource, ids, meta }: GetManyParams): Promise<GetManyResult<TData>> {
-      const select = (meta?.select as string) ?? '*';
-      const { data, error } = await client.from(resource).select(select).in('id', ids);
-      if (error) throw error;
-      return { data: (data ?? []) as unknown as TData[] };
-    },
-
-    async createMany<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, variables }: CreateManyParams<TVariables>): Promise<CreateManyResult<TData>> {
-      const { data, error } = await client.from(resource).insert(variables).select();
-      if (error) throw error;
-      return { data: (data ?? []) as TData[] };
-    },
-
-    async updateMany<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, ids, variables }: UpdateManyParams<TVariables>): Promise<UpdateManyResult<TData>> {
-      const { data, error } = await client.from(resource).update(variables).in('id', ids).select();
-      if (error) throw error;
-      return { data: (data ?? []) as TData[] };
-    },
-
-    async deleteMany<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, ids }: DeleteManyParams<TVariables>): Promise<DeleteManyResult<TData>> {
-      const { data, error } = await client.from(resource).delete().in('id', ids).select();
-      if (error) throw error;
-      return { data: (data ?? []) as TData[] };
-    },
-
-    async custom<TData = unknown, TVariables = unknown>({ url, method, payload, headers }: CustomParams<TVariables>): Promise<CustomResult<TData>> {
-      const response = await fetch(url, {
-        method: method.toUpperCase(),
-        headers: { 'Content-Type': 'application/json', ...headers },
-        body: payload ? JSON.stringify(payload) : undefined,
-      });
-      if (!response.ok) throw new Error(`Custom request failed: ${response.status}`);
-      const data = await response.json();
-      return { data: data as TData };
-    },
-  };
+import type { DataProvider } from '@svadmin/core';
+import { createRefineAdapter } from '@svadmin/refine-adapter';
+/**
+ * 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
+ */
+export async function createSupabaseDataProvider(...args: any[]): Promise<DataProvider> {
+  // @ts-ignore Peer dependency
+  const pkg = (await import('@refinedev/supabase')) as any;
+  const init: any = pkg.dataProvider || pkg.default || pkg.DataProvider;
+  const refineProvider = init(...args);
+  return createRefineAdapter(refineProvider);
 }

package/src/live-provider.ts

@@ -3,43 +3,56 @@ import type { SupabaseClient, RealtimeChannel } from '@supabase/supabase-js';
 import type { LiveProvider, LiveEvent } from '@svadmin/core';
 
 export function createSupabaseLiveProvider(client: SupabaseClient): LiveProvider {
+  const subscribers = new Map<string, Set<(event: LiveEvent) => void>>();
   const channels = new Map<string, RealtimeChannel>();
 
   function getOrCreateChannel(resource: string): RealtimeChannel {
     let channel = channels.get(resource);
     if (!channel) {
-      channel = client.channel(`live-${resource}`);
-      channels.set(resource, channel);
-    }
-    return channel;
-  }
-
-  return {
-    subscribe({ resource, callback }) {
-      const channel = getOrCreateChannel(resource)
+      channel = client.channel(`live-${resource}`)
         .on(
           'postgres_changes',
           { event: '*', schema: 'public', table: resource },
           (payload) => {
-            callback({
+            const event: LiveEvent = {
               type: payload.eventType as LiveEvent['type'],
               resource,
               payload: (payload.new ?? payload.old ?? {}) as Record<string, unknown>,
-            });
+            };
+            subscribers.get(resource)?.forEach(cb => cb(event));
           }
         )
-        .on('broadcast', { event: 'live-event' }, ({ payload: broadcastPayload }) => {
-          if (broadcastPayload) {
-            callback(broadcastPayload as LiveEvent);
+        .on('broadcast', { event: 'live-event' }, ({ payload }) => {
+          if (payload) {
+            subscribers.get(resource)?.forEach(cb => cb(payload as LiveEvent));
           }
         })
         .subscribe();
-
       channels.set(resource, channel);
+    }
+    return channel;
+  }
+
+  return {
+    subscribe({ resource, callback }) {
+      if (!subscribers.has(resource)) subscribers.set(resource, new Set());
+      subscribers.get(resource)!.add(callback);
+
+      getOrCreateChannel(resource);
 
       return () => {
-        channel.unsubscribe();
-        channels.delete(resource);
+        const cbs = subscribers.get(resource);
+        if (cbs) {
+          cbs.delete(callback);
+          if (cbs.size === 0) {
+            subscribers.delete(resource);
+            const channel = channels.get(resource);
+            if (channel) {
+              channel.unsubscribe();
+              channels.delete(resource);
+            }
+          }
+        }
       };
     },