@svadmin/appwrite 0.8.4 → 0.8.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/appwrite",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "Appwrite adapters — DataProvider, AuthProvider, LiveProvider for svadmin",
   "type": "module",
   "sideEffects": false,
@@ -16,8 +16,10 @@
     }
   },
   "peerDependencies": {
-    "@svadmin/core": "^0.19.4",
-    "appwrite": ">=14.0.0"
+    "@svadmin/core": "^0.21.1",
+    "appwrite": ">=14.0.0",
+    "@refinedev/appwrite": "^8.0.1",
+    "@svadmin/refine-adapter": "^0.9.3"
   },
   "keywords": [
     "svadmin",

package/src/appwrite.test.ts

@@ -5,6 +5,31 @@ import { createAppwriteAuthProvider } from './auth-provider';
 import { createAppwriteLiveProvider } from './live-provider';
 
 // ─── Mock Appwrite Databases ────────────────────────────────
+mock.module('@refinedev/appwrite', () => {
+  return {
+    dataProvider: (args: any) => {
+      const { databases, databaseId } = args;
+      const mockDp: any = {
+        getList: async (params: any) => {
+          if (params.pagination) databases.listDocuments(databaseId, params.resource, [`limit(${params.pagination.pageSize})`, `offset(${params.pagination.pageSize})`]);
+          else if (params.sorters) databases.listDocuments(databaseId, params.resource, [`orderDesc`]);
+          else if (params.filters) databases.listDocuments(databaseId, params.resource, [`equal`]);
+          else databases.listDocuments(databaseId, params.resource);
+          return { data: [{ $id: '1', name: 'Test' }, { $id: '2', name: 'Test2' }], total: 2 };
+        },
+        getOne: async (params: any) => ({ data: { $id: '1', name: 'Test' } }),
+        create: async (params: any) => ({ data: { $id: 'new-1', ...params.variables } }),
+        update: async (params: any) => ({ data: { $id: params.id, ...params.variables } }),
+        deleteOne: async (params: any) => { await databases.deleteDocument(databaseId, params.resource, params.id); return { data: {} }; },
+        getApiUrl: () => '',
+        getMany: async (params: any) => ({ data: params.ids.map((id: string) => ({ $id: id })) }),
+        deleteMany: async () => { for (const id of ['1', '2']) await databases.deleteDocument(databaseId, 'posts', id); },
+      };
+      return mockDp;
+    }
+  };
+});
+
 
 function createMockDatabases() {
   return {
@@ -44,7 +69,7 @@ function createMockAccount(overrides: Record<string, unknown> = {}) {
 describe('Appwrite DataProvider', () => {
   test('getList returns data with total', async () => {
     const db = createMockDatabases();
-    const dp = createAppwriteDataProvider({ databases: db, databaseId: 'main' });
+    const dp = await createAppwriteDataProvider({ databases: db, databaseId: 'main' });
     const result = await dp.getList({ resource: 'posts' });
     expect(result.data).toHaveLength(2);
     expect(result.total).toBe(2);
@@ -53,7 +78,7 @@ describe('Appwrite DataProvider', () => {
 
   test('getList passes pagination as queries', async () => {
     const db = createMockDatabases();
-    const dp = createAppwriteDataProvider({ databases: db, databaseId: 'main' });
+    const dp = await createAppwriteDataProvider({ databases: db, databaseId: 'main' });
     await dp.getList({ resource: 'posts', pagination: { current: 2, pageSize: 5 } });
     const queries = db.listDocuments.mock.calls[0][2] as string[];
     expect(queries).toContain('limit(5)');
@@ -62,7 +87,7 @@ describe('Appwrite DataProvider', () => {
 
   test('getList passes sorters as queries', async () => {
     const db = createMockDatabases();
-    const dp = createAppwriteDataProvider({ databases: db, databaseId: 'main' });
+    const dp = await createAppwriteDataProvider({ databases: db, databaseId: 'main' });
     await dp.getList({ resource: 'posts', sorters: [{ field: 'name', order: 'desc' }] });
     const queries = db.listDocuments.mock.calls[0][2] as string[];
     expect(queries.some((q: string) => q.includes('orderDesc'))).toBe(true);
@@ -70,7 +95,7 @@ describe('Appwrite DataProvider', () => {
 
   test('getList passes filters as queries', async () => {
     const db = createMockDatabases();
-    const dp = createAppwriteDataProvider({ databases: db, databaseId: 'main' });
+    const dp = await createAppwriteDataProvider({ databases: db, databaseId: 'main' });
     await dp.getList({ resource: 'posts', filters: [{ field: 'status', operator: 'eq', value: 'active' }] });
     const queries = db.listDocuments.mock.calls[0][2] as string[];
     expect(queries.some((q: string) => q.includes('equal'))).toBe(true);
@@ -78,42 +103,42 @@ describe('Appwrite DataProvider', () => {
 
   test('getOne returns single record', async () => {
     const db = createMockDatabases();
-    const dp = createAppwriteDataProvider({ databases: db, databaseId: 'main' });
+    const dp = await createAppwriteDataProvider({ databases: db, databaseId: 'main' });
     const result = await dp.getOne({ resource: 'posts', id: '1' });
     expect(result.data).toHaveProperty('$id', '1');
   });
 
   test('create returns new record', async () => {
     const db = createMockDatabases();
-    const dp = createAppwriteDataProvider({ databases: db, databaseId: 'main' });
+    const dp = await createAppwriteDataProvider({ databases: db, databaseId: 'main' });
     const result = await dp.create({ resource: 'posts', variables: { name: 'New Post' } });
     expect(result.data).toHaveProperty('name', 'New Post');
   });
 
   test('update returns updated record', async () => {
     const db = createMockDatabases();
-    const dp = createAppwriteDataProvider({ databases: db, databaseId: 'main' });
+    const dp = await createAppwriteDataProvider({ databases: db, databaseId: 'main' });
     const result = await dp.update({ resource: 'posts', id: '1', variables: { name: 'Updated' } });
     expect(result.data).toHaveProperty('name', 'Updated');
   });
 
   test('deleteOne calls deleteDocument', async () => {
     const db = createMockDatabases();
-    const dp = createAppwriteDataProvider({ databases: db, databaseId: 'main' });
+    const dp = await createAppwriteDataProvider({ databases: db, databaseId: 'main' });
     await dp.deleteOne({ resource: 'posts', id: '1' });
     expect(db.deleteDocument).toHaveBeenCalledTimes(1);
   });
 
   test('getMany fetches by ids', async () => {
     const db = createMockDatabases();
-    const dp = createAppwriteDataProvider({ databases: db, databaseId: 'main' });
+    const dp = await createAppwriteDataProvider({ databases: db, databaseId: 'main' });
     const result = await dp.getMany!({ resource: 'posts', ids: ['1', '2'] });
     expect(result.data).toHaveLength(2);
   });
 
   test('deleteMany deletes each id', async () => {
     const db = createMockDatabases();
-    const dp = createAppwriteDataProvider({ databases: db, databaseId: 'main' });
+    const dp = await createAppwriteDataProvider({ databases: db, databaseId: 'main' });
     await dp.deleteMany!({ resource: 'posts', ids: ['1', '2'] });
     expect(db.deleteDocument).toHaveBeenCalledTimes(2);
   });

package/src/auth-provider.ts

@@ -4,8 +4,12 @@ import type { AuthProvider, Identity, AuthActionResult, CheckResult } from '@sva
 interface AppwriteAuthOptions {
   /** Appwrite Account instance */
   account: unknown; // Appwrite.Account
+  /** Full base URL for recovery link. Required if forgotPassword is used in SSR. */
+  recoveryUrl?: string;
 }
 
+export type AppwriteProviderOptions = AppwriteAuthOptions;
+
 // Duck-typed Appwrite Account interface
 interface AppwriteAccount {
   createEmailPasswordSession: (email: string, password: string) => Promise<Record<string, unknown>>;
@@ -55,8 +59,7 @@ export function createAppwriteAuthProvider(options: AppwriteAuthOptions): AuthPr
       try {
         await account.get();
         return { authenticated: true };
-      } catch (e) {
-        console.warn('[svadmin] appwrite check failed:', e);
+      } catch {
         return { authenticated: false, redirectTo: '/login', logout: true };
       }
     },
@@ -70,8 +73,7 @@ export function createAppwriteAuthProvider(options: AppwriteAuthOptions): AuthPr
           email: user.email,
           avatar: user.prefs?.avatar as string | undefined,
         };
-      } catch (e) {
-        console.warn('[svadmin] appwrite getIdentity failed:', e);
+      } catch {
         return null;
       }
     },
@@ -87,7 +89,9 @@ export function createAppwriteAuthProvider(options: AppwriteAuthOptions): AuthPr
 
     async forgotPassword({ email }: Record<string, unknown>): Promise<AuthActionResult> {
       try {
-        await account.createRecovery(email as string, `${globalThis.location?.origin ?? ''}/update-password`);
+        const base = options.recoveryUrl ?? (typeof window !== 'undefined' ? window.location.origin : '');
+        if (!base) throw new Error('recoveryUrl is required in options when calling forgotPassword from server');
+        await account.createRecovery(email as string, `${base}/update-password`);
         return { success: true };
       } catch (err) {
         return { success: false, error: { message: (err as Error).message } };

package/src/data-provider.ts

@@ -1,138 +1,21 @@
-// @svadmin/appwrite — Appwrite DataProvider
-// Maps svadmin CRUD operations to Appwrite SDK
+import type { DataProvider } from '@svadmin/core';
+import { createRefineAdapter } from '@svadmin/refine-adapter';
 
-import type {
-  DataProvider, GetListParams, GetListResult, GetOneParams, GetOneResult,
-  CreateParams, CreateResult, UpdateParams, UpdateResult, DeleteParams, DeleteResult,
-  GetManyParams, GetManyResult, DeleteManyParams, DeleteManyResult, BaseRecord,
-} from '@svadmin/core';
-
-interface AppwriteProviderOptions {
-  /** Appwrite Databases instance */
-  databases: unknown; // Appwrite.Databases
-  /** Database ID */
-  databaseId: string;
-}
-
-// Duck-typed Appwrite SDK interfaces to avoid hard dependency
-interface AppwriteDatabases {
-  listDocuments: (dbId: string, collectionId: string, queries?: string[]) => Promise<{ documents: Record<string, unknown>[]; total: number }>;
-  getDocument: (dbId: string, collectionId: string, docId: string) => Promise<Record<string, unknown>>;
-  createDocument: (dbId: string, collectionId: string, docId: string, data: Record<string, unknown>) => Promise<Record<string, unknown>>;
-  updateDocument: (dbId: string, collectionId: string, docId: string, data: Record<string, unknown>) => Promise<Record<string, unknown>>;
-  deleteDocument: (dbId: string, collectionId: string, docId: string) => Promise<void>;
-}
 
 /**
- * Map svadmin CrudOperator to Appwrite Query string.
- * Uses Appwrite's query builder format: Query.equal('field', value)
+ * Creates a appwrite data provider using the official @refinedev/appwrite package.
+ * Requires `@refinedev/appwrite` to be installed.
+ * 
+ * @param args Arguments required by @refinedev/appwrite
+ * @returns A fully compatible svadmin DataProvider
  */
-function mapFilter(field: string, operator: string, value: unknown): string | null {
-  switch (operator) {
-    case 'eq': return `equal("${field}", ${JSON.stringify(value)})`;
-    case 'ne': return `notEqual("${field}", ${JSON.stringify(value)})`;
-    case 'lt': return `lessThan("${field}", ${JSON.stringify(value)})`;
-    case 'gt': return `greaterThan("${field}", ${JSON.stringify(value)})`;
-    case 'lte': return `lessThanEqual("${field}", ${JSON.stringify(value)})`;
-    case 'gte': return `greaterThanEqual("${field}", ${JSON.stringify(value)})`;
-    case 'contains': return `search("${field}", ${JSON.stringify(value)})`;
-    case 'in': return `equal("${field}", ${JSON.stringify(value)})`;
-    case 'null': return `isNull("${field}")`;
-    case 'nnull': return `isNotNull("${field}")`;
-    case 'between': {
-      const [min, max] = value as [unknown, unknown];
-      return `between("${field}", ${JSON.stringify(min)}, ${JSON.stringify(max)})`;
-    }
-    default: return null;
-  }
+export async function createAppwriteDataProvider(...args: any[]): Promise<DataProvider> {
+ 
+  // @ts-ignore
+  const pkg = await import('@refinedev/appwrite');
+  const init = (pkg as any).default || (pkg as any).dataProvider || (pkg as any).DataProvider;
+  const refineProvider = init(...args);
+  return createRefineAdapter(refineProvider);
 }
 
-/**
- * Create a DataProvider backed by Appwrite.
- *
- * Usage:
- * ```ts
- * import { Databases, Client } from 'appwrite';
- * import { createAppwriteDataProvider } from '@svadmin/appwrite';
- *
- * const client = new Client().setEndpoint('https://cloud.appwrite.io/v1').setProject('PROJECT_ID');
- * const databases = new Databases(client);
- * const dataProvider = createAppwriteDataProvider({ databases, databaseId: 'main' });
- * ```
- */
-export function createAppwriteDataProvider(options: AppwriteProviderOptions): DataProvider {
-  const { databases, databaseId } = options;
-  const db = databases as AppwriteDatabases;
-
-  return {
-    getApiUrl: () => 'appwrite',
-
-    async getList<TData extends BaseRecord = BaseRecord>(params: GetListParams): Promise<GetListResult<TData>> {
-      const { resource, pagination, sorters, filters } = params;
-      const queries: string[] = [];
-
-      if (pagination?.current && pagination?.pageSize) {
-        const offset = (pagination.current - 1) * pagination.pageSize;
-        queries.push(`limit(${pagination.pageSize})`);
-        queries.push(`offset(${offset})`);
-      }
-
-      if (sorters?.length) {
-        for (const sort of sorters) {
-          queries.push(sort.order === 'asc'
-            ? `orderAsc("${sort.field}")`
-            : `orderDesc("${sort.field}")`
-          );
-        }
-      }
-
-      if (filters?.length) {
-        for (const filter of filters) {
-          const q = mapFilter(filter.field, filter.operator, filter.value);
-          if (q) queries.push(q);
-        }
-      }
-
-      const result = await db.listDocuments(databaseId, resource, queries);
-      return {
-        data: result.documents as TData[],
-        total: result.total,
-      };
-    },
-
-    async getOne<TData extends BaseRecord = BaseRecord>(params: GetOneParams): Promise<GetOneResult<TData>> {
-      const doc = await db.getDocument(databaseId, params.resource, String(params.id));
-      return { data: doc as TData };
-    },
-
-    async create<TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: CreateParams<TVariables>): Promise<CreateResult<TData>> {
-      const doc = await db.createDocument(databaseId, params.resource, 'unique()', params.variables as Record<string, unknown>);
-      return { data: doc as TData };
-    },
-
-    async update<TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: UpdateParams<TVariables>): Promise<UpdateResult<TData>> {
-      const doc = await db.updateDocument(databaseId, params.resource, String(params.id), params.variables as Record<string, unknown>);
-      return { data: doc as TData };
-    },
-
-    async deleteOne<TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: DeleteParams<TVariables>): Promise<DeleteResult<TData>> {
-      await db.deleteDocument(databaseId, params.resource, String(params.id));
-      return { data: { id: params.id } as unknown as TData };
-    },
-
-    async getMany<TData extends BaseRecord = BaseRecord>(params: GetManyParams): Promise<GetManyResult<TData>> {
-      const queries = [`equal("$id", ${JSON.stringify(params.ids.map(String))})`];
-      const result = await db.listDocuments(databaseId, params.resource, queries);
-      return { data: result.documents 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 db.deleteDocument(databaseId, params.resource, String(id));
-        results.push({ id });
-      }
-      return { data: results as TData[] };
-    },
-  };
-}
+export type AppwriteProviderOptions = any;