👽️(chore): generate joanie api client

src/frontend/index.ts

@@ -0,0 +1,27 @@
+import context from 'utils/context';
+import { AppClient, OpenAPIConfig } from './v1'
+import { JOANIE_API_VERSION } from 'settings';
+
+/**
+ * Build Joanie API Routes interface.
+ */
+const getAPIEndpoint = () => {
+    const endpoint = context?.joanie_backend?.endpoint;
+    const version = JOANIE_API_VERSION;
+
+    if (!endpoint) {
+      throw new Error('[JOANIE] - Joanie API endpoint is not defined.');
+    }
+
+    return `${endpoint}/api/${version}`;
+  };
+
+
+const config: OpenAPIConfig = {
+  BASE: getAPIEndpoint(),
+  VERSION: '1',
+  WITH_CREDENTIALS: true,
+  CREDENTIALS: 'include',
+}
+
+export const api = new AppClient(config).default

src/frontend/js/api/joanie/gen/ApiClientJoanie.ts

@@ -0,0 +1,58 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { BaseHttpRequest } from './core/BaseHttpRequest';
+import type { OpenAPIConfig } from './core/OpenAPI';
+import { FetchHttpRequest } from './core/FetchHttpRequest';
+
+import { AddressesService } from './services/AddressesService';
+import { CertificatesService } from './services/CertificatesService';
+import { CourseRunsService } from './services/CourseRunsService';
+import { CourseRunsSyncService } from './services/CourseRunsSyncService';
+import { CreditCardsService } from './services/CreditCardsService';
+import { EnrollmentsService } from './services/EnrollmentsService';
+import { OrdersService } from './services/OrdersService';
+import { PaymentsService } from './services/PaymentsService';
+import { ProductsService } from './services/ProductsService';
+
+type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
+
+export class ApiClientJoanie {
+
+  public readonly addresses: AddressesService;
+  public readonly certificates: CertificatesService;
+  public readonly courseRuns: CourseRunsService;
+  public readonly courseRunsSync: CourseRunsSyncService;
+  public readonly creditCards: CreditCardsService;
+  public readonly enrollments: EnrollmentsService;
+  public readonly orders: OrdersService;
+  public readonly payments: PaymentsService;
+  public readonly products: ProductsService;
+
+  public readonly request: BaseHttpRequest;
+
+  constructor(config?: Partial<OpenAPIConfig>, HttpRequest: HttpRequestConstructor = FetchHttpRequest) {
+    this.request = new HttpRequest({
+      BASE: config?.BASE ?? 'http://localhost:8071/api/v1.0',
+      VERSION: config?.VERSION ?? '1.0',
+      WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
+      CREDENTIALS: config?.CREDENTIALS ?? 'include',
+      TOKEN: config?.TOKEN,
+      USERNAME: config?.USERNAME,
+      PASSWORD: config?.PASSWORD,
+      HEADERS: config?.HEADERS,
+      ENCODE_PATH: config?.ENCODE_PATH,
+    });
+
+    this.addresses = new AddressesService(this.request);
+    this.certificates = new CertificatesService(this.request);
+    this.courseRuns = new CourseRunsService(this.request);
+    this.courseRunsSync = new CourseRunsSyncService(this.request);
+    this.creditCards = new CreditCardsService(this.request);
+    this.enrollments = new EnrollmentsService(this.request);
+    this.orders = new OrdersService(this.request);
+    this.payments = new PaymentsService(this.request);
+    this.products = new ProductsService(this.request);
+  }
+}
+

src/frontend/js/api/joanie/gen/core/ApiError.ts

@@ -0,0 +1,24 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+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: any;
+  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;
+  }
+}

src/frontend/js/api/joanie/gen/core/ApiRequestOptions.ts

@@ -0,0 +1,16 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ApiRequestOptions = {
+  readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+  readonly url: string;
+  readonly path?: Record<string, any>;
+  readonly cookies?: Record<string, any>;
+  readonly headers?: Record<string, any>;
+  readonly query?: Record<string, any>;
+  readonly formData?: Record<string, any>;
+  readonly body?: any;
+  readonly mediaType?: string;
+  readonly responseHeader?: string;
+  readonly errors?: Record<number, string>;
+};

src/frontend/js/api/joanie/gen/core/ApiResult.ts

@@ -0,0 +1,10 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ApiResult = {
+  readonly url: string;
+  readonly ok: boolean;
+  readonly status: number;
+  readonly statusText: string;
+  readonly body: any;
+};

src/frontend/js/api/joanie/gen/core/BaseHttpRequest.ts

@@ -0,0 +1,13 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { CancelablePromise } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+
+export abstract class BaseHttpRequest {
+
+  constructor(public readonly config: OpenAPIConfig) {}
+
+  public abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}

src/frontend/js/api/joanie/gen/core/CancelablePromise.ts

@@ -0,0 +1,128 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+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> {
+  readonly [Symbol.toStringTag]!: string;
+
+  private _isResolved: boolean;
+  private _isRejected: boolean;
+  private _isCancelled: boolean;
+  private readonly _cancelHandlers: (() => void)[];
+  private readonly _promise: Promise<T>;
+  private _resolve?: (value: T | PromiseLike<T>) => void;
+  private _reject?: (reason?: any) => void;
+
+  constructor(
+    executor: (
+      resolve: (value: T | PromiseLike<T>) => void,
+      reject: (reason?: any) => 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;
+        this._resolve?.(value);
+      };
+
+      const onReject = (reason?: any): void => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isRejected = true;
+        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);
+    });
+  }
+
+  public then<TResult1 = T, TResult2 = never>(
+    onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+    onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
+  ): Promise<TResult1 | TResult2> {
+    return this._promise.then(onFulfilled, onRejected);
+  }
+
+  public catch<TResult = never>(
+    onRejected?: ((reason: any) => 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;
+    this._reject?.(new CancelError('Request aborted'));
+  }
+
+  public get isCancelled(): boolean {
+    return this._isCancelled;
+  }
+}

src/frontend/js/api/joanie/gen/core/FetchHttpRequest.ts

@@ -0,0 +1,25 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import { BaseHttpRequest } from './BaseHttpRequest';
+import type { CancelablePromise } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+import { request as __request } from './request';
+
+export class FetchHttpRequest extends BaseHttpRequest {
+
+  constructor(config: OpenAPIConfig) {
+    super(config);
+  }
+
+  /**
+   * Request method
+   * @param options The request options from the service
+   * @returns CancelablePromise<T>
+   * @throws ApiError
+   */
+  public override request<T>(options: ApiRequestOptions): CancelablePromise<T> {
+    return __request(this.config, options);
+  }
+}

src/frontend/js/api/joanie/gen/core/OpenAPI.ts

@@ -0,0 +1,31 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ApiRequestOptions } from './ApiRequestOptions';
+
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+
+export type OpenAPIConfig = {
+  BASE: string;
+  VERSION: string;
+  WITH_CREDENTIALS: boolean;
+  CREDENTIALS: 'include' | 'omit' | 'same-origin';
+  TOKEN?: string | Resolver<string>;
+  USERNAME?: string | Resolver<string>;
+  PASSWORD?: string | Resolver<string>;
+  HEADERS?: Headers | Resolver<Headers>;
+  ENCODE_PATH?: (path: string) => string;
+};
+
+export const OpenAPI: OpenAPIConfig = {
+  BASE: 'http://localhost:8071/api/v1.0',
+  VERSION: '1.0',
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: 'include',
+  TOKEN: undefined,
+  USERNAME: undefined,
+  PASSWORD: undefined,
+  HEADERS: undefined,
+  ENCODE_PATH: undefined,
+};