@vrplatform/api 1.3.1 → 2.0.0-experimental.1

package/src/index.ts

@@ -1,11 +1,13 @@
-import type { useIngest } from './ingest';
 import type { ApiClient } from './types';
+import type { ApiClientV2 } from './types-v2';
 
 export * from './client';
+export * from './client-v2';
 export * from './error';
 export * from './generated/v1';
-export * from './ingest';
+export * as v2 from './generated/v2';
 export * from './types';
+export * from './types-v2';
 
-export type ApiIngest = ReturnType<typeof useIngest>;
 export type VRPlatformApi = ApiClient;
+export type VRPlatformApiV2 = ApiClientV2;

package/src/types-v2.ts

@@ -0,0 +1,93 @@
+import type createClient from 'openapi-fetch';
+import type { paths as pathsV2 } from './generated/v2';
+
+export type ApiClientV2 = ReturnType<typeof createClient<pathsV2>> & {
+  sessionId: string;
+};
+
+type ResponseCombinationsV2 = {
+  [Path in keyof pathsV2]: {
+    [Method in keyof pathsV2[Path]]: pathsV2[Path][Method] extends never
+      ? never
+      : pathsV2[Path][Method] extends {
+            responses: {
+              200: { content: { 'application/json': unknown } };
+            };
+          }
+        ? `${Method & string}:${Path}`
+        : never;
+  }[keyof pathsV2[Path]];
+}[keyof pathsV2];
+
+export type ResponseDataV2<T extends ResponseCombinationsV2> =
+  T extends `${infer Method}:${infer Path}`
+    ? Path extends keyof pathsV2
+      ? Method extends keyof pathsV2[Path]
+        ? pathsV2[Path][Method] extends {
+            responses: {
+              200: { content: { 'application/json': infer Data } };
+            };
+          }
+          ? Data
+          : never
+        : never
+      : never
+    : never;
+
+type RequestBodyCombinationsV2 = {
+  [Path in keyof pathsV2]: {
+    [Method in keyof pathsV2[Path]]: pathsV2[Path][Method] extends never
+      ? never
+      : pathsV2[Path][Method] extends {
+            requestBody: {
+              content: { 'application/json': unknown };
+            };
+          }
+        ? `${Method & string}:${Path}`
+        : never;
+  }[keyof pathsV2[Path]];
+}[keyof pathsV2];
+
+export type RequestBodyV2<T extends RequestBodyCombinationsV2> =
+  T extends `${infer Method}:${infer Path}`
+    ? Path extends keyof pathsV2
+      ? Method extends keyof pathsV2[Path]
+        ? pathsV2[Path][Method] extends {
+            requestBody: {
+              content: { 'application/json': infer Data };
+            };
+          }
+          ? Data
+          : never
+        : never
+      : never
+    : never;
+
+type RequestParamCombinationsV2 = {
+  [Path in keyof pathsV2]: {
+    [Method in keyof pathsV2[Path]]: pathsV2[Path][Method] extends never
+      ? never
+      : pathsV2[Path][Method] extends {
+            parameters: {
+              query?: Record<string, unknown>;
+            };
+          }
+        ? `${Method & string}:${Path}`
+        : never;
+  }[keyof pathsV2[Path]];
+}[keyof pathsV2];
+
+export type RequestQueryV2<T extends RequestParamCombinationsV2> =
+  T extends `${infer Method}:${infer Path}`
+    ? Path extends keyof pathsV2
+      ? Method extends keyof pathsV2[Path]
+        ? pathsV2[Path][Method] extends {
+            parameters: {
+              query?: infer Data;
+            };
+          }
+          ? Data
+          : never
+        : never
+      : never
+    : never;

package/src/generated/openapi-fetch.ts

@@ -1,433 +0,0 @@
-import type {
-  ErrorResponse,
-  FilterKeys,
-  HttpMethod,
-  IsOperationRequestBodyOptional,
-  MediaType,
-  OperationRequestBodyContent,
-  PathsWithMethod,
-  RequiredKeysOf,
-  ResponseObjectMap,
-  SuccessResponse,
-} from 'openapi-typescript-helpers';
-
-/** Options for each client instance */
-interface ClientOptions extends Omit<RequestInit, 'headers'> {
-  /** set the common root URL for all API requests */
-  baseUrl?: string;
-  /** custom fetch (defaults to globalThis.fetch) */
-  fetch?: (input: Request) => Promise<Response>;
-  /** custom Request (defaults to globalThis.Request) */
-  Request?: typeof Request;
-  /** global querySerializer */
-  querySerializer?: QuerySerializer<unknown> | QuerySerializerOptions;
-  /** global bodySerializer */
-  bodySerializer?: BodySerializer<unknown>;
-  headers?: HeadersOptions;
-  /** RequestInit extension object to pass as 2nd argument to fetch when supported (defaults to undefined) */
-  requestInitExt?: Record<string, unknown>;
-}
-
-type HeadersOptions =
-  | Required<RequestInit>['headers']
-  | Record<
-      string,
-      | string
-      | number
-      | boolean
-      | (string | number | boolean)[]
-      | null
-      | undefined
-    >;
-
-type QuerySerializer<T> = (
-  query: T extends { parameters: any }
-    ? NonNullable<T['parameters']['query']>
-    : Record<string, unknown>
-) => string;
-
-/** @see https://swagger.io/docs/specification/serialization/#query */
-type QuerySerializerOptions = {
-  /** Set serialization for arrays. @see https://swagger.io/docs/specification/serialization/#query */
-  array?: {
-    /** default: "form" */
-    style: 'form' | 'spaceDelimited' | 'pipeDelimited';
-    /** default: true */
-    explode: boolean;
-  };
-  /** Set serialization for objects. @see https://swagger.io/docs/specification/serialization/#query */
-  object?: {
-    /** default: "deepObject" */
-    style: 'form' | 'deepObject';
-    /** default: true */
-    explode: boolean;
-  };
-  /**
-   * The `allowReserved` keyword specifies whether the reserved characters
-   * `:/?#[]@!$&'()*+,;=` in parameter values are allowed to be sent as they
-   * are, or should be percent-encoded. By default, allowReserved is `false`,
-   * and reserved characters are percent-encoded.
-   * @see https://swagger.io/docs/specification/serialization/#query
-   */
-  allowReserved?: boolean;
-};
-
-type BodySerializer<T> = (body: OperationRequestBodyContent<T>) => any;
-
-type BodyType<T = unknown> = {
-  json: T;
-  text: Awaited<ReturnType<Response['text']>>;
-  blob: Awaited<ReturnType<Response['blob']>>;
-  arrayBuffer: Awaited<ReturnType<Response['arrayBuffer']>>;
-  stream: Response['body'];
-};
-type ParseAs = keyof BodyType;
-type ParseAsResponse<T, Options> = Options extends {
-  parseAs: ParseAs;
-}
-  ? BodyType<T>[Options['parseAs']]
-  : T;
-
-interface DefaultParamsOption {
-  params?: {
-    query?: Record<string, unknown>;
-  };
-}
-
-type ParamsOption<T> = T extends {
-  parameters: any;
-}
-  ? RequiredKeysOf<T['parameters']> extends never
-    ? { params?: T['parameters'] }
-    : { params: T['parameters'] }
-  : DefaultParamsOption;
-
-type RequestBodyOption<T> = OperationRequestBodyContent<T> extends never
-  ? { body?: never }
-  : IsOperationRequestBodyOptional<T> extends true
-    ? { body?: OperationRequestBodyContent<T> }
-    : { body: OperationRequestBodyContent<T> };
-
-type FetchOptions<T> = RequestOptions<T> &
-  Omit<RequestInit, 'body' | 'headers'>;
-
-type FetchResponse<
-  T extends Record<string | number, any>,
-  Options,
-  Media extends MediaType,
-> =
-  | {
-      data: ParseAsResponse<
-        SuccessResponse<ResponseObjectMap<T>, Media>,
-        Options
-      >;
-      error?: never;
-      response: Response;
-    }
-  | {
-      data?: never;
-      error: ErrorResponse<ResponseObjectMap<T>, Media>;
-      response: Response;
-    };
-
-type RequestOptions<T> = ParamsOption<T> &
-  RequestBodyOption<T> & {
-    baseUrl?: string;
-    querySerializer?: QuerySerializer<T> | QuerySerializerOptions;
-    bodySerializer?: BodySerializer<T>;
-    parseAs?: ParseAs;
-    fetch?: ClientOptions['fetch'];
-    headers?: HeadersOptions;
-  };
-
-type MergedOptions<T = unknown> = {
-  baseUrl: string;
-  parseAs: ParseAs;
-  querySerializer: QuerySerializer<T>;
-  bodySerializer: BodySerializer<T>;
-  fetch: typeof globalThis.fetch;
-};
-
-interface MiddlewareCallbackParams {
-  /** Current Request object */
-  request: Request;
-  /** The original OpenAPI schema path (including curly braces) */
-  readonly schemaPath: string;
-  /** OpenAPI parameters as provided from openapi-fetch */
-  readonly params: {
-    query?: Record<string, unknown>;
-    header?: Record<string, unknown>;
-    path?: Record<string, unknown>;
-    cookie?: Record<string, unknown>;
-  };
-  /** Unique ID for this request */
-  readonly id: string;
-  /** createClient options (read-only) */
-  readonly options: MergedOptions;
-}
-
-type MiddlewareOnRequest = (options: MiddlewareCallbackParams) =>
-  | void
-  | Request
-  | Response
-  | undefined
-  // biome-ignore lint/suspicious/noConfusingVoidType: N
-  | Promise<Request | Response | undefined | void>;
-type MiddlewareOnResponse = (
-  options: MiddlewareCallbackParams & { response: Response }
-  // biome-ignore lint/suspicious/noConfusingVoidType: N
-) => void | Response | undefined | Promise<Response | undefined | void>;
-type MiddlewareOnError = (
-  options: MiddlewareCallbackParams & { error: unknown }
-  // biome-ignore lint/suspicious/noConfusingVoidType: N
-) => void | Response | Error | Promise<void | Response | Error>;
-
-type Middleware =
-  | {
-      onRequest: MiddlewareOnRequest;
-      onResponse?: MiddlewareOnResponse;
-      onError?: MiddlewareOnError;
-    }
-  | {
-      onRequest?: MiddlewareOnRequest;
-      onResponse: MiddlewareOnResponse;
-      onError?: MiddlewareOnError;
-    }
-  | {
-      onRequest?: MiddlewareOnRequest;
-      onResponse?: MiddlewareOnResponse;
-      onError: MiddlewareOnError;
-    };
-
-/** This type helper makes the 2nd function param required if params/requestBody are required; otherwise, optional */
-type MaybeOptionalInit<Params, Location extends keyof Params> = RequiredKeysOf<
-  FetchOptions<FilterKeys<Params, Location>>
-> extends never
-  ? FetchOptions<FilterKeys<Params, Location>> | undefined
-  : FetchOptions<FilterKeys<Params, Location>>;
-
-// The final init param to accept.
-// - Determines if the param is optional or not.
-// - Performs arbitrary [key: string] addition.
-// Note: the addition MUST happen after all the inference happens (otherwise TS can’t infer if init is required or not).
-type InitParam<Init> = RequiredKeysOf<Init> extends never
-  ? [(Init & { [key: string]: unknown })?]
-  : [Init & { [key: string]: unknown }];
-
-type ClientMethod<
-  // biome-ignore lint/complexity/noBannedTypes: N
-  Paths extends Record<string, Record<HttpMethod, {}>>,
-  Method extends HttpMethod,
-  Media extends MediaType,
-> = <
-  Path extends PathsWithMethod<Paths, Method>,
-  Init extends MaybeOptionalInit<Paths[Path], Method>,
->(
-  url: Path,
-  ...init: InitParam<Init>
-) => Promise<FetchResponse<Paths[Path][Method], Init, Media>>;
-
-type ClientRequestMethod<
-  // biome-ignore lint/complexity/noBannedTypes: N
-  Paths extends Record<string, Record<HttpMethod, {}>>,
-  Media extends MediaType,
-> = <
-  Method extends HttpMethod,
-  Path extends PathsWithMethod<Paths, Method>,
-  Init extends MaybeOptionalInit<Paths[Path], Method>,
->(
-  method: Method,
-  url: Path,
-  ...init: InitParam<Init>
-) => Promise<FetchResponse<Paths[Path][Method], Init, Media>>;
-
-type ClientForPath<
-  PathInfo extends Record<string | number, any>,
-  Media extends MediaType,
-> = {
-  [Method in keyof PathInfo as Uppercase<string & Method>]: <
-    Init extends MaybeOptionalInit<PathInfo, Method>,
-  >(
-    ...init: InitParam<Init>
-  ) => Promise<FetchResponse<PathInfo[Method], Init, Media>>;
-};
-
-interface Client<Paths extends {}, Media extends MediaType = MediaType> {
-  request: ClientRequestMethod<Paths, Media>;
-  /** Call a GET endpoint */
-  GET: ClientMethod<Paths, 'get', Media>;
-  /** Call a PUT endpoint */
-  PUT: ClientMethod<Paths, 'put', Media>;
-  /** Call a POST endpoint */
-  POST: ClientMethod<Paths, 'post', Media>;
-  /** Call a DELETE endpoint */
-  DELETE: ClientMethod<Paths, 'delete', Media>;
-  /** Call a OPTIONS endpoint */
-  OPTIONS: ClientMethod<Paths, 'options', Media>;
-  /** Call a HEAD endpoint */
-  HEAD: ClientMethod<Paths, 'head', Media>;
-  /** Call a PATCH endpoint */
-  PATCH: ClientMethod<Paths, 'patch', Media>;
-  /** Call a TRACE endpoint */
-  TRACE: ClientMethod<Paths, 'trace', Media>;
-  /** Register middleware */
-  use(...middleware: Middleware[]): void;
-  /** Unregister middleware */
-  eject(...middleware: Middleware[]): void;
-}
-
-type ClientPathsWithMethod<
-  CreatedClient extends Client<any, any>,
-  Method extends HttpMethod,
-> = CreatedClient extends Client<infer Paths, infer _Media>
-  ? PathsWithMethod<Paths, Method>
-  : never;
-
-type MethodResponse<
-  CreatedClient extends Client<any, any>,
-  Method extends HttpMethod,
-  Path extends ClientPathsWithMethod<CreatedClient, Method>,
-  // biome-ignore lint/complexity/noBannedTypes: Bla
-  Options = {},
-> = CreatedClient extends Client<
-  infer Paths extends { [key: string]: any },
-  infer Media extends MediaType
->
-  ? NonNullable<FetchResponse<Paths[Path][Method], Options, Media>['data']>
-  : never;
-
-declare function createClient<
-  Paths extends {},
-  Media extends MediaType = MediaType,
->(clientOptions?: ClientOptions): Client<Paths, Media>;
-
-type PathBasedClient<
-  Paths extends Record<string | number, any>,
-  Media extends MediaType = MediaType,
-> = {
-  [Path in keyof Paths]: ClientForPath<Paths[Path], Media>;
-};
-
-declare function wrapAsPathBasedClient<
-  Paths extends {},
-  Media extends MediaType = MediaType,
->(client: Client<Paths, Media>): PathBasedClient<Paths, Media>;
-
-declare function createPathBasedClient<
-  Paths extends {},
-  Media extends MediaType = MediaType,
->(clientOptions?: ClientOptions): PathBasedClient<Paths, Media>;
-
-/** Serialize primitive params to string */
-declare function serializePrimitiveParam(
-  name: string,
-  value: string,
-  options?: { allowReserved?: boolean }
-): string;
-
-/** Serialize object param to string */
-declare function serializeObjectParam(
-  name: string,
-  value: Record<string, unknown>,
-  options: {
-    style: 'simple' | 'label' | 'matrix' | 'form' | 'deepObject';
-    explode: boolean;
-    allowReserved?: boolean;
-  }
-): string;
-
-/** Serialize array param to string */
-declare function serializeArrayParam(
-  name: string,
-  value: unknown[],
-  options: {
-    style:
-      | 'simple'
-      | 'label'
-      | 'matrix'
-      | 'form'
-      | 'spaceDelimited'
-      | 'pipeDelimited';
-    explode: boolean;
-    allowReserved?: boolean;
-  }
-): string;
-
-/** Serialize query params to string */
-declare function createQuerySerializer<T = unknown>(
-  options?: QuerySerializerOptions
-): (queryParams: T) => string;
-
-/**
- * Handle different OpenAPI 3.x serialization styles
- * @type {import("openapi-fetch").defaultPathSerializer}
- * @see https://swagger.io/docs/specification/serialization/#path
- */
-declare function defaultPathSerializer(
-  pathname: string,
-  pathParams: Record<string, unknown>
-): string;
-
-/** Serialize body object to string */
-declare function defaultBodySerializer<T>(body: T): string;
-
-/** Construct URL string from baseUrl and handle path and query params */
-declare function createFinalURL<O>(
-  pathname: string,
-  options: {
-    baseUrl: string;
-    params: {
-      query?: Record<string, unknown>;
-      path?: Record<string, unknown>;
-    };
-    querySerializer: QuerySerializer<O>;
-  }
-): string;
-
-/** Merge headers a and b, with b taking priority */
-declare function mergeHeaders(
-  ...allHeaders: (HeadersOptions | undefined)[]
-): Headers;
-
-/** Remove trailing slash from url */
-declare function removeTrailingSlash(url: string): string;
-
-export {
-  createFinalURL,
-  createPathBasedClient,
-  createQuerySerializer,
-  defaultBodySerializer,
-  defaultPathSerializer,
-  mergeHeaders,
-  removeTrailingSlash,
-  serializeArrayParam,
-  serializeObjectParam,
-  serializePrimitiveParam,
-  wrapAsPathBasedClient,
-};
-export type {
-  BodySerializer,
-  Client,
-  ClientForPath,
-  ClientMethod,
-  ClientOptions,
-  ClientPathsWithMethod,
-  ClientRequestMethod,
-  DefaultParamsOption,
-  FetchOptions,
-  FetchResponse,
-  HeadersOptions,
-  MaybeOptionalInit,
-  MergedOptions,
-  MethodResponse,
-  Middleware,
-  MiddlewareCallbackParams,
-  ParamsOption,
-  ParseAs,
-  ParseAsResponse,
-  PathBasedClient,
-  QuerySerializer,
-  QuerySerializerOptions,
-  RequestBodyOption,
-  RequestOptions,
-};