nfx-ui 0.20.0 → 0.22.0

package/src/apis/clients.ts

@@ -0,0 +1,122 @@
+/**
+ * Axios instances + interceptors for Identity HTTP.
+ * publicClient: login / refresh. protectedClient: Bearer + 401 → refreshAuthTokens.
+ */
+import type { InternalAxiosRequestConfig } from "axios";
+import type { ApiErrorBody } from "@/types";
+
+import axios, { AxiosError } from "axios";
+import applyCaseMiddleware from "axios-case-converter";
+import { authEventEmitter, authEvents } from "@/events/auth";
+import { AuthStore, clearAuth, hasSelectedProfile } from "@/stores/auth";
+import { shouldForceLogoutAfterAuthRetry, shouldImmediateForceLogoutOnApiError } from "@/utils/sessionErrors";
+import { safeOr } from "@/utils/safe";
+
+import { refreshAuthTokens } from "./authRefresh";
+import { API_ENDPOINTS } from "./ip";
+
+export const protectedClient = applyCaseMiddleware(
+  axios.create({
+    baseURL: API_ENDPOINTS.IDENTITY,
+    timeout: 8000,
+  }),
+);
+
+export const publicClient = applyCaseMiddleware(
+  axios.create({
+    baseURL: API_ENDPOINTS.IDENTITY,
+    timeout: 8000,
+  }),
+);
+
+export const publicClientWithoutTransform = axios.create({
+  baseURL: API_ENDPOINTS.IDENTITY,
+  timeout: 8000,
+});
+
+declare module "axios" {
+  export interface AxiosRequestConfig {
+    _retry?: boolean;
+  }
+}
+
+protectedClient.interceptors.request.use(
+  (config: InternalAxiosRequestConfig) => {
+    const accessToken = AuthStore.getState().accessToken;
+    if (accessToken) config.headers.Authorization = `Bearer ${accessToken}`;
+    return config;
+  },
+  (error) => Promise.reject(error),
+);
+
+function logApiError(error: AxiosError<ApiErrorBody>): void {
+  const errorData = error.response?.data;
+  const msg = errorData?.message;
+  if (msg) {
+    console.log("❌ API Error:", {
+      message: msg,
+      errCode: errorData?.errCode,
+      status: safeOr(error.response?.status, errorData?.status),
+      url: error.config?.url,
+      method: error.config?.method,
+    });
+  } else if (import.meta.env.DEV && error.response?.status) {
+    console.log("❌ HTTP Error:", {
+      status: error.response.status,
+      url: error.config?.url,
+      method: error.config?.method,
+    });
+  }
+}
+
+protectedClient.interceptors.response.use(
+  (response) => response,
+  async (error: unknown) => {
+    if (!(error instanceof AxiosError)) {
+      return Promise.reject(error);
+    }
+    logApiError(error);
+
+    const emitLogout = () => {
+      if (!AuthStore.getState().isAuthValid) return;
+      if (!hasSelectedProfile(AuthStore.getState().currentProfileId)) return;
+      const aID = AuthStore.getState().currentAccountId;
+      authEventEmitter.emit(authEvents.LOGOUT, aID ?? undefined);
+      clearAuth();
+    };
+
+    if (shouldImmediateForceLogoutOnApiError(error)) {
+      emitLogout();
+      return Promise.reject(error);
+    }
+
+    if (error.response?.status === 401 && error.config && !error.config._retry) {
+      error.config._retry = true;
+      try {
+        const refreshed = await refreshAuthTokens("401");
+        if (!refreshed) {
+          emitLogout();
+          return Promise.reject(error);
+        }
+        return protectedClient.request(error.config);
+      } catch {
+        emitLogout();
+        return Promise.reject(error);
+      }
+    }
+
+    if (shouldForceLogoutAfterAuthRetry(error)) {
+      emitLogout();
+    }
+
+    return Promise.reject(error);
+  },
+);
+
+publicClient.interceptors.response.use(
+  (response) => response,
+  (error: unknown) => {
+    if (error instanceof AxiosError) logApiError(error as AxiosError<ApiErrorBody>);
+    return Promise.reject(error);
+  },
+);

package/src/apis/index.ts

@@ -0,0 +1,15 @@
+/**
+ * HTTP surface: Identity clients / ip / repositories / session refresh.
+ */
+export { protectedClient, publicClient, publicClientWithoutTransform } from "./clients";
+export * from "./ip";
+export * from "./repositories";
+export { getIdentityRepositories, setIdentityRepositories } from "./activeIdentityRepositories";
+export {
+  AUTH_TOKEN_REFRESH_MAX_BUFFER_MS,
+  AUTH_TOKEN_REFRESH_REMAINING_RATIO,
+  clearScheduledTokenRefresh,
+  refreshAuthTokens,
+  scheduleAccessTokenRefresh,
+  type AuthTokenRefreshSource,
+} from "./authRefresh";

package/src/apis/ip.path.ts

@@ -0,0 +1,39 @@
+import type { Array } from "../types/utils";
+
+const [BASE, CHILDREN] = [Symbol(), Symbol()];
+
+export type PathNode<T> = string & {
+  [K in keyof T]: T[K] extends (...args: infer A) => infer R
+    ? R extends object
+      ? (...args: A) => PathNode<R>
+      : (...args: A) => string
+    : T[K] extends object
+      ? PathNode<T[K]>
+      : string;
+};
+
+export const path = <T extends Record<string, unknown>>(base: string, children: T): PathNode<T> =>
+  Object.assign(
+    Object.defineProperties(new String(base), {
+      [BASE]: { value: base },
+      [CHILDREN]: { value: children },
+      toString: { value: () => base },
+      valueOf: { value: () => base },
+      [Symbol.toPrimitive]: { value: () => base },
+    }),
+    Object.fromEntries(
+      Object.entries(children).map(([k, v]) => [
+        k,
+        typeof v === "function"
+          ? (...args: Array<unknown>) => {
+              const result = (v as (...args: Array<unknown>) => unknown)(...args);
+              return BASE in Object(result)
+                ? path(`${base}${(result as Record<symbol, string>)[BASE]}`, (result as Record<symbol, Record<string, unknown>>)[CHILDREN] ?? {})
+                : `${base}${result}`;
+            }
+          : BASE in Object(v)
+            ? path(`${base}${(v as Record<symbol, string>)[BASE]}`, (v as Record<symbol, Record<string, unknown>>)[CHILDREN] ?? {})
+            : `${base}${v}`,
+      ]),
+    ),
+  ) as PathNode<T>;

package/src/apis/ip.ts

@@ -0,0 +1,123 @@
+import type { DataResponse } from "@/types";
+
+import { path } from "./ip.path";
+
+export { path } from "./ip.path";
+
+function resolveIdentityApiUrl(): string {
+  const identity = (import.meta.env.VITE_IDENTITY_API_URL as string | undefined)?.trim();
+  if (identity) return identity.replace(/\/$/, "");
+  const raw = (import.meta.env.VITE_API_URL as string | undefined)?.trim() ?? "";
+  return raw.replace(/\/$/, "");
+}
+
+export function dataFromResponse<T>(res: DataResponse<T>, context: string): T {
+  const v = res.data;
+  if (v == null) {
+    throw new Error(`API response missing data (${context})`);
+  }
+  return v;
+}
+
+export const API_ENDPOINTS = {
+  IDENTITY: resolveIdentityApiUrl(),
+} as const;
+
+export const URL_PATHS = {
+  AUTH: path("/auth", {
+    LoginWithEmail: "/login/with-email",
+    LoginWithPhone: "/login/with-phone",
+    LoginGitHub: "/login/github",
+    LoginGitHubUrl: "/login/github/url",
+    SignupSendCode: "/signup/send-code",
+    SignupWithEmail: "/signup/with-email",
+    Refresh: "/refresh",
+    Logout: "/logout",
+    Locales: path("/locales", {
+      errorsByLang: (lang: string) => `/${lang}`,
+    }),
+    Messages: path("/messages", {
+      byLang: (lang: string) => `/${lang}`,
+    }),
+    Me: path("/me", {
+      SelectProfile: "/select-profile",
+      FullAccountInformationWithForgerProfile: "/full-account-information-with-forger-profile",
+      FullAccountInformationWithAuthorityProfile: "/full-account-information-with-authority-profile",
+      ForgerProfile: "/forger-profile",
+      ForgerProfileSettings: "/forger-profile-settings",
+      ForgerProfileAvatars: "/forger-profile/avatars",
+      ForgerProfileBackgrounds: "/forger-profile/backgrounds",
+      ForgerProfilePreference: "/forger-profile/preference",
+      AuthorityProfile: "/authority-profile",
+      AuthorityProfileSettings: "/authority-profile-settings",
+      AuthorityProfileAvatars: "/authority-profile/avatars",
+      AuthorityProfileBackgrounds: "/authority-profile/backgrounds",
+      AuthorityProfilePreference: "/authority-profile/preference",
+      Profiles: "/profiles",
+      SearchForgerProfiles: "/profiles/search",
+      ProfileById: (profileId: string) => `/profiles/${profileId}`,
+      PublicProfileCardById: (profileId: string) => `/profiles/${profileId}/public-card`,
+      AuthorityProfiles: "/authority-profiles",
+      SearchAuthorityProfiles: "/authority-profiles/search",
+      AuthorityProfileById: (profileId: string) => `/authority-profiles/${profileId}`,
+      GitHub: "/github",
+      Emails: "/emails",
+      EmailById: (emailId: string) => `/emails/${emailId}`,
+      EmailSendVerificationCode: (emailId: string) => `/emails/${emailId}/send-verification-code`,
+      EmailVerify: (emailId: string) => `/emails/${emailId}/verify`,
+      EmailPrimary: (emailId: string) => `/emails/${emailId}/primary`,
+      Phones: "/phones",
+      PhoneById: (phoneId: string) => `/phones/${phoneId}`,
+      PhoneSendVerificationCode: (phoneId: string) => `/phones/${phoneId}/send-verification-code`,
+      PhoneVerify: (phoneId: string) => `/phones/${phoneId}/verify`,
+      PhonePrimary: (phoneId: string) => `/phones/${phoneId}/primary`,
+      Password: "/password",
+      PasswordSendVerificationCode: "/password/send-verification-code",
+    }),
+    Owner: path("/owner", {
+      ForgerProfiles: "/forger-profiles",
+      AuthorityProfiles: "/authority-profiles",
+      UpdateAuthorityProfileRoles: (profileId: string) => `/authority-profiles/${profileId}/roles`,
+    }),
+  }),
+  ASSET: path("/asset", {
+    Locales: path("/locales", {
+      errorsByLang: (lang: string) => `/${lang}`,
+    }),
+    Messages: path("/messages", {
+      byLang: (lang: string) => `/${lang}`,
+    }),
+    Images: path("/images", {
+      uploadUrl: "/upload-url",
+      uploadUrls: "/upload-urls",
+      confirm: "/confirm",
+      confirmMany: "/confirm-images",
+      deleteById: (id: string) => `/${id}`,
+      fileById: (id: string) => `/${id}/file`,
+    }),
+    Files: path("/files", {
+      uploadUrl: "/upload-url",
+      uploadUrls: "/upload-urls",
+      confirm: "/confirm",
+      confirmMany: "/confirm-files",
+      deleteById: (id: string) => `/${id}`,
+      fileById: (id: string) => `/${id}/file`,
+    }),
+    Videos: path("/videos", {
+      uploadUrl: "/upload-url",
+      uploadUrls: "/upload-urls",
+      confirm: "/confirm",
+      confirmMany: "/confirm-videos",
+      deleteById: (id: string) => `/${id}`,
+      fileById: (id: string) => `/${id}/file`,
+    }),
+    Audios: path("/audios", {
+      uploadUrl: "/upload-url",
+      uploadUrls: "/upload-urls",
+      confirm: "/confirm",
+      confirmMany: "/confirm-audios",
+      deleteById: (id: string) => `/${id}`,
+      fileById: (id: string) => `/${id}/file`,
+    }),
+  }),
+} as const;

package/src/apis/repositories/AssetRepository.ts

@@ -0,0 +1,68 @@
+import type { Asset, DataResponse } from "@/types";
+
+import { protectedClient, publicClientWithoutTransform } from "../clients";
+import { API_ENDPOINTS, dataFromResponse, URL_PATHS } from "../ip";
+
+type Kind = Asset.Kind;
+
+export interface AssetRepository {
+  GetErrorTranslations(lang: string): Promise<Record<string, string>>;
+  List(kind: Kind): Promise<Asset.Response.Detail[]>;
+  PrepareUpload(kind: Kind, params: Asset.Request.PrepareUpload): Promise<Asset.Response.PrepareUpload>;
+  PrepareUploads(kind: Kind, params: Asset.Request.PrepareUploads): Promise<Asset.Response.PrepareUploads>;
+  ConfirmUpload(kind: Kind, params: Asset.Request.ConfirmUpload): Promise<void>;
+  ConfirmUploads(kind: Kind, params: Asset.Request.ConfirmUploads): Promise<void>;
+  Delete(kind: Kind, id: string): Promise<void>;
+  FileURL(kind: Kind, id: string): string;
+}
+
+function kindPaths(kind: Kind) {
+  switch (kind) {
+    case "files":
+      return URL_PATHS.ASSET.Files;
+    case "videos":
+      return URL_PATHS.ASSET.Videos;
+    case "audios":
+      return URL_PATHS.ASSET.Audios;
+    default:
+      return URL_PATHS.ASSET.Images;
+  }
+}
+
+export class ApiAssetRepository implements AssetRepository {
+  async GetErrorTranslations(lang: string): Promise<Record<string, string>> {
+    const { data } = await publicClientWithoutTransform.get<Record<string, string>>(URL_PATHS.ASSET.Locales.errorsByLang(lang));
+    return data;
+  }
+
+  async List(kind: Kind): Promise<Asset.Response.Detail[]> {
+    const { data } = await protectedClient.get<DataResponse<Asset.Response.Detail[]>>(String(kindPaths(kind)));
+    return dataFromResponse(data, `List ${kind}`);
+  }
+
+  async PrepareUpload(kind: Kind, params: Asset.Request.PrepareUpload): Promise<Asset.Response.PrepareUpload> {
+    const { data } = await protectedClient.post<DataResponse<Asset.Response.PrepareUpload>>(kindPaths(kind).uploadUrl, params);
+    return dataFromResponse(data, `Prepare ${kind}`);
+  }
+
+  async PrepareUploads(kind: Kind, params: Asset.Request.PrepareUploads): Promise<Asset.Response.PrepareUploads> {
+    const { data } = await protectedClient.post<DataResponse<Asset.Response.PrepareUploads>>(kindPaths(kind).uploadUrls, params);
+    return dataFromResponse(data, `Prepare many ${kind}`);
+  }
+
+  async ConfirmUpload(kind: Kind, params: Asset.Request.ConfirmUpload): Promise<void> {
+    await protectedClient.post(kindPaths(kind).confirm, params);
+  }
+
+  async ConfirmUploads(kind: Kind, params: Asset.Request.ConfirmUploads): Promise<void> {
+    await protectedClient.post(kindPaths(kind).confirmMany, params);
+  }
+
+  async Delete(kind: Kind, id: string): Promise<void> {
+    await protectedClient.delete(kindPaths(kind).deleteById(id));
+  }
+
+  FileURL(kind: Kind, id: string): string {
+    return `${API_ENDPOINTS.IDENTITY}${kindPaths(kind).fileById(id)}`;
+  }
+}