create-pardx-scaffold 0.1.0

package/template/packages/utils/json.util.ts

@@ -0,0 +1,9 @@
+export default {
+  parse(data: string, defaultValue: any): any {
+    try {
+      return JSON.parse(data);
+    } catch (e) {
+      return defaultValue;
+    }
+  },
+};

package/template/packages/utils/mask.util.ts

@@ -0,0 +1,348 @@
+/**
+ * 敏感数据脱敏工具
+ * Sensitive Data Masking Utility
+ */
+
+export interface MaskOptions {
+  /** 保留前缀字符数 */
+  prefixLength?: number;
+  /** 保留后缀字符数 */
+  suffixLength?: number;
+  /** 掩码字符 */
+  maskChar?: string;
+  /** 掩码数量（固定数量而非根据原文长度） */
+  fixedMaskLength?: number;
+}
+
+/**
+ * 通用字符串脱敏
+ */
+function maskString(str: string, options: MaskOptions = {}): string {
+  if (!str || typeof str !== 'string') return str;
+
+  const {
+    prefixLength = 0,
+    suffixLength = 0,
+    maskChar = '*',
+    fixedMaskLength,
+  } = options;
+
+  if (str.length <= prefixLength + suffixLength) {
+    return str;
+  }
+
+  const prefix = str.slice(0, prefixLength);
+  const suffix = str.slice(-suffixLength || undefined);
+  const maskLength =
+    fixedMaskLength ?? str.length - prefixLength - suffixLength;
+  const mask = maskChar.repeat(Math.max(maskLength, 1));
+
+  return suffixLength > 0 ? `${prefix}${mask}${suffix}` : `${prefix}${mask}`;
+}
+
+/**
+ * 邮箱脱敏
+ * example@gmail.com → ex***@gmail.com
+ */
+function maskEmail(email: string): string {
+  if (!email || typeof email !== 'string' || !email.includes('@')) {
+    return email;
+  }
+
+  const [local, domain] = email.split('@');
+  const maskedLocal = local.length <= 2 ? local : `${local.slice(0, 2)}***`;
+
+  return `${maskedLocal}@${domain}`;
+}
+
+/**
+ * 手机号脱敏
+ * 13812345678 → 138****5678
+ */
+function maskPhone(phone: string): string {
+  if (!phone || typeof phone !== 'string') return phone;
+
+  // 处理带国际区号的手机号
+  const cleanPhone = phone.replace(/[\s\-\+]/g, '');
+
+  if (cleanPhone.length < 7) return phone;
+
+  // 中国手机号 11 位
+  if (cleanPhone.length === 11) {
+    return cleanPhone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2');
+  }
+
+  // 其他格式：保留前 3 后 4
+  return maskString(cleanPhone, {
+    prefixLength: 3,
+    suffixLength: 4,
+    fixedMaskLength: 4,
+  });
+}
+
+/**
+ * 身份证脱敏
+ * 110101199001011234 → 1101**********1234
+ */
+function maskIdCard(id: string): string {
+  if (!id || typeof id !== 'string') return id;
+
+  const cleanId = id.replace(/[\s\-]/g, '');
+
+  if (cleanId.length < 15) return id;
+
+  return maskString(cleanId, {
+    prefixLength: 4,
+    suffixLength: 4,
+    fixedMaskLength: 10,
+  });
+}
+
+/**
+ * 银行卡脱敏
+ * 6222021234567890123 → 6222 **** **** 0123
+ */
+function maskBankCard(card: string): string {
+  if (!card || typeof card !== 'string') return card;
+
+  const cleanCard = card.replace(/[\s\-]/g, '');
+
+  if (cleanCard.length < 13) return card;
+
+  const prefix = cleanCard.slice(0, 4);
+  const suffix = cleanCard.slice(-4);
+
+  return `${prefix} **** **** ${suffix}`;
+}
+
+/**
+ * 姓名脱敏
+ * 张三 → 张*
+ * 王小明 → 王*明
+ * John Doe → J***e
+ */
+function maskName(name: string): string {
+  if (!name || typeof name !== 'string') return name;
+
+  const trimmedName = name.trim();
+
+  if (trimmedName.length < 2) return trimmedName;
+
+  if (trimmedName.length === 2) {
+    return `${trimmedName[0]}*`;
+  }
+
+  const first = trimmedName[0];
+  const last = trimmedName[trimmedName.length - 1];
+  const middleMask = '*'.repeat(trimmedName.length - 2);
+
+  return `${first}${middleMask}${last}`;
+}
+
+/**
+ * 地址脱敏
+ * 北京市朝阳区xxx街道123号 → 北京市朝阳区***
+ */
+function maskAddress(address: string): string {
+  if (!address || typeof address !== 'string') return address;
+
+  const trimmedAddress = address.trim();
+
+  if (trimmedAddress.length <= 6) return trimmedAddress;
+
+  // 保留前 6 个字符（通常是省市区）
+  return `${trimmedAddress.slice(0, 6)}***`;
+}
+
+/**
+ * IP 地址脱敏
+ * 192.168.1.100 → 192.168.*.*
+ */
+function maskIp(ip: string): string {
+  if (!ip || typeof ip !== 'string') return ip;
+
+  // IPv4
+  if (ip.includes('.')) {
+    const parts = ip.split('.');
+    if (parts.length === 4) {
+      return `${parts[0]}.${parts[1]}.*.*`;
+    }
+  }
+
+  // IPv6: 保留前两段
+  if (ip.includes(':')) {
+    const parts = ip.split(':');
+    if (parts.length >= 2) {
+      return `${parts[0]}:${parts[1]}:****:****`;
+    }
+  }
+
+  return ip;
+}
+
+/**
+ * Token/密钥脱敏
+ * eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9... → eyJh***...9
+ */
+function maskToken(token: string): string {
+  if (!token || typeof token !== 'string') return token;
+
+  if (token.length <= 8) return '***';
+
+  return `${token.slice(0, 4)}***${token.slice(-4)}`;
+}
+
+/**
+ * 密码脱敏（总是显示固定星号）
+ */
+function maskPassword(_password: string): string {
+  return '********';
+}
+
+/**
+ * URL 脱敏（隐藏查询参数中的敏感信息）
+ */
+function maskUrl(
+  url: string,
+  sensitiveParams: string[] = ['token', 'key', 'secret', 'password', 'apiKey'],
+): string {
+  if (!url || typeof url !== 'string') return url;
+
+  try {
+    const urlObj = new URL(url);
+    sensitiveParams.forEach((param) => {
+      if (urlObj.searchParams.has(param)) {
+        urlObj.searchParams.set(param, '***');
+      }
+    });
+    return urlObj.toString();
+  } catch {
+    return url;
+  }
+}
+
+/**
+ * 敏感字段名列表
+ */
+const SENSITIVE_FIELDS = [
+  'password',
+  'token',
+  'accessToken',
+  'refreshToken',
+  'secret',
+  'apiKey',
+  'apiSecret',
+  'privateKey',
+  'credential',
+  'authorization',
+];
+
+/**
+ * 自动检测并脱敏对象中的敏感字段
+ */
+function maskObject<T extends Record<string, any>>(
+  obj: T,
+  additionalFields: string[] = [],
+): T {
+  if (!obj || typeof obj !== 'object') return obj;
+
+  const sensitiveFields = [...SENSITIVE_FIELDS, ...additionalFields];
+  const result: Record<string, any> = { ...obj };
+
+  for (const key of Object.keys(result)) {
+    const lowerKey = key.toLowerCase();
+
+    // 检查是否为敏感字段
+    const isSensitive = sensitiveFields.some((field) =>
+      lowerKey.includes(field.toLowerCase()),
+    );
+
+    if (isSensitive && typeof result[key] === 'string') {
+      result[key] = '***';
+      continue;
+    }
+
+    // 递归处理嵌套对象
+    if (
+      result[key] &&
+      typeof result[key] === 'object' &&
+      !Array.isArray(result[key])
+    ) {
+      result[key] = maskObject(result[key], additionalFields);
+    }
+
+    // 处理数组
+    if (Array.isArray(result[key])) {
+      result[key] = result[key].map((item: any) =>
+        typeof item === 'object' ? maskObject(item, additionalFields) : item,
+      );
+    }
+
+    // 特殊字段处理
+    if (lowerKey === 'email' && typeof result[key] === 'string') {
+      result[key] = maskEmail(result[key]);
+    } else if (
+      (lowerKey === 'phone' || lowerKey === 'mobile') &&
+      typeof result[key] === 'string'
+    ) {
+      result[key] = maskPhone(result[key]);
+    } else if (lowerKey === 'idcard' && typeof result[key] === 'string') {
+      result[key] = maskIdCard(result[key]);
+    } else if (lowerKey === 'ip' && typeof result[key] === 'string') {
+      result[key] = maskIp(result[key]);
+    }
+  }
+
+  return result as T;
+}
+
+/**
+ * 脱敏工具对象
+ */
+const maskUtil = {
+  /** 通用字符串脱敏 */
+  string: maskString,
+  /** 邮箱脱敏 */
+  email: maskEmail,
+  /** 手机号脱敏 */
+  phone: maskPhone,
+  /** 身份证脱敏 */
+  idCard: maskIdCard,
+  /** 银行卡脱敏 */
+  bankCard: maskBankCard,
+  /** 姓名脱敏 */
+  name: maskName,
+  /** 地址脱敏 */
+  address: maskAddress,
+  /** IP 地址脱敏 */
+  ip: maskIp,
+  /** Token/密钥脱敏 */
+  token: maskToken,
+  /** 密码脱敏 */
+  password: maskPassword,
+  /** URL 脱敏 */
+  url: maskUrl,
+  /** 对象自动脱敏 */
+  object: maskObject,
+  /** 敏感字段名列表 */
+  SENSITIVE_FIELDS,
+};
+
+export default maskUtil;
+
+// 同时导出独立函数以支持按需导入
+export {
+  maskString,
+  maskEmail,
+  maskPhone,
+  maskIdCard,
+  maskBankCard,
+  maskName,
+  maskAddress,
+  maskIp,
+  maskToken,
+  maskPassword,
+  maskUrl,
+  maskObject,
+  SENSITIVE_FIELDS,
+};

package/template/packages/utils/object.util.ts

@@ -0,0 +1,149 @@
+import validate from './validate.util';
+import jsonUtil from './json.util';
+import { pick } from 'lodash';
+
+type NestedObject = {
+  [key: string]: NestedObject | {};
+};
+export default {
+  filter(object: any, fields: string[]) {
+    return pick(object, fields);
+  },
+  getType(data: any): string {
+    if (Array.isArray(data)) return 'array';
+    if (data === null) return 'null';
+    return typeof data;
+  },
+  isCustomType(object: any, constructorName: string): boolean {
+    return (
+      object &&
+      typeof object === 'object' &&
+      typeof object.constructor === 'function' &&
+      object.constructor.name === constructorName
+    );
+  },
+  getValue(data: any, name: string, defaultValue: any = null): any {
+    let objData =
+      typeof data === 'string' ? jsonUtil.parse(data, defaultValue) : data;
+    if (this.getType(name) !== 'string') return defaultValue;
+    if (this.getType(objData) !== 'object' || objData === null)
+      return defaultValue;
+
+    if (name.includes('.')) {
+      return name.split('.').reduce((acc, key) => {
+        return acc !== defaultValue
+          ? this.getValue(acc, key, defaultValue)
+          : defaultValue;
+      }, objData);
+    } else {
+      return objData.hasOwnProperty(name) && validate.isNotBlank(objData[name])
+        ? objData[name]
+        : defaultValue;
+    }
+  },
+  addProperty(obj: any, key: string, value: any): any {
+    const addObj: any = {};
+    addObj[key] = value;
+    if (!this.isCustomType(obj, 'Object')) {
+      obj = {};
+    }
+    obj = {
+      ...obj,
+      ...addObj,
+    };
+    return obj;
+  },
+  removeProperty(obj: any, key: string): any {
+    if (!obj?.hasOwnProperty(key)) {
+      return obj;
+    }
+    // 使用扩展运算符创建新对象，并排除指定的 key
+    const { [key]: omitted, ...newObj } = obj;
+    return newObj;
+  },
+  removePropertys(obj: any, keys: string[]): any {
+    return keys.reduce((acc, key) => this.removeProperty(acc, key), obj);
+  },
+  // 数组的项目是Object的处理
+  addPropertyInArray(array: any[], key: string, value: any): any[] {
+    return array
+      .filter((item) => this.isCustomType(item, 'Object'))
+      .map((item) => this.addProperty(item, key, value));
+  },
+  removePropertysInArray(array: any[], keys: string[]): any[] {
+    return array.map((item) => this.removePropertys(item, keys));
+  },
+  setNestedValue(obj: any, path: string, value: any): void {
+    // 将字符串路径转换为路径数组
+    const pathArray = path.split('.');
+
+    // 确保路径数组不为空
+    if (pathArray.length === 0) {
+      throw new Error('Path cannot be an empty string.');
+    }
+
+    // 遍历路径数组，除了最后一个元素
+    for (let i = 0; i < pathArray.length - 1; i++) {
+      const key = pathArray[i];
+
+      // 如果当前层的字段不存在，则创建它（假设它是一个对象）
+      if (!obj.hasOwnProperty(key) || typeof obj[key] !== 'object') {
+        obj[key] = {};
+      }
+
+      // 向下遍历到下一层对象
+      obj = obj[key];
+    }
+    // 设置最后一个字段的值
+    const lastKey = pathArray[pathArray.length - 1];
+    obj[lastKey] = value;
+  },
+
+  traverseKeys(obj: NestedObject | any, parentKeys: string[] = []): string[][] {
+    const keyPaths: string[][] = [];
+
+    // 遍历对象的每一个属性
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        // 构建当前键的完整路径
+        const currentKeys = [...parentKeys, key];
+
+        // 添加到key路径数组中
+        keyPaths.push(currentKeys);
+
+        // 如果值是对象，则递归遍历
+        if (typeof obj[key] === 'object' && obj[key] !== null) {
+          // 递归调用并合并返回的key路径
+          keyPaths.push(...this.traverseKeys(obj[key], currentKeys));
+        }
+      }
+    }
+
+    return keyPaths;
+  },
+  isEqual(object1: any, object2: any): boolean {
+    if (object1 === object2) {
+      return true;
+    }
+    if (!object1 || !object2) {
+      return false;
+    }
+    const keys1 = Object.keys(object1);
+    const keys2 = Object.keys(object2);
+    if (keys1.length !== keys2.length) {
+      return false;
+    }
+    for (const key of keys1) {
+      const val1 = object1[key];
+      const val2 = object2[key];
+      if (typeof val1 === 'object' && typeof val2 === 'object') {
+        if (!this.isEqual(val1, val2)) {
+          return false;
+        }
+      } else if (val1 !== val2) {
+        return false;
+      }
+    }
+    return true;
+  },
+};

package/template/packages/utils/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "@repo/utils",
+  "version": "0.1.0",
+  "private": true,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -p tsconfig.build.json --watch",
+    "clean": "rimraf dist",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./cn": {
+      "types": "./dist/cn.d.ts",
+      "default": "./dist/cn.js"
+    },
+    "./file": {
+      "types": "./dist/file.d.ts",
+      "default": "./dist/file.js"
+    },
+    "./encrypt": {
+      "types": "./dist/encrypt.d.ts",
+      "default": "./dist/encrypt.js"
+    },
+    "./fetch": {
+      "types": "./dist/fetch.d.ts",
+      "default": "./dist/fetch.js"
+    },
+    "./headers": {
+      "types": "./dist/headers.d.ts",
+      "default": "./dist/headers.js"
+    },
+    "./array": {
+      "types": "./dist/array.util.d.ts",
+      "default": "./dist/array.util.js"
+    },
+    "./bigint": {
+      "types": "./dist/bigint.util.d.ts",
+      "default": "./dist/bigint.util.js"
+    },
+    "./ip": {
+      "types": "./dist/ip.util.d.ts",
+      "default": "./dist/ip.util.js"
+    },
+    "./json": {
+      "types": "./dist/json.util.d.ts",
+      "default": "./dist/json.util.js"
+    },
+    "./object": {
+      "types": "./dist/object.util.d.ts",
+      "default": "./dist/object.util.js"
+    },
+    "./string": {
+      "types": "./dist/string.util.d.ts",
+      "default": "./dist/string.util.js"
+    },
+    "./timer": {
+      "types": "./dist/timer.util.d.ts",
+      "default": "./dist/timer.util.js"
+    },
+    "./urlencode": {
+      "types": "./dist/urlencode.util.d.ts",
+      "default": "./dist/urlencode.util.js"
+    },
+    "./validate": {
+      "types": "./dist/validate.util.d.ts",
+      "default": "./dist/validate.util.js"
+    },
+    "./serialize": {
+      "types": "./dist/serialize.util.d.ts",
+      "default": "./dist/serialize.util.js"
+    },
+    "./bcrypt": {
+      "types": "./dist/bcrypt.util.d.ts",
+      "default": "./dist/bcrypt.util.js"
+    }
+  },
+  "dependencies": {
+    "@repo/config": "workspace:*",
+    "@repo/constants": "workspace:*",
+    "@repo/types": "workspace:*",
+    "clsx": "^2.0.0",
+    "crypto-js": "^4.2.0",
+    "lodash": "^4.17.23",
+    "moment-timezone": "^0.5.48",
+    "pinyin-pro": "^3.28.0",
+    "tailwind-merge": "^2.0.0",
+    "uuid": "^11.1.0"
+  },
+  "optionalDependencies": {
+    "bcrypt": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^5.0.2",
+    "@types/crypto-js": "^4.2.2",
+    "@types/jest": "^29.5.12",
+    "@types/lodash": "^4.17.21",
+    "@types/minimatch": "^6.0.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.3",
+    "typescript": "^5"
+  }
+}

package/template/packages/utils/serialize.util.ts

@@ -0,0 +1,17 @@
+export default {
+  bigInt(obj: unknown): unknown {
+    if (typeof obj === 'bigint') {
+      return parseInt(`${obj}`); // 将BigInt值转换为字符串，'n'作为标记表示这是一个BigInt
+    } else if (typeof obj === 'object' && obj !== null) {
+      return JSON.parse(
+        JSON.stringify(obj, (_key, value) => {
+          if (typeof value === 'bigint') {
+            return parseInt(`${value}`);
+          }
+          return value;
+        }),
+      );
+    }
+    return obj; // 对于非对象类型，直接返回
+  },
+};