@sapporta/rest-core 3.52.1 → 3.52.2

package/src/lib/infer-types.ts

@@ -1,282 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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]}`
-      : '',
-  );
-};