@data-client/rest 0.16.4 → 0.16.6

package/src/__tests__/RestEndpoint.ts

@@ -1,4 +1,4 @@
-import { Entity, schema, Collection } from '@data-client/endpoint';
+import { Entity, schema, Collection, Values } from '@data-client/endpoint';
 import { useController, useCache } from '@data-client/react';
 import { useSuspense } from '@data-client/react';
 import { CacheProvider } from '@data-client/react';
@@ -145,6 +145,13 @@ const getNextPage3 = getArticleList3.getPage;
   flat.move.schema satisfies number;
   // @ts-expect-error - push schema should not be any
   flat.push.schema satisfies number;
+  // body should be derived from collection's entity schema, not any
+  // @ts-expect-error
+  flat.push.body satisfies number;
+  // @ts-expect-error
+  flat.move.body satisfies number;
+  // @ts-expect-error
+  flat.remove.body satisfies number;
 
   // nested Collection schema should also be typed
   const nested = new RestEndpoint({
@@ -161,6 +168,63 @@ const getNextPage3 = getArticleList3.getPage;
   nested.move.schema satisfies number;
   // @ts-expect-error - nested push schema should not be any
   nested.push.schema satisfies number;
+  // @ts-expect-error
+  nested.push.body satisfies number;
+  // @ts-expect-error
+  nested.move.body satisfies number;
+  // @ts-expect-error
+  nested.remove.body satisfies number;
+
+  // With explicit body: PATCH extenders should have Partial body
+  type Body = { title: string; content: string };
+  const withBody = new RestEndpoint({
+    urlPrefix: 'http://test.com',
+    path: '/articles/:id',
+    schema: new Collection([PaginatedArticle]),
+    method: 'GET',
+    body: {} as Body,
+  });
+  // POST extenders keep full body type
+  // @ts-expect-error - push body should not be any
+  withBody.push.body satisfies number;
+  withBody.push.body satisfies Body | Body[] | FormData | undefined;
+  // @ts-expect-error - unshift body should not be any
+  withBody.unshift.body satisfies number;
+  // PATCH extenders get Partial body (like partialUpdate)
+  // @ts-expect-error - move body should not be any
+  withBody.move.body satisfies number;
+  withBody.move.body satisfies Partial<Body> | FormData | undefined;
+  // @ts-expect-error - remove body should not be any
+  withBody.remove.body satisfies number;
+  withBody.remove.body satisfies
+    | Partial<Body>
+    | Partial<Body>[]
+    | FormData
+    | undefined;
+  // push body requires full Body (not partial)
+  () => withBody.push({ id: 'a' }, { title: 'hi', content: 'there' });
+  // @ts-expect-error - push rejects partial body
+  () => withBody.push({ id: 'a' }, { title: 'hi' });
+  // move body accepts partial Body (PATCH semantics)
+  () => withBody.move({ id: 'a' }, { title: 'hi' });
+  () => withBody.move({ id: 'a' }, { content: 'there' });
+  // @ts-expect-error - move rejects invalid fields
+  () => withBody.move({ id: 'a' }, { invalid: 'field' });
+
+  // Values Collection: assign body should accept Record<string, entity>
+  const valuesEndpoint = new RestEndpoint({
+    urlPrefix: 'http://test.com',
+    path: '/articles',
+    schema: new Collection(new Values(PaginatedArticle)),
+    method: 'GET',
+  });
+  // @ts-expect-error - assign body should not be any
+  valuesEndpoint.assign.body satisfies number;
+  valuesEndpoint.assign.body satisfies
+    | Record<string, Partial<PaginatedArticle>>
+    | FormData
+    | undefined;
+  () => valuesEndpoint.assign({ myKey: { id: 5, title: 'hi', content: 'ho' } });
 };
 
 describe('RestEndpoint', () => {
@@ -1736,6 +1800,426 @@ describe('RestEndpoint.fetch()', () => {
     expect(() => noColletionEndpoint.getPage).toThrowErrorMatchingSnapshot();
   });
 });
+
+describe('content property', () => {
+  const binaryData = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+
+  it("content: 'blob' calls response.blob()", async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/octet-stream',
+      })
+      .get('/files/1')
+      .reply(200, binaryData);
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+      content: 'blob',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it("content: 'text' calls response.text()", async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'text/plain',
+      })
+      .get('/files/1')
+      .reply(200, 'hello world');
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+      content: 'text',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBe('hello world');
+  });
+
+  it("content: 'json' calls response.json() strictly", async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'text/plain',
+      })
+      .get('/files/1')
+      .reply(200, { ok: true });
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+      content: 'json',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toEqual({ ok: true });
+  });
+
+  it('content: blob with schema set throws', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/octet-stream',
+      })
+      .get('/files/1')
+      .reply(200, binaryData);
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+      content: 'blob',
+      schema: User,
+    } as any);
+    await expect(async () => await ep({ id: 1 })).rejects.toMatchObject({
+      status: 400,
+      message: expect.stringContaining('incompatible with schema'),
+    });
+  });
+
+  it.each(['blob', 'text', 'arrayBuffer', 'stream'] as const)(
+    'content: %s with schema warns at construction',
+    content => {
+      const errorSpy = jest
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      try {
+        new RestEndpoint({
+          path: 'http\\://test.com/files/:id',
+          content,
+          schema: User,
+        } as any);
+        expect(errorSpy).toHaveBeenCalledWith(
+          expect.stringContaining('incompatible with schema'),
+        );
+      } finally {
+        errorSpy.mockRestore();
+      }
+    },
+  );
+
+  it('204 with content: blob returns null', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+      })
+      .get('/files/1')
+      .reply(204);
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+      content: 'blob',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBe(null);
+  });
+
+  it("extend({ content: 'blob' }) propagates", async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/octet-stream',
+      })
+      .get('/files/1')
+      .reply(200, binaryData);
+
+    const base = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const blobEp = base.extend({ content: 'blob' });
+    expect(blobEp.content).toBe('blob');
+    const result = await blobEp({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('subclass with content = blob works', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/octet-stream',
+      })
+      .get('/files/1')
+      .reply(200, binaryData);
+
+    class BlobEndpoint<O extends RestGenerics = any> extends RestEndpoint<O> {
+      content = 'blob' as const;
+    }
+    const ep = new BlobEndpoint({ path: 'http\\://test.com/files/:id' });
+    expect(ep.content).toBe('blob');
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it("content: 'arrayBuffer' calls response.arrayBuffer()", async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/octet-stream',
+      })
+      .get('/files/1')
+      .reply(200, Buffer.from([1, 2, 3, 4]));
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+      content: 'arrayBuffer',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(ArrayBuffer);
+  });
+
+  it("content: 'stream' returns response.body", async () => {
+    const mockBody = {
+      getReader() {
+        return {};
+      },
+    };
+    const mockResponse = {
+      ok: true,
+      status: 200,
+      body: mockBody,
+      headers: new Headers({ 'Content-Type': 'application/octet-stream' }),
+    } as unknown as Response;
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+      content: 'stream',
+      fetchResponse() {
+        return Promise.resolve(mockResponse);
+      },
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBe(mockBody);
+  });
+});
+
+describe('auto-detection (no content)', () => {
+  it('Content-Type: image/png returns blob', async () => {
+    const imgData = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'image/png',
+      })
+      .get('/files/1')
+      .reply(200, imgData);
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('Content-Type: application/octet-stream returns blob', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/octet-stream',
+      })
+      .get('/files/1')
+      .reply(200, Buffer.from([1, 2, 3]));
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('Content-Type: application/pdf returns blob', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/pdf',
+      })
+      .get('/files/1')
+      .reply(200, Buffer.from([0x25, 0x50, 0x44, 0x46]));
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('Content-Type: text/plain returns text (unchanged)', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'text/plain',
+      })
+      .get('/files/1')
+      .reply(200, 'plain text');
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBe('plain text');
+  });
+
+  it('Content-Type: application/json returns JSON (unchanged)', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/json',
+      })
+      .get('/files/1')
+      .reply(200, { id: 1, name: 'test' });
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toEqual({ id: 1, name: 'test' });
+  });
+
+  it('Content-Type: application/xml returns text (text-like)', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/xml',
+      })
+      .get('/files/1')
+      .reply(200, '<root>hi</root>');
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBe('<root>hi</root>');
+  });
+
+  it('Content-Type: audio/mpeg returns blob', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'audio/mpeg',
+      })
+      .get('/files/1')
+      .reply(200, Buffer.from([0xff, 0xfb]));
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('Content-Type: video/mp4 returns blob', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'video/mp4',
+      })
+      .get('/files/1')
+      .reply(200, Buffer.from([0x00, 0x00]));
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('Content-Type: font/woff2 returns blob', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'font/woff2',
+      })
+      .get('/files/1')
+      .reply(200, Buffer.from([0x77, 0x4f]));
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('Content-Type: XLSX (openxmlformats) returns blob', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type':
+          'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      })
+      .get('/files/1')
+      .reply(200, Buffer.from([0x50, 0x4b, 0x03, 0x04]));
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('Content-Type: DOCX (openxmlformats) returns blob', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type':
+          'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      })
+      .get('/files/1')
+      .reply(200, Buffer.from([0x50, 0x4b, 0x03, 0x04]));
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('Content-Type: PPTX (openxmlformats) returns blob', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type':
+          'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+      })
+      .get('/files/1')
+      .reply(200, Buffer.from([0x50, 0x4b, 0x03, 0x04]));
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBeInstanceOf(Blob);
+  });
+
+  it('binary content-type with normalizable schema throws', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/octet-stream',
+      })
+      .get('/files/1')
+      .reply(200, Buffer.from([1, 2, 3]));
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+      schema: User,
+    });
+    await expect(async () => await ep({ id: 1 })).rejects.toMatchObject({
+      status: 400,
+    });
+  });
+
+  it('No Content-Type returns text (backward compat)', async () => {
+    nock(/.*/)
+      .defaultReplyHeaders({
+        'Access-Control-Allow-Origin': '*',
+      })
+      .get('/files/1')
+      .reply(200, 'no content type');
+
+    const ep = new RestEndpoint({
+      path: 'http\\://test.com/files/:id',
+    });
+    const result = await ep({ id: 1 });
+    expect(result).toBe('no content type');
+  });
+});
 const proto = Object.prototype;
 const gpo = Object.getPrototypeOf;
 

package/src/__tests__/resource-construction.test.ts

@@ -1361,6 +1361,53 @@ describe('resource()', () => {
     expect(result.current.task3?.status).toEqual('in-progress');
   });
 
+  it('extender body types should match mutation endpoint semantics', () => {
+    // resource without explicit body: extenders derive from Partial<Denormalize<schema>>
+    type PushBody = (typeof UserResource)['getList']['push']['body'];
+    type MoveBody = (typeof UserResource)['getList']['move']['body'];
+    type RemoveBody = (typeof UserResource)['getList']['remove']['body'];
+
+    // push (POST) body should not be any
+    // @ts-expect-error
+    ({}) as PushBody satisfies number;
+    // move (PATCH) body should not be any
+    // @ts-expect-error
+    ({}) as MoveBody satisfies number;
+    // remove (PATCH) body should not be any
+    // @ts-expect-error
+    ({}) as RemoveBody satisfies number;
+
+    // resource with explicit body: PATCH extenders should accept partial body
+    interface MyBody {
+      title: string;
+      content: string;
+    }
+    const TypedResource = resource({
+      path: 'http\\://test.com/articles/:id',
+      schema: User,
+      body: {} as MyBody,
+    });
+
+    // POST extenders: push requires full body
+    () => TypedResource.getList.push({ title: 'hi', content: 'there' });
+    // @ts-expect-error - push requires full body, not partial
+    () => TypedResource.getList.push({ title: 'hi' });
+
+    // PATCH extenders: move accepts partial body (like partialUpdate)
+    () => TypedResource.getList.move({ id: '1' }, { title: 'hi' });
+    () => TypedResource.getList.move({ id: '1' }, { content: 'there' });
+    // @ts-expect-error - move rejects invalid fields
+    () => TypedResource.getList.move({ id: '1' }, { invalid: 'field' });
+
+    // PATCH extenders: remove accepts partial body
+    () => TypedResource.getList.remove({ group: 'a' }, { title: 'hi' });
+    // @ts-expect-error - remove rejects invalid fields
+    () => TypedResource.getList.remove({ group: 'a' }, { invalid: 'field' });
+
+    // partialUpdate also accepts partial body
+    () => TypedResource.partialUpdate({ id: '1' }, { title: 'hi' });
+  });
+
   it.each([
     {
       response: {

package/src/index.ts

@@ -14,6 +14,7 @@ export type {
   AddEndpoint,
   PaginationFieldEndpoint,
   PaginationEndpoint,
+  ContentType,
 } from './RestEndpoint.js';
 export type { RestEndpoint as IRestEndpoint } from './RestEndpointTypes.js';
 export { getUrlBase, getUrlTokens } from './RestHelpers.js';
@@ -46,5 +47,6 @@ export type {
   PathArgsAndSearch,
 } from './pathTypes.js';
 
+export type { CollectionOptions } from '@data-client/endpoint';
 export * from '@data-client/endpoint';
 export * from './RestEndpoint.js';

package/src/pathToRegexp.ts

@@ -0,0 +1,2 @@
+export type { PathFunction, Token, ParamData } from 'path-to-regexp';
+export { compile, parse, pathToRegexp } from 'path-to-regexp';