@data-client/rest 0.15.6 → 0.16.0

package/src/RestHelpers.ts

@@ -1,32 +1,39 @@
-import { compile, PathFunction, parse } from 'path-to-regexp';
+import { compile, PathFunction, parse, Token, ParamData } from 'path-to-regexp';
 
 import { ShortenPath } from './pathTypes.js';
 
-const urlBaseCache: Map<string, PathFunction<object>> = new Map();
-export function getUrlBase(path: string): PathFunction {
-  if (!urlBaseCache.has(path)) {
-    urlBaseCache.set(
-      path,
-      compile(path, {
-        encode: encodeURIComponent,
-        validate: false,
-      }),
-    );
+const urlBaseCache: Record<string, PathFunction<object>> = Object.create(null);
+export function getUrlBase(path: string): PathFunction<ParamData> {
+  if (!(path in urlBaseCache)) {
+    urlBaseCache[path] = compile(path);
   }
-  return urlBaseCache.get(path) as PathFunction;
+  return urlBaseCache[path];
 }
 
-const urlTokensCache: Map<string, Set<string>> = new Map();
+const urlTokensCache: Record<string, Set<string>> = Object.create(null);
 export function getUrlTokens(path: string): Set<string> {
-  if (!urlTokensCache.has(path)) {
-    urlTokensCache.set(
-      path,
-      new Set(
-        parse(path).map(t => (typeof t === 'string' ? t : `${t['name']}`)),
-      ),
-    );
+  if (!(path in urlTokensCache)) {
+    urlTokensCache[path] = tokenMap(parse(path).tokens);
+  }
+  return urlTokensCache[path];
+}
+
+function tokenMap(tokens: Token[]): Set<string> {
+  const tokenNames = new Set<string>();
+  for (const token of tokens) {
+    switch (token.type) {
+      case 'param':
+      case 'wildcard':
+        tokenNames.add(token.name);
+        break;
+      case 'group':
+        for (const name of tokenMap(token.tokens)) {
+          tokenNames.add(name);
+        }
+        break;
+    }
   }
-  return urlTokensCache.get(path) as Set<string>;
+  return tokenNames;
 }
 
 const proto = Object.prototype;
@@ -40,11 +47,12 @@ export function isPojo(obj: unknown): obj is Record<string, any> {
 }
 
 export function shortenPath<S extends string>(path: S): ShortenPath<S> {
-  const lastColonIndex = path.lastIndexOf(':');
-  if (lastColonIndex === -1)
-    throw new Error('Resource path requires at least one :parameter');
-  // this is for when not specifying a specific item like create/list
-  let shortUrlRoot: ShortenPath<S> = path.substring(0, lastColonIndex) as any;
+  const lastTokenIndex = Math.max(path.lastIndexOf(':'), path.lastIndexOf('*'));
+  if (lastTokenIndex === -1)
+    throw new Error(
+      'Resource path requires at least one :parameter or *wildcard',
+    );
+  let shortUrlRoot: ShortenPath<S> = path.substring(0, lastTokenIndex) as any;
   if (shortUrlRoot[shortUrlRoot.length - 1] === '/')
     shortUrlRoot = shortUrlRoot.substring(
       0,

package/src/__tests__/Resource.test.ts

@@ -5,6 +5,7 @@ import { CacheProvider } from '@data-client/react';
 import nock from 'nock';
 
 import { makeRenderDataClient } from '../../../test';
+import NetworkError from '../NetworkError';
 import { ResourcePath } from '../pathTypes';
 import resource from '../resource';
 import RestEndpoint from '../RestEndpoint';
@@ -133,6 +134,18 @@ describe('resource()', () => {
     () => UserResource.get.url({ sdf: '5' });
   });
 
+  it('should omit optional path params when undefined', () => {
+    const ep = new RestEndpoint({ path: '/users{/:id}' });
+    expect(ep.url({ id: undefined })).toBe('/users');
+    expect(ep.url({ id: '5' })).toBe('/users/5');
+    expect(ep.url({})).toBe('/users');
+
+    const ep2 = new RestEndpoint({ path: '/users{/:id}{/:group}' });
+    expect(ep2.url({ id: undefined, group: undefined })).toBe('/users');
+    expect(ep2.url({ id: '5', group: undefined })).toBe('/users/5');
+    expect(ep2.url({ id: undefined })).toBe('/users');
+  });
+
   it('should handle multiarg urls', () => {
     const MyUserResource = resource({
       path: 'http\\://test.com/groups/:group/users/:id',
@@ -179,6 +192,50 @@ describe('resource()', () => {
     () => useSuspense(MyUserResource.get, { group: 'yay', id: '5' });
   });
 
+  it('should shorten wildcard (*) paths for getList', () => {
+    const FileResource = resource({
+      path: '/repos/:owner/*path',
+      schema: User,
+    });
+
+    // get uses the full path with wildcard
+    expect(
+      FileResource.get.url({ owner: 'john', path: ['src', 'index.ts'] }),
+    ).toBe('/repos/john/src/index.ts');
+    // getList strips the last *wildcard token
+    expect(FileResource.getList.url({ owner: 'john' })).toBe('/repos/john');
+    // create (push) also uses shortened path
+    expect(FileResource.create.url({ owner: 'john' }, {} as any)).toBe(
+      '/repos/john',
+    );
+
+    // type checks: get requires both owner and path (array)
+    // @ts-expect-error - missing path
+    () => FileResource.get.url({ owner: 'john' });
+    // @ts-expect-error - path must be array
+    () => FileResource.get.url({ owner: 'john', path: 'src/index.ts' });
+    // getList only requires owner (extra props become search params)
+    () => FileResource.getList({ owner: 'john' });
+    // @ts-expect-error - missing required owner param
+    () => FileResource.getList({});
+  });
+
+  it('should shorten path when wildcard comes after multiple params', () => {
+    const DeepResource = resource({
+      path: '/api/:version/files/*path',
+      schema: User,
+    });
+
+    expect(
+      DeepResource.get.url({ version: 'v2', path: ['docs', 'readme.md'] }),
+    ).toBe('/api/v2/files/docs/readme.md');
+    expect(DeepResource.getList.url({ version: 'v2' })).toBe('/api/v2/files');
+
+    // @ts-expect-error - missing version
+    () => DeepResource.getList({});
+    () => DeepResource.getList({ version: 'v2' });
+  });
+
   it('should automatically name methods', () => {
     expect(PaginatedArticleResource.get.name).toBe('PaginatedArticle.get');
     expect(PaginatedArticleResource.create.name).toBe(
@@ -302,6 +359,44 @@ describe('resource()', () => {
     expect(res).toEqual({ id: 500 });
   });
 
+  it('getList.move should have similar properties to update', () => {
+    expect(UserResource.getList.move.method).toBe('PATCH');
+    // move uses the full entity path (same as update), not the shortened list path
+    expect(UserResource.getList.move.url({ id: '5' }, {})).toBe(
+      'http://test.com/user/5',
+    );
+    expect(UserResource.update.url({ id: '5' }, {})).toBe(
+      'http://test.com/user/5',
+    );
+    // schema is the Collection.move variant (not the raw Entity like update)
+    expect(UserResource.getList.move.schema).toBeDefined();
+    expect(UserResource.getList.move.schema).not.toBe(
+      UserResource.update.schema,
+    );
+    // inherits getOptimisticResponse from getList (which has optimistic via extraMutateOptions)
+    expect(typeof UserResource.getList.move.getOptimisticResponse).toBe(
+      typeof UserResource.update.getOptimisticResponse,
+    );
+    // name distinguishes it from update
+    expect(UserResource.getList.move.name).toBe('User.getList.partialUpdate');
+    // searchParams are removed (move targets a specific entity, not a filtered list)
+    expect(UserResource.getList.move.searchParams).toBeUndefined();
+  });
+
+  it('getList.move should handle multiarg urls', () => {
+    const MyUserResource = resource({
+      path: 'http\\://test.com/groups/:group/users/:id',
+      schema: User,
+    });
+    expect(MyUserResource.getList.move.url({ group: 'big', id: '5' }, {})).toBe(
+      'http://test.com/groups/big/users/5',
+    );
+    // same as update path
+    expect(MyUserResource.update.url({ group: 'big', id: '5' }, {})).toBe(
+      'http://test.com/groups/big/users/5',
+    );
+  });
+
   it('should spread `url` member', () => {
     const entity = UrlArticle.fromJS({ url: 'five' });
     const spread = { ...entity };
@@ -309,3 +404,39 @@ describe('resource()', () => {
     expect(Object.hasOwn(entity, 'url')).toBeTruthy();
   });
 });
+
+describe('NetworkError', () => {
+  it('toJSON() should serialize error with status, message, and url', () => {
+    const mockResponse = {
+      status: 404,
+      statusText: 'Not Found',
+      url: 'http://test.com/api/missing',
+    } as Response;
+
+    const error = new NetworkError(mockResponse);
+    const json = error.toJSON();
+
+    expect(json).toEqual({
+      name: 'NetworkError',
+      status: 404,
+      message: 'http://test.com/api/missing: Not Found',
+      url: 'http://test.com/api/missing',
+    });
+  });
+
+  it('toJSON() output should be JSON.stringify-able', () => {
+    const mockResponse = {
+      status: 500,
+      statusText: 'Internal Server Error',
+      url: 'http://test.com/api/broken',
+    } as Response;
+
+    const error = new NetworkError(mockResponse);
+    const serialized = JSON.stringify(error);
+    const parsed = JSON.parse(serialized);
+
+    expect(parsed.name).toBe('NetworkError');
+    expect(parsed.status).toBe(500);
+    expect(parsed.url).toBe('http://test.com/api/broken');
+  });
+});

package/src/__tests__/RestEndpoint.ts

@@ -1,11 +1,11 @@
 import { Entity, schema, Collection } from '@data-client/endpoint';
-import { useController } from '@data-client/react';
+import { useController, useCache } from '@data-client/react';
 import { useSuspense } from '@data-client/react';
 import { CacheProvider } from '@data-client/react';
 import { CoolerArticle, CoolerArticleResource } from '__tests__/new';
 import nock from 'nock';
 
-import { makeRenderDataClient } from '../../../test';
+import { makeRenderDataClient, act } from '../../../test';
 import RestEndpoint, {
   Defaults,
   RestEndpointConstructorOptions,
@@ -132,6 +132,35 @@ const getNextPage3 = getArticleList3.getPage;
   a.getPage({ cursor: 'hi', blob: 'ho' });
   // @ts-expect-error
   a.getPage({ blob: 'ho' });
+
+  // Compare flat vs nested Collection schema type inference
+  const flat = new RestEndpoint({
+    urlPrefix: 'http://test.com',
+    path: '/articles/:id',
+    schema: new Collection([PaginatedArticle]),
+    method: 'GET',
+  });
+  // flat Collection schema should be typed
+  // @ts-expect-error - schema should not be any
+  flat.move.schema satisfies number;
+  // @ts-expect-error - push schema should not be any
+  flat.push.schema satisfies number;
+
+  // nested Collection schema should also be typed
+  const nested = new RestEndpoint({
+    urlPrefix: 'http://test.com',
+    path: '/articles/:id',
+    schema: {
+      nextPage: '',
+      data: { results: new Collection([PaginatedArticle]) },
+    },
+    method: 'GET',
+    searchParams: {} as { group: string },
+  });
+  // @ts-expect-error - nested move schema should not be any
+  nested.move.schema satisfies number;
+  // @ts-expect-error - nested push schema should not be any
+  nested.push.schema satisfies number;
 };
 
 describe('RestEndpoint', () => {
@@ -208,9 +237,9 @@ describe('RestEndpoint', () => {
   });
 
   it('only optional path means the arg is not required', () => {
-    const ep = new RestEndpoint({ path: '/users/:id?/:group?' });
+    const ep = new RestEndpoint({ path: '/users{/:id}{/:group}' });
     const epbody = new RestEndpoint({
-      path: '/users/:id?/:group?',
+      path: '/users{/:id}{/:group}',
       body: { title: '' },
       method: 'POST',
     });
@@ -226,6 +255,64 @@ describe('RestEndpoint', () => {
     () => epbody({ title: 'hi' }, { title: 'hi' });
   });
 
+  it('should omit optional path params when undefined', () => {
+    const ep = new RestEndpoint({ path: '/users{/:id}' });
+    expect(ep.url({ id: undefined })).toBe('/users');
+    expect(ep.url({ id: '5' })).toBe('/users/5');
+    expect(ep.url({})).toBe('/users');
+
+    const ep2 = new RestEndpoint({ path: '/users{/:id}{/:group}' });
+    expect(ep2.url({ id: undefined, group: undefined })).toBe('/users');
+    expect(ep2.url({ id: '5', group: undefined })).toBe('/users/5');
+    expect(ep2.url({ id: undefined })).toBe('/users');
+  });
+
+  it('should handle wildcard (*) path params as arrays', () => {
+    const ep = new RestEndpoint({ path: '/files/*path' });
+    expect(ep.url({ path: ['a', 'b', 'c'] })).toBe('/files/a/b/c');
+    expect(ep.url({ path: ['single'] })).toBe('/files/single');
+
+    // @ts-expect-error - path must be an array, not a string
+    () => ep.url({ path: 'a/b/c' });
+    // @ts-expect-error - missing required wildcard param
+    () => ep.url({});
+  });
+
+  it('should handle wildcard with regular params', () => {
+    const ep = new RestEndpoint({ path: '/users/:id/*rest' });
+    expect(ep.url({ id: '5', rest: ['docs', 'file'] })).toBe(
+      '/users/5/docs/file',
+    );
+    expect(ep.url({ id: '42', rest: ['a'] })).toBe('/users/42/a');
+
+    // @ts-expect-error - missing id
+    () => ep.url({ rest: ['a'] });
+    // @ts-expect-error - missing rest
+    () => ep.url({ id: '5' });
+  });
+
+  it('should handle optional wildcard params', () => {
+    const ep = new RestEndpoint({ path: '/files{/*path}' });
+    expect(ep.url({ path: ['a', 'b'] })).toBe('/files/a/b');
+    expect(ep.url({})).toBe('/files');
+    expect(ep.url({ path: undefined })).toBe('/files');
+    () => ep();
+  });
+
+  it('should handle optional wildcard with required param', () => {
+    const ep = new RestEndpoint({ path: '/users/:id{/*rest}' });
+    expect(ep.url({ id: '5', rest: ['docs', 'file'] })).toBe(
+      '/users/5/docs/file',
+    );
+    expect(ep.url({ id: '5' })).toBe('/users/5');
+    expect(ep.url({ id: '5', rest: undefined })).toBe('/users/5');
+
+    // @ts-expect-error - missing required param id
+    () => ep.url({});
+    // @ts-expect-error - rest should be array, not string
+    () => ep.url({ id: '5', rest: 'docs/file' });
+  });
+
   it('should allow sideEffect overrides', () => {
     const weirdGetUser = new RestEndpoint({
       path: 'http\\://test.com/user/:id',
@@ -364,6 +451,113 @@ describe('RestEndpoint', () => {
     expect(getArticleList3.remove.name).toMatchSnapshot();
   });
 
+  it('move: should extend name of parent endpoint', () => {
+    expect(getArticleList3.move.name).toMatchSnapshot();
+  });
+
+  it('move should work with deeply nested Collection', async () => {
+    class GroupedArticle extends Entity {
+      readonly id: number | undefined = undefined;
+      readonly title: string = '';
+      readonly group: string = '';
+    }
+
+    const getGroupedArticles = new RestEndpoint({
+      urlPrefix: 'http://test.com',
+      path: '/grouped-articles',
+      movePath: '/grouped-articles/:id',
+      schema: {
+        nextPage: '',
+        data: { results: new Collection([GroupedArticle]) },
+      },
+      method: 'GET',
+      searchParams: {} as { group: string },
+    });
+
+    // Verify schema is correctly extracted from nested structure
+    expect(getGroupedArticles.move.schema).toBeTruthy();
+    expect(getGroupedArticles.move.method).toBe('PATCH');
+
+    // Diagnose schema type - should not be any
+    // @ts-expect-error - schema should not be any
+    getGroupedArticles.move.schema satisfies number;
+
+    mynock.patch(/grouped-articles/).reply(200, (uri, body: any) => ({
+      id: 2,
+      title: 'Article 2',
+      group: 'beta',
+      ...(typeof body === 'string' ? JSON.parse(body) : body),
+    }));
+
+    const { result, controller } = renderDataClient(
+      () => {
+        return {
+          alpha: useCache(getGroupedArticles, { group: 'alpha' }),
+          beta: useCache(getGroupedArticles, { group: 'beta' }),
+        };
+      },
+      {
+        initialFixtures: [
+          {
+            endpoint: getGroupedArticles,
+            args: [{ group: 'alpha' }],
+            response: {
+              nextPage: '2',
+              data: {
+                results: [
+                  { id: 1, title: 'Article 1', group: 'alpha' },
+                  { id: 2, title: 'Article 2', group: 'alpha' },
+                ],
+              },
+            },
+          },
+          {
+            endpoint: getGroupedArticles,
+            args: [{ group: 'beta' }],
+            response: {
+              nextPage: '2',
+              data: {
+                results: [{ id: 3, title: 'Article 3', group: 'beta' }],
+              },
+            },
+          },
+        ],
+      },
+    );
+
+    expect(result.current.alpha?.data.results).toHaveLength(2);
+    expect(result.current.beta?.data.results).toHaveLength(1);
+
+    // Move article 2 from alpha to beta
+    await act(async () => {
+      const response = await controller.fetch(
+        getGroupedArticles.move,
+        { id: 2 },
+        {
+          id: 2,
+          title: 'Article 2',
+          group: 'beta',
+        },
+      );
+      // Type test: response should be a single GroupedArticle, not an array
+      response.title satisfies string;
+      expect(response.title).toBe('Article 2');
+      expect(response.group).toBe('beta');
+    });
+
+    // article should be removed from alpha
+    expect(result.current.alpha?.data.results).toHaveLength(1);
+    const alphaResults = result.current.alpha!.data.results!;
+    expect(alphaResults[0]?.title).toBe('Article 1');
+
+    // article should be added to beta
+    const betaResults = result.current.beta!.data.results!;
+    expect(betaResults).toHaveLength(2);
+    expect(betaResults.map((a: any) => a.title)).toEqual(
+      expect.arrayContaining(['Article 3', 'Article 2']),
+    );
+  });
+
   // TODO: but we need a Values collection
   // it('assign: should extend name of parent endpoint', () => {
   //   expect(getArticleList3.assign.name).toMatchSnapshot();
@@ -1500,6 +1694,20 @@ describe('RestEndpoint.fetch()', () => {
     expect(noColletionEndpoint.remove.schema).toBeFalsy();
   });
 
+  it('without Collection in schema - endpoint.move schema should be null', () => {
+    const noColletionEndpoint = new RestEndpoint({
+      urlPrefix: 'http://test.com/article-paginated/',
+      path: ':group',
+      name: 'get',
+      schema: {
+        nextPage: '',
+        data: { results: [PaginatedArticle] },
+      },
+      method: 'GET',
+    });
+    expect(noColletionEndpoint.move.schema).toBeFalsy();
+  });
+
   it('without Collection in schema - endpoint.getPage should throw', () => {
     const noColletionEndpoint = new RestEndpoint({
       urlPrefix: 'http://test.com/article-paginated/',

package/src/__tests__/__snapshots__/RestEndpoint.ts.snap

@@ -2,6 +2,8 @@
 
 exports[`RestEndpoint getPage: should extend name of parent endpoint 1`] = `"http://test.com/article-paginated.getPage"`;
 
+exports[`RestEndpoint move: should extend name of parent endpoint 1`] = `"http://test.com/article-paginated.partialUpdate"`;
+
 exports[`RestEndpoint push: should extend name of parent endpoint 1`] = `"http://test.com/article-paginated.create"`;
 
 exports[`RestEndpoint remove: should extend name of parent endpoint 1`] = `"http://test.com/article-paginated.remove"`;

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

@@ -4,7 +4,7 @@ exports[`resource() UserResource.delete should work with  1`] = `"not found"`;
 
 exports[`resource() UserResource.delete should work with {"id": 5} 1`] = `"not found"`;
 
-exports[`resource() should not allow paths without at least one argument 1`] = `"Resource path requires at least one :parameter"`;
+exports[`resource() should not allow paths without at least one argument 1`] = `"Resource path requires at least one :parameter or *wildcard"`;
 
 exports[`resource() warnings should warn when mis-capitalizing options 1`] = `
 [

package/src/__tests__/hookifyResource.ts

@@ -63,7 +63,14 @@ describe('hookifyResource()', () => {
     };
 
     let renderDataClient: ReturnType<typeof makeRenderDataClient>;
+    let errorSpy: jest.SpyInstance;
 
+    beforeAll(() => {
+      errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    });
+    afterAll(() => {
+      errorSpy.mockRestore();
+    });
     beforeEach(() => {
       renderDataClient = makeRenderDataClient(CacheProvider);