microboard-ui-temp 0.0.3

package/src/shared/Logger.ts

@@ -0,0 +1,72 @@
+interface ILoggerStorage {
+	add(record: string): void;
+	get(): string[];
+	clear(): void;
+}
+
+class MemoryLoggerStorage implements ILoggerStorage {
+	private records: string[] = [];
+
+	add(record: string): void {
+		this.records.push(record);
+	}
+
+	get(): string[] {
+		return this.records;
+	}
+
+	clear(): void {
+		this.records = [];
+	}
+}
+
+class BufferedLogger {
+	private context: string | null = null;
+	isEnabled = false;
+
+	constructor(private readonly storage: ILoggerStorage) {}
+
+	enable() {
+		this.isEnabled = true;
+	}
+
+	disable() {
+		this.isEnabled = false;
+		this.storage.clear();
+	}
+
+	log(record: string) {
+		if (!this.isEnabled) {
+			return;
+		}
+		const timestamp = new Date().toLocaleString();
+		this.storage.add(
+			(this.context ? `[${this.context}] ` : "") +
+				`${timestamp}: ${record}`,
+		);
+	}
+
+	setContext(ctx: string) {
+		this.context = ctx;
+	}
+
+	getContext(ctx: string) {
+		this.context = ctx;
+	}
+
+	downloadLogs(filename: string) {
+		const records = this.storage.get();
+		const data = records.join("\n");
+		const blob = new Blob([data], { type: "text/plain" });
+		const url = URL.createObjectURL(blob);
+		const a = document.createElement("a");
+		a.href = url;
+		a.download = filename;
+		document.body.appendChild(a);
+		a.click();
+		document.body.removeChild(a);
+		URL.revokeObjectURL(url);
+	}
+}
+
+export const MemoryLogger = new BufferedLogger(new MemoryLoggerStorage());

package/src/shared/RawEvents.ts

@@ -0,0 +1,7 @@
+import { BoardEvent } from "microboard-temp";
+
+export interface RawEvents {
+	confirmedEvents: BoardEvent[];
+	eventsToSend: BoardEvent[];
+	newEvents: BoardEvent[];
+}

package/src/shared/Subject.ts

@@ -0,0 +1,29 @@
+/**
+ * Subject class to implement the observer pattern.
+ * Observer is passed as a callback function.
+ * Observers recive published object to read its properties
+ * and call its methods to get its current state.
+ * */
+export class Subject<Type> {
+	observers: ((object: Type) => void)[] = [];
+
+	subscribe(observer: (object: Type) => void): void {
+		const index = this.observers.indexOf(observer);
+		if (index === -1) {
+			this.observers.push(observer);
+		}
+	}
+
+	unsubscribe(observer: (object: Type) => void): void {
+		const index = this.observers.indexOf(observer);
+		if (index !== -1) {
+			this.observers.splice(index, 1);
+		}
+	}
+
+	publish(object: Type): void {
+		for (const observer of this.observers) {
+			observer(object);
+		}
+	}
+}

package/src/shared/SubjectOperation.ts

@@ -0,0 +1,31 @@
+/**
+ * Subject class to implement the observer pattern.
+ * Observer is passed as a callback function.
+ * Observers recive published object to read its properties
+ * and call its methods to get its current state.
+ * Observers also recive operation that was performed on the subject.
+ * */
+
+export class SubjectOperation<Subject, Operation> {
+	observers: ((subject: Subject, op: Operation) => void)[] = [];
+
+	subscribe(observer: (subject: Subject, op: Operation) => void): void {
+		const index = this.observers.indexOf(observer);
+		if (index === -1) {
+			this.observers.push(observer);
+		}
+	}
+
+	unsubscribe(observer: (subject: Subject, op: Operation) => void): void {
+		const index = this.observers.indexOf(observer);
+		if (index !== -1) {
+			this.observers.splice(index, 1);
+		}
+	}
+
+	publish(subject: Subject, op: Operation): void {
+		for (const observer of this.observers) {
+			observer(subject, op);
+		}
+	}
+}

package/src/shared/ViewSettings.tsx

@@ -0,0 +1,9 @@
+import { mainnet, polygon, arbitrum } from "viem/chains";
+
+export const ViewSettings = {
+	WagmiConfig: {
+		appName: "board_test",
+		projectId: "b1c6e6a21e23505e28fe385a0da4135f",
+		chains: [mainnet, polygon, arbitrum],
+	} as const,
+};

package/src/shared/api/ai/api.ts

@@ -0,0 +1,6 @@
+import { api } from "../base/base";
+import { GenerateChartBody, GenerateChartResponse } from "./types";
+
+export function generateChart(body: GenerateChartBody) {
+	return api.post<GenerateChartResponse>("/ai/generate", body);
+}

package/src/shared/api/ai/index.ts

@@ -0,0 +1,3 @@
+export * from "./api";
+export * from "./types";
+export * from "./requestMap";

package/src/shared/api/ai/requestMap.ts

@@ -0,0 +1,22 @@
+export const requestMap = {
+	createChat: {
+		method: "POST",
+		url: "/ai/chats",
+	},
+	generateChart: {
+		method: "POST",
+		url: "/ai/generate",
+	},
+	getChats: {
+		method: "GET",
+		url: "/ai/chats",
+	},
+	getChatDetails: {
+		method: "GET",
+		url: (chatId: number) => `/ai/chats/${chatId}`,
+	},
+	deleteChat: {
+		method: "DELETE",
+		url: (chatId: number) => `/ai/chats/${chatId}`,
+	},
+};

package/src/shared/api/ai/types.ts

@@ -0,0 +1,6 @@
+export interface GenerateChartBody {
+	input: string;
+	withContext?: boolean;
+}
+
+export type GenerateChartResponse = { message: string };

package/src/shared/api/auth/api.ts

@@ -0,0 +1,78 @@
+import { api } from "../base/base";
+import type { MessageResponse } from "../types";
+import type { User } from "../users";
+import type {
+	ChangePasswordPayload,
+	CheckVerificationCodesPayload,
+	ForgotPasswordPayload,
+	LoginPayload,
+	RegisterPayload,
+	ResendMailPayload,
+	RestorePasswordPayload,
+	Tokens,
+	VerifyMailPayload,
+	GetNoncePayload,
+	VerifySignaturePayload,
+} from "./types";
+
+export const ACCESS_TOKEN_KEY = "accessToken";
+export const REFRESH_TOKEN_KEY = "refreshToken";
+
+export function changePassword(body: ChangePasswordPayload) {
+	return api.patch<MessageResponse>("/auth/password/change", body);
+}
+
+export function login(body: LoginPayload) {
+	return api.post<Tokens>("/auth/login", body);
+}
+
+export function refreshTokens() {
+	return api.post<Tokens>("/auth/refresh");
+}
+
+export function register(body: RegisterPayload) {
+	return api.post<User>("/auth/register", body);
+}
+
+export function logout() {
+	return api.put<MessageResponse>("/auth/logout");
+}
+
+export function verifyMail(body: VerifyMailPayload) {
+	return api.post<Tokens>("/auth/verify", body);
+}
+
+export function resendMail(body: ResendMailPayload) {
+	return api.post<MessageResponse>("/auth/resendEmail", body);
+}
+
+export function checkVerificationCodes(body: CheckVerificationCodesPayload) {
+	return api.post<MessageResponse>("/auth/checkVerificationCodes", body);
+}
+
+export function forgotPassword(body: ForgotPasswordPayload) {
+	return api.post<MessageResponse>("/auth/password/restore/request", body);
+}
+
+export function restorePassword(body: RestorePasswordPayload) {
+	return api.post<MessageResponse>("/auth/password/restore", body);
+}
+
+export function getNonce(body: GetNoncePayload) {
+	return api.post<MessageResponse>("/auth/crypto/nonce", body);
+}
+
+export function verifySignature(body: VerifySignaturePayload) {
+	return api.post<Tokens>("/auth/crypto/verify", body);
+}
+
+export function requestAddEmail(body: CheckVerificationCodesPayload) {
+	return api.post<MessageResponse & { email: string }>(
+		"/auth/email/verify/request",
+		body,
+	);
+}
+
+export function addEmail(body: VerifyMailPayload) {
+	return api.post<MessageResponse>("/auth/email/verify", body);
+}

package/src/shared/api/auth/index.ts

@@ -0,0 +1,2 @@
+export * from "./api";
+export * from "./types";

package/src/shared/api/auth/types.ts

@@ -0,0 +1,51 @@
+export type UniqueString = `0x${string}`;
+
+export type ChangePasswordPayload = {
+	oldPassword: string;
+	newPassword: string;
+};
+
+export type RegisterPayload = {
+	email: string;
+	password: string;
+	name: string;
+	newsletter: boolean;
+};
+
+export type LoginPayload = Omit<RegisterPayload, "newsletter" | "name">;
+
+export type Tokens = {
+	accessToken: string;
+	refreshToken: string;
+};
+
+export type VerifyMailPayload = {
+	email: string;
+	passcode: string;
+};
+
+export type ResendMailPayload = {
+	email: string;
+};
+
+export type CheckVerificationCodesPayload = {
+	email: string;
+};
+
+export type ForgotPasswordPayload = {
+	email: string;
+};
+
+export type RestorePasswordPayload = {
+	token: string;
+	newPassword: string;
+};
+
+export type GetNoncePayload = {
+	address: UniqueString;
+};
+
+export type VerifySignaturePayload = {
+	address: UniqueString;
+	signature: UniqueString;
+};

package/src/shared/api/base/base.ts

@@ -0,0 +1,244 @@
+import { getApiUrl } from "Config";
+import { createSearchParams, type URLSearchParamsInit } from "react-router-dom";
+import { HTTPError } from "./httpError";
+import { HTTPResponse } from "./httpResponse";
+import { Interceptors } from "./interceptors";
+import type {
+	HTTPConfig,
+	HTTPRequestConfig,
+	MutationRequestBody,
+	ParamsRecord,
+} from "./types";
+import { conf } from "microboard-temp";
+const { i18n } = conf;
+
+const RETRY_DELAY = 5_000;
+const RETRY_ATTEMPTS = 3;
+
+export class HTTP {
+	private readonly baseURL: string;
+	private readonly headers: Record<string, string>;
+	private fetchCache = new Map<string, Promise<HTTPResponse<unknown>>>();
+	readonly interceptors = new Interceptors();
+
+	constructor(config: HTTPConfig) {
+		this.baseURL = config.baseURL;
+		this.headers = config.headers ?? {};
+	}
+
+	private getQuery(query?: URLSearchParamsInit): string {
+		return createSearchParams(query).toString();
+	}
+
+	private replacePathParams(path: string, params?: ParamsRecord): string {
+		if (!params) {
+			return path;
+		}
+
+		return path.replace(/:(\w+)/g, (_, key) => {
+			if (params[key]) {
+				return String(params[key]);
+			}
+
+			return key;
+		});
+	}
+	getUrl(
+		path = "",
+		params?: ParamsRecord,
+		query?: URLSearchParamsInit,
+	): string {
+		const queryString = this.getQuery(query);
+		return `${this.baseURL}${this.replacePathParams(
+			path,
+			params,
+		)}${queryString ? `?${queryString}` : ""}`;
+	}
+
+	private async $fetch<
+		R,
+		Q extends URLSearchParamsInit = URLSearchParamsInit,
+		P extends ParamsRecord = ParamsRecord,
+	>(path: string, config: HTTPRequestConfig<Q, P>): Promise<HTTPResponse<R>> {
+		const cacheKey = `${path}:${JSON.stringify(config)}`;
+
+		if (this.fetchCache.has(cacheKey)) {
+			return this.fetchCache.get(cacheKey) as Promise<HTTPResponse<R>>;
+		}
+
+		const fetchWithRetry = async (
+			retries: number,
+		): Promise<HTTPResponse<R>> => {
+			try {
+				const modifiedConfig =
+					await this.interceptors.triggerRequestInterceptors(config);
+				const response = await fetch(
+					this.getUrl(path, config.params, config.query),
+					{
+						...modifiedConfig,
+						headers: {
+							...this.headers,
+							...modifiedConfig.headers,
+							...config.headers,
+							"x-client-language": i18n.language,
+						},
+						credentials: "include",
+					},
+				);
+
+				if (!response.ok) {
+					const message = await response.json();
+					throw new HTTPError(
+						response.status,
+						message.message,
+						response,
+						response.url,
+					);
+				}
+
+				const customResponse = new HTTPResponse<R>(response);
+				if (customResponse.status !== 204) {
+					customResponse.data = await response.json();
+				} else {
+					customResponse.data = null;
+				}
+
+				this.interceptors.triggerResponseSuccessInterceptors(
+					customResponse,
+				);
+
+				return customResponse;
+			} catch (error) {
+				if (error instanceof HTTPError) {
+					if (error.status >= 400 && error.status < 500) {
+						// Immediately throw for 4xx errors
+						throw error;
+					}
+				}
+				if (retries > 0) {
+					// Retry for 5xx errors and unexpected exceptions
+					await new Promise(resolve =>
+						setTimeout(resolve, RETRY_DELAY),
+					);
+					return fetchWithRetry(retries - 1);
+				}
+				this.interceptors.triggerResponseErrorInterceptors(error);
+				throw error;
+			} finally {
+				this.fetchCache.delete(cacheKey);
+			}
+		};
+
+		const fetchPromise = fetchWithRetry(RETRY_ATTEMPTS);
+		this.fetchCache.set(cacheKey, fetchPromise);
+		return fetchPromise;
+	}
+
+	get<
+		R,
+		Q extends URLSearchParamsInit = URLSearchParamsInit,
+		P extends ParamsRecord = ParamsRecord,
+	>(
+		path: string,
+		config?: HTTPRequestConfig<Q, P>,
+	): Promise<HTTPResponse<R>> {
+		return this.$fetch<R>(path, {
+			method: "GET",
+			...config,
+		});
+	}
+
+	post<
+		R,
+		B extends MutationRequestBody = MutationRequestBody,
+		P extends ParamsRecord = ParamsRecord,
+	>(
+		path: string,
+		body?: B,
+		config?: HTTPRequestConfig<URLSearchParamsInit, P>,
+	): Promise<HTTPResponse<R>> {
+		const stringifiedBody = JSON.stringify(body);
+
+		return this.$fetch<R>(path, {
+			method: "POST",
+			body: stringifiedBody,
+			...config,
+		});
+	}
+
+	patch<
+		R,
+		B extends MutationRequestBody = MutationRequestBody,
+		P extends ParamsRecord = ParamsRecord,
+	>(
+		path: string,
+		body?: B,
+		config?: HTTPRequestConfig<URLSearchParamsInit, P>,
+	): Promise<HTTPResponse<R>> {
+		const stringifiedBody = JSON.stringify(body);
+		return this.$fetch<R>(path, {
+			method: "PATCH",
+			body: stringifiedBody,
+			...config,
+		});
+	}
+
+	patchRaw<R, P extends ParamsRecord = ParamsRecord>(
+		path: string,
+		file: File,
+		config?: HTTPRequestConfig<URLSearchParamsInit, P>,
+	): Promise<HTTPResponse<R>> {
+		return this.$fetch<R>(path, {
+			method: "PATCH",
+			body: file,
+			...config,
+			headers: {
+				"Content-Type": file.type,
+			},
+		});
+	}
+
+	put<
+		R,
+		B extends MutationRequestBody = MutationRequestBody,
+		P extends ParamsRecord = ParamsRecord,
+	>(
+		path: string,
+		body?: B,
+		config?: HTTPRequestConfig<URLSearchParamsInit, P>,
+	): Promise<HTTPResponse<R>> {
+		const stringifiedBody = JSON.stringify(body);
+
+		return this.$fetch<R>(path, {
+			method: "PUT",
+			body: stringifiedBody,
+			...config,
+		});
+	}
+
+	delete<
+		R,
+		Q extends URLSearchParamsInit = URLSearchParamsInit,
+		P extends ParamsRecord = ParamsRecord,
+		B extends MutationRequestBody = MutationRequestBody,
+	>(
+		path: string,
+		config?: HTTPRequestConfig<Q, P>,
+		body?: B,
+	): Promise<HTTPResponse<R>> {
+		const stringifiedBody = JSON.stringify(body);
+
+		return this.$fetch<R>(path, {
+			method: "DELETE",
+			...config,
+			body: stringifiedBody,
+		});
+	}
+}
+
+export const api = new HTTP({
+	baseURL: getApiUrl(),
+	headers: {
+		"Content-Type": "application/json",
+	},
+});

package/src/shared/api/base/httpError.ts

@@ -0,0 +1,10 @@
+export class HTTPError extends Error {
+	constructor(
+		public status: number,
+		public message: string,
+		public response: Response,
+		public url: string,
+	) {
+		super(message);
+	}
+}

package/src/shared/api/base/httpResponse.ts

@@ -0,0 +1,7 @@
+export class HTTPResponse<R> extends Response {
+	data: R | null = null;
+
+	constructor(response: Response) {
+		super(response.status !== 204 ? response.body : null, response);
+	}
+}

package/src/shared/api/base/interceptors.ts

@@ -0,0 +1,64 @@
+import type { HTTPError } from "./httpError";
+import type { HTTPResponse } from "./httpResponse";
+import type { HTTPRequestConfig } from "./types";
+
+type RequestInterceptor = (
+	config: HTTPRequestConfig,
+) => HTTPRequestConfig | Promise<HTTPRequestConfig>;
+type ResponseSuccessInterceptor = (response: HTTPResponse<unknown>) => void;
+type ResponseErrorInterceptor = (error: HTTPError | unknown) => void;
+
+export class Interceptors {
+	requestInterceptors: Set<RequestInterceptor> = new Set();
+	responseSuccessInterceptors: Set<ResponseSuccessInterceptor> = new Set();
+	responseErrorInterceptors: Set<ResponseErrorInterceptor> = new Set();
+
+	addRequestInterceptor(interceptor: RequestInterceptor) {
+		this.requestInterceptors.add(interceptor);
+	}
+
+	addResponseSuccessInterceptor(interceptor: ResponseSuccessInterceptor) {
+		this.responseSuccessInterceptors.add(interceptor);
+	}
+
+	addResponseErrorInterceptor(interceptor: ResponseErrorInterceptor) {
+		this.responseErrorInterceptors.add(interceptor);
+	}
+
+	removeRequestInterceptor(interceptor: RequestInterceptor) {
+		this.requestInterceptors.delete(interceptor);
+	}
+
+	removeResponseSuccessInterceptor(interceptor: ResponseSuccessInterceptor) {
+		this.responseSuccessInterceptors.delete(interceptor);
+	}
+
+	removeResponseErrorInterceptor(interceptor: ResponseErrorInterceptor) {
+		this.responseErrorInterceptors.delete(interceptor);
+	}
+
+	async triggerRequestInterceptors(
+		config: HTTPRequestConfig,
+	): Promise<HTTPRequestConfig> {
+		const configs = await Promise.all(
+			Array.from(this.requestInterceptors).map(interceptor =>
+				interceptor(config),
+			),
+		);
+		return configs.reduce((acc, cfg) => ({ ...acc, ...cfg }), {
+			...config,
+		});
+	}
+
+	triggerResponseSuccessInterceptors(response: HTTPResponse<unknown>) {
+		this.responseSuccessInterceptors.forEach(interceptor =>
+			interceptor(response),
+		);
+	}
+
+	triggerResponseErrorInterceptors(error: HTTPError | unknown) {
+		this.responseErrorInterceptors.forEach(interceptor =>
+			interceptor(error),
+		);
+	}
+}

package/src/shared/api/base/types.ts

@@ -0,0 +1,18 @@
+import type { URLSearchParamsInit } from "react-router-dom";
+
+export type HTTPConfig = {
+	baseURL: string;
+	headers?: Record<string, string>;
+};
+
+export type HTTPRequestConfig<
+	Q extends URLSearchParamsInit = URLSearchParamsInit,
+	P extends ParamsRecord = ParamsRecord,
+> = RequestInit & {
+	params?: P;
+	query?: Q;
+};
+
+export type ParamsRecord = Record<string, string | number>;
+
+export type MutationRequestBody = Record<string, any>;