🎨 Run biome after OpenAPI client generation

frontend/biome.json

@@ -4,7 +4,7 @@
     "enabled": true
   },
   "files": {
-    "ignore": ["node_modules", "src/client/", "src/routeTree.gen.ts"]
+    "ignore": ["node_modules", "src/routeTree.gen.ts"]
   },
   "linter": {
     "enabled": true,

frontend/package.json

@@ -8,7 +8,7 @@
     "build": "tsc && vite build",
     "lint": "biome check --apply-unsafe --no-errors-on-unmatched --files-ignore-unknown=true ./",
     "preview": "vite preview",
-    "generate-client": "openapi-ts --input ./openapi.json --output ./src/client --client axios --exportSchemas true"
+    "generate-client": "openapi-ts --input ./openapi.json --output ./src/client --client axios --exportSchemas true && biome format --write ./src/client"
   },
   "dependencies": {
     "@chakra-ui/icons": "2.1.1",

frontend/src/client/core/ApiError.ts

@@ -1,21 +1,25 @@
-import type { ApiRequestOptions } from './ApiRequestOptions';
-import type { ApiResult } from './ApiResult';
+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;
+  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);
+  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;
-	}
-}
+    this.name = "ApiError"
+    this.url = response.url
+    this.status = response.status
+    this.statusText = response.statusText
+    this.body = response.body
+    this.request = request
+  }
+}

frontend/src/client/core/ApiRequestOptions.ts

@@ -1,13 +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>;
-};
+  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>
+}

frontend/src/client/core/ApiResult.ts

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

frontend/src/client/core/CancelablePromise.ts

@@ -1,126 +1,126 @@
 export class CancelError extends Error {
-	constructor(message: string) {
-		super(message);
-		this.name = 'CancelError';
-	}
-
-	public get isCancelled(): boolean {
-		return true;
-	}
+  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;
+  readonly isResolved: boolean
+  readonly isRejected: boolean
+  readonly isCancelled: boolean
 
-	(cancelHandler: () => void): void;
+  (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;
-	}
-}
+  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
+  }
+}