feat: Add optional secondary param if query args arne't required

Author: oliverbutler

.changeset/fresh-cups-speak.md

@@ -0,0 +1,7 @@
+---
+'@ts-rest/core': minor
+'@ts-rest/react-query': minor
+'@ts-rest/solid-query': minor
+---
+
+Added the ability to omit the second parameter if there no required query parameters

apps/example-microservice/web-app/src/App.tsx

@@ -2,9 +2,7 @@ import React from 'react';
 import { postsClient } from './main';
 
 export const App = () => {
-  const { data } = postsClient.getPosts.useQuery(['posts'], {
-    query: {},
-  });
+  const { data } = postsClient.getPosts.useQuery(['posts']);
 
   const posts = data?.body || [];
 

…ct-query/src/lib/ts-rest-client.spec.tsx …/example-next/tests/react-query.spec.tsxlibs/ts-rest/react-query/src/lib/ts-rest-client.spec.tsx renamed to apps/example-next/tests/react-query.spec.tsx libs/ts-rest/react-query/src/lib/ts-rest-client.spec.tsx renamed to apps/example-next/tests/react-query.spec.tsx

@@ -1,11 +1,115 @@
-import { router } from './test-fixtures';
-import { initQueryClient } from './ts-rest-client';
-import { renderHook } from '@testing-library/react-hooks';
-import { waitFor } from '@testing-library/react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
+import { waitFor } from '@testing-library/react';
+import { renderHook } from '@testing-library/react-hooks';
+import { initContract } from '@ts-rest/core';
+import { initQueryClient } from '@ts-rest/react-query';
 import React from 'react';
+import { z } from 'zod';
+
+const c = initContract();
+
+export type Post = {
+  id: string;
+  title: string;
+  description: string | null;
+  content: string | null;
+  published: boolean;
+  authorId: string;
+};
+
+export type User = {
+  id: string;
+  email: string;
+  name: string | null;
+};
+
+const postsRouter = c.router({
+  getPost: {
+    method: 'GET',
+    path: `/posts/:id`,
+    responses: {
+      200: c.response<Post | null>(),
+    },
+  },
+  getPosts: {
+    method: 'GET',
+    path: '/posts',
+    responses: {
+      200: c.response<Post[]>(),
+    },
+    query: z.object({
+      take: z.number().optional(),
+      skip: z.number().optional(),
+    }),
+  },
+  createPost: {
+    method: 'POST',
+    path: '/posts',
+    responses: {
+      200: c.response<Post>(),
+    },
+    body: z.object({
+      title: z.string(),
+      content: z.string(),
+      published: z.boolean().optional(),
+      description: z.string().optional(),
+      authorId: z.string(),
+    }),
+  },
+  mutationWithQuery: {
+    method: 'POST',
+    path: '/posts',
+    responses: {
+      200: c.response<Post>(),
+    },
+    body: z.object({}),
+    query: z.object({
+      test: z.string(),
+    }),
+  },
+  updatePost: {
+    method: 'PUT',
+    path: `/posts/:id`,
+    responses: {
+      200: c.response<Post>(),
+    },
+    body: z.object({
+      title: z.string(),
+      content: z.string(),
+      published: z.boolean().optional(),
+      description: z.string().optional(),
+      authorId: z.string(),
+    }),
+  },
+  patchPost: {
+    method: 'PATCH',
+    path: `/posts/:id`,
+    responses: {
+      200: c.response<Post>(),
+    },
+    body: null,
+  },
+  deletePost: {
+    method: 'DELETE',
+    path: `/posts/:id`,
+    responses: {
+      200: c.response<boolean>(),
+    },
+    body: null,
+  },
+});
+
+// Three endpoints, two for posts, and one for health
+export const router = c.router({
+  posts: postsRouter,
+  health: {
+    method: 'GET',
+    path: '/health',
+    responses: {
+      200: c.response<{ message: string }>(),
+    },
+  },
+});
 
 const api = jest.fn();
 

libs/ts-rest/core/src/lib/client.spec.ts

@@ -1,5 +1,5 @@
-import { initClient } from './client';
 import { initContract } from '..';
+import { initClient } from './client';
 
 import { z } from 'zod';
 
@@ -149,6 +149,24 @@ describe('client', () => {
       });
     });
 
+    it('w/ no parameters (not provided)', async () => {
+      const value = { key: 'value' };
+      api.mockResolvedValue({ body: value, status: 200 });
+
+      const result = await client.posts.getPosts();
+
+      expect(result).toStrictEqual({ body: value, status: 200 });
+
+      expect(api).toHaveBeenCalledWith({
+        method: 'GET',
+        path: 'http://api.com/posts',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: undefined,
+      });
+    });
+
     it('w/ query parameters', async () => {
       const value = { key: 'value' };
       api.mockResolvedValue({ body: value, status: 200 });

libs/ts-rest/core/src/lib/client.ts

@@ -3,11 +3,16 @@ import { AppRoute, AppRouteMutation, AppRouter, isAppRoute } from './dsl';
 import { insertParamsIntoPath, ParamsFromUrl } from './paths';
 import { convertQueryParamsToUrlString } from './query';
 import { HTTPStatusCode } from './status-codes';
-import { Merge, Without, ZodInferOrType } from './type-utils';
+import {
+  AreAllPropertiesOptional,
+  Merge,
+  Without,
+  ZodInferOrType,
+} from './type-utils';
 
 type RecursiveProxyObj<T extends AppRouter> = {
   [TKey in keyof T]: T[TKey] extends AppRoute
-    ? DataReturn<T[TKey]>
+    ? AppRouteFunction<T[TKey]>
     : T[TKey] extends AppRouter
     ? RecursiveProxyObj<T[TKey]>
     : never;
@@ -43,7 +48,9 @@ interface DataReturnArgs<TRoute extends AppRoute> {
     ? AppRouteBodyOrFormData<TRoute>
     : never;
   params: PathParamsFromUrl<TRoute>;
-  query: TRoute['query'] extends ZodTypeAny
+  query: AreAllPropertiesOptional<
+    AppRouteMutationType<TRoute['query']>
+  > extends false
     ? AppRouteMutationType<TRoute['query']>
     : never;
 }
@@ -63,9 +70,14 @@ export type ApiRouteResponse<T> =
 /**
  * Returned from a mutation or query call
  */
-export type DataReturn<TRoute extends AppRoute> = (
-  args: Without<DataReturnArgs<TRoute>, never>
-) => Promise<ApiRouteResponse<TRoute['responses']>>;
+export type AppRouteFunction<TRoute extends AppRoute> =
+  AreAllPropertiesOptional<Without<DataReturnArgs<TRoute>, never>> extends true
+    ? (
+        args?: Without<DataReturnArgs<TRoute>, never>
+      ) => Promise<ApiRouteResponse<TRoute['responses']>>
+    : (
+        args: Without<DataReturnArgs<TRoute>, never>
+      ) => Promise<ApiRouteResponse<TRoute['responses']>>;
 
 export interface ClientArgs {
   baseUrl: string;

libs/ts-rest/core/src/lib/type-utils.ts

@@ -88,3 +88,9 @@ type NarrowRaw<T> =
 type NarrowNotZod<T> = Try<T, ZodType, NarrowRaw<T>>;
 
 export type Narrow<T> = Try<T, [], NarrowNotZod<T>>;
+
+export type AreAllPropertiesOptional<T> = {
+  [K in keyof T]-?: undefined extends T[K] ? true : false;
+}[keyof T] extends true
+  ? true
+  : false;