create-pardx-scaffold 0.1.0

package/template/apps/web/lib/requests.ts

@@ -0,0 +1,177 @@
+import { API_CONFIG } from './config';
+
+function urlEncode(params: Record<string, unknown>) {
+  if (params && typeof params === 'object' && !Array.isArray(params)) {
+    const filteredParams = Object.fromEntries(
+      Object.entries(params).filter(([, v]) => v !== '' && v !== undefined),
+    );
+    return new URLSearchParams(
+      filteredParams as Record<string, string>,
+    ).toString();
+  }
+  return '';
+}
+
+type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+
+interface Params {
+  cacheTime?: number; //缓存时间，单位为s。默认强缓存，0为不缓存
+  params?: Record<string, unknown>;
+  headers?: Record<string, unknown>;
+}
+
+interface Props extends Params {
+  url: string;
+  method: Method;
+}
+
+type Config =
+  | { next: { revalidate: number } }
+  | { cache: 'no-store' }
+  | { cache: 'force-cache' };
+
+class Request {
+  /**
+   * 请求拦截器
+   */
+  interceptorsRequest({ url, method, params, cacheTime, headers = {} }: Props) {
+    let requestPayload = ''; //请求体数据
+    const config: Config =
+      cacheTime || cacheTime === 0
+        ? cacheTime > 0
+          ? { next: { revalidate: cacheTime } }
+          : { cache: 'no-store' }
+        : { cache: 'force-cache' };
+
+    if (params && method === 'GET') {
+      //fetch对GET请求等，不支持将参数传在body上，只能拼接url
+      url = `${url}?${urlEncode(params)}`;
+    } else {
+      //非form-data传输JSON数据格式
+      if (
+        params &&
+        headers &&
+        headers['Content-Type'] === 'application/x-www-form-urlencoded'
+      ) {
+        // Encode params as x-www-form-urlencoded
+        requestPayload = urlEncode(params);
+      } else if (
+        !['[object FormData]', '[object URLSearchParams]'].includes(
+          Object.prototype.toString.call(params),
+        )
+      ) {
+        Object.assign(headers, { 'Content-Type': 'application/json' });
+        requestPayload = JSON.stringify(params);
+      }
+    }
+    return {
+      url,
+      options: {
+        method,
+        headers,
+        body:
+          method !== 'GET' && method !== 'DELETE' ? requestPayload : undefined,
+        ...config,
+      },
+    };
+  }
+
+  /**
+   * 响应拦截器
+   */
+  async interceptorsResponse<T>(res: Response): Promise<T> {
+    return new Promise((resolve, reject) => {
+      const requestUrl = res.url;
+      if (res.ok) {
+        res
+          .clone()
+          .json()
+          .then((data) => resolve(data as T))
+          .catch(async () => {
+            const text = await res.clone().text();
+            resolve(text as unknown as T);
+          });
+      } else {
+        res
+          .clone()
+          .text()
+          .then((text) => {
+            try {
+              return resolve(JSON.parse(text));
+            } catch {
+              return reject({ code: 500, message: text, url: requestUrl });
+            }
+          });
+      }
+    });
+  }
+
+  async httpFactory<T>({ url = '', params = {}, method }: Props): Promise<T> {
+    // 使用 Agno API 基础地址
+    const req = this.interceptorsRequest({
+      url: url.startsWith('http') ? url : API_CONFIG.agnoApiBaseUrl + url,
+      method,
+      params: params.params as Record<string, unknown>,
+      cacheTime: params.cacheTime as number,
+      headers: params.headers as Record<string, unknown>,
+    });
+    const res = await fetch(req.url, req.options as RequestInit).catch(
+      (err) => {
+        console.error('request error:', err);
+        return Response.json({
+          code: 500,
+          message: '服务器暂不可用，请稍后重试',
+          url: req.url,
+        });
+      },
+    );
+    return this.interceptorsResponse<T>(res);
+  }
+
+  async request<T>(method: Method, url: string, params?: Params): Promise<T> {
+    return this.httpFactory<T>({
+      url,
+      params: params as Record<string, unknown>,
+      method,
+    });
+  }
+
+  get<T>(url: string, params?: Params): Promise<T> {
+    return this.request('GET', url, params);
+  }
+
+  post<T>(url: string, params?: Params): Promise<T> {
+    return this.request('POST', url, params);
+  }
+
+  put<T>(url: string, params?: Params): Promise<T> {
+    return this.request('PUT', url, params);
+  }
+
+  delete<T>(url: string, params?: Params): Promise<T> {
+    return this.request('DELETE', url, params);
+  }
+
+  patch<T>(url: string, params?: Params): Promise<T> {
+    return this.request('PATCH', url, params);
+  }
+}
+
+const request = new Request();
+
+export interface DataResponse<T> {
+  code: number;
+  message: string;
+  success: boolean;
+  data: T;
+}
+
+export interface Pages<T> {
+  totalElements: number;
+  pageNum: number;
+  pageSize: number;
+  totalPage: number;
+  content: T[];
+}
+
+export default request;

package/template/apps/web/lib/storage/index.ts

@@ -0,0 +1,158 @@
+'use client';
+
+/**
+ * 统一的 localStorage 存储管理模块
+ * 细粒度存储，避免数据冗余，支持独立更新
+ */
+
+import type { UserInfo, LoginSuccess } from '@repo/contracts';
+
+// ============================================================================
+// Type Definitions
+// ============================================================================
+
+/**
+ * Token 数据
+ */
+export interface TokenData {
+  access: string;
+  refresh: string;
+  accessExpire: number;
+  expire: number;
+}
+
+/**
+ * 存储键名常量
+ */
+const STORAGE_KEYS = {
+  USER: 'user',
+  TOKENS: 'tokens',
+} as const;
+
+// ============================================================================
+// Storage Operations
+// ============================================================================
+
+/**
+ * 存储用户信息
+ */
+export function setUser(user: UserInfo): void {
+  if (typeof window === 'undefined') return;
+  localStorage.setItem(STORAGE_KEYS.USER, JSON.stringify(user));
+  window.dispatchEvent(new Event('userInfoUpdated'));
+}
+
+/**
+ * 获取用户信息
+ */
+export function getUser(): UserInfo | null {
+  if (typeof window === 'undefined') return null;
+  const userStr = localStorage.getItem(STORAGE_KEYS.USER);
+  if (!userStr) return null;
+  try {
+    return JSON.parse(userStr) as UserInfo;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 更新用户信息（部分更新）
+ */
+export function updateUser(updates: Partial<UserInfo>): void {
+  const currentUser = getUser();
+  if (!currentUser) return;
+  setUser({ ...currentUser, ...updates });
+}
+
+/**
+ * 存储 Token 数据
+ */
+export function setTokens(tokens: TokenData): void {
+  if (typeof window === 'undefined') return;
+  localStorage.setItem(STORAGE_KEYS.TOKENS, JSON.stringify(tokens));
+}
+
+/**
+ * 获取 Token 数据
+ */
+export function getTokens(): TokenData | null {
+  if (typeof window === 'undefined') return null;
+  const tokensStr = localStorage.getItem(STORAGE_KEYS.TOKENS);
+  if (!tokensStr) return null;
+  try {
+    return JSON.parse(tokensStr) as TokenData;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 获取 Access Token
+ */
+export function getAccessToken(): string | null {
+  const tokens = getTokens();
+  return tokens?.access || null;
+}
+
+/**
+ * 获取 Refresh Token
+ */
+export function getRefreshToken(): string | null {
+  const tokens = getTokens();
+  return tokens?.refresh || null;
+}
+
+/**
+ * 检查 Access Token 是否过期
+ */
+export function isTokenExpired(): boolean {
+  const tokens = getTokens();
+  if (!tokens?.accessExpire) return true;
+  return Date.now() >= tokens.accessExpire;
+}
+
+/**
+ * 存储登录数据（统一入口）
+ * 将登录返回的数据拆分为细粒度存储
+ */
+export function setLoginData(data: LoginSuccess): void {
+  if (typeof window === 'undefined') return;
+
+  // 存储用户信息
+  setUser(data.user);
+
+  // 存储 Token 数据
+  setTokens({
+    access: data.access,
+    refresh: data.refresh,
+    accessExpire: data.accessExpire,
+    expire: data.expire,
+  });
+}
+
+/**
+ * 清除所有存储数据
+ */
+export function clearAll(): void {
+  if (typeof window === 'undefined') return;
+  localStorage.removeItem(STORAGE_KEYS.USER);
+  localStorage.removeItem(STORAGE_KEYS.TOKENS);
+
+  // 清除旧格式的数据（兼容性清理）
+  localStorage.removeItem('userInfo');
+  localStorage.removeItem('tokenData');
+  localStorage.removeItem('loginData');
+  localStorage.removeItem('token');
+}
+
+// ============================================================================
+// Backward Compatibility (临时兼容旧代码)
+// ============================================================================
+
+/**
+ * 获取 Token（兼容旧代码）
+ */
+export function getToken(): string | null {
+  return getAccessToken();
+}

package/template/apps/web/lib/upload/api.ts

@@ -0,0 +1,260 @@
+import { uploaderClient } from '../api/contracts/client';
+import { UploadError, UploadErrorCode } from './errors';
+
+// Helper function: extract error message from response (for logging only)
+function getErrorMsg(body: unknown, defaultMsg: string): string {
+  if (
+    body &&
+    typeof body === 'object' &&
+    'msg' in body &&
+    typeof body.msg === 'string'
+  ) {
+    return body.msg;
+  }
+  return defaultMsg;
+}
+
+// Type guard for folderId
+type FolderId = 'root' | `${string}-${string}-${string}-${string}-${string}`;
+
+function isValidFolderId(id: string): id is FolderId {
+  return (
+    id === 'root' ||
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)
+  );
+}
+
+/**
+ * 上传元数据（用于秒传后处理）
+ */
+export interface UploadMetadata {
+  jobDescriptionId?: string; // 简历上传使用
+  meetingId?: string; // 会议录音上传使用
+  autoParse?: boolean; // 是否自动触发解析
+}
+
+/**
+ * 获取私有上传 Token
+ */
+export interface GetUploadTokenParams {
+  filename: string;
+  signature: string;
+  fsize: number;
+  folderId: string;
+  spaceId: string;
+  thumbImg?: string;
+  domain?: string;
+  metadata?: UploadMetadata;
+}
+
+export interface FileSystem {
+  id: string;
+  name: string;
+  type: string;
+  spaceId: string;
+  parentId: string | null;
+  fsize: number;
+  url?: string;
+  fileKeyId?: string;
+  origin?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface UploadTokenData {
+  // 文件不存在时返回的字段
+  token?: string;
+  key?: string;
+  fileId?: string;
+
+  // 文件已存在（秒传）时返回的字段
+  success?: boolean;
+  fileSystem?: FileSystem;
+  space?: Record<string, unknown>;
+  parent?: Record<string, unknown>;
+  usage?: Record<string, unknown>;
+}
+
+export async function getUploadTokenPrivate(
+  params: GetUploadTokenParams,
+): Promise<UploadTokenData> {
+  if (!isValidFolderId(params.folderId)) {
+    throw new UploadError(
+      UploadErrorCode.GET_UPLOAD_TOKEN_FAILED,
+      'Invalid folderId format',
+    );
+  }
+
+  const response = await uploaderClient.getPrivateToken({
+    body: {
+      filename: params.filename,
+      signature: params.signature,
+      fsize: params.fsize,
+    },
+  });
+
+  if (response.status === 200) {
+    return response.body.data as UploadTokenData;
+  }
+
+  console.error(getErrorMsg(response.body, 'Failed to get upload token'));
+  throw new UploadError(UploadErrorCode.GET_UPLOAD_TOKEN_FAILED);
+}
+
+/**
+ * 初始化分片上传
+ */
+export interface InitMultipartUploadParams {
+  signature: string;
+  filename: string;
+  fsize: number;
+  spaceId: string;
+  folderId: string;
+  metadata?: UploadMetadata;
+}
+
+export interface InitMultipartUploadData {
+  uploadId?: string; // 秒传时可能没有 uploadId
+  fileId: string;
+  key: string;
+  spaceId: string;
+  // 秒传时可能返回完整的文件信息
+  success?: boolean;
+  fileSystem?: FileSystem;
+  space?: Record<string, unknown>;
+  parent?: Record<string, unknown>;
+}
+
+export async function initMultipartUpload(
+  params: InitMultipartUploadParams,
+): Promise<InitMultipartUploadData> {
+  if (!isValidFolderId(params.folderId)) {
+    throw new UploadError(
+      UploadErrorCode.INIT_MULTIPART_FAILED,
+      'Invalid folderId format',
+    );
+  }
+
+  const response = await uploaderClient.initMultipart({
+    body: {
+      signature: params.signature,
+      filename: params.filename,
+      fsize: params.fsize,
+    },
+  });
+
+  if (response.status === 200) {
+    return response.body.data as InitMultipartUploadData;
+  }
+
+  console.error(getErrorMsg(response.body, 'Failed to init multipart upload'));
+  throw new UploadError(UploadErrorCode.INIT_MULTIPART_FAILED);
+}
+
+/**
+ * 获取分片上传 Token
+ */
+export interface GetChunkUploadTokenParams {
+  signature: string;
+  filename: string;
+  uploadId: string;
+  partNumber: number;
+  fsize: number;
+  spaceId: string;
+  folderId: string;
+  key: string;
+}
+
+export interface ChunkUploadTokenData {
+  token: string;
+}
+
+export async function getChunkUploadToken(
+  params: GetChunkUploadTokenParams,
+): Promise<ChunkUploadTokenData> {
+  const response = await uploaderClient.getMultipartToken({
+    body: {
+      signature: params.signature,
+      filename: params.filename,
+      uploadId: params.uploadId,
+      partNumber: params.partNumber,
+      fsize: params.fsize,
+      key: params.key,
+    },
+  });
+
+  if (response.status === 200) {
+    return { token: response.body.data.token || '' };
+  }
+
+  console.error(getErrorMsg(response.body, 'Failed to get chunk upload token'));
+  throw new UploadError(UploadErrorCode.GET_CHUNK_TOKEN_FAILED);
+}
+
+/**
+ * 完成上传
+ */
+export interface CompleteUploadParams {
+  signature: string;
+  filename: string;
+  fileId: string;
+  fsize: number;
+  spaceId: string;
+  uploadId?: string;
+  parts?: Array<{ ETag: string; PartNumber: number }>;
+  key?: string;
+  thumbImg?: string;
+  metadata?: UploadMetadata;
+}
+
+export interface CompleteUploadData {
+  data?: {
+    url?: string;
+    origin?: string;
+    fileSystem?: FileSystem;
+  };
+  fileSystem?: FileSystem;
+  success?: boolean;
+}
+
+export async function completeUpload(
+  params: CompleteUploadParams,
+): Promise<CompleteUploadData> {
+  const response = await uploaderClient.complete({
+    body: {
+      signature: params.signature,
+      fileId: params.fileId,
+    },
+  });
+
+  if (response.status === 200) {
+    return response.body.data as CompleteUploadData;
+  }
+
+  console.error(getErrorMsg(response.body, 'Failed to complete upload'));
+  throw new UploadError(UploadErrorCode.COMPLETE_UPLOAD_FAILED);
+}
+
+/**
+ * 取消上传
+ */
+export interface AbortUploadParams {
+  signature: string;
+  uploadId: string;
+  spaceId: string;
+  fileId: string;
+}
+
+export async function abortUpload(params: AbortUploadParams): Promise<void> {
+  const response = await uploaderClient.abort({
+    body: {
+      signature: params.signature,
+      fileId: params.fileId,
+    },
+  });
+
+  if (response.status !== 200) {
+    console.error(getErrorMsg(response.body, 'Failed to abort upload'));
+    throw new UploadError(UploadErrorCode.ABORT_UPLOAD_FAILED);
+  }
+}