@svadmin/elysia 0.6.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/elysia",
-  "version": "0.6.0",
+  "version": "0.9.0",
   "description": "Elysia DataProvider for svadmin — CRUD convention + InferResourceMap type utility",
   "type": "module",
   "sideEffects": false,

package/src/data-provider.test.ts

@@ -0,0 +1,440 @@
+// Tests for enhanced Elysia DataProvider
+import { describe, it, expect, beforeEach, mock, afterEach } from 'bun:test';
+import { createElysiaDataProvider } from './data-provider';
+import type { DataProvider } from '@svadmin/core';
+
+// ─── Mock fetch ──────────────────────────────────────────────
+
+const originalFetch = globalThis.fetch;
+let mockFetchFn: ReturnType<typeof mock>;
+
+function setupMockFetch(response: unknown, status = 200, statusText = 'OK') {
+  mockFetchFn = mock(() =>
+    Promise.resolve({
+      ok: status >= 200 && status < 300,
+      status,
+      statusText,
+      json: () => Promise.resolve(response),
+      text: () => Promise.resolve(JSON.stringify(response)),
+    } as Response)
+  );
+  globalThis.fetch = mockFetchFn as unknown as typeof fetch;
+}
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+// ─── Basic CRUD ──────────────────────────────────────────────
+
+describe('createElysiaDataProvider', () => {
+  let provider: DataProvider;
+
+  beforeEach(() => {
+    provider = createElysiaDataProvider({ apiUrl: 'http://localhost:3000' });
+  });
+
+  it('should return the API URL', () => {
+    expect(provider.getApiUrl()).toBe('http://localhost:3000');
+  });
+
+  // ─── getList ───────────────────────────────────────────────
+
+  describe('getList', () => {
+    it('should fetch list with { items, total } format', async () => {
+      const mockData = { items: [{ id: 1, name: 'Test' }], total: 1 };
+      setupMockFetch(mockData);
+
+      const result = await provider.getList({ resource: 'posts' });
+
+      expect(result.data).toEqual([{ id: 1, name: 'Test' }]);
+      expect(result.total).toBe(1);
+      expect(mockFetchFn).toHaveBeenCalledTimes(1);
+      const [url] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+      expect(url).toContain('http://localhost:3000/posts?');
+      expect(url).toContain('_page=1');
+      expect(url).toContain('_limit=10');
+    });
+
+    it('should fetch list with { data, total } format', async () => {
+      const mockData = { data: [{ id: 1 }, { id: 2 }], total: 42 };
+      setupMockFetch(mockData);
+
+      const result = await provider.getList({ resource: 'users' });
+      expect(result.data).toEqual([{ id: 1 }, { id: 2 }]);
+      expect(result.total).toBe(42);
+    });
+
+    it('should fetch list with raw array format', async () => {
+      const mockData = [{ id: 1 }, { id: 2 }, { id: 3 }];
+      setupMockFetch(mockData);
+
+      const result = await provider.getList({ resource: 'channels' });
+      expect(result.data).toEqual(mockData);
+      expect(result.total).toBe(3);
+    });
+
+    it('should apply pagination params', async () => {
+      setupMockFetch({ items: [], total: 0 });
+
+      await provider.getList({
+        resource: 'posts',
+        pagination: { current: 3, pageSize: 25 },
+      });
+
+      const [url] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+      expect(url).toContain('_page=3');
+      expect(url).toContain('_limit=25');
+    });
+
+    it('should apply sorters', async () => {
+      setupMockFetch({ items: [], total: 0 });
+
+      await provider.getList({
+        resource: 'posts',
+        sorters: [{ field: 'name', order: 'asc' }],
+      });
+
+      const [url] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+      expect(url).toContain('_sort=name');
+      expect(url).toContain('_order=asc');
+    });
+
+    it('should apply filters', async () => {
+      setupMockFetch({ items: [], total: 0 });
+
+      await provider.getList({
+        resource: 'posts',
+        filters: [
+          { field: 'status', operator: 'eq', value: 'active' },
+          { field: 'name', operator: 'contains', value: 'test' },
+          { field: 'age', operator: 'gte', value: 18 },
+        ],
+      });
+
+      const [url] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+      expect(url).toContain('status=active');
+      expect(url).toContain('name_like=test');
+      expect(url).toContain('age_gte=18');
+    });
+  });
+
+  // ─── getOne ────────────────────────────────────────────────
+
+  describe('getOne', () => {
+    it('should fetch a single record', async () => {
+      const mockData = { id: 1, name: 'Test' };
+      setupMockFetch(mockData);
+
+      const result = await provider.getOne({ resource: 'posts', id: 1 });
+      expect(result.data).toEqual(mockData);
+
+      const [url] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe('http://localhost:3000/posts/1');
+    });
+  });
+
+  // ─── create ────────────────────────────────────────────────
+
+  describe('create', () => {
+    it('should create a record with POST', async () => {
+      const mockData = { id: 1, name: 'New' };
+      setupMockFetch(mockData);
+
+      const result = await provider.create({
+        resource: 'posts',
+        variables: { name: 'New' },
+      });
+
+      expect(result.data).toEqual(mockData);
+      const [url, init] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe('http://localhost:3000/posts');
+      expect(init.method).toBe('POST');
+      expect(init.body).toBe('{"name":"New"}');
+    });
+  });
+
+  // ─── update ────────────────────────────────────────────────
+
+  describe('update', () => {
+    it('should default to PATCH method', async () => {
+      const mockData = { id: 1, name: 'Updated' };
+      setupMockFetch(mockData);
+
+      await provider.update({
+        resource: 'posts',
+        id: 1,
+        variables: { name: 'Updated' },
+      });
+
+      const [, init] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+      expect(init.method).toBe('PATCH');
+    });
+  });
+
+  // ─── deleteOne ─────────────────────────────────────────────
+
+  describe('deleteOne', () => {
+    it('should delete a record', async () => {
+      setupMockFetch({ id: 1 });
+
+      const result = await provider.deleteOne({ resource: 'posts', id: 1 });
+      expect(result.data).toEqual({ id: 1 });
+
+      const [url, init] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe('http://localhost:3000/posts/1');
+      expect(init.method).toBe('DELETE');
+    });
+  });
+
+  // ─── error handling ────────────────────────────────────────
+
+  describe('error handling', () => {
+    it('should throw on non-OK response', async () => {
+      setupMockFetch({ error: 'Not found' }, 404, 'Not Found');
+
+      await expect(
+        provider.getOne({ resource: 'posts', id: 999 })
+      ).rejects.toThrow('HTTP 404');
+    });
+  });
+});
+
+// ─── updateMethod option ─────────────────────────────────────
+
+describe('updateMethod: PUT', () => {
+  it('should use PUT for updates when configured', async () => {
+    const provider = createElysiaDataProvider({
+      apiUrl: 'http://localhost:3000',
+      updateMethod: 'PUT',
+    });
+
+    setupMockFetch({ id: 1, name: 'Updated' });
+
+    await provider.update({
+      resource: 'channels',
+      id: 1,
+      variables: { name: 'Updated' },
+    });
+
+    const [url, init] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe('http://localhost:3000/channels/1');
+    expect(init.method).toBe('PUT');
+  });
+
+  it('should use PUT for updateMany when configured', async () => {
+    const provider = createElysiaDataProvider({
+      apiUrl: 'http://localhost:3000',
+      updateMethod: 'PUT',
+    });
+
+    setupMockFetch({ id: 1 });
+
+    await provider.updateMany!({
+      resource: 'channels',
+      ids: [1, 2],
+      variables: { status: 'active' },
+    });
+
+    for (const call of mockFetchFn.mock.calls) {
+      const [, init] = call as [string, RequestInit];
+      expect(init.method).toBe('PUT');
+    }
+  });
+});
+
+// ─── withCredentials option ──────────────────────────────────
+
+describe('withCredentials', () => {
+  it('should include credentials when enabled', async () => {
+    const provider = createElysiaDataProvider({
+      apiUrl: 'http://localhost:3000',
+      withCredentials: true,
+    });
+
+    setupMockFetch({ items: [], total: 0 });
+
+    await provider.getList({ resource: 'posts' });
+
+    const [, init] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+    expect(init.credentials).toBe('include');
+  });
+
+  it('should not include credentials when disabled', async () => {
+    const provider = createElysiaDataProvider({
+      apiUrl: 'http://localhost:3000',
+    });
+
+    setupMockFetch({ items: [], total: 0 });
+
+    await provider.getList({ resource: 'posts' });
+
+    const [, init] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+    expect(init.credentials).toBeUndefined();
+  });
+});
+
+// ─── resourceUrlMap option ───────────────────────────────────
+
+describe('resourceUrlMap', () => {
+  it('should map resource names to custom URL segments', async () => {
+    const provider = createElysiaDataProvider({
+      apiUrl: 'http://localhost:3000/admin',
+      resourceUrlMap: {
+        user_groups: 'user-groups',
+        rateLimits: 'rate-limits',
+      },
+    });
+
+    setupMockFetch([{ id: 1 }]);
+
+    await provider.getList({ resource: 'user_groups' });
+    const [url1] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+    expect(url1).toContain('http://localhost:3000/admin/user-groups?');
+
+    setupMockFetch({ id: 1 });
+
+    await provider.getOne({ resource: 'rateLimits', id: 1 });
+    const [url2] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+    expect(url2).toBe('http://localhost:3000/admin/rate-limits/1');
+  });
+
+  it('should use resource name as-is when no mapping exists', async () => {
+    const provider = createElysiaDataProvider({
+      apiUrl: 'http://localhost:3000',
+      resourceUrlMap: { mapped: 'mapped-url' },
+    });
+
+    setupMockFetch({ items: [], total: 0 });
+
+    await provider.getList({ resource: 'unmapped' });
+    const [url] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+    expect(url).toContain('http://localhost:3000/unmapped?');
+  });
+});
+
+// ─── parseListResponse option ────────────────────────────────
+
+describe('parseListResponse', () => {
+  it('should use custom parser when provided', async () => {
+    const provider = createElysiaDataProvider({
+      apiUrl: 'http://localhost:3000',
+      parseListResponse: <T>(json: unknown) => {
+        const obj = json as { results: T[]; count: number };
+        return { data: obj.results, total: obj.count };
+      },
+    });
+
+    setupMockFetch({ results: [{ id: 1 }], count: 100 });
+
+    const result = await provider.getList({ resource: 'posts' });
+    expect(result.data).toEqual([{ id: 1 }]);
+    expect(result.total).toBe(100);
+  });
+});
+
+// ─── headers option ──────────────────────────────────────────
+
+describe('headers', () => {
+  it('should support static headers', async () => {
+    const provider = createElysiaDataProvider({
+      apiUrl: 'http://localhost:3000',
+      headers: { 'Authorization': 'Bearer token123' },
+    });
+
+    setupMockFetch({ items: [], total: 0 });
+
+    await provider.getList({ resource: 'posts' });
+
+    const [, init] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+    const headers = init.headers as Record<string, string>;
+    expect(headers['Authorization']).toBe('Bearer token123');
+    expect(headers['Content-Type']).toBe('application/json');
+  });
+
+  it('should support dynamic headers function', async () => {
+    let token = 'token1';
+    const provider = createElysiaDataProvider({
+      apiUrl: 'http://localhost:3000',
+      headers: () => ({ 'Authorization': `Bearer ${token}` }),
+    });
+
+    setupMockFetch({ items: [], total: 0 });
+
+    await provider.getList({ resource: 'posts' });
+    let [, init] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+    expect((init.headers as Record<string, string>)['Authorization']).toBe('Bearer token1');
+
+    // Change token
+    token = 'token2';
+    setupMockFetch({ items: [], total: 0 });
+
+    await provider.getList({ resource: 'posts' });
+    [, init] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+    expect((init.headers as Record<string, string>)['Authorization']).toBe('Bearer token2');
+  });
+});
+
+// ─── custom method ───────────────────────────────────────────
+
+describe('custom', () => {
+  it('should support custom API calls', async () => {
+    const provider = createElysiaDataProvider({
+      apiUrl: 'http://localhost:3000',
+      withCredentials: true,
+    });
+
+    setupMockFetch({ success: true, modelsCount: 42 });
+
+    const result = await provider.custom!({
+      url: 'http://localhost:3000/channels/1/sync-models',
+      method: 'post',
+    });
+
+    expect(result.data).toEqual({ success: true, modelsCount: 42 });
+    const [url, init] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe('http://localhost:3000/channels/1/sync-models');
+    expect(init.method).toBe('POST');
+    expect(init.credentials).toBe('include');
+  });
+});
+
+// ─── bulk operations ─────────────────────────────────────────
+
+describe('bulk operations', () => {
+  it('should support getMany', async () => {
+    const provider = createElysiaDataProvider({ apiUrl: 'http://localhost:3000' });
+    setupMockFetch([{ id: 1 }, { id: 2 }]);
+
+    const result = await provider.getMany!({ resource: 'posts', ids: [1, 2] });
+    expect(result.data).toEqual([{ id: 1 }, { id: 2 }]);
+
+    const [url] = mockFetchFn.mock.calls[0] as [string, RequestInit];
+    expect(url).toContain('id=1&id=2');
+  });
+
+  it('should support createMany', async () => {
+    const provider = createElysiaDataProvider({ apiUrl: 'http://localhost:3000' });
+    setupMockFetch({ id: 1, name: 'A' });
+
+    const result = await provider.createMany!({
+      resource: 'posts',
+      variables: [{ name: 'A' }, { name: 'B' }],
+    });
+
+    expect(mockFetchFn).toHaveBeenCalledTimes(2);
+  });
+
+  it('should support deleteMany', async () => {
+    const provider = createElysiaDataProvider({ apiUrl: 'http://localhost:3000' });
+    setupMockFetch({ success: true });
+
+    await provider.deleteMany!({ resource: 'posts', ids: [1, 2, 3] });
+
+    expect(mockFetchFn).toHaveBeenCalledTimes(3);
+    for (const call of mockFetchFn.mock.calls) {
+      const [, init] = call as [string, RequestInit];
+      expect(init.method).toBe('DELETE');
+    }
+  });
+});

package/src/data-provider.ts

@@ -1,6 +1,6 @@
 // Elysia DataProvider — CRUD convention compatible
 // Expects backend routes following: GET /resource, GET /resource/:id, POST /resource, PATCH /resource/:id, DELETE /resource/:id
-// Response format for lists: { items: T[], total: number }
+// Response format for lists: { items: T[], total: number } (also supports raw arrays)
 
 import type {
   DataProvider, GetListParams, GetListResult, GetOneParams, GetOneResult,
@@ -15,16 +15,51 @@ export interface ElysiaDataProviderOptions {
   apiUrl: string;
   /** Static headers or a function returning headers (useful for auth tokens) */
   headers?: Record<string, string> | (() => Record<string, string>);
+  /**
+   * HTTP method to use for update operations.
+   * @default 'PATCH'
+   */
+  updateMethod?: 'PATCH' | 'PUT';
+  /**
+   * Whether to include credentials (cookies) in requests.
+   * Set to `true` for cookie-based authentication.
+   * @default false
+   */
+  withCredentials?: boolean;
+  /**
+   * Custom resource-to-URL segment mapping.
+   * Maps a resource name to a URL segment, e.g. `{ user_groups: 'user-groups' }`.
+   * When not provided, the resource name is used as-is.
+   */
+  resourceUrlMap?: Record<string, string>;
+  /**
+   * Custom response parser for list endpoints.
+   * When provided, this function extracts `{ data, total }` from the raw JSON response.
+   * Use the `resource` parameter to apply different parsers per resource.
+   * Useful when the backend response format differs from `{ items, total }`.
+   *
+   * @default Handles `{ items, total }` and raw arrays automatically
+   */
+  parseListResponse?: <T>(json: unknown, resource: string) => { data: T[]; total: number };
 }
 
 function resolveHeaders(opts: ElysiaDataProviderOptions): Record<string, string> {
-  const base = { 'Content-Type': 'application/json' };
+  const base: Record<string, string> = { 'Content-Type': 'application/json' };
   const extra = typeof opts.headers === 'function' ? opts.headers() : (opts.headers ?? {});
   return { ...base, ...extra };
 }
 
-async function request<T>(url: string, headers: Record<string, string>, init?: RequestInit): Promise<T> {
-  const response = await fetch(url, { ...init, headers: { ...headers, ...init?.headers } });
+function resolveResourceUrl(opts: ElysiaDataProviderOptions, resource: string): string {
+  const segment = opts.resourceUrlMap?.[resource] ?? resource;
+  return `${opts.apiUrl}/${segment}`;
+}
+
+async function request<T>(url: string, headers: Record<string, string>, init?: RequestInit, withCredentials?: boolean): Promise<T> {
+  const fetchInit: RequestInit = { ...init, headers: { ...headers, ...init?.headers } };
+  if (withCredentials) {
+    fetchInit.credentials = 'include';
+  }
+  const response = await fetch(url, fetchInit);
   if (!response.ok) {
     const body = await response.text().catch(() => '');
     throw new Error(`HTTP ${response.status}: ${response.statusText}${body ? ` — ${body}` : ''}`);
@@ -32,14 +67,49 @@ async function request<T>(url: string, headers: Record<string, string>, init?: R
   return response.json();
 }
 
+/**
+ * Default list response parser.
+ * Supports:
+ * - `{ items: T[], total: number }` (standard)
+ * - `{ data: T[], total: number }` (common alternative)
+ * - `T[]` (raw array — total is inferred from array length)
+ */
+function defaultParseListResponse<T>(json: unknown): { data: T[]; total: number } {
+  if (Array.isArray(json)) {
+    return { data: json as T[], total: json.length };
+  }
+  const obj = json as Record<string, unknown>;
+  if (Array.isArray(obj.items)) {
+    return { data: obj.items as T[], total: obj.total !== undefined ? Number(obj.total) : obj.items.length };
+  }
+  if (Array.isArray(obj.data)) {
+    return { data: obj.data as T[], total: obj.total !== undefined ? Number(obj.total) : obj.data.length };
+  }
+  throw new Error('Unrecognized list response format. Expected { items, total }, { data, total }, or an array.');
+}
+
 /**
  * Creates a DataProvider for Elysia backends using the CRUD plugin convention.
  *
- * List responses are expected to return `{ items: T[], total: number }`.
- * Single-record responses return the record directly.
+ * List responses support multiple formats:
+ * - `{ items: T[], total: number }` (standard CRUD convention)
+ * - `{ data: T[], total: number }` (common alternative)
+ * - `T[]` (raw array — total is inferred from length)
+ *
+ * @example
+ * ```ts
+ * const dataProvider = createElysiaDataProvider({
+ *   apiUrl: 'http://localhost:3000/api',
+ *   withCredentials: true,  // cookie auth
+ *   updateMethod: 'PUT',    // use PUT instead of PATCH
+ *   resourceUrlMap: {
+ *     user_groups: 'user-groups',
+ *   },
+ * });
+ * ```
  */
 export function createElysiaDataProvider(opts: ElysiaDataProviderOptions): DataProvider {
-  const { apiUrl } = opts;
+  const { apiUrl, updateMethod = 'PATCH', withCredentials = false } = opts;
 
   return {
     getApiUrl: () => apiUrl,
@@ -63,78 +133,91 @@ export function createElysiaDataProvider(opts: ElysiaDataProviderOptions): DataP
         }
       }
 
-      const url = `${apiUrl}/${resource}?${params.toString()}`;
+      const baseUrl = resolveResourceUrl(opts, resource);
+      const url = `${baseUrl}?${params.toString()}`;
       const headers = resolveHeaders(opts);
-      const json = await request<{ items: TData[]; total: number }>(url, headers);
-      return { data: json.items, total: json.total };
+      const json = await request<unknown>(url, headers, undefined, withCredentials);
+
+      if (opts.parseListResponse) {
+        return opts.parseListResponse<TData>(json, resource);
+      }
+      return defaultParseListResponse<TData>(json);
     },
 
     async getOne<TData extends BaseRecord = BaseRecord>({ resource, id }: GetOneParams): Promise<GetOneResult<TData>> {
-      const data = await request<TData>(`${apiUrl}/${resource}/${id}`, resolveHeaders(opts));
+      const baseUrl = resolveResourceUrl(opts, resource);
+      const data = await request<TData>(`${baseUrl}/${id}`, resolveHeaders(opts), undefined, withCredentials);
       return { data };
     },
 
     async create<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, variables }: CreateParams<TVariables>): Promise<CreateResult<TData>> {
-      const data = await request<TData>(`${apiUrl}/${resource}`, resolveHeaders(opts), {
+      const baseUrl = resolveResourceUrl(opts, resource);
+      const data = await request<TData>(baseUrl, resolveHeaders(opts), {
         method: 'POST',
         body: JSON.stringify(variables),
-      });
+      }, withCredentials);
       return { data };
     },
 
     async update<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, id, variables }: UpdateParams<TVariables>): Promise<UpdateResult<TData>> {
-      const data = await request<TData>(`${apiUrl}/${resource}/${id}`, resolveHeaders(opts), {
-        method: 'PATCH',
+      const baseUrl = resolveResourceUrl(opts, resource);
+      const data = await request<TData>(`${baseUrl}/${id}`, resolveHeaders(opts), {
+        method: updateMethod,
         body: JSON.stringify(variables),
-      });
+      }, withCredentials);
       return { data };
     },
 
     async deleteOne<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, id }: DeleteParams<TVariables>): Promise<DeleteResult<TData>> {
-      const data = await request<TData>(`${apiUrl}/${resource}/${id}`, resolveHeaders(opts), {
+      const baseUrl = resolveResourceUrl(opts, resource);
+      const data = await request<TData>(`${baseUrl}/${id}`, resolveHeaders(opts), {
         method: 'DELETE',
-      });
+      }, withCredentials);
       return { data };
     },
 
     async getMany<TData extends BaseRecord = BaseRecord>({ resource, ids }: GetManyParams): Promise<GetManyResult<TData>> {
-      const params = ids.map(id => `id=${id}`).join('&');
-      const data = await request<TData[]>(`${apiUrl}/${resource}?${params}`, resolveHeaders(opts));
+      const baseUrl = resolveResourceUrl(opts, resource);
+      const params = ids.map(id => `id=${encodeURIComponent(String(id))}`).join('&');
+      const data = await request<TData[]>(`${baseUrl}?${params}`, resolveHeaders(opts), undefined, withCredentials);
       return { data };
     },
 
     async createMany<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, variables }: CreateManyParams<TVariables>): Promise<CreateManyResult<TData>> {
-      const results: TData[] = [];
-      for (const vars of variables) {
-        const data = await request<TData>(`${apiUrl}/${resource}`, resolveHeaders(opts), {
-          method: 'POST',
-          body: JSON.stringify(vars),
-        });
-        results.push(data);
-      }
+      const baseUrl = resolveResourceUrl(opts, resource);
+      const results = await Promise.all(
+        variables.map(vars =>
+          request<TData>(baseUrl, resolveHeaders(opts), {
+            method: 'POST',
+            body: JSON.stringify(vars),
+          }, withCredentials)
+        )
+      );
       return { data: results };
     },
 
     async updateMany<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, ids, variables }: UpdateManyParams<TVariables>): Promise<UpdateManyResult<TData>> {
-      const results: TData[] = [];
-      for (const id of ids) {
-        const data = await request<TData>(`${apiUrl}/${resource}/${id}`, resolveHeaders(opts), {
-          method: 'PATCH',
-          body: JSON.stringify(variables),
-        });
-        results.push(data);
-      }
+      const baseUrl = resolveResourceUrl(opts, resource);
+      const results = await Promise.all(
+        ids.map(id =>
+          request<TData>(`${baseUrl}/${id}`, resolveHeaders(opts), {
+            method: updateMethod,
+            body: JSON.stringify(variables),
+          }, withCredentials)
+        )
+      );
       return { data: results };
     },
 
     async deleteMany<TData extends BaseRecord = BaseRecord, TVariables = unknown>({ resource, ids }: DeleteManyParams<TVariables>): Promise<DeleteManyResult<TData>> {
-      const results: TData[] = [];
-      for (const id of ids) {
-        const data = await request<TData>(`${apiUrl}/${resource}/${id}`, resolveHeaders(opts), {
-          method: 'DELETE',
-        });
-        results.push(data);
-      }
+      const baseUrl = resolveResourceUrl(opts, resource);
+      const results = await Promise.all(
+        ids.map(id =>
+          request<TData>(`${baseUrl}/${id}`, resolveHeaders(opts), {
+            method: 'DELETE',
+          }, withCredentials)
+        )
+      );
       return { data: results };
     },
 
@@ -142,7 +225,7 @@ export function createElysiaDataProvider(opts: ElysiaDataProviderOptions): DataP
       const data = await request<TData>(url, { ...resolveHeaders(opts), ...headers }, {
         method: method.toUpperCase(),
         body: payload ? JSON.stringify(payload) : undefined,
-      });
+      }, withCredentials);
       return { data };
     },
   };