@sapporta/rest-core 3.52.1

package/src/lib/infer-types.ts

@@ -0,0 +1,282 @@
+import {
+  AppRoute,
+  AppRouteMutation,
+  AppRouter,
+  AppRouteStrictStatusCodes,
+  ContractAnyType,
+  ContractNoBodyType,
+  ContractOtherResponse,
+  InferHeadersInput,
+  InferHeadersOutput,
+} from './dsl';
+import { HTTPStatusCode } from './status-codes';
+import {
+  And,
+  Extends,
+  LowercaseKeys,
+  Merge,
+  Not,
+  OptionalIfAllOptional,
+  Or,
+  PartialByLooseKeys,
+  Prettify,
+  Without,
+  SchemaOutputOrType,
+  SchemaInputOrType,
+} from './type-utils';
+import {
+  ApiFetcher,
+  ClientArgs,
+  OverridableClientArgs,
+  FetchOptions,
+} from './client';
+import { ParamsFromUrl } from './paths';
+
+type ExtractExtraParametersFromClientArgs<
+  TClientArgs extends Pick<ClientArgs, 'api'>,
+> = TClientArgs['api'] extends ApiFetcher
+  ? Omit<Parameters<TClientArgs['api']>[0], keyof Parameters<ApiFetcher>[0]>
+  : {};
+
+/**
+ * Extract the path params from the path in the contract
+ */
+type PathParamsFromUrl<T extends AppRoute> = ParamsFromUrl<
+  T['path']
+> extends infer U
+  ? U
+  : never;
+
+/**
+ * Merge `PathParamsFromUrl<T>` with pathParams schema if it exists
+ */
+type PathParamsWithCustomValidators<
+  T extends AppRoute,
+  TClientOrServer extends 'client' | 'server' = 'server',
+> = 'pathParams' extends keyof T
+  ? Merge<
+      PathParamsFromUrl<T>,
+      TClientOrServer extends 'server'
+        ? SchemaOutputOrType<T['pathParams']>
+        : SchemaInputOrType<T['pathParams']>
+    >
+  : PathParamsFromUrl<T>;
+
+export type ResolveResponseType<
+  T extends
+    | ContractAnyType
+    | ContractNoBodyType
+    | ContractOtherResponse<ContractAnyType>,
+> = T extends ContractOtherResponse<infer U> ? U : T;
+
+export type InferResponseDefinedStatusCodes<
+  T extends AppRoute,
+  TStatus extends HTTPStatusCode = HTTPStatusCode,
+> = {
+  [K in keyof T['responses'] & TStatus]: K;
+}[keyof T['responses'] & TStatus];
+
+export type InferResponseUndefinedStatusCodes<
+  T extends AppRoute,
+  TStatus extends HTTPStatusCode = HTTPStatusCode,
+> = Exclude<TStatus, InferResponseDefinedStatusCodes<T, TStatus>>;
+
+type AppRouteResponses<
+  T extends AppRoute,
+  TStatus extends HTTPStatusCode,
+  TClientOrServer extends 'client' | 'server',
+  TStrictStatusCodes extends 'default' | 'ignore' | 'force' = 'default',
+> =
+  | {
+      [K in keyof T['responses'] & TStatus]: {
+        status: K;
+        body: TClientOrServer extends 'server'
+          ? SchemaInputOrType<ResolveResponseType<T['responses'][K]>>
+          : SchemaOutputOrType<ResolveResponseType<T['responses'][K]>>;
+      } & (TClientOrServer extends 'client'
+        ? {
+            headers: Headers;
+          }
+        : {});
+    }[keyof T['responses'] & TStatus]
+  | (Or<
+      Extends<TStrictStatusCodes, 'force'>,
+      And<
+        Extends<T, AppRouteStrictStatusCodes>,
+        Not<Extends<TStrictStatusCodes, 'ignore'>>
+      >
+    > extends true
+      ? never
+      : Exclude<TStatus, keyof T['responses']> extends never
+      ? never
+      : {
+          status: Exclude<TStatus, keyof T['responses']>;
+          body: unknown;
+        } & (TClientOrServer extends 'client'
+          ? {
+              headers: Headers;
+            }
+          : {}));
+
+export type ServerInferResponses<
+  T extends AppRoute | AppRouter,
+  TStatus extends HTTPStatusCode = HTTPStatusCode,
+  TStrictStatusCodes extends 'default' | 'ignore' | 'force' = 'default',
+> = T extends AppRoute
+  ? Prettify<AppRouteResponses<T, TStatus, 'server', TStrictStatusCodes>>
+  : T extends AppRouter
+  ? {
+      [TKey in keyof T]: ServerInferResponses<
+        T[TKey],
+        TStatus,
+        TStrictStatusCodes
+      >;
+    }
+  : never;
+
+export type ClientInferResponses<
+  T extends AppRoute | AppRouter,
+  TStatus extends HTTPStatusCode = HTTPStatusCode,
+  TStrictStatusCodes extends 'default' | 'ignore' | 'force' = 'default',
+> = T extends AppRoute
+  ? Prettify<AppRouteResponses<T, TStatus, 'client', TStrictStatusCodes>>
+  : T extends AppRouter
+  ? {
+      [TKey in keyof T]: ClientInferResponses<
+        T[TKey],
+        TStatus,
+        TStrictStatusCodes
+      >;
+    }
+  : never;
+
+export type ServerInferResponseBody<
+  T extends AppRoute,
+  TStatus extends keyof T['responses'] = keyof T['responses'],
+> = Prettify<AppRouteResponses<T, TStatus & HTTPStatusCode, 'server'>['body']>;
+
+export type ClientInferResponseBody<
+  T extends AppRoute,
+  TStatus extends keyof T['responses'] = keyof T['responses'],
+> = Prettify<AppRouteResponses<T, TStatus & HTTPStatusCode, 'client'>['body']>;
+
+type BodyWithoutFileIfMultiPart<T extends AppRouteMutation> =
+  T['contentType'] extends 'multipart/form-data'
+    ? Without<SchemaOutputOrType<T['body']>, File | File[]>
+    : SchemaOutputOrType<T['body']>;
+
+export type ServerInferRequest<
+  T extends AppRoute | AppRouter,
+  TServerHeaders = never,
+> = T extends AppRoute
+  ? Prettify<
+      Without<
+        {
+          params: [keyof PathParamsWithCustomValidators<T>] extends [never]
+            ? never
+            : Prettify<PathParamsWithCustomValidators<T>>;
+          body: T extends AppRouteMutation
+            ? BodyWithoutFileIfMultiPart<T>
+            : never;
+          query: 'query' extends keyof T
+            ? SchemaOutputOrType<T['query']>
+            : never;
+          headers: 'headers' extends keyof T
+            ? Prettify<
+                InferHeadersOutput<T> &
+                  ([TServerHeaders] extends [never]
+                    ? {}
+                    : Omit<
+                        TServerHeaders,
+                        keyof LowercaseKeys<InferHeadersOutput<T>>
+                      >)
+              >
+            : TServerHeaders;
+        },
+        never
+      >
+    >
+  : T extends AppRouter
+  ? { [TKey in keyof T]: ServerInferRequest<T[TKey], TServerHeaders> }
+  : never;
+
+type ClientInferRequestBase<
+  T extends AppRoute,
+  TClientArgs extends Omit<ClientArgs, 'baseUrl'> = {},
+  THeaders = 'headers' extends keyof T
+    ? /**
+       * We want to only require headers that the user did not provide
+       * in the base headers of the client
+       */
+      Prettify<
+        PartialByLooseKeys<
+          LowercaseKeys<InferHeadersInput<T>>,
+          keyof LowercaseKeys<TClientArgs['baseHeaders']>
+        >
+      >
+    : never,
+  TFetchOptions extends FetchOptions = FetchOptions,
+> = Prettify<
+  Without<
+    {
+      params: [keyof PathParamsWithCustomValidators<T, 'client'>] extends [
+        never,
+      ]
+        ? never
+        : Prettify<PathParamsWithCustomValidators<T, 'client'>>;
+      body: T extends AppRouteMutation
+        ? T['body'] extends null
+          ? never
+          : T['contentType'] extends 'multipart/form-data'
+          ? FormData | SchemaInputOrType<T['body']>
+          : T['contentType'] extends 'application/x-www-form-urlencoded'
+          ? string | SchemaInputOrType<T['body']>
+          : SchemaInputOrType<T['body']>
+        : never;
+      query: 'query' extends keyof T
+        ? T['query'] extends null
+          ? never
+          : SchemaInputOrType<T['query']>
+        : never;
+      headers: THeaders;
+      extraHeaders?: [THeaders] extends [never]
+        ? Record<string, string>
+        : {
+            [K in keyof RequiredKeys<InferHeadersInput<T>>]?: never;
+          } & Record<string, string>;
+      fetchOptions?: FetchOptions;
+      overrideClientOptions?: Partial<OverridableClientArgs>;
+
+      /**
+       * @deprecated Use `fetchOptions.cache` instead
+       */
+      cache?: 'cache' extends keyof TFetchOptions
+        ? TFetchOptions['cache']
+        : never;
+
+      /**
+       * @deprecated Use `fetchOptions.next` instead
+       */
+      next?: 'next' extends keyof TFetchOptions ? TFetchOptions['next'] : never;
+    } & ExtractExtraParametersFromClientArgs<TClientArgs>,
+    never
+  >
+>;
+
+type RequiredKeys<T> = {
+  [K in keyof T]-?: T[K];
+};
+
+export type ClientInferRequest<
+  T extends AppRoute | AppRouter,
+  TClientArgs extends Omit<ClientArgs, 'baseUrl'> = {},
+> = T extends AppRoute
+  ? ClientInferRequestBase<T, TClientArgs>
+  : T extends AppRouter
+  ? { [TKey in keyof T]: ClientInferRequest<T[TKey]> }
+  : never;
+
+export type PartialClientInferRequest<
+  TRoute extends AppRoute,
+  TClientArgs extends Omit<ClientArgs, 'baseUrl'> = {},
+> = OptionalIfAllOptional<ClientInferRequest<TRoute, TClientArgs>>;

package/src/lib/paths.spec.ts

@@ -0,0 +1,138 @@
+import { expectType } from 'tsd';
+import { insertParamsIntoPath, ParamsFromUrl } from './paths';
+
+const type = <T>() => '' as unknown as T;
+
+const url = '/post/:id/comments/:commentId';
+expectType<{ id: string; commentId: string }>(
+  type<ParamsFromUrl<typeof url>>(),
+);
+
+const url2 = '/post/:id/comments';
+expectType<{ id: string }>(type<ParamsFromUrl<typeof url2>>());
+
+const url3 = '/post/:id';
+expectType<{ id: string }>(type<ParamsFromUrl<typeof url3>>());
+
+const urlNoParams = '/posts';
+expectType<{}>(type<ParamsFromUrl<typeof urlNoParams>>());
+
+const urlManyParams = '/post/:id/comments/:commentId/:commentId2';
+expectType<{ id: string; commentId: string; commentId2: string }>(
+  type<ParamsFromUrl<typeof urlManyParams>>(),
+);
+
+const urlOptional = '/post/:id?';
+expectType<{
+  id?: string;
+}>(type<ParamsFromUrl<typeof urlOptional>>());
+
+const urlManyOptional = '/post/:id?/comments/:commentId?';
+expectType<{
+  id?: string;
+  commentId?: string;
+}>(type<ParamsFromUrl<typeof urlManyOptional>>());
+
+const urlMixedOptional = '/post/:id/comments/:commentId?';
+expectType<{
+  id: string;
+  commentId?: string;
+}>(type<ParamsFromUrl<typeof urlMixedOptional>>());
+
+const urlMixedOptional2 = '/post/:id?/comments/:commentId';
+expectType<{
+  id?: string;
+  commentId: string;
+}>(type<ParamsFromUrl<typeof urlMixedOptional2>>());
+
+describe('insertParamsIntoPath', () => {
+  it('should insert params into path', () => {
+    expect(
+      insertParamsIntoPath({
+        path: '/post/:id/comments/:commentId',
+        params: { commentId: '2', id: '1' },
+      }),
+    ).toBe('/post/1/comments/2');
+  });
+
+  it('should insert params into path with no params', () => {
+    expect(
+      insertParamsIntoPath({
+        path: '/posts',
+        params: { a: '1' },
+      }),
+    ).toBe('/posts');
+  });
+
+  it('should insert params into path with many params', () => {
+    expect(
+      insertParamsIntoPath({
+        path: '/post/:id/comments/:commentId/:commentId2',
+        params: { commentId: '2', commentId2: '3', id: '1' },
+      }),
+    ).toBe('/post/1/comments/2/3');
+  });
+
+  it('should insert into paths with only one param', () => {
+    expect(
+      insertParamsIntoPath({
+        path: '/:id',
+        params: { id: '1' },
+      }),
+    ).toBe('/1');
+  });
+
+  it('should insert optional params into path with many params', () => {
+    expect(
+      insertParamsIntoPath({
+        path: '/post/:id?/comments/:commentId?/:commentId2?',
+        params: { commentId: '2', commentId2: '3', id: '1' },
+      }),
+    ).toBe('/post/1/comments/2/3');
+  });
+
+  it('should insert optional params into path with no params', () => {
+    expect(
+      insertParamsIntoPath({
+        path: '/post/:id?/comments/:commentId?/:commentId2?',
+        params: {},
+      }),
+    ).toBe('/post/comments');
+  });
+
+  it('should insert not have trailing slashes', () => {
+    expect(
+      insertParamsIntoPath({
+        path: '/post/:id?/comments/:commentId?/:commentId2?/:commentId3?',
+        params: {},
+      }),
+    ).toBe('/post/comments');
+  });
+
+  it('should insert optional params into paths with only one param', () => {
+    expect(
+      insertParamsIntoPath({
+        path: '/:id?',
+        params: { id: '1' },
+      }),
+    ).toBe('/1');
+  });
+
+  it('should preserve trailing slashes in path', () => {
+    expect(
+      insertParamsIntoPath({
+        path: '/:id/',
+        params: { id: '1' },
+      }),
+    ).toBe('/1/');
+  });
+
+  it('should preserve trailing slashes in path with optional params', () => {
+    expect(
+      insertParamsIntoPath({
+        path: '/post/:id?/comments/:commentId?/:commentId2?/:commentId3?/',
+        params: {},
+      }),
+    ).toBe('/post/comments/');
+  });
+});

package/src/lib/paths.ts

@@ -0,0 +1,61 @@
+type ResolveOptionalPathParam<T extends string> =
+  T extends `${infer PathParam}?`
+    ? {
+        [key in PathParam]?: string | undefined;
+      }
+    : {
+        [key in T]: string;
+      };
+
+/**
+ * @params T - The URL e.g. /posts/:id
+ * @params TAcc - Accumulator object
+ */
+type RecursivelyExtractPathParams<T extends string> = T extends ''
+  ? Record<never, never>
+  : T extends `${infer Left}/:${infer PathParam}/${infer Right}`
+  ? ResolveOptionalPathParam<PathParam> &
+      RecursivelyExtractPathParams<Left> &
+      RecursivelyExtractPathParams<Right>
+  : T extends `:${infer PathParam}/${infer Right}`
+  ? ResolveOptionalPathParam<PathParam> & RecursivelyExtractPathParams<Right>
+  : T extends `${infer Left}/:${infer PathParam}`
+  ? ResolveOptionalPathParam<PathParam> & RecursivelyExtractPathParams<Left>
+  : T extends `:${infer PathParam}`
+  ? ResolveOptionalPathParam<PathParam>
+  : Record<never, never>;
+
+/**
+ * Extract path params from path function
+ *
+ * `{ id: string, commentId: string }`
+ *
+ * @params T - The URL e.g. /posts/:id
+ */
+export type ParamsFromUrl<T extends string> =
+  RecursivelyExtractPathParams<T> extends infer U
+    ? {
+        [key in keyof U]: U[key];
+      }
+    : never;
+
+/**
+ * @param path - The URL e.g. /posts/:id
+ * @param params - The params e.g. `{ id: string }`
+ * @returns - The URL with the params e.g. /posts/123
+ */
+export const insertParamsIntoPath = <T extends string>({
+  path,
+  params,
+}: {
+  path: T;
+  params: ParamsFromUrl<T>;
+}) => {
+  const pathParams: Record<string, string> = params;
+
+  return path.replace(/\/?:([^/?]+)\??/g, (matched, p) =>
+    pathParams[p]
+      ? `${matched.startsWith('/') ? '/' : ''}${pathParams[p]}`
+      : '',
+  );
+};