@hamjimin/xplat-back 0.1.0 → 0.2.0

package/dist/modules/utils/lodash.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LodashUtils = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+/**
+ * Lodash 유틸리티 래퍼
+ *
+ * company-common-utils를 참고하여 작성되었습니다.
+ * 모든 lodash 함수에 직접 접근할 수 있도록 제공합니다.
+ */
+class LodashUtils {
+    /**
+     * lodash 인스턴스 직접 접근
+     */
+    get _() {
+        return lodash_1.default;
+    }
+    /**
+     * 객체 깊은 복사
+     */
+    deepClone(value) {
+        return lodash_1.default.cloneDeep(value);
+    }
+    /**
+     * 객체 병합
+     */
+    merge(target, ...sources) {
+        return lodash_1.default.merge(target, ...sources);
+    }
+    /**
+     * 배열에서 중복 제거
+     */
+    uniq(array) {
+        return lodash_1.default.uniq(array);
+    }
+    /**
+     * 객체에서 특정 경로의 값 가져오기
+     */
+    get(object, path, defaultValue) {
+        return lodash_1.default.get(object, path, defaultValue);
+    }
+    /**
+     * 객체에 특정 경로로 값 설정
+     */
+    set(object, path, value) {
+        return lodash_1.default.set(object, path, value);
+    }
+    /**
+     * 배열 그룹화
+     */
+    groupBy(collection, iteratee) {
+        return lodash_1.default.groupBy(collection, iteratee);
+    }
+    /**
+     * 디바운스 함수
+     */
+    debounce(func, wait, options) {
+        return lodash_1.default.debounce(func, wait, options);
+    }
+    /**
+     * 스로틀 함수
+     */
+    throttle(func, wait, options) {
+        return lodash_1.default.throttle(func, wait, options);
+    }
+    /**
+     * 배열에서 특정 조건으로 필터링
+     */
+    filter(collection, predicate) {
+        return lodash_1.default.filter(collection, predicate);
+    }
+    /**
+     * 배열에서 특정 조건으로 찾기
+     */
+    find(collection, predicate) {
+        return lodash_1.default.find(collection, predicate);
+    }
+    /**
+     * 배열에서 특정 조건으로 매핑
+     */
+    map(collection, iteratee) {
+        return lodash_1.default.map(collection, iteratee);
+    }
+    /**
+     * 배열에서 특정 조건으로 리듀스
+     */
+    reduce(collection, iteratee, accumulator) {
+        return lodash_1.default.reduce(collection, iteratee, accumulator);
+    }
+    /**
+     * 객체 키 순회
+     */
+    keys(object) {
+        return lodash_1.default.keys(object);
+    }
+    /**
+     * 객체 값 순회
+     */
+    values(object) {
+        return lodash_1.default.values(object);
+    }
+    /**
+     * 객체가 비어있는지 확인
+     */
+    isEmpty(value) {
+        return lodash_1.default.isEmpty(value);
+    }
+    /**
+     * 객체 병합 (assign과 유사)
+     */
+    assign(target, ...sources) {
+        return lodash_1.default.assign(target, ...sources);
+    }
+    /**
+     * 객체 키-값 쌍으로 변환
+     */
+    toPairs(object) {
+        return lodash_1.default.toPairs(object);
+    }
+    /**
+     * 키-값 쌍에서 객체로 변환
+     */
+    fromPairs(pairs) {
+        return lodash_1.default.fromPairs(pairs);
+    }
+    /**
+     * 배열을 청크로 나누기
+     */
+    chunk(array, size) {
+        return lodash_1.default.chunk(array, size);
+    }
+    /**
+     * 배열에서 특정 값 제거
+     */
+    without(array, ...values) {
+        return lodash_1.default.without(array, ...values);
+    }
+    /**
+     * 배열 평탄화
+     */
+    flatten(array) {
+        return lodash_1.default.flatten(array);
+    }
+    /**
+     * 배열 깊이 평탄화
+     */
+    flattenDeep(array) {
+        return lodash_1.default.flattenDeep(array);
+    }
+}
+exports.LodashUtils = LodashUtils;

package/dist/modules/utils/password.d.ts

@@ -0,0 +1,31 @@
+/**
+ * bcrypt를 사용한 비밀번호 해싱
+ * @param password 평문 비밀번호
+ * @returns 해시된 비밀번호
+ */
+export declare function bcryptPassword(password: string): Promise<string>;
+/**
+ * bcrypt를 사용한 비밀번호 검증
+ * @param password 평문 비밀번호
+ * @param hash 해시된 비밀번호
+ * @returns 일치 여부
+ */
+export declare function checkPassword(password: string, hash: string): Promise<boolean>;
+/**
+ * AES-256-CBC를 사용한 비밀번호 암호화
+ * @param password 평문 비밀번호
+ * @returns 암호화된 비밀번호 (hex 문자열)
+ */
+export declare function cryptoPassword(password: string): Promise<string | null>;
+/**
+ * AES-256-CBC를 사용한 비밀번호 복호화
+ * @param encryptedPassword 암호화된 비밀번호 (hex 문자열)
+ * @returns 복호화된 비밀번호
+ */
+export declare function decryptPassword(encryptedPassword: string): string | null;
+/**
+ * 랜덤 비밀번호 생성
+ * @param length 비밀번호 길이 (기본값: 12)
+ * @returns 생성된 비밀번호
+ */
+export declare function generatePassword(length?: number): string;

package/dist/modules/utils/password.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bcryptPassword = bcryptPassword;
+exports.checkPassword = checkPassword;
+exports.cryptoPassword = cryptoPassword;
+exports.decryptPassword = decryptPassword;
+exports.generatePassword = generatePassword;
+const bcrypt_1 = __importDefault(require("bcrypt"));
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * 비밀번호 유틸리티
+ *
+ * zium-backend의 commonUtil.ts를 기반으로 작성되었습니다.
+ */
+// 환경변수에서 암호화 키 가져오기 (선택사항)
+const getCryptoKey = () => {
+    const key = process.env.CRYPTO_KEY;
+    if (key) {
+        return Buffer.from(key, 'utf8').subarray(0, 32);
+    }
+    return null;
+};
+const getCryptoIV = () => {
+    const iv = process.env.CRYPTO_IV;
+    if (iv) {
+        return Buffer.from(iv, 'utf8').subarray(0, 16);
+    }
+    return null;
+};
+const algorithm = 'aes-256-cbc';
+/**
+ * bcrypt를 사용한 비밀번호 해싱
+ * @param password 평문 비밀번호
+ * @returns 해시된 비밀번호
+ */
+async function bcryptPassword(password) {
+    const saltRounds = 10;
+    return await bcrypt_1.default.hash(password, saltRounds);
+}
+/**
+ * bcrypt를 사용한 비밀번호 검증
+ * @param password 평문 비밀번호
+ * @param hash 해시된 비밀번호
+ * @returns 일치 여부
+ */
+async function checkPassword(password, hash) {
+    return await bcrypt_1.default.compare(password, hash);
+}
+/**
+ * AES-256-CBC를 사용한 비밀번호 암호화
+ * @param password 평문 비밀번호
+ * @returns 암호화된 비밀번호 (hex 문자열)
+ */
+async function cryptoPassword(password) {
+    const key = getCryptoKey();
+    const iv = getCryptoIV();
+    if (key && iv) {
+        const cipher = crypto_1.default.createCipheriv(algorithm, key, iv);
+        let encrypted = cipher.update(password, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return encrypted;
+    }
+    return null;
+}
+/**
+ * AES-256-CBC를 사용한 비밀번호 복호화
+ * @param encryptedPassword 암호화된 비밀번호 (hex 문자열)
+ * @returns 복호화된 비밀번호
+ */
+function decryptPassword(encryptedPassword) {
+    const key = getCryptoKey();
+    const iv = getCryptoIV();
+    if (key && iv) {
+        try {
+            const decipher = crypto_1.default.createDecipheriv(algorithm, key, iv);
+            let decrypted = decipher.update(encryptedPassword, 'hex', 'utf8');
+            decrypted += decipher.final('utf8');
+            return decrypted;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * 랜덤 비밀번호 생성
+ * @param length 비밀번호 길이 (기본값: 12)
+ * @returns 생성된 비밀번호
+ */
+function generatePassword(length = 12) {
+    const charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*';
+    let password = '';
+    for (let i = 0; i < length; i++) {
+        const randomIndex = Math.floor(Math.random() * charset.length);
+        password += charset[randomIndex];
+    }
+    return password;
+}

package/dist/modules/utils/pk.d.ts

@@ -0,0 +1,18 @@
+/**
+ * PK 생성 유틸리티
+ *
+ * zium-backend의 commonUtil.ts를 기반으로 작성되었습니다.
+ */
+/**
+ * UUID 기반 PK 생성
+ * @param convertStr 접두사 (예: "paymentLog")
+ * @returns 생성된 PK (예: "paymentLog12247a5935e18e6ce1b5225")
+ */
+export declare function makePK(convertStr?: string): Promise<string>;
+/**
+ * 지정한 길이만큼의 ID를 생성합니다
+ * @param length 생성할 총 길이 (예: 32)
+ * @param prefix 선택: 앞쪽에 붙일 접두사 (예: "order")
+ * @returns 생성된 ID
+ */
+export declare function makePKWithLength(length: number, prefix?: string): Promise<string>;

package/dist/modules/utils/pk.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePK = makePK;
+exports.makePKWithLength = makePKWithLength;
+const uuid_1 = require("uuid");
+/**
+ * PK 생성 유틸리티
+ *
+ * zium-backend의 commonUtil.ts를 기반으로 작성되었습니다.
+ */
+/**
+ * UUID 기반 PK 생성
+ * @param convertStr 접두사 (예: "paymentLog")
+ * @returns 생성된 PK (예: "paymentLog12247a5935e18e6ce1b5225")
+ */
+async function makePK(convertStr) {
+    if (convertStr) {
+        const strLength = convertStr.length;
+        let makeIds = (0, uuid_1.v4)();
+        makeIds = makeIds.replace(/-/g, '');
+        return convertStr + makeIds.slice(strLength);
+    }
+    else {
+        return (0, uuid_1.v4)();
+    }
+}
+/**
+ * 지정한 길이만큼의 ID를 생성합니다
+ * @param length 생성할 총 길이 (예: 32)
+ * @param prefix 선택: 앞쪽에 붙일 접두사 (예: "order")
+ * @returns 생성된 ID
+ */
+async function makePKWithLength(length, prefix = '') {
+    const uuid = (0, uuid_1.v4)().replace(/-/g, '');
+    const prefixLength = prefix.length;
+    if (prefixLength >= length) {
+        return prefix.substring(0, length);
+    }
+    const randomPart = uuid.substring(0, length - prefixLength);
+    return prefix + randomPart;
+}

package/dist/modules/utils/response.d.ts

@@ -0,0 +1,20 @@
+import { ApiCode } from '../constants/api-code';
+/**
+ * 성공 응답 생성
+ * @param data 응답 데이터
+ * @returns 포맷된 응답 객체
+ */
+export declare function success(data: any): any;
+/**
+ * 에러 응답 생성
+ * @param code 에러 코드
+ * @param message 커스텀 메시지 (선택사항)
+ * @returns 포맷된 에러 응답 객체
+ */
+export declare function error(code: number, message?: string): ApiCode;
+/**
+ * 안전한 응답 전송 (null 처리 포함)
+ * @param data 응답 데이터
+ * @returns 처리된 응답 데이터
+ */
+export declare function safeResponse(data: any): any;

package/dist/modules/utils/response.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.success = success;
+exports.error = error;
+exports.safeResponse = safeResponse;
+const api_code_1 = require("../constants/api-code");
+/**
+ * 응답 포맷팅 유틸리티
+ *
+ * zium-backend의 commonUtil.ts를 기반으로 작성되었습니다.
+ */
+/**
+ * null 값을 빈 문자열로 변환 (재귀적)
+ * @param obj 변환할 객체
+ * @returns 변환된 객체
+ */
+function replaceNullWithEmptyString(obj) {
+    // 빈 객체는 그대로 유지
+    if (typeof obj === 'object' && !Array.isArray(obj) && Object.keys(obj).length === 0) {
+        return {};
+    }
+    // 빈 배열은 그대로 유지
+    if (Array.isArray(obj) && obj.length === 0) {
+        return [];
+    }
+    // 배열 처리 - 각 요소를 재귀적으로 처리
+    if (Array.isArray(obj)) {
+        return obj.map((item) => replaceNullWithEmptyString(item));
+    }
+    // 객체 처리 - 각 property를 재귀적으로 처리
+    if (typeof obj === 'object' && obj !== null) {
+        const processed = Object.keys(obj).reduce((acc, key) => ({
+            ...acc,
+            [key]: replaceNullWithEmptyString(obj[key]),
+        }), {});
+        return processed;
+    }
+    // null, undefined를 빈 문자열로 변환
+    if (obj === null || obj === undefined) {
+        return '';
+    }
+    // 기본값 (문자열, 숫자 등)은 그대로 반환
+    return obj;
+}
+/**
+ * 성공 응답 생성
+ * @param data 응답 데이터
+ * @returns 포맷된 응답 객체
+ */
+function success(data) {
+    const processedData = replaceNullWithEmptyString(data);
+    if (processedData.list) {
+        return {
+            ...(0, api_code_1.getApiCode)(200),
+            list: processedData.list,
+            totalCount: processedData.totalCount,
+            totalPage: processedData.totalPage,
+        };
+    }
+    else {
+        return {
+            ...(0, api_code_1.getApiCode)(200),
+            data: processedData,
+        };
+    }
+}
+/**
+ * 에러 응답 생성
+ * @param code 에러 코드
+ * @param message 커스텀 메시지 (선택사항)
+ * @returns 포맷된 에러 응답 객체
+ */
+function error(code, message) {
+    const apiCode = (0, api_code_1.getApiCode)(code);
+    return {
+        ...apiCode,
+        message: message || apiCode.msg,
+    };
+}
+/**
+ * 안전한 응답 전송 (null 처리 포함)
+ * @param data 응답 데이터
+ * @returns 처리된 응답 데이터
+ */
+function safeResponse(data) {
+    return replaceNullWithEmptyString(data);
+}

package/dist/modules/utils/validation.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 유효성 검증 유틸리티
+ *
+ * zium-backend의 commonUtil.ts를 기반으로 작성되었습니다.
+ */
+/**
+ * 이메일 형식 검증
+ * @param email 검증할 이메일 주소
+ * @returns 유효성 여부
+ */
+export declare function isEmail(email: string): boolean;
+/**
+ * 비밀번호 형식 검증
+ * - 최소 8자 이상
+ * - 영문, 숫자, 특수문자 포함 (선택사항)
+ * @param password 검증할 비밀번호
+ * @param options 검증 옵션
+ * @returns 유효성 여부
+ */
+export declare function isPassword(password: string, options?: {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumber?: boolean;
+    requireSpecialChar?: boolean;
+}): boolean;
+/**
+ * 휴대폰 번호 형식 검증 (한국)
+ * @param phone 검증할 휴대폰 번호
+ * @returns 유효성 여부
+ */
+export declare function isPhone(phone: string): boolean;
+/**
+ * 문자열이 비어있지 않은지 검증
+ * @param str 검증할 문자열
+ * @returns 유효성 여부
+ */
+export declare function isNotEmpty(str: string): boolean;
+/**
+ * 숫자 형식 검증
+ * @param value 검증할 값
+ * @returns 유효성 여부
+ */
+export declare function isNumber(value: any): boolean;
+/**
+ * URL 형식 검증
+ * @param url 검증할 URL
+ * @returns 유효성 여부
+ */
+export declare function isURL(url: string): boolean;

package/dist/modules/utils/validation.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * 유효성 검증 유틸리티
+ *
+ * zium-backend의 commonUtil.ts를 기반으로 작성되었습니다.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmail = isEmail;
+exports.isPassword = isPassword;
+exports.isPhone = isPhone;
+exports.isNotEmpty = isNotEmpty;
+exports.isNumber = isNumber;
+exports.isURL = isURL;
+/**
+ * 이메일 형식 검증
+ * @param email 검증할 이메일 주소
+ * @returns 유효성 여부
+ */
+function isEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+/**
+ * 비밀번호 형식 검증
+ * - 최소 8자 이상
+ * - 영문, 숫자, 특수문자 포함 (선택사항)
+ * @param password 검증할 비밀번호
+ * @param options 검증 옵션
+ * @returns 유효성 여부
+ */
+function isPassword(password, options = {}) {
+    const { minLength = 8, requireUppercase = false, requireLowercase = false, requireNumber = false, requireSpecialChar = false, } = options;
+    if (password.length < minLength) {
+        return false;
+    }
+    if (requireUppercase && !/[A-Z]/.test(password)) {
+        return false;
+    }
+    if (requireLowercase && !/[a-z]/.test(password)) {
+        return false;
+    }
+    if (requireNumber && !/[0-9]/.test(password)) {
+        return false;
+    }
+    if (requireSpecialChar && !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * 휴대폰 번호 형식 검증 (한국)
+ * @param phone 검증할 휴대폰 번호
+ * @returns 유효성 여부
+ */
+function isPhone(phone) {
+    // 하이픈 포함/제외 모두 허용
+    const cleaned = phone.replace(/-/g, '');
+    const phoneRegex = /^01[0-9]{9}$/;
+    return phoneRegex.test(cleaned);
+}
+/**
+ * 문자열이 비어있지 않은지 검증
+ * @param str 검증할 문자열
+ * @returns 유효성 여부
+ */
+function isNotEmpty(str) {
+    return str !== null && str !== undefined && str.trim().length > 0;
+}
+/**
+ * 숫자 형식 검증
+ * @param value 검증할 값
+ * @returns 유효성 여부
+ */
+function isNumber(value) {
+    return !isNaN(value) && !isNaN(parseFloat(value));
+}
+/**
+ * URL 형식 검증
+ * @param url 검증할 URL
+ * @returns 유효성 여부
+ */
+function isURL(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/types/index.d.ts

@@ -73,3 +73,29 @@ export interface ExtendedRequest extends Request {
  */
 export interface ExtendedResponse extends Response {
 }
+/**
+ * 인증된 요청 타입 (JWT 미들웨어 사용 시)
+ */
+export interface AuthenticatedRequest extends Request {
+    user?: {
+        id: string;
+        role?: string;
+        [key: string]: any;
+    };
+    accessToken?: {
+        id: string;
+        role?: string;
+        [key: string]: any;
+    };
+}
+/**
+ * XplatSystem 인스턴스 타입
+ */
+export interface XplatSystemInstance {
+    app: import('../modules/app').AppModule;
+    router: import('../modules/router').RouterModule;
+    auth: import('../modules/auth').AuthModule;
+    utils: import('../modules/utils').UtilsModule;
+    middleware: import('../modules/middleware').MiddlewareModule;
+    constants: import('../modules/constants').ConstantsModule;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamjimin/xplat-back",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Express + TypeScript 백엔드 스캐폴딩 도구 (zium-backend 기반)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,13 +34,25 @@
   "dependencies": {
     "express": "^4.18.2",
     "cookie-parser": "^1.4.6",
-    "cors": "^2.8.5"
+    "cors": "^2.8.5",
+    "jsonwebtoken": "^9.0.2",
+    "bcrypt": "^5.1.1",
+    "crypto-js": "^4.2.0",
+    "lodash": "^4.17.21",
+    "uuid": "^9.0.1",
+    "@aws-sdk/client-s3": "^3.922.0",
+    "@aws-sdk/s3-request-presigner": "^3.922.0"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",
     "@types/node": "^20.10.0",
     "@types/cookie-parser": "^1.4.6",
     "@types/cors": "^2.8.17",
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/bcrypt": "^5.0.2",
+    "@types/crypto-js": "^4.2.2",
+    "@types/lodash": "^4.14.202",
+    "@types/uuid": "^9.0.8",
     "typescript": "^5.3.3"
   }
 }