@svadmin/pocketbase 0.3.0

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@svadmin/pocketbase",
+  "version": "0.3.0",
+  "description": "PocketBase adapters — DataProvider, AuthProvider, LiveProvider for svadmin",
+  "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.3.0",
+    "pocketbase": ">=0.21.0"
+  },
+  "keywords": ["svadmin", "pocketbase", "data-provider", "auth-provider", "live-provider"],
+  "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/auth-provider.ts

@@ -0,0 +1,120 @@
+// @svadmin/pocketbase — PocketBase AuthProvider
+import type { AuthProvider, Identity, AuthActionResult, CheckResult } from '@svadmin/core';
+
+interface PocketBaseAuthOptions {
+  /** PocketBase client instance */
+  pb: unknown; // PocketBase
+}
+
+// Duck-typed PocketBase client with auth methods
+interface PBClientAuth {
+  authStore: {
+    isValid: boolean;
+    model: { id: string; name?: string; email: string; avatar?: string; [key: string]: unknown } | null;
+    clear: () => void;
+    token: string;
+  };
+  collection: (name: string) => {
+    authWithPassword: (email: string, password: string) => Promise<{ record: Record<string, unknown>; token: string }>;
+    create: (data: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    requestPasswordReset: (email: string) => Promise<boolean>;
+    confirmPasswordReset: (token: string, password: string, passwordConfirm: string) => Promise<boolean>;
+  };
+}
+
+/**
+ * Create an AuthProvider backed by PocketBase.
+ *
+ * Usage:
+ * ```ts
+ * import PocketBase from 'pocketbase';
+ * import { createPocketBaseAuthProvider } from '@svadmin/pocketbase';
+ *
+ * const pb = new PocketBase('http://127.0.0.1:8090');
+ * const authProvider = createPocketBaseAuthProvider({ pb });
+ * ```
+ */
+export function createPocketBaseAuthProvider(options: PocketBaseAuthOptions): AuthProvider {
+  const pb = options.pb as PBClientAuth;
+
+  return {
+    async login({ email, password, collection }: Record<string, unknown>): Promise<AuthActionResult> {
+      try {
+        const col = (collection as string) || 'users';
+        await pb.collection(col).authWithPassword(email as string, password as string);
+        return { success: true, redirectTo: '/' };
+      } catch (err) {
+        return { success: false, error: { message: (err as Error).message } };
+      }
+    },
+
+    async logout(): Promise<AuthActionResult> {
+      pb.authStore.clear();
+      return { success: true, redirectTo: '/login' };
+    },
+
+    async check(): Promise<CheckResult> {
+      if (pb.authStore.isValid && pb.authStore.model) {
+        return { authenticated: true };
+      }
+      return { authenticated: false, redirectTo: '/login', logout: true };
+    },
+
+    async getIdentity(): Promise<Identity | null> {
+      const model = pb.authStore.model;
+      if (!model) return null;
+      return {
+        id: model.id,
+        name: model.name || model.email.split('@')[0],
+        email: model.email,
+        avatar: model.avatar,
+      };
+    },
+
+    async register({ email, password, passwordConfirm, name, collection }: Record<string, unknown>): Promise<AuthActionResult> {
+      try {
+        const col = (collection as string) || 'users';
+        await pb.collection(col).create({
+          email: email as string,
+          password: password as string,
+          passwordConfirm: (passwordConfirm ?? password) as string,
+          name: name as string | undefined,
+        });
+        return { success: true, redirectTo: '/login' };
+      } catch (err) {
+        return { success: false, error: { message: (err as Error).message } };
+      }
+    },
+
+    async forgotPassword({ email, collection }: Record<string, unknown>): Promise<AuthActionResult> {
+      try {
+        const col = (collection as string) || 'users';
+        await pb.collection(col).requestPasswordReset(email as string);
+        return { success: true };
+      } catch (err) {
+        return { success: false, error: { message: (err as Error).message } };
+      }
+    },
+
+    async updatePassword({ token, password, passwordConfirm, collection }: Record<string, unknown>): Promise<AuthActionResult> {
+      try {
+        const col = (collection as string) || 'users';
+        await pb.collection(col).confirmPasswordReset(
+          token as string,
+          password as string,
+          (passwordConfirm ?? password) as string,
+        );
+        return { success: true, redirectTo: '/' };
+      } catch (err) {
+        return { success: false, error: { message: (err as Error).message } };
+      }
+    },
+
+    async onError(error: unknown): Promise<{ redirectTo?: string; logout?: boolean }> {
+      if (error instanceof Error && (error.message.includes('401') || error.message.includes('403'))) {
+        return { redirectTo: '/login', logout: true };
+      }
+      return {};
+    },
+  };
+}

package/src/data-provider.ts

@@ -0,0 +1,122 @@
+// @svadmin/pocketbase — PocketBase DataProvider
+// Maps svadmin CRUD operations to PocketBase SDK
+
+import type {
+  DataProvider, GetListParams, GetListResult, GetOneParams, GetOneResult,
+  CreateParams, CreateResult, UpdateParams, UpdateResult, DeleteParams, DeleteResult,
+  GetManyParams, GetManyResult, DeleteManyParams, DeleteManyResult, BaseRecord,
+} from '@svadmin/core';
+
+interface PocketBaseProviderOptions {
+  /** PocketBase client instance */
+  pb: unknown; // PocketBase
+}
+
+// Duck-typed PocketBase collection interface
+interface PBCollection {
+  getList: (page: number, perPage: number, options?: { sort?: string; filter?: string }) => Promise<{ items: Record<string, unknown>[]; totalItems: number }>;
+  getOne: (id: string) => Promise<Record<string, unknown>>;
+  getFullList: (options?: { sort?: string; filter?: string; batch?: number }) => Promise<Record<string, unknown>[]>;
+  create: (data: Record<string, unknown>) => Promise<Record<string, unknown>>;
+  update: (id: string, data: Record<string, unknown>) => Promise<Record<string, unknown>>;
+  delete: (id: string) => Promise<boolean>;
+}
+
+interface PBClient {
+  collection: (name: string) => PBCollection;
+  buildUrl: (path: string) => string;
+}
+
+function buildSort(sorters?: { field: string; order: 'asc' | 'desc' }[]): string | undefined {
+  if (!sorters?.length) return undefined;
+  return sorters.map(s => s.order === 'desc' ? `-${s.field}` : s.field).join(',');
+}
+
+function buildFilter(filters?: { field: string; operator: string; value: unknown }[]): string | undefined {
+  if (!filters?.length) return undefined;
+  return filters.map(f => {
+    const v = f.value;
+    switch (f.operator) {
+      case 'eq': return `${f.field} = '${v}'`;
+      case 'ne': return `${f.field} != '${v}'`;
+      case 'contains': return `${f.field} ~ '${v}'`;
+      case 'ncontains': return `${f.field} !~ '${v}'`;
+      case 'gt': return `${f.field} > '${v}'`;
+      case 'gte': return `${f.field} >= '${v}'`;
+      case 'lt': return `${f.field} < '${v}'`;
+      case 'lte': return `${f.field} <= '${v}'`;
+      case 'null': return `${f.field} = ''`;
+      case 'nnull': return `${f.field} != ''`;
+      case 'in': return `${f.field} ?= '${(v as unknown[]).join("' || " + f.field + " ?= '")}'`;
+      default: return `${f.field} = '${v}'`;
+    }
+  }).join(' && ');
+}
+
+/**
+ * Create a DataProvider backed by PocketBase.
+ *
+ * Usage:
+ * ```ts
+ * import PocketBase from 'pocketbase';
+ * import { createPocketBaseDataProvider } from '@svadmin/pocketbase';
+ *
+ * const pb = new PocketBase('http://127.0.0.1:8090');
+ * const dataProvider = createPocketBaseDataProvider({ pb });
+ * ```
+ */
+export function createPocketBaseDataProvider(options: PocketBaseProviderOptions): DataProvider {
+  const pb = options.pb as PBClient;
+
+  return {
+    getApiUrl: () => pb.buildUrl('/api'),
+
+    async getList<TData extends BaseRecord = BaseRecord>(params: GetListParams): Promise<GetListResult<TData>> {
+      const page = params.pagination?.current ?? 1;
+      const perPage = params.pagination?.pageSize ?? 10;
+      const result = await pb.collection(params.resource).getList(page, perPage, {
+        sort: buildSort(params.sorters),
+        filter: buildFilter(params.filters),
+      });
+      return {
+        data: result.items as TData[],
+        total: result.totalItems,
+      };
+    },
+
+    async getOne<TData extends BaseRecord = BaseRecord>(params: GetOneParams): Promise<GetOneResult<TData>> {
+      const record = await pb.collection(params.resource).getOne(String(params.id));
+      return { data: record as TData };
+    },
+
+    async create<TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: CreateParams<TVariables>): Promise<CreateResult<TData>> {
+      const record = await pb.collection(params.resource).create(params.variables as Record<string, unknown>);
+      return { data: record as TData };
+    },
+
+    async update<TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: UpdateParams<TVariables>): Promise<UpdateResult<TData>> {
+      const record = await pb.collection(params.resource).update(String(params.id), params.variables as Record<string, unknown>);
+      return { data: record as TData };
+    },
+
+    async deleteOne<TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: DeleteParams<TVariables>): Promise<DeleteResult<TData>> {
+      await pb.collection(params.resource).delete(String(params.id));
+      return { data: { id: params.id } as unknown as TData };
+    },
+
+    async getMany<TData extends BaseRecord = BaseRecord>(params: GetManyParams): Promise<GetManyResult<TData>> {
+      const filter = params.ids.map(id => `id = '${id}'`).join(' || ');
+      const records = await pb.collection(params.resource).getFullList({ filter });
+      return { data: records as TData[] };
+    },
+
+    async deleteMany<TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: DeleteManyParams<TVariables>): Promise<DeleteManyResult<TData>> {
+      const results: unknown[] = [];
+      for (const id of params.ids) {
+        await pb.collection(params.resource).delete(String(id));
+        results.push({ id });
+      }
+      return { data: results as TData[] };
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+// @svadmin/pocketbase — PocketBase adapters
+
+export { createPocketBaseDataProvider } from './data-provider';
+export { createPocketBaseAuthProvider } from './auth-provider';
+export { createPocketBaseLiveProvider } from './live-provider';

package/src/live-provider.ts

@@ -0,0 +1,65 @@
+// @svadmin/pocketbase — PocketBase LiveProvider (SSE Realtime)
+import type { LiveProvider, LiveEvent } from '@svadmin/core';
+
+interface PocketBaseLiveOptions {
+  /** PocketBase client instance */
+  pb: unknown; // PocketBase
+}
+
+// Duck-typed PocketBase realtime interface
+interface PBClientRealtime {
+  collection: (name: string) => {
+    subscribe: (topic: string, callback: (data: PBRealtimeEvent) => void) => Promise<void>;
+    unsubscribe: (topic?: string) => Promise<void>;
+  };
+}
+
+interface PBRealtimeEvent {
+  action: 'create' | 'update' | 'delete';
+  record: Record<string, unknown>;
+}
+
+/**
+ * Map PocketBase realtime action to svadmin LiveEvent type.
+ */
+function mapAction(action: string): LiveEvent['type'] {
+  switch (action) {
+    case 'create': return 'INSERT';
+    case 'update': return 'UPDATE';
+    case 'delete': return 'DELETE';
+    default: return 'UPDATE';
+  }
+}
+
+/**
+ * Create a LiveProvider backed by PocketBase Realtime (SSE).
+ *
+ * Usage:
+ * ```ts
+ * import PocketBase from 'pocketbase';
+ * import { createPocketBaseLiveProvider } from '@svadmin/pocketbase';
+ *
+ * const pb = new PocketBase('http://127.0.0.1:8090');
+ * const liveProvider = createPocketBaseLiveProvider({ pb });
+ * ```
+ */
+export function createPocketBaseLiveProvider(options: PocketBaseLiveOptions): LiveProvider {
+  const pb = options.pb as PBClientRealtime;
+
+  return {
+    subscribe({ resource, callback }) {
+      // PocketBase subscribe uses '*' for all events on a collection
+      pb.collection(resource).subscribe('*', (data) => {
+        callback({
+          type: mapAction(data.action),
+          resource,
+          payload: data.record,
+        });
+      });
+
+      return () => {
+        pb.collection(resource).unsubscribe('*');
+      };
+    },
+  };
+}

package/src/pocketbase.test.ts

@@ -0,0 +1,212 @@
+// @svadmin/pocketbase — Unit Tests
+import { describe, test, expect, mock } from 'bun:test';
+import { createPocketBaseDataProvider } from './data-provider';
+import { createPocketBaseAuthProvider } from './auth-provider';
+import { createPocketBaseLiveProvider } from './live-provider';
+
+// ─── Mock PocketBase Client ─────────────────────────────────
+
+function createMockPB() {
+  const mockCollection = {
+    getList: mock(async () => ({
+      items: [{ id: '1', name: 'Test' }, { id: '2', name: 'Test2' }],
+      totalItems: 2,
+    })),
+    getOne: mock(async (id: string) => ({ id, name: 'Test' })),
+    getFullList: mock(async () => [{ id: '1' }, { id: '2' }]),
+    create: mock(async (data: Record<string, unknown>) => ({ id: 'new-1', ...data })),
+    update: mock(async (id: string, data: Record<string, unknown>) => ({ id, ...data })),
+    delete: mock(async () => true),
+    subscribe: mock(async () => {}),
+    unsubscribe: mock(async () => {}),
+    authWithPassword: mock(async () => ({ record: { id: 'user-1' }, token: 'tok' })),
+    requestPasswordReset: mock(async () => true),
+    confirmPasswordReset: mock(async () => true),
+  };
+
+  return {
+    pb: {
+      collection: mock(() => mockCollection),
+      buildUrl: mock((path: string) => `http://localhost:8090${path}`),
+      authStore: {
+        isValid: true,
+        model: { id: 'user-1', name: 'Admin', email: 'admin@test.com' },
+        clear: mock(() => {}),
+        token: 'test-token',
+      },
+    },
+    mockCollection,
+  };
+}
+
+// ─── DataProvider Tests ─────────────────────────────────────
+
+describe('PocketBase DataProvider', () => {
+  test('getList returns data with total', async () => {
+    const { pb } = createMockPB();
+    const dp = createPocketBaseDataProvider({ pb });
+    const result = await dp.getList({ resource: 'posts' });
+    expect(result.data).toHaveLength(2);
+    expect(result.total).toBe(2);
+  });
+
+  test('getList passes pagination', async () => {
+    const { pb, mockCollection } = createMockPB();
+    const dp = createPocketBaseDataProvider({ pb });
+    await dp.getList({ resource: 'posts', pagination: { current: 3, pageSize: 20 } });
+    expect(mockCollection.getList).toHaveBeenCalledWith(3, 20, expect.anything());
+  });
+
+  test('getList passes sorters', async () => {
+    const { pb, mockCollection } = createMockPB();
+    const dp = createPocketBaseDataProvider({ pb });
+    await dp.getList({ resource: 'posts', sorters: [{ field: 'name', order: 'desc' }] });
+    const opts = mockCollection.getList.mock.calls[0][2] as { sort?: string };
+    expect(opts.sort).toBe('-name');
+  });
+
+  test('getList passes filters', async () => {
+    const { pb, mockCollection } = createMockPB();
+    const dp = createPocketBaseDataProvider({ pb });
+    await dp.getList({ resource: 'posts', filters: [{ field: 'status', operator: 'eq', value: 'active' }] });
+    const opts = mockCollection.getList.mock.calls[0][2] as { filter?: string };
+    expect(opts.filter).toContain("status = 'active'");
+  });
+
+  test('getOne returns single record', async () => {
+    const { pb } = createMockPB();
+    const dp = createPocketBaseDataProvider({ pb });
+    const result = await dp.getOne({ resource: 'posts', id: '1' });
+    expect(result.data).toHaveProperty('id', '1');
+  });
+
+  test('create returns new record', async () => {
+    const { pb } = createMockPB();
+    const dp = createPocketBaseDataProvider({ pb });
+    const result = await dp.create({ resource: 'posts', variables: { name: 'New' } });
+    expect(result.data).toHaveProperty('name', 'New');
+  });
+
+  test('update returns updated record', async () => {
+    const { pb } = createMockPB();
+    const dp = createPocketBaseDataProvider({ pb });
+    const result = await dp.update({ resource: 'posts', id: '1', variables: { name: 'Updated' } });
+    expect(result.data).toHaveProperty('name', 'Updated');
+  });
+
+  test('deleteOne calls delete', async () => {
+    const { pb, mockCollection } = createMockPB();
+    const dp = createPocketBaseDataProvider({ pb });
+    await dp.deleteOne({ resource: 'posts', id: '1' });
+    expect(mockCollection.delete).toHaveBeenCalledWith('1');
+  });
+
+  test('getMany fetches all ids', async () => {
+    const { pb, mockCollection } = createMockPB();
+    const dp = createPocketBaseDataProvider({ pb });
+    const result = await dp.getMany!({ resource: 'posts', ids: ['1', '2'] });
+    expect(result.data).toHaveLength(2);
+    const filterArg = mockCollection.getFullList.mock.calls[0][0] as { filter?: string };
+    expect(filterArg.filter).toContain("id = '1'");
+  });
+
+  test('deleteMany deletes each', async () => {
+    const { pb, mockCollection } = createMockPB();
+    const dp = createPocketBaseDataProvider({ pb });
+    await dp.deleteMany!({ resource: 'posts', ids: ['1', '2'] });
+    expect(mockCollection.delete).toHaveBeenCalledTimes(2);
+  });
+
+  test('getApiUrl returns correct url', () => {
+    const { pb } = createMockPB();
+    const dp = createPocketBaseDataProvider({ pb });
+    expect(dp.getApiUrl()).toBe('http://localhost:8090/api');
+  });
+});
+
+// ─── AuthProvider Tests ─────────────────────────────────────
+
+describe('PocketBase AuthProvider', () => {
+  test('login success', async () => {
+    const { pb } = createMockPB();
+    const auth = createPocketBaseAuthProvider({ pb });
+    const result = await auth.login({ email: 'admin@test.com', password: 'pass' });
+    expect(result.success).toBe(true);
+    expect(result.redirectTo).toBe('/');
+  });
+
+  test('login failure', async () => {
+    const { pb, mockCollection } = createMockPB();
+    mockCollection.authWithPassword = mock(async () => { throw new Error('Invalid credentials'); });
+    const auth = createPocketBaseAuthProvider({ pb });
+    const result = await auth.login({ email: 'bad', password: 'bad' });
+    expect(result.success).toBe(false);
+    expect(result.error?.message).toBe('Invalid credentials');
+  });
+
+  test('logout clears auth store', async () => {
+    const { pb } = createMockPB();
+    const auth = createPocketBaseAuthProvider({ pb });
+    const result = await auth.logout();
+    expect(result.success).toBe(true);
+    expect(pb.authStore.clear).toHaveBeenCalledTimes(1);
+  });
+
+  test('check returns authenticated when valid', async () => {
+    const { pb } = createMockPB();
+    const auth = createPocketBaseAuthProvider({ pb });
+    const result = await auth.check();
+    expect(result.authenticated).toBe(true);
+  });
+
+  test('check returns not authenticated when invalid', async () => {
+    const { pb } = createMockPB();
+    pb.authStore.isValid = false;
+    const auth = createPocketBaseAuthProvider({ pb });
+    const result = await auth.check();
+    expect(result.authenticated).toBe(false);
+  });
+
+  test('getIdentity returns user', async () => {
+    const { pb } = createMockPB();
+    const auth = createPocketBaseAuthProvider({ pb });
+    const identity = await auth.getIdentity();
+    expect(identity).not.toBeNull();
+    expect(identity!.name).toBe('Admin');
+  });
+
+  test('getIdentity returns null when no model', async () => {
+    const { pb } = createMockPB();
+    pb.authStore.model = null as unknown as typeof pb.authStore.model;
+    const auth = createPocketBaseAuthProvider({ pb });
+    const identity = await auth.getIdentity();
+    expect(identity).toBeNull();
+  });
+
+  test('register success', async () => {
+    const { pb } = createMockPB();
+    const auth = createPocketBaseAuthProvider({ pb });
+    const result = await auth.register!({ email: 'new@test.com', password: 'pass', passwordConfirm: 'pass' });
+    expect(result.success).toBe(true);
+  });
+});
+
+// ─── LiveProvider Tests ─────────────────────────────────────
+
+describe('PocketBase LiveProvider', () => {
+  test('subscribe calls pb.collection().subscribe', () => {
+    const { pb, mockCollection } = createMockPB();
+    const lp = createPocketBaseLiveProvider({ pb });
+    const cb = mock(() => {});
+    lp.subscribe({ resource: 'posts', callback: cb });
+    expect(mockCollection.subscribe).toHaveBeenCalledWith('*', expect.any(Function));
+  });
+
+  test('unsubscribe calls pb.collection().unsubscribe', () => {
+    const { pb, mockCollection } = createMockPB();
+    const lp = createPocketBaseLiveProvider({ pb });
+    const unsub = lp.subscribe({ resource: 'posts', callback: () => {} });
+    unsub();
+    expect(mockCollection.unsubscribe).toHaveBeenCalledWith('*');
+  });
+});