@data-client/rest 0.15.6 → 0.16.0

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

@@ -64,6 +64,13 @@ describe('resource()', () => {
     isAdmin: true,
   };
 
+  let errorSpy: jest.SpyInstance;
+  beforeAll(() => {
+    errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+  afterAll(() => {
+    errorSpy.mockRestore();
+  });
   beforeEach(() => {
     nock(/.*/)
       .persist()
@@ -818,6 +825,542 @@ describe('resource()', () => {
       );
   });
 
+  it('UserResource.getList.move should work', async () => {
+    mynock.patch(`/groups/five/users/2`).reply(200, (uri, body: any) => ({
+      id: 2,
+      username: 'user2',
+      email: 'user2@example.com',
+      group: 'ten',
+      ...body,
+    }));
+
+    const { result, controller } = renderDataClient(
+      () => {
+        return {
+          user2: useQuery(User, { id: 2 }),
+          groupFive: useCache(UserResource.getList, { group: 'five' }),
+          groupTen: useCache(UserResource.getList, { group: 'ten' }),
+        };
+      },
+      {
+        initialFixtures: [
+          {
+            endpoint: UserResource.getList,
+            args: [{ group: 'five' }],
+            response: [
+              {
+                id: 1,
+                username: 'user1',
+                email: 'user1@example.com',
+                group: 'five',
+              },
+              {
+                id: 2,
+                username: 'user2',
+                email: 'user2@example.com',
+                group: 'five',
+              },
+            ],
+          },
+          {
+            endpoint: UserResource.getList,
+            args: [{ group: 'ten' }],
+            response: [
+              {
+                id: 3,
+                username: 'user3',
+                email: 'user3@example.com',
+                group: 'ten',
+              },
+            ],
+          },
+        ],
+      },
+    );
+
+    expect(result.current.groupFive).toHaveLength(2);
+    expect(result.current.groupTen).toHaveLength(1);
+
+    // PATCH /groups/five/users/2 - moves user 2 from 'five' to 'ten'
+    await act(async () => {
+      const response = await controller.fetch(
+        UserResource.getList.move,
+        { group: 'five', id: '2' },
+        {
+          id: 2,
+          group: 'ten',
+        },
+      );
+      expect(response.id).toEqual(2);
+    });
+
+    // user should be removed from group 'five'
+    expect(result.current.groupFive).toHaveLength(1);
+    expect(result.current.groupFive?.[0]?.username).toBe('user1');
+
+    // user should be added to group 'ten'
+    expect(result.current.groupTen).toHaveLength(2);
+    expect(result.current.groupTen?.map((u: any) => u.username)).toEqual(
+      expect.arrayContaining(['user3', 'user2']),
+    );
+
+    // entity should be updated
+    expect(result.current.user2?.group).toEqual('ten');
+
+    // move uses full path params (group + id), no searchParams
+    () =>
+      controller.fetch(
+        UserResource.getList.move,
+        { group: 'five', id: 2 },
+        { id: 1, group: 'ten' },
+      );
+    () =>
+      controller.fetch(
+        UserResource.getList.move,
+        // @ts-expect-error - missing required group
+        { id: 2 },
+        { id: 1 },
+      );
+    // @ts-expect-error
+    () => controller.fetch(UserResource.getList.move, { username: 'never' });
+    // @ts-expect-error
+    () => controller.fetch(UserResource.getList.move, 1, 'hi');
+    () =>
+      controller.fetch(
+        UserResource.getList.move,
+        { group: 'five', id: 2 },
+        // @ts-expect-error
+        { sdf: 'never' },
+      );
+    () =>
+      controller.fetch(
+        UserResource.getList.move,
+        // @ts-expect-error
+        { sdf: 'five', id: 2 },
+        { id: 1 },
+      );
+  });
+
+  it('getList.move should work when entity lacks path param field', async () => {
+    // Entity has 'status' but NOT 'team' - team is only a URL path param
+    // Collection keys include both team (from path) and status (from searchParams)
+    class Task extends Entity {
+      readonly id: number | undefined = undefined;
+      readonly title: string = '';
+      readonly status: string = 'backlog';
+
+      pk() {
+        return this.id?.toString();
+      }
+    }
+
+    const TeamTaskResource = resource({
+      path: 'http\\://test.com/teams/:team/tasks/:id',
+      searchParams: {} as { status: string },
+      schema: Task,
+    });
+
+    mynock.patch(`/teams/alpha/tasks/3`).reply(200, (uri, body: any) => ({
+      id: 3,
+      title: 'My Task',
+      status: 'in-progress',
+      ...body,
+    }));
+
+    const { result, controller } = renderDataClient(
+      () => {
+        return {
+          task3: useQuery(Task, { id: 3 }),
+          backlog: useCache(TeamTaskResource.getList, {
+            team: 'alpha',
+            status: 'backlog',
+          }),
+          inProgress: useCache(TeamTaskResource.getList, {
+            team: 'alpha',
+            status: 'in-progress',
+          }),
+        };
+      },
+      {
+        initialFixtures: [
+          {
+            endpoint: TeamTaskResource.getList,
+            args: [{ team: 'alpha', status: 'backlog' }],
+            response: [
+              { id: 1, title: 'Task 1', status: 'backlog' },
+              { id: 3, title: 'My Task', status: 'backlog' },
+            ],
+          },
+          {
+            endpoint: TeamTaskResource.getList,
+            args: [{ team: 'alpha', status: 'in-progress' }],
+            response: [{ id: 2, title: 'Task 2', status: 'in-progress' }],
+          },
+        ],
+      },
+    );
+
+    expect(result.current.backlog).toHaveLength(2);
+    expect(result.current.inProgress).toHaveLength(1);
+
+    // PATCH /teams/alpha/tasks/3 - move task 3 from backlog to in-progress
+    // 'team' is only in URL params (not on entity); 'status' is in body and on entity
+    await act(async () => {
+      const response = await controller.fetch(
+        TeamTaskResource.getList.move,
+        { team: 'alpha', id: '3' },
+        { id: 3, status: 'in-progress' },
+      );
+      expect(response.id).toEqual(3);
+    });
+
+    // task should be removed from backlog
+    expect(result.current.backlog).toHaveLength(1);
+    expect(result.current.backlog?.[0]?.title).toBe('Task 1');
+
+    // task should be added to in-progress
+    expect(result.current.inProgress).toHaveLength(2);
+    expect(result.current.inProgress?.map((t: any) => t.title)).toEqual(
+      expect.arrayContaining(['Task 2', 'My Task']),
+    );
+
+    // entity should be updated
+    expect(result.current.task3?.status).toEqual('in-progress');
+  });
+
+  it('getList.move should work with searchParams-based collections', async () => {
+    class Task extends Entity {
+      readonly id: number | undefined = undefined;
+      readonly title: string = '';
+      readonly status: string = 'backlog';
+
+      pk() {
+        return this.id?.toString();
+      }
+    }
+
+    const TaskResource = resource({
+      path: 'http\\://test.com/tasks/:id',
+      searchParams: {} as { status: string },
+      schema: Task,
+    });
+
+    mynock.patch(`/tasks/3`).reply(200, (uri, body: any) => ({
+      id: 3,
+      title: 'My Task',
+      status: 'in-progress',
+      ...body,
+    }));
+
+    const { result, controller } = renderDataClient(
+      () => {
+        return {
+          task3: useQuery(Task, { id: 3 }),
+          backlog: useCache(TaskResource.getList, { status: 'backlog' }),
+          inProgress: useCache(TaskResource.getList, {
+            status: 'in-progress',
+          }),
+        };
+      },
+      {
+        initialFixtures: [
+          {
+            endpoint: TaskResource.getList,
+            args: [{ status: 'backlog' }],
+            response: [
+              { id: 1, title: 'Task 1', status: 'backlog' },
+              { id: 3, title: 'My Task', status: 'backlog' },
+            ],
+          },
+          {
+            endpoint: TaskResource.getList,
+            args: [{ status: 'in-progress' }],
+            response: [{ id: 2, title: 'Task 2', status: 'in-progress' }],
+          },
+        ],
+      },
+    );
+
+    expect(result.current.backlog).toHaveLength(2);
+    expect(result.current.inProgress).toHaveLength(1);
+
+    // PATCH /tasks/3 - moves task 3 from 'backlog' to 'in-progress'
+    await act(async () => {
+      const response = await controller.fetch(
+        TaskResource.getList.move,
+        { id: '3' },
+        { id: 3, status: 'in-progress' },
+      );
+      expect(response.id).toEqual(3);
+    });
+
+    // task should be removed from backlog
+    expect(result.current.backlog).toHaveLength(1);
+    expect(result.current.backlog?.[0]?.title).toBe('Task 1');
+
+    // task should be added to in-progress
+    expect(result.current.inProgress).toHaveLength(2);
+    expect(result.current.inProgress?.map((t: any) => t.title)).toEqual(
+      expect.arrayContaining(['Task 2', 'My Task']),
+    );
+
+    // entity should be updated
+    expect(result.current.task3?.status).toEqual('in-progress');
+  });
+
+  it('getList.move should work with FormData body', async () => {
+    class Task extends Entity {
+      readonly id: number | undefined = undefined;
+      readonly title: string = '';
+      readonly status: string = 'backlog';
+
+      pk() {
+        return this.id?.toString();
+      }
+    }
+
+    const TaskResource = resource({
+      path: 'http\\://test.com/tasks/:id',
+      searchParams: {} as { status: string },
+      schema: Task,
+    });
+
+    mynock.patch(`/tasks/3`).reply(200, (uri, body: any) => ({
+      id: 3,
+      title: 'My Task',
+      status: 'in-progress',
+      ...(body instanceof FormData ? Object.fromEntries(body.entries()) : body),
+    }));
+
+    const { result, controller } = renderDataClient(
+      () => {
+        return {
+          task3: useQuery(Task, { id: 3 }),
+          backlog: useCache(TaskResource.getList, { status: 'backlog' }),
+          inProgress: useCache(TaskResource.getList, {
+            status: 'in-progress',
+          }),
+        };
+      },
+      {
+        initialFixtures: [
+          {
+            endpoint: TaskResource.getList,
+            args: [{ status: 'backlog' }],
+            response: [
+              { id: 1, title: 'Task 1', status: 'backlog' },
+              { id: 3, title: 'My Task', status: 'backlog' },
+            ],
+          },
+          {
+            endpoint: TaskResource.getList,
+            args: [{ status: 'in-progress' }],
+            response: [{ id: 2, title: 'Task 2', status: 'in-progress' }],
+          },
+        ],
+      },
+    );
+
+    expect(result.current.backlog).toHaveLength(2);
+    expect(result.current.inProgress).toHaveLength(1);
+
+    // Use FormData as the body (simulates multipart form submission)
+    const formData = new FormData();
+    formData.append('id', '3');
+    formData.append('status', 'in-progress');
+
+    await act(async () => {
+      const response = await controller.fetch(
+        TaskResource.getList.move,
+        { id: '3' },
+        formData,
+      );
+      expect(response.id).toEqual(3);
+    });
+
+    // task should be removed from backlog
+    expect(result.current.backlog).toHaveLength(1);
+    expect(result.current.backlog?.[0]?.title).toBe('Task 1');
+
+    // task should be added to in-progress
+    expect(result.current.inProgress).toHaveLength(2);
+    expect(result.current.inProgress?.map((t: any) => t.title)).toEqual(
+      expect.arrayContaining(['Task 2', 'My Task']),
+    );
+
+    // entity should be updated
+    expect(result.current.task3?.status).toEqual('in-progress');
+  });
+
+  it('getList.move should work optimistically with path-based collections', async () => {
+    const OptUserResource = resource({
+      path: 'http\\://test.com/groups/:group/users/:id',
+      schema: User,
+      optimistic: true,
+    });
+
+    mynock.patch(`/groups/five/users/2`).reply(200, () => ({
+      id: 2,
+      username: 'user2',
+      email: 'user2@example.com',
+      group: 'ten',
+    }));
+
+    const { result, controller } = renderDataClient(
+      () => {
+        return {
+          user2: useQuery(User, { id: 2 }),
+          groupFive: useCache(OptUserResource.getList, { group: 'five' }),
+          groupTen: useCache(OptUserResource.getList, { group: 'ten' }),
+        };
+      },
+      {
+        initialFixtures: [
+          {
+            endpoint: OptUserResource.getList,
+            args: [{ group: 'five' }],
+            response: [
+              {
+                id: 1,
+                username: 'user1',
+                email: 'user1@example.com',
+                group: 'five',
+              },
+              {
+                id: 2,
+                username: 'user2',
+                email: 'user2@example.com',
+                group: 'five',
+              },
+            ],
+          },
+          {
+            endpoint: OptUserResource.getList,
+            args: [{ group: 'ten' }],
+            response: [
+              {
+                id: 3,
+                username: 'user3',
+                email: 'user3@example.com',
+                group: 'ten',
+              },
+            ],
+          },
+        ],
+      },
+    );
+
+    expect(OptUserResource.getList.move.getOptimisticResponse).toBeDefined();
+    expect(result.current.groupFive).toHaveLength(2);
+    expect(result.current.groupTen).toHaveLength(1);
+
+    let promise: any;
+    act(() => {
+      promise = controller.fetch(
+        OptUserResource.getList.move,
+        { group: 'five', id: '2' },
+        { id: 2, group: 'ten' },
+      );
+    });
+
+    // optimistic: should update immediately before network responds
+    expect(result.current.groupFive).toHaveLength(1);
+    expect(result.current.groupFive?.[0]?.username).toBe('user1');
+    expect(result.current.groupTen).toHaveLength(2);
+    expect(result.current.groupTen?.map((u: any) => u.username)).toEqual(
+      expect.arrayContaining(['user3', 'user2']),
+    );
+    expect(result.current.user2?.group).toEqual('ten');
+
+    // after server response, should still be correct
+    await act(() => promise);
+    expect(result.current.groupFive).toHaveLength(1);
+    expect(result.current.groupTen).toHaveLength(2);
+    expect(result.current.user2?.group).toEqual('ten');
+  });
+
+  it('getList.move should work optimistically with searchParams-based collections', async () => {
+    class Task extends Entity {
+      readonly id: number | undefined = undefined;
+      readonly title: string = '';
+      readonly status: string = 'backlog';
+
+      pk() {
+        return this.id?.toString();
+      }
+    }
+
+    const TaskResource = resource({
+      path: 'http\\://test.com/tasks/:id',
+      searchParams: {} as { status: string },
+      schema: Task,
+      optimistic: true,
+    });
+
+    mynock.patch(`/tasks/3`).reply(200, () => ({
+      id: 3,
+      title: 'My Task',
+      status: 'in-progress',
+    }));
+
+    const { result, controller } = renderDataClient(
+      () => {
+        return {
+          task3: useQuery(Task, { id: 3 }),
+          backlog: useCache(TaskResource.getList, { status: 'backlog' }),
+          inProgress: useCache(TaskResource.getList, {
+            status: 'in-progress',
+          }),
+        };
+      },
+      {
+        initialFixtures: [
+          {
+            endpoint: TaskResource.getList,
+            args: [{ status: 'backlog' }],
+            response: [
+              { id: 1, title: 'Task 1', status: 'backlog' },
+              { id: 3, title: 'My Task', status: 'backlog' },
+            ],
+          },
+          {
+            endpoint: TaskResource.getList,
+            args: [{ status: 'in-progress' }],
+            response: [{ id: 2, title: 'Task 2', status: 'in-progress' }],
+          },
+        ],
+      },
+    );
+
+    expect(TaskResource.getList.move.getOptimisticResponse).toBeDefined();
+    expect(result.current.backlog).toHaveLength(2);
+    expect(result.current.inProgress).toHaveLength(1);
+
+    let promise: any;
+    act(() => {
+      promise = controller.fetch(
+        TaskResource.getList.move,
+        { id: '3' },
+        { id: 3, status: 'in-progress' },
+      );
+    });
+
+    // optimistic: should update immediately before network responds
+    expect(result.current.backlog).toHaveLength(1);
+    expect(result.current.backlog?.[0]?.title).toBe('Task 1');
+    expect(result.current.inProgress).toHaveLength(2);
+    expect(result.current.inProgress?.map((t: any) => t.title)).toEqual(
+      expect.arrayContaining(['Task 2', 'My Task']),
+    );
+    expect(result.current.task3?.status).toEqual('in-progress');
+
+    // after server response, should still be correct
+    await act(() => promise);
+    expect(result.current.backlog).toHaveLength(1);
+    expect(result.current.inProgress).toHaveLength(2);
+    expect(result.current.task3?.status).toEqual('in-progress');
+  });
+
   it.each([
     {
       response: {

package/src/pathTypes.ts

@@ -1,8 +1,14 @@
-type OnlyOptional<S extends string> =
-  S extends `${infer K}}?` ? K
-  : S extends `${infer K}?` ? K
-  : never;
-type OnlyRequired<S extends string> = S extends `${string}?` ? never : S;
+type CleanKey<S extends string> = S extends `"${infer K}"` ? K : S;
+
+type KeyName<K extends string> = CleanKey<
+  K extends `*${infer N}}` ? N
+  : K extends `*${infer N}` ? N
+  : K extends `${infer N}}` ? N
+  : K
+>;
+
+type KeyVal<K extends string> =
+  K extends `*${string}` ? string[] : string | number;
 
 /** Parameters for a given path */
 export type PathArgs<S extends string> =
@@ -14,43 +20,49 @@ export type PathArgs<S extends string> =
 /** Computes the union of keys for a path string */
 export type PathKeys<S extends string> =
   string extends S ? string
-  : S extends `${infer A}\\${':' | '?' | '+' | '*' | '{' | '}'}${infer B}` ?
+  : S extends `${infer A}\\${':' | '*' | '}'}${infer B}` ?
     PathKeys<A> | PathKeys<B>
-  : PathSplits<S>;
+  : Splits<S, ':'> | Splits<S, '*'>;
 
-type PathSplits<S extends string> =
-  S extends (
-    `${string}:${infer K}${'/' | ',' | '%' | '&' | '+' | '*' | '{'}${infer R}`
+type Splits<S extends string, M extends ':' | '*'> =
+  S extends `${string}${M}${infer K}${M}${infer R}` ?
+    Splits<`${M}${K}`, M> | Splits<`${M}${R}`, M>
+  : S extends (
+    `${string}${M}${infer K}${'/' | '\\' | '%' | '&' | '*' | ':' | '{' | ';' | ',' | '!' | '@'}${infer R}`
   ) ?
-    PathSplits<`:${K}`> | PathSplits<R>
-  : S extends `${string}:${infer K}:${infer R}` ?
-    PathSplits<`:${K}`> | PathSplits<`:${R}`>
-  : S extends `${string}:${infer K}` ? K
+    Splits<`${M}${K}`, M> | Splits<R, M>
+  : S extends `${string}${M}${infer K}` ?
+    M extends '*' ?
+      `*${K}`
+    : K
   : never;
 
 export type KeysToArgs<Key extends string> = {
-  [K in Key as OnlyOptional<K>]?: string | number;
-} & (OnlyRequired<Key> extends never ? unknown
+  [K in Key as K extends `${string}}` ? KeyName<K> : never]?: KeyVal<K>;
+} & (Exclude<Key, `${string}}`> extends never ? unknown
 : {
-    [K in Key as OnlyRequired<K>]: string | number;
+    [K in Key as K extends `${string}}` ? never : KeyName<K>]: KeyVal<K>;
   });
 
 export type PathArgsAndSearch<S extends string> =
-  OnlyRequired<PathKeys<S>> extends never ?
+  Exclude<PathKeys<S>, `${string}}`> extends never ?
     Record<string, number | string | boolean> | undefined
   : {
-      [K in PathKeys<S> as OnlyRequired<K>]: string | number;
-    } & Record<string, number | string>;
+      [K in PathKeys<S> as K extends `${string}}` ? never
+      : KeyName<K>]: KeyVal<K>;
+    } & Record<string, number | string | string[]>;
 
-/** Removes the last :token */
+/** Removes the last :param or *wildcard token */
 export type ShortenPath<S extends string> =
   string extends S ? string
-  : S extends `${infer B}:${infer R}` ? TrimColon<`${B}:${ShortenPath<R>}`>
+  : S extends `${infer B}:${infer R}` ? TrimToken<`${B}:${ShortenPath<R>}`>
+  : S extends `${infer B}*${infer R}` ? TrimToken<`${B}*${ShortenPath<R>}`>
   : '';
 
-type TrimColon<S extends string> =
+type TrimToken<S extends string> =
   string extends S ? string
   : S extends `${infer R}:` ? R
+  : S extends `${infer R}*` ? R
   : S;
 
 export type ResourcePath = string; // `${string}:${string}`; TODO: Maybe do this in the future? Seems to hard to understand for now

package/src/resource.ts

@@ -96,6 +96,7 @@ This warning will not show in production.`,
   const getList = new Endpoint({
     ...extraMutateOptions,
     paginationField: paginationField as string,
+    movePath: path,
     path: shortenedPath,
     schema: new Collection([schema as any]),
     name: getName('getList'),
@@ -112,6 +113,7 @@ This warning will not show in production.`,
       method: 'PUT',
       name: getName('update'),
     }),
+    // TODO(breaking): Move to getList.move
     partialUpdate: new Endpoint({
       ...extraPartialOptions,
       path,

package/src/resourceTypes.ts

@@ -84,7 +84,7 @@ export interface Resource<
         schema: schema.Collection<
           [O['schema']],
           ParamToArgs<
-            O['searchParams'] extends undefined ?
+            [O['searchParams']] extends [undefined] ?
               KeysToArgs<ShortenPath<O['path']>>
             : O['searchParams'] & PathArgs<ShortenPath<O['path']>>
           >
@@ -92,6 +92,7 @@ export interface Resource<
         body: 'body' extends keyof O ? O['body']
         : Partial<Denormalize<O['schema']>>;
         searchParams: O['searchParams'];
+        movePath: O['path'];
       } & Pick<O, 'paginationField'>
     >
   : GetEndpoint<
@@ -107,6 +108,7 @@ export interface Resource<
         body: 'body' extends keyof O ? O['body']
         : Partial<Denormalize<O['schema']>>;
         searchParams: Record<string, number | string | boolean> | undefined;
+        movePath: O['path'];
       } & Pick<O, 'paginationField'>
     >;
   /** Create a new item (POST)