@svadmin/supabase 0.0.1

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@svadmin/supabase",
+  "version": "0.0.1",
+  "description": "Supabase adapters — DataProvider, AuthProvider, LiveProvider, AuditHandler",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "src/**/*"
+  ],
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "peerDependencies": {
+    "@svadmin/core": "0.1.0",
+    "@supabase/supabase-js": "^2.0.0"
+  },
+  "license": "MIT",
+  "author": "zuohuadong",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zuohuadong/svadmin.git"
+  },
+  "homepage": "https://github.com/zuohuadong/svadmin#readme",
+  "bugs": {
+    "url": "https://github.com/zuohuadong/svadmin/issues"
+  }
+}

package/src/audit-handler.ts

@@ -0,0 +1,16 @@
+// Supabase AuditHandler — writes audit entries to a Supabase table
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { AuditHandler, AuditEntry } from '@svadmin/core';
+
+export function createSupabaseAuditHandler(client: SupabaseClient): AuditHandler {
+  return async (entry: AuditEntry) => {
+    await client.from('audit_log').insert({
+      action: entry.action,
+      resource: entry.resource,
+      record_id: entry.recordId ? String(entry.recordId) : null,
+      user_id: entry.userId,
+      details: entry.details,
+      created_at: entry.timestamp,
+    });
+  };
+}

package/src/auth-provider.ts

@@ -0,0 +1,76 @@
+// Supabase AuthProvider
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { AuthProvider, Identity, AuthActionResult, CheckResult } from '@svadmin/core';
+import { audit } from '@svadmin/core';
+
+export function createSupabaseAuthProvider(client: SupabaseClient): AuthProvider {
+  return {
+    async login({ email, password }: Record<string, unknown>): Promise<AuthActionResult> {
+      const { data, error } = await client.auth.signInWithPassword({
+        email: email as string,
+        password: password as string,
+      });
+      if (error) return { success: false, error: { message: error.message } };
+      audit({ action: 'login', userId: data.user?.id });
+      return { success: true, redirectTo: '/' };
+    },
+
+    async logout(): Promise<AuthActionResult> {
+      const { data: { user } } = await client.auth.getUser();
+      await client.auth.signOut();
+      audit({ action: 'logout', userId: user?.id });
+      return { success: true, redirectTo: '/login' };
+    },
+
+    async check(): Promise<CheckResult> {
+      const { data: { session } } = await client.auth.getSession();
+      if (session) return { authenticated: true };
+      return { authenticated: false, redirectTo: '/login', logout: true };
+    },
+
+    async getIdentity(): Promise<Identity | null> {
+      const { data: { user } } = await client.auth.getUser();
+      if (!user) return null;
+      return {
+        id: user.id,
+        name: user.user_metadata?.name ?? user.email?.split('@')[0] ?? 'User',
+        email: user.email,
+        avatar: user.user_metadata?.avatar_url,
+      };
+    },
+
+    async getPermissions(): Promise<unknown> {
+      const { data: { user } } = await client.auth.getUser();
+      return user?.user_metadata?.role ?? 'user';
+    },
+
+    async register({ email, password, ...rest }: Record<string, unknown>): Promise<AuthActionResult> {
+      const { error } = await client.auth.signUp({
+        email: email as string,
+        password: password as string,
+        options: { data: rest },
+      });
+      if (error) return { success: false, error: { message: error.message } };
+      return { success: true, redirectTo: '/login' };
+    },
+
+    async forgotPassword({ email }: Record<string, unknown>): Promise<AuthActionResult> {
+      const { error } = await client.auth.resetPasswordForEmail(email as string);
+      if (error) return { success: false, error: { message: error.message } };
+      return { success: true };
+    },
+
+    async updatePassword({ password }: Record<string, unknown>): Promise<AuthActionResult> {
+      const { error } = await client.auth.updateUser({ password: password as string });
+      if (error) return { success: false, error: { message: error.message } };
+      return { success: true, redirectTo: '/' };
+    },
+
+    async onError(error: unknown): Promise<{ redirectTo?: string; logout?: boolean }> {
+      if (error instanceof Error && error.message.includes('401')) {
+        return { redirectTo: '/login', logout: true };
+      }
+      return {};
+    },
+  };
+}

package/src/data-provider.ts

@@ -0,0 +1,113 @@
+// 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,
+} from '@svadmin/core';
+
+export function createSupabaseDataProvider(client: SupabaseClient, apiUrl?: string): DataProvider {
+  const resolvedApiUrl = apiUrl ?? '';
+
+  return {
+    getApiUrl: () => resolvedApiUrl,
+
+    async getList<T>({ resource, pagination, sorters, filters, meta }: GetListParams): Promise<GetListResult<T>> {
+      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 T[], total: count ?? 0 };
+    },
+
+    async getOne<T>({ resource, id, meta }: GetOneParams): Promise<GetOneResult<T>> {
+      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 T };
+    },
+
+    async create<T>({ resource, variables }: CreateParams): Promise<CreateResult<T>> {
+      const { data, error } = await client.from(resource).insert(variables).select().single();
+      if (error) throw error;
+      return { data: data as T };
+    },
+
+    async update<T>({ resource, id, variables }: UpdateParams): Promise<UpdateResult<T>> {
+      const { data, error } = await client.from(resource).update(variables).eq('id', id).select().single();
+      if (error) throw error;
+      return { data: data as T };
+    },
+
+    async deleteOne<T>({ resource, id }: DeleteParams): Promise<DeleteResult<T>> {
+      const { data, error } = await client.from(resource).delete().eq('id', id).select().single();
+      if (error) throw error;
+      return { data: data as T };
+    },
+
+    async getMany<T>({ resource, ids, meta }: GetManyParams): Promise<GetManyResult<T>> {
+      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 T[] };
+    },
+
+    async createMany<T>({ resource, variables }: CreateManyParams): Promise<CreateManyResult<T>> {
+      const { data, error } = await client.from(resource).insert(variables).select();
+      if (error) throw error;
+      return { data: (data ?? []) as T[] };
+    },
+
+    async updateMany<T>({ resource, ids, variables }: UpdateManyParams): Promise<UpdateManyResult<T>> {
+      const { data, error } = await client.from(resource).update(variables).in('id', ids).select();
+      if (error) throw error;
+      return { data: (data ?? []) as T[] };
+    },
+
+    async deleteMany<T>({ resource, ids }: DeleteManyParams): Promise<DeleteManyResult<T>> {
+      const { data, error } = await client.from(resource).delete().in('id', ids).select();
+      if (error) throw error;
+      return { data: (data ?? []) as T[] };
+    },
+
+    async custom<T>({ url, method, payload, headers }: CustomParams): Promise<CustomResult<T>> {
+      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 T };
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+// @svadmin/supabase — Supabase adapters
+
+export { createSupabaseDataProvider } from './data-provider';
+export { createSupabaseAuthProvider } from './auth-provider';
+export { createSupabaseLiveProvider } from './live-provider';
+export { createSupabaseAuditHandler } from './audit-handler';

package/src/live-provider.ts

@@ -0,0 +1,33 @@
+// Supabase LiveProvider — Real-time subscriptions via Supabase Realtime
+import type { SupabaseClient, RealtimeChannel } from '@supabase/supabase-js';
+import type { LiveProvider, LiveEvent } from '@svadmin/core';
+
+export function createSupabaseLiveProvider(client: SupabaseClient): LiveProvider {
+  const channels = new Map<string, RealtimeChannel>();
+
+  return {
+    subscribe({ resource, callback }) {
+      const channel = client
+        .channel(`live-${resource}`)
+        .on(
+          'postgres_changes',
+          { event: '*', schema: 'public', table: resource },
+          (payload) => {
+            callback({
+              type: payload.eventType as LiveEvent['type'],
+              resource,
+              payload: (payload.new ?? payload.old ?? {}) as Record<string, unknown>,
+            });
+          }
+        )
+        .subscribe();
+
+      channels.set(resource, channel);
+
+      return () => {
+        channel.unsubscribe();
+        channels.delete(resource);
+      };
+    },
+  };
+}