@svadmin/supabase 0.9.10 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/supabase",
-  "version": "0.9.10",
+  "version": "0.11.0",
   "description": "Supabase adapters — DataProvider, AuthProvider, LiveProvider, AuditHandler",
   "type": "module",
   "sideEffects": false,
@@ -13,12 +13,17 @@
     ".": {
       "types": "./src/index.ts",
       "default": "./src/index.ts"
+    },
+    "./supacloud": {
+      "types": "./src/supacloud.ts",
+      "default": "./src/supacloud.ts"
     }
   },
   "peerDependencies": {
-    "@svadmin/core": "^0.23.6",
+    "@svadmin/core": "^0.25.0",
     "@supabase/supabase-js": "^2.0.0",
-    "@refinedev/supabase": "^5.0.0"
+    "@refinedev/supabase": "^5.0.0",
+    "@supacloud/js": "^0.10.0"
   },
   "license": "MIT",
   "author": "zuohuadong",
@@ -40,6 +45,9 @@
     },
     "@refinedev/supabase": {
       "optional": true
+    },
+    "@supacloud/js": {
+      "optional": true
     }
   },
   "dependencies": {

package/src/index.ts

@@ -4,3 +4,13 @@ export { createSupabaseDataProvider } from './data-provider';
 export { createSupabaseAuthProvider } from './auth-provider';
 export { createSupabaseLiveProvider } from './live-provider';
 export { createSupabaseAuditHandler } from './audit-handler';
+export {
+  createSupaCloudTaskProvider,
+  createSupaCloudTaskLiveProvider,
+} from './supacloud';
+export type {
+  SupaCloudTaskClient,
+  SupaCloudTaskRecord,
+  CreateSupaCloudTaskProviderOptions,
+  CreateSupaCloudTaskLiveProviderOptions,
+} from './supacloud';

package/src/supabase.test.ts

@@ -212,3 +212,114 @@ describe('Supabase LiveProvider', () => {
     expect(sendArgs.payload.type).toBe('INSERT');
   });
 });
+
+
+// ─── SupaCloud Task Provider Tests ───────────────────────────────
+describe('SupaCloud Task Provider', () => {
+  test('submit proxies to supacloud tasks client', async () => {
+    const { createSupaCloudTaskProvider } = await import('./supacloud');
+    const taskHandle = {
+      id: 'task-1',
+      wait: mock(async () => ({ id: 'task-1', status: 'done' })),
+    };
+    const supacloud = {
+      submit: mock(async () => taskHandle),
+      get: mock(async () => ({ id: 'task-1', status: 'done' })),
+    };
+
+    const provider = createSupaCloudTaskProvider({ supacloud });
+    const result = await provider.submit('image.generate', {
+      body: { prompt: 'poster' },
+      idempotencyKey: 'job-1',
+    });
+
+    expect(supacloud.submit).toHaveBeenCalledWith('image.generate', {
+      body: { prompt: 'poster' },
+      idempotencyKey: 'job-1',
+    });
+    expect(result).toBe(taskHandle);
+  });
+
+  test('list normalizes object payload with data field', async () => {
+    const { createSupaCloudTaskProvider } = await import('./supacloud');
+    const supacloud: import('@svadmin/core').TaskProvider<{ id: string; status: string }> = {
+      submit: mock(async () => ({ wait: async () => ({ id: 'task-1', status: 'queued' }) })),
+      get: mock(async () => ({ id: 'task-1', status: 'queued' })),
+      list: mock(async () => ({ data: [{ id: 'task-1', status: 'queued' }] })),
+    };
+
+    const provider = createSupaCloudTaskProvider({ supacloud });
+    if (!provider.list) throw new Error('provider.list should exist');
+    const tasks = await provider.list();
+
+    expect(tasks).toEqual({
+      data: [{ id: 'task-1', status: 'queued' }],
+      total: 1,
+    });
+  });
+
+  test('listDlq throws clear error when capability is missing', async () => {
+    const { createSupaCloudTaskProvider } = await import('./supacloud');
+    const supacloud: import('@svadmin/core').TaskProvider<{ id: string }> = {
+      submit: mock(async () => ({ wait: async () => ({ id: 'task-1' }) })),
+      get: mock(async () => ({ id: 'task-1' })),
+    };
+
+    const provider = createSupaCloudTaskProvider({ supacloud });
+    if (!provider.listDlq) throw new Error('provider.listDlq should exist');
+
+    await expect(provider.listDlq()).rejects.toThrow('tasks.listDlq');
+  });
+});
+
+
+// ─── SupaCloud Task LiveProvider Tests ───────────────────────────
+describe('SupaCloud Task LiveProvider', () => {
+  test('subscribe requires taskId in liveParams', async () => {
+    const { createSupaCloudTaskLiveProvider } = await import('./supacloud');
+    const supacloud = {
+      subscribe: mock(() => ({ unsubscribe: mock(() => {}) })),
+    };
+
+    const live = createSupaCloudTaskLiveProvider({ supacloud });
+
+    expect(() =>
+      live.subscribe({
+        resource: 'tasks',
+        callback: () => {},
+      }),
+    ).toThrow('liveParams.taskId');
+  });
+
+  test('subscribe maps task updates into svadmin live events', async () => {
+    const { createSupaCloudTaskLiveProvider } = await import('./supacloud');
+    let receivedTaskCallback: ((task: Record<string, unknown>) => void) | undefined;
+    const unsubscribe = mock(() => {});
+    const supacloud = {
+      subscribe: mock((taskId: string, callback: (task: Record<string, unknown>) => void) => {
+        receivedTaskCallback = callback;
+        expect(taskId).toBe('task-42');
+        return { unsubscribe };
+      }),
+    };
+
+    const live = createSupaCloudTaskLiveProvider({ supacloud });
+    const callback = mock(() => {});
+    const stop = live.subscribe({
+      resource: 'tasks',
+      liveParams: { taskId: 'task-42' },
+      callback,
+    });
+
+    receivedTaskCallback?.({ id: 'task-42', status: 'running' });
+
+    expect(callback).toHaveBeenCalledWith({
+      type: 'UPDATE',
+      resource: 'tasks',
+      payload: { id: 'task-42', status: 'running' },
+    });
+
+    stop();
+    expect(unsubscribe).toHaveBeenCalled();
+  });
+});

package/src/supacloud.ts

@@ -0,0 +1,144 @@
+import type {
+  LiveEvent,
+  LiveProvider,
+  SubmitTaskOptions,
+  TaskHandle,
+  TaskListResult,
+  TaskProvider,
+  TaskRecord,
+  TaskSubscription,
+} from '@svadmin/core';
+
+export interface SupaCloudTaskRecord extends TaskRecord {
+  [key: string]: unknown;
+}
+
+export interface SupaCloudTaskClient<TTask extends SupaCloudTaskRecord = SupaCloudTaskRecord> {
+  submit(taskName: string, options?: SubmitTaskOptions): Promise<TaskHandle<TTask>>;
+  get(taskId: string): Promise<TTask>;
+  list?(params?: Record<string, unknown>): Promise<TTask[] | { data?: TTask[] }>;
+  listDlq?(params?: Record<string, unknown>): Promise<TTask[] | { data?: TTask[] }>;
+  cancel?(taskId: string): Promise<unknown>;
+  retry?(taskId: string): Promise<unknown>;
+  subscribe?(
+    taskId: string,
+    callback: (task: TTask) => void
+  ): TaskSubscription | (() => void) | void;
+}
+
+export interface CreateSupaCloudTaskProviderOptions<
+  TTask extends SupaCloudTaskRecord = SupaCloudTaskRecord,
+> {
+  supacloud: SupaCloudTaskClient<TTask>;
+}
+
+export interface CreateSupaCloudTaskLiveProviderOptions<
+  TTask extends SupaCloudTaskRecord = SupaCloudTaskRecord,
+> {
+  supacloud: Pick<SupaCloudTaskClient<TTask>, 'subscribe'>;
+  resource?: string;
+  mapTaskToEvent?: (task: TTask, resource: string) => LiveEvent;
+}
+
+function normalizeTaskSubscription(
+  subscription: TaskSubscription | (() => void) | void,
+): (() => void) | undefined {
+  if (!subscription) return undefined;
+  if (typeof subscription === 'function') return subscription;
+  if (typeof subscription.unsubscribe === 'function') {
+    return () => subscription.unsubscribe();
+  }
+  return undefined;
+}
+
+function normalizeTaskList<TTask extends SupaCloudTaskRecord>(
+  value: TTask[] | { data?: TTask[] },
+): TaskListResult<TTask> {
+  const data = Array.isArray(value) ? value : (value.data ?? []);
+  return {
+    data,
+    total: data.length,
+  };
+}
+
+function defaultMapTaskToEvent<TTask extends SupaCloudTaskRecord>(
+  task: TTask,
+  resource: string,
+): LiveEvent {
+  return {
+    type: 'UPDATE',
+    resource,
+    payload: task as Record<string, unknown>,
+  };
+}
+
+export function createSupaCloudTaskProvider<
+  TTask extends SupaCloudTaskRecord = SupaCloudTaskRecord,
+>(options: CreateSupaCloudTaskProviderOptions<TTask>): TaskProvider<TTask> {
+  const { supacloud } = options;
+
+  return {
+    submit(taskName, submitOptions) {
+      return supacloud.submit(taskName, submitOptions);
+    },
+    get(taskId) {
+      return supacloud.get(taskId);
+    },
+    async list(params) {
+      if (!supacloud.list) {
+        throw new Error('[svadmin/supabase] SupaCloud client does not implement tasks.list');
+      }
+      return normalizeTaskList(await supacloud.list(params));
+    },
+    async listDlq(params) {
+      if (!supacloud.listDlq) {
+        throw new Error('[svadmin/supabase] SupaCloud client does not implement tasks.listDlq');
+      }
+      return normalizeTaskList(await supacloud.listDlq(params));
+    },
+    cancel(taskId) {
+      if (!supacloud.cancel) {
+        throw new Error('[svadmin/supabase] SupaCloud client does not implement tasks.cancel');
+      }
+      return supacloud.cancel(taskId);
+    },
+    retry(taskId) {
+      if (!supacloud.retry) {
+        throw new Error('[svadmin/supabase] SupaCloud client does not implement tasks.retry');
+      }
+      return supacloud.retry(taskId);
+    },
+    subscribe(taskId, callback) {
+      if (!supacloud.subscribe) {
+        throw new Error('[svadmin/supabase] SupaCloud client does not implement tasks.subscribe');
+      }
+      return supacloud.subscribe(taskId, callback);
+    },
+  };
+}
+
+export function createSupaCloudTaskLiveProvider<
+  TTask extends SupaCloudTaskRecord = SupaCloudTaskRecord,
+>(options: CreateSupaCloudTaskLiveProviderOptions<TTask>): LiveProvider {
+  const resourceName = options.resource ?? 'tasks';
+  const mapTaskToEvent = options.mapTaskToEvent ?? defaultMapTaskToEvent<TTask>;
+
+  return {
+    subscribe({ resource, liveParams, callback }) {
+      if (!options.supacloud.subscribe) {
+        throw new Error('[svadmin/supabase] SupaCloud client does not implement tasks.subscribe');
+      }
+
+      const taskId = typeof liveParams?.taskId === 'string' ? liveParams.taskId : undefined;
+      if (!taskId) {
+        throw new Error('[svadmin/supabase] createSupaCloudTaskLiveProvider requires liveParams.taskId');
+      }
+
+      const unsubscribe = options.supacloud.subscribe(taskId, (task) => {
+        callback(mapTaskToEvent(task, resource || resourceName));
+      });
+
+      return normalizeTaskSubscription(unsubscribe) ?? (() => {});
+    },
+  };
+}