will try to deploy

apps/nextjs/src/app/(app)/dashboard/page.tsx

@@ -5,13 +5,14 @@ export default async function Home() {
   const supabase = createClient();
   const { data } = await supabase.auth.getSession();
 
-  const token = data?.session?.access_token ?? "";
+  const token = data.session?.access_token ?? "";
 
   return (
     <main className="">
       <div className="flex flex-col gap-8">
         <h1 className="my-2 text-2xl font-bold">Upload a patient's chart</h1>
         <FileUpload token={token} />
+        <p>{`Disclaimer: This demo site is for demonstration purposes only; please do not submit any Personal Health Information (PHI) or other sensitive data.`}</p>
       </div>
     </main>
   );

apps/nextjs/src/app/layout.tsx

@@ -14,7 +14,7 @@ import { OpenAPI } from "@wellchart/api/client";
 
 import { env } from "~/env";
 
-if (process.env.NODE_ENV === "production") {
+if (env.NODE_ENV === "production") {
   OpenAPI.BASE = env.FASTAPI_URL;
 }
 

apps/nextjs/src/components/upload/file-upload.tsx

@@ -94,7 +94,7 @@ const FileUpload = (props: { token: string }) => {
         onChange={(e) => {
           const files = e.target.files;
           if (files) {
-            setFile(files[0] as File);
+            setFile(files[0]!);
           }
         }}
         accept=".zip"

packages/api/eslint.config.js

@@ -3,7 +3,7 @@ import baseConfig from "@wellchart/eslint-config/base";
 /** @type {import('typescript-eslint').Config} */
 export default [
   {
-    ignores: ["dist/**"],
+    ignores: ["dist/**", "src/lib/api/client"],
   },
   ...baseConfig,
 ];

packages/api/src/lib/api/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;
+  }
+}

packages/api/src/lib/api/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>;
-};
+export interface 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>;
+}

packages/api/src/lib/api/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;
-};
+export interface ApiResult<TData = any> {
+  readonly body: TData;
+  readonly ok: boolean;
+  readonly status: number;
+  readonly statusText: string;
+  readonly url: string;
+}

packages/api/src/lib/api/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;
+  }
+}