@firela/api-types 0.0.0-canary.209966

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@firela/api-types",
+  "version": "0.0.0-canary.209966",
+  "description": "TypeScript types generated from IGN OpenAPI specification",
+  "license": "MIT",
+  "author": "FireLa Team",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fire-zu/ign.git",
+    "directory": "libs/api-types"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./client": {
+      "types": "./dist/generated/sdk.gen.d.ts",
+      "import": "./dist/generated/sdk.gen.mjs",
+      "default": "./dist/generated/sdk.gen.js"
+    }
+  },
+  "files": ["dist", "src"],
+  "scripts": {
+    "sync": "npx ts-node scripts/sync-spec.ts",
+    "generate": "npm run sync && openapi-ts",
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "lint": "spectral lint openapi.yaml",
+    "prepublishOnly": "npm run generate && npm run build"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@hey-api/client-fetch": "^0.4.0",
+    "@hey-api/openapi-ts": "^0.45.0",
+    "@stoplight/spectral-cli": "^6.11.0",
+    "ts-node": "^10.9.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/generated/core/ApiError.ts

@@ -0,0 +1,25 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+
+export class ApiError extends Error {
+  public readonly url: string;
+  public readonly status: number;
+  public readonly statusText: string;
+  public readonly body: unknown;
+  public readonly request: ApiRequestOptions;
+
+  constructor(
+    request: ApiRequestOptions,
+    response: ApiResult,
+    message: string
+  ) {
+    super(message);
+
+    this.name = 'ApiError';
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request;
+  }
+}

package/src/generated/core/ApiRequestOptions.ts

@@ -0,0 +1,20 @@
+export type ApiRequestOptions = {
+  readonly method:
+    | 'GET'
+    | 'PUT'
+    | 'POST'
+    | 'DELETE'
+    | 'OPTIONS'
+    | 'HEAD'
+    | 'PATCH';
+  readonly url: string;
+  readonly path?: Record<string, unknown>;
+  readonly cookies?: Record<string, unknown>;
+  readonly headers?: Record<string, unknown>;
+  readonly query?: Record<string, unknown>;
+  readonly formData?: Record<string, unknown>;
+  readonly body?: any;
+  readonly mediaType?: string;
+  readonly responseHeader?: string;
+  readonly errors?: Record<number, string>;
+};

package/src/generated/core/ApiResult.ts

@@ -0,0 +1,7 @@
+export type ApiResult<TData = any> = {
+  readonly body: TData;
+  readonly ok: boolean;
+  readonly status: number;
+  readonly statusText: string;
+  readonly url: string;
+};

package/src/generated/core/CancelablePromise.ts

@@ -0,0 +1,126 @@
+export class CancelError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'CancelError';
+  }
+
+  public get isCancelled(): boolean {
+    return true;
+  }
+}
+
+export interface OnCancel {
+  readonly isResolved: boolean;
+  readonly isRejected: boolean;
+  readonly isCancelled: boolean;
+
+  (cancelHandler: () => void): void;
+}
+
+export class CancelablePromise<T> implements Promise<T> {
+  private _isResolved: boolean;
+  private _isRejected: boolean;
+  private _isCancelled: boolean;
+  readonly cancelHandlers: (() => void)[];
+  readonly promise: Promise<T>;
+  private _resolve?: (value: T | PromiseLike<T>) => void;
+  private _reject?: (reason?: unknown) => void;
+
+  constructor(
+    executor: (
+      resolve: (value: T | PromiseLike<T>) => void,
+      reject: (reason?: unknown) => void,
+      onCancel: OnCancel
+    ) => void
+  ) {
+    this._isResolved = false;
+    this._isRejected = false;
+    this._isCancelled = false;
+    this.cancelHandlers = [];
+    this.promise = new Promise<T>((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+
+      const onResolve = (value: T | PromiseLike<T>): void => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isResolved = true;
+        if (this._resolve) this._resolve(value);
+      };
+
+      const onReject = (reason?: unknown): void => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isRejected = true;
+        if (this._reject) this._reject(reason);
+      };
+
+      const onCancel = (cancelHandler: () => void): void => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this.cancelHandlers.push(cancelHandler);
+      };
+
+      Object.defineProperty(onCancel, 'isResolved', {
+        get: (): boolean => this._isResolved
+      });
+
+      Object.defineProperty(onCancel, 'isRejected', {
+        get: (): boolean => this._isRejected
+      });
+
+      Object.defineProperty(onCancel, 'isCancelled', {
+        get: (): boolean => this._isCancelled
+      });
+
+      return executor(onResolve, onReject, onCancel as OnCancel);
+    });
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'Cancellable Promise';
+  }
+
+  public then<TResult1 = T, TResult2 = never>(
+    onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+    onRejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null
+  ): Promise<TResult1 | TResult2> {
+    return this.promise.then(onFulfilled, onRejected);
+  }
+
+  public catch<TResult = never>(
+    onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null
+  ): Promise<T | TResult> {
+    return this.promise.catch(onRejected);
+  }
+
+  public finally(onFinally?: (() => void) | null): Promise<T> {
+    return this.promise.finally(onFinally);
+  }
+
+  public cancel(): void {
+    if (this._isResolved || this._isRejected || this._isCancelled) {
+      return;
+    }
+    this._isCancelled = true;
+    if (this.cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this.cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn('Cancellation threw an error', error);
+        return;
+      }
+    }
+    this.cancelHandlers.length = 0;
+    if (this._reject) this._reject(new CancelError('Request aborted'));
+  }
+
+  public get isCancelled(): boolean {
+    return this._isCancelled;
+  }
+}

package/src/generated/core/OpenAPI.ts

@@ -0,0 +1,56 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+
+type Headers = Record<string, string>;
+type Middleware<T> = (value: T) => T | Promise<T>;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+
+export class Interceptors<T> {
+  _fns: Middleware<T>[];
+
+  constructor() {
+    this._fns = [];
+  }
+
+  eject(fn: Middleware<T>) {
+    const index = this._fns.indexOf(fn);
+    if (index !== -1) {
+      this._fns = [...this._fns.slice(0, index), ...this._fns.slice(index + 1)];
+    }
+  }
+
+  use(fn: Middleware<T>) {
+    this._fns = [...this._fns, fn];
+  }
+}
+
+export type OpenAPIConfig = {
+  BASE: string;
+  CREDENTIALS: 'include' | 'omit' | 'same-origin';
+  ENCODE_PATH?: ((path: string) => string) | undefined;
+  HEADERS?: Headers | Resolver<Headers> | undefined;
+  PASSWORD?: string | Resolver<string> | undefined;
+  TOKEN?: string | Resolver<string> | undefined;
+  USERNAME?: string | Resolver<string> | undefined;
+  VERSION: string;
+  WITH_CREDENTIALS: boolean;
+  interceptors: {
+    request: Interceptors<RequestInit>;
+    response: Interceptors<Response>;
+  };
+};
+
+export const OpenAPI: OpenAPIConfig = {
+  BASE: '',
+  CREDENTIALS: 'include',
+  ENCODE_PATH: undefined,
+  HEADERS: undefined,
+  PASSWORD: undefined,
+  TOKEN: undefined,
+  USERNAME: undefined,
+  VERSION: 'dev',
+  WITH_CREDENTIALS: false,
+  interceptors: {
+    request: new Interceptors(),
+    response: new Interceptors()
+  }
+};

package/src/generated/core/request.ts

@@ -0,0 +1,391 @@
+import { ApiError } from './ApiError';
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+import { CancelablePromise } from './CancelablePromise';
+import type { OnCancel } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+
+export const isString = (value: unknown): value is string => {
+  return typeof value === 'string';
+};
+
+export const isStringWithValue = (value: unknown): value is string => {
+  return isString(value) && value !== '';
+};
+
+export const isBlob = (value: any): value is Blob => {
+  return value instanceof Blob;
+};
+
+export const isFormData = (value: unknown): value is FormData => {
+  return value instanceof FormData;
+};
+
+export const base64 = (str: string): string => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    // @ts-ignore
+    return Buffer.from(str).toString('base64');
+  }
+};
+
+export const getQueryString = (params: Record<string, unknown>): string => {
+  const qs: string[] = [];
+
+  const append = (key: string, value: unknown) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+
+  const encodePair = (key: string, value: unknown) => {
+    if (value === undefined || value === null) {
+      return;
+    }
+
+    if (value instanceof Date) {
+      append(key, value.toISOString());
+    } else if (Array.isArray(value)) {
+      value.forEach((v) => encodePair(key, v));
+    } else if (typeof value === 'object') {
+      Object.entries(value).forEach(([k, v]) => encodePair(`${key}[${k}]`, v));
+    } else {
+      append(key, value);
+    }
+  };
+
+  Object.entries(params).forEach(([key, value]) => encodePair(key, value));
+
+  return qs.length ? `?${qs.join('&')}` : '';
+};
+
+const getUrl = (config: OpenAPIConfig, options: ApiRequestOptions): string => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+
+  const path = options.url
+    .replace('{api-version}', config.VERSION)
+    .replace(/{(.*?)}/g, (substring: string, group: string) => {
+      if (options.path?.hasOwnProperty(group)) {
+        return encoder(String(options.path[group]));
+      }
+      return substring;
+    });
+
+  const url = config.BASE + path;
+  return options.query ? url + getQueryString(options.query) : url;
+};
+
+export const getFormData = (
+  options: ApiRequestOptions
+): FormData | undefined => {
+  if (options.formData) {
+    const formData = new FormData();
+
+    const process = (key: string, value: unknown) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+
+    Object.entries(options.formData)
+      .filter(([, value]) => value !== undefined && value !== null)
+      .forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          value.forEach((v) => process(key, v));
+        } else {
+          process(key, value);
+        }
+      });
+
+    return formData;
+  }
+  return undefined;
+};
+
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+
+export const resolve = async <T>(
+  options: ApiRequestOptions,
+  resolver?: T | Resolver<T>
+): Promise<T | undefined> => {
+  if (typeof resolver === 'function') {
+    return (resolver as Resolver<T>)(options);
+  }
+  return resolver;
+};
+
+export const getHeaders = async (
+  config: OpenAPIConfig,
+  options: ApiRequestOptions
+): Promise<Headers> => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    resolve(options, config.TOKEN),
+    resolve(options, config.USERNAME),
+    resolve(options, config.PASSWORD),
+    resolve(options, config.HEADERS)
+  ]);
+
+  const headers = Object.entries({
+    Accept: 'application/json',
+    ...additionalHeaders,
+    ...options.headers
+  })
+    .filter(([, value]) => value !== undefined && value !== null)
+    .reduce(
+      (headers, [key, value]) => ({
+        ...headers,
+        [key]: String(value)
+      }),
+      {} as Record<string, string>
+    );
+
+  if (isStringWithValue(token)) {
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers['Authorization'] = `Basic ${credentials}`;
+  }
+
+  if (options.body !== undefined) {
+    if (options.mediaType) {
+      headers['Content-Type'] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers['Content-Type'] = options.body.type || 'application/octet-stream';
+    } else if (isString(options.body)) {
+      headers['Content-Type'] = 'text/plain';
+    } else if (!isFormData(options.body)) {
+      headers['Content-Type'] = 'application/json';
+    }
+  }
+
+  return new Headers(headers);
+};
+
+export const getRequestBody = (options: ApiRequestOptions): unknown => {
+  if (options.body !== undefined) {
+    if (
+      options.mediaType?.includes('application/json') ||
+      options.mediaType?.includes('+json')
+    ) {
+      return JSON.stringify(options.body);
+    } else if (
+      isString(options.body) ||
+      isBlob(options.body) ||
+      isFormData(options.body)
+    ) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
+    }
+  }
+  return undefined;
+};
+
+export const sendRequest = async (
+  config: OpenAPIConfig,
+  options: ApiRequestOptions,
+  url: string,
+  body: any,
+  formData: FormData | undefined,
+  headers: Headers,
+  onCancel: OnCancel
+): Promise<Response> => {
+  const controller = new AbortController();
+
+  let request: RequestInit = {
+    headers,
+    body: body ?? formData,
+    method: options.method,
+    signal: controller.signal
+  };
+
+  if (config.WITH_CREDENTIALS) {
+    request.credentials = config.CREDENTIALS;
+  }
+
+  for (const fn of config.interceptors.request._fns) {
+    request = await fn(request);
+  }
+
+  onCancel(() => controller.abort());
+
+  return await fetch(url, request);
+};
+
+export const getResponseHeader = (
+  response: Response,
+  responseHeader?: string
+): string | undefined => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return undefined;
+};
+
+export const getResponseBody = async (response: Response): Promise<unknown> => {
+  if (response.status !== 204) {
+    try {
+      const contentType = response.headers.get('Content-Type');
+      if (contentType) {
+        const binaryTypes = [
+          'application/octet-stream',
+          'application/pdf',
+          'application/zip',
+          'audio/',
+          'image/',
+          'video/'
+        ];
+        if (
+          contentType.includes('application/json') ||
+          contentType.includes('+json')
+        ) {
+          return await response.json();
+        } else if (binaryTypes.some((type) => contentType.includes(type))) {
+          return await response.blob();
+        } else if (contentType.includes('multipart/form-data')) {
+          return await response.formData();
+        } else if (contentType.includes('text/')) {
+          return await response.text();
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return undefined;
+};
+
+export const catchErrorCodes = (
+  options: ApiRequestOptions,
+  result: ApiResult
+): void => {
+  const errors: Record<number, string> = {
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Payload Too Large',
+    414: 'URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Range Not Satisfiable',
+    417: 'Expectation Failed',
+    418: 'Im a teapot',
+    421: 'Misdirected Request',
+    422: 'Unprocessable Content',
+    423: 'Locked',
+    424: 'Failed Dependency',
+    425: 'Too Early',
+    426: 'Upgrade Required',
+    428: 'Precondition Required',
+    429: 'Too Many Requests',
+    431: 'Request Header Fields Too Large',
+    451: 'Unavailable For Legal Reasons',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported',
+    506: 'Variant Also Negotiates',
+    507: 'Insufficient Storage',
+    508: 'Loop Detected',
+    510: 'Not Extended',
+    511: 'Network Authentication Required',
+    ...options.errors
+  };
+
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+
+  if (!result.ok) {
+    const errorStatus = result.status ?? 'unknown';
+    const errorStatusText = result.statusText ?? 'unknown';
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return undefined;
+      }
+    })();
+
+    throw new ApiError(
+      options,
+      result,
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+    );
+  }
+};
+
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export const request = <T>(
+  config: OpenAPIConfig,
+  options: ApiRequestOptions
+): CancelablePromise<T> => {
+  return new CancelablePromise(async (resolve, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options);
+
+      if (!onCancel.isCancelled) {
+        let response = await sendRequest(
+          config,
+          options,
+          url,
+          body,
+          formData,
+          headers,
+          onCancel
+        );
+
+        for (const fn of config.interceptors.response._fns) {
+          response = await fn(response);
+        }
+
+        const responseBody = await getResponseBody(response);
+        const responseHeader = getResponseHeader(
+          response,
+          options.responseHeader
+        );
+
+        const result: ApiResult = {
+          url,
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody
+        };
+
+        catchErrorCodes(options, result);
+
+        resolve(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};

package/src/generated/index.ts

@@ -0,0 +1,7 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export { ApiError } from './core/ApiError';
+export { CancelablePromise, CancelError } from './core/CancelablePromise';
+export { OpenAPI, type OpenAPIConfig } from './core/OpenAPI';
+export * from './schemas.gen';
+export * from './services.gen';
+export * from './types.gen';