@hamjimin/xplat-back 0.1.0 → 0.3.0

package/dist/modules/storage/s3.d.ts

@@ -0,0 +1,80 @@
+import { S3Client } from '@aws-sdk/client-s3';
+/**
+ * S3 스토리지 유틸리티
+ *
+ * zium-backend의 util/s3.ts를 기반으로 작성되었습니다.
+ */
+export interface S3Config {
+    region?: string;
+    bucket?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+}
+/**
+ * 날짜 기반 접두사 생성 (YYYY/MM/DD)
+ */
+export declare function getDatePrefix(d?: Date): string;
+/**
+ * S3 키 생성
+ */
+export declare function buildS3Key(basePrefix: string, fileName: string, d?: Date): string;
+/**
+ * S3 클라이언트 생성
+ */
+export declare function createS3Client(config?: S3Config): S3Client;
+/**
+ * S3 객체 가져오기
+ */
+export declare function getObject(s3Client: S3Client, params: {
+    key: string;
+    bucket: string;
+    downloadFileName?: string;
+}): Promise<import("@aws-sdk/client-s3").GetObjectCommandOutput>;
+/**
+ * PDF 버퍼 업로드
+ */
+export declare function uploadPdfBuffer(s3Client: S3Client, params: {
+    basePrefix: string;
+    fileName: string;
+    body: Buffer;
+    bucket: string;
+}): Promise<{
+    bucket: string;
+    key: string;
+}>;
+/**
+ * 일반 파일 업로드
+ */
+export declare function uploadFile(s3Client: S3Client, params: {
+    key: string;
+    body: Buffer | string;
+    bucket: string;
+    contentType?: string;
+}): Promise<{
+    bucket: string;
+    key: string;
+}>;
+/**
+ * Presigned 다운로드 URL 생성
+ */
+export declare function getPresignedDownloadUrl(s3Client: S3Client, params: {
+    key: string;
+    bucket: string;
+    expiresInSec?: number;
+    downloadFileName?: string;
+}): Promise<string>;
+/**
+ * S3 객체 삭제
+ */
+export declare function deleteObjectByKey(s3Client: S3Client, params: {
+    key: string;
+    bucket: string;
+}): Promise<void>;
+/**
+ * URL에서 S3 키 추출
+ */
+export declare function extractKeyFromUrl(urlOrKey: string, bucket: string): string;
+/**
+ * S3 객체 URL 생성
+ */
+export declare function buildObjectUrl(key: string, bucket: string, region?: string): string;

package/dist/modules/storage/s3.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDatePrefix = getDatePrefix;
+exports.buildS3Key = buildS3Key;
+exports.createS3Client = createS3Client;
+exports.getObject = getObject;
+exports.uploadPdfBuffer = uploadPdfBuffer;
+exports.uploadFile = uploadFile;
+exports.getPresignedDownloadUrl = getPresignedDownloadUrl;
+exports.deleteObjectByKey = deleteObjectByKey;
+exports.extractKeyFromUrl = extractKeyFromUrl;
+exports.buildObjectUrl = buildObjectUrl;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+/**
+ * 날짜 기반 접두사 생성 (YYYY/MM/DD)
+ */
+function getDatePrefix(d = new Date()) {
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    return `${yyyy}/${mm}/${dd}`;
+}
+/**
+ * S3 키 생성
+ */
+function buildS3Key(basePrefix, fileName, d = new Date()) {
+    return `${basePrefix}/${getDatePrefix(d)}/${fileName}`;
+}
+/**
+ * S3 클라이언트 생성
+ */
+function createS3Client(config = {}) {
+    const region = config.region || process.env.AWS_REGION || 'ap-northeast-2';
+    const accessKeyId = config.accessKeyId || process.env.S3_ACCESS_KEY || '';
+    const secretAccessKey = config.secretAccessKey || process.env.S3_SECRET_KEY || '';
+    return new client_s3_1.S3Client({
+        region,
+        credentials: {
+            accessKeyId,
+            secretAccessKey,
+        },
+    });
+}
+/**
+ * S3 객체 가져오기
+ */
+async function getObject(s3Client, params) {
+    const command = new client_s3_1.GetObjectCommand({
+        Bucket: params.bucket,
+        Key: params.key,
+    });
+    return await s3Client.send(command);
+}
+/**
+ * PDF 버퍼 업로드
+ */
+async function uploadPdfBuffer(s3Client, params) {
+    const key = buildS3Key(params.basePrefix, params.fileName);
+    await s3Client.send(new client_s3_1.PutObjectCommand({
+        Bucket: params.bucket,
+        Key: key,
+        Body: params.body,
+        ContentType: 'application/pdf',
+    }));
+    return { bucket: params.bucket, key };
+}
+/**
+ * 일반 파일 업로드
+ */
+async function uploadFile(s3Client, params) {
+    await s3Client.send(new client_s3_1.PutObjectCommand({
+        Bucket: params.bucket,
+        Key: params.key,
+        Body: params.body,
+        ContentType: params.contentType || 'application/octet-stream',
+    }));
+    return { bucket: params.bucket, key: params.key };
+}
+/**
+ * Presigned 다운로드 URL 생성
+ */
+async function getPresignedDownloadUrl(s3Client, params) {
+    const command = new client_s3_1.GetObjectCommand({
+        Bucket: params.bucket,
+        Key: params.key,
+        ResponseContentType: 'application/pdf',
+        ResponseContentDisposition: params.downloadFileName
+            ? `attachment; filename="${params.downloadFileName}"`
+            : 'attachment',
+    });
+    const url = await (0, s3_request_presigner_1.getSignedUrl)(s3Client, command, {
+        expiresIn: params.expiresInSec || 3600,
+    });
+    return url;
+}
+/**
+ * S3 객체 삭제
+ */
+async function deleteObjectByKey(s3Client, params) {
+    await s3Client.send(new client_s3_1.DeleteObjectCommand({
+        Bucket: params.bucket,
+        Key: params.key,
+    }));
+}
+/**
+ * URL에서 S3 키 추출
+ */
+function extractKeyFromUrl(urlOrKey, bucket) {
+    if (!/^https?:\/\//i.test(urlOrKey)) {
+        return urlOrKey.replace(/^\//, '');
+    }
+    try {
+        const u = new URL(urlOrKey);
+        let p = u.pathname || '';
+        if (p.startsWith('/'))
+            p = p.slice(1);
+        if (p.startsWith(`${bucket}/`)) {
+            p = p.slice(bucket.length + 1);
+        }
+        return p;
+    }
+    catch (_) {
+        return urlOrKey;
+    }
+}
+/**
+ * S3 객체 URL 생성
+ */
+function buildObjectUrl(key, bucket, region) {
+    const r = region || process.env.AWS_REGION || 'ap-northeast-2';
+    return `https://${bucket}.s3.${r}.amazonaws.com/${key}`;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * 날짜/시간 유틸리티
+ *
+ * zium-backend의 commonUtil.ts를 기반으로 작성되었습니다.
+ */
+/**
+ * UTC를 한국 시간(KST) 문자열로 변환
+ * @param date Date 객체
+ * @returns "YYYY-MM-DD HH:mm:ss" 형식의 문자열
+ */
+export declare function convertUTCtoKST(date: Date): string;
+/**
+ * 한국 시간 문자열을 Date 객체로 변환
+ * @param dateStr "2024-01-15"
+ * @param timeStr "14:30"
+ * @returns Date 객체 (한국 시간 기준)
+ */
+export declare function convertKSTtoDate(dateStr: string, timeStr: string): Date;
+/**
+ * 한국 시간 Date 객체 생성
+ * @param dateStr "2024-01-15"
+ * @param timeStr "14:30"
+ * @returns Date 객체 (한국 시간으로 설정됨)
+ */
+export declare function createKoreaDate(dateStr: string, timeStr: string): Date;
+/**
+ * 현재 한국 시간 반환
+ * @returns Date 객체
+ */
+export declare function getCurrentKoreaTime(): Date;
+/**
+ * Date 객체를 한국 시간 문자열로 변환
+ * @param date Date 객체
+ * @param format "datetime" | "date" | "time"
+ * @returns 포맷된 한국 시간 문자열
+ */
+export declare function formatKoreaTime(date: Date, format?: 'datetime' | 'date' | 'time'): string;

package/dist/modules/utils/date.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * 날짜/시간 유틸리티
+ *
+ * zium-backend의 commonUtil.ts를 기반으로 작성되었습니다.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertUTCtoKST = convertUTCtoKST;
+exports.convertKSTtoDate = convertKSTtoDate;
+exports.createKoreaDate = createKoreaDate;
+exports.getCurrentKoreaTime = getCurrentKoreaTime;
+exports.formatKoreaTime = formatKoreaTime;
+/**
+ * UTC를 한국 시간(KST) 문자열로 변환
+ * @param date Date 객체
+ * @returns "YYYY-MM-DD HH:mm:ss" 형식의 문자열
+ */
+function convertUTCtoKST(date) {
+    if (!(date instanceof Date) || isNaN(date.getTime()))
+        return '';
+    const kstDate = new Date(date.getTime() + 9 * 60 * 60 * 1000);
+    return kstDate.toISOString().replace('T', ' ').substring(0, 19);
+}
+/**
+ * 한국 시간 문자열을 Date 객체로 변환
+ * @param dateStr "2024-01-15"
+ * @param timeStr "14:30"
+ * @returns Date 객체 (한국 시간 기준)
+ */
+function convertKSTtoDate(dateStr, timeStr) {
+    const combined = `${dateStr} ${timeStr}:00`;
+    const koreaTime = new Date(combined);
+    // 한국 시간을 UTC로 변환 (9시간 빼기)
+    return new Date(koreaTime.getTime() - 9 * 60 * 60 * 1000);
+}
+/**
+ * 한국 시간 Date 객체 생성
+ * @param dateStr "2024-01-15"
+ * @param timeStr "14:30"
+ * @returns Date 객체 (한국 시간으로 설정됨)
+ */
+function createKoreaDate(dateStr, timeStr) {
+    const [year, month, day] = dateStr.split('-').map(Number);
+    const [hours, minutes] = timeStr.split(':').map(Number);
+    // UTC 기준으로 생성하여 formatKoreaTime과 호환
+    return new Date(Date.UTC(year, month - 1, day, hours, minutes, 0, 0));
+}
+/**
+ * 현재 한국 시간 반환
+ * @returns Date 객체
+ */
+function getCurrentKoreaTime() {
+    return new Date();
+}
+/**
+ * Date 객체를 한국 시간 문자열로 변환
+ * @param date Date 객체
+ * @param format "datetime" | "date" | "time"
+ * @returns 포맷된 한국 시간 문자열
+ */
+function formatKoreaTime(date, format = 'datetime') {
+    const kstString = convertUTCtoKST(date);
+    switch (format) {
+        case 'date':
+            return kstString.split(' ')[0]; // "2024-01-15"
+        case 'time':
+            return kstString.split(' ')[1]; // "14:30:00"
+        case 'datetime':
+        default:
+            return kstString; // "2024-01-15 14:30:00"
+    }
+}

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

@@ -0,0 +1,44 @@
+import { LodashUtils } from './lodash';
+/**
+ * UtilsModule - 공통 유틸리티 모듈
+ */
+export declare class UtilsModule {
+    readonly date: DateUtils;
+    readonly password: PasswordUtils;
+    readonly response: ResponseUtils;
+    readonly validation: ValidationUtils;
+    readonly pk: PKUtils;
+    readonly lodash: LodashUtils;
+    constructor();
+}
+export declare class DateUtils {
+    convertUTCtoKST(date: Date): string;
+    convertKSTtoDate(dateStr: string, timeStr: string): Date;
+    createKoreaDate(dateStr: string, timeStr: string): Date;
+    getCurrentKoreaTime(): Date;
+    formatKoreaTime(date: Date, format?: 'datetime' | 'date' | 'time'): string;
+}
+export declare class PasswordUtils {
+    bcrypt(password: string): Promise<string>;
+    check(password: string, hash: string): Promise<boolean>;
+    crypto(password: string): Promise<string | null>;
+    decrypt(encryptedPassword: string): string | null;
+    generate(length?: number): string;
+}
+export declare class ResponseUtils {
+    success(data: any): any;
+    error(code: number, message?: string): any;
+    safeResponse(data: any): any;
+}
+export declare class ValidationUtils {
+    isEmail(email: string): boolean;
+    isPassword(password: string, options?: any): boolean;
+    isPhone(phone: string): boolean;
+    isNotEmpty(str: string): boolean;
+    isNumber(value: any): boolean;
+    isURL(url: string): boolean;
+}
+export declare class PKUtils {
+    make(convertStr?: string): Promise<string>;
+    makeWithLength(length: number, prefix?: string): Promise<string>;
+}

package/dist/modules/utils/index.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PKUtils = exports.ValidationUtils = exports.ResponseUtils = exports.PasswordUtils = exports.DateUtils = exports.UtilsModule = void 0;
+const dateUtils = __importStar(require("./date"));
+const passwordUtils = __importStar(require("./password"));
+const responseUtils = __importStar(require("./response"));
+const validationUtils = __importStar(require("./validation"));
+const pkUtils = __importStar(require("./pk"));
+const lodash_1 = require("./lodash");
+/**
+ * UtilsModule - 공통 유틸리티 모듈
+ */
+class UtilsModule {
+    constructor() {
+        this.date = new DateUtils();
+        this.password = new PasswordUtils();
+        this.response = new ResponseUtils();
+        this.validation = new ValidationUtils();
+        this.pk = new PKUtils();
+        this.lodash = new lodash_1.LodashUtils();
+    }
+}
+exports.UtilsModule = UtilsModule;
+// 날짜 유틸리티 클래스
+class DateUtils {
+    convertUTCtoKST(date) {
+        return dateUtils.convertUTCtoKST(date);
+    }
+    convertKSTtoDate(dateStr, timeStr) {
+        return dateUtils.convertKSTtoDate(dateStr, timeStr);
+    }
+    createKoreaDate(dateStr, timeStr) {
+        return dateUtils.createKoreaDate(dateStr, timeStr);
+    }
+    getCurrentKoreaTime() {
+        return dateUtils.getCurrentKoreaTime();
+    }
+    formatKoreaTime(date, format = 'datetime') {
+        return dateUtils.formatKoreaTime(date, format);
+    }
+}
+exports.DateUtils = DateUtils;
+// 비밀번호 유틸리티 클래스
+class PasswordUtils {
+    async bcrypt(password) {
+        return passwordUtils.bcryptPassword(password);
+    }
+    async check(password, hash) {
+        return passwordUtils.checkPassword(password, hash);
+    }
+    async crypto(password) {
+        return passwordUtils.cryptoPassword(password);
+    }
+    decrypt(encryptedPassword) {
+        return passwordUtils.decryptPassword(encryptedPassword);
+    }
+    generate(length = 12) {
+        return passwordUtils.generatePassword(length);
+    }
+}
+exports.PasswordUtils = PasswordUtils;
+// 응답 유틸리티 클래스
+class ResponseUtils {
+    success(data) {
+        return responseUtils.success(data);
+    }
+    error(code, message) {
+        return responseUtils.error(code, message);
+    }
+    safeResponse(data) {
+        return responseUtils.safeResponse(data);
+    }
+}
+exports.ResponseUtils = ResponseUtils;
+// 검증 유틸리티 클래스
+class ValidationUtils {
+    isEmail(email) {
+        return validationUtils.isEmail(email);
+    }
+    isPassword(password, options) {
+        return validationUtils.isPassword(password, options);
+    }
+    isPhone(phone) {
+        return validationUtils.isPhone(phone);
+    }
+    isNotEmpty(str) {
+        return validationUtils.isNotEmpty(str);
+    }
+    isNumber(value) {
+        return validationUtils.isNumber(value);
+    }
+    isURL(url) {
+        return validationUtils.isURL(url);
+    }
+}
+exports.ValidationUtils = ValidationUtils;
+// PK 생성 유틸리티 클래스
+class PKUtils {
+    async make(convertStr) {
+        return pkUtils.makePK(convertStr);
+    }
+    async makeWithLength(length, prefix = '') {
+        return pkUtils.makePKWithLength(length, prefix);
+    }
+}
+exports.PKUtils = PKUtils;

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

@@ -0,0 +1,107 @@
+import _ from 'lodash';
+/**
+ * Lodash 유틸리티 래퍼
+ *
+ * company-common-utils를 참고하여 작성되었습니다.
+ * 모든 lodash 함수에 직접 접근할 수 있도록 제공합니다.
+ */
+export declare class LodashUtils {
+    /**
+     * lodash 인스턴스 직접 접근
+     */
+    get _(): _.LoDashStatic;
+    /**
+     * 객체 깊은 복사
+     */
+    deepClone<T>(value: T): T;
+    /**
+     * 객체 병합
+     */
+    merge<T extends object>(target: T, ...sources: Partial<T>[]): T;
+    /**
+     * 배열에서 중복 제거
+     */
+    uniq<T>(array: T[]): T[];
+    /**
+     * 객체에서 특정 경로의 값 가져오기
+     */
+    get<T>(object: any, path: string, defaultValue?: T): T;
+    /**
+     * 객체에 특정 경로로 값 설정
+     */
+    set<T>(object: any, path: string, value: T): any;
+    /**
+     * 배열 그룹화
+     */
+    groupBy<T>(collection: T[], iteratee: string | ((item: T) => string)): Record<string, T[]>;
+    /**
+     * 디바운스 함수
+     */
+    debounce<T extends (...args: any[]) => any>(func: T, wait: number, options?: _.DebounceSettings): _.DebouncedFunc<T>;
+    /**
+     * 스로틀 함수
+     */
+    throttle<T extends (...args: any[]) => any>(func: T, wait: number, options?: _.ThrottleSettings): _.DebouncedFunc<T>;
+    /**
+     * 배열에서 특정 조건으로 필터링
+     */
+    filter<T>(collection: T[], predicate: ((item: T) => boolean) | string | object): T[];
+    /**
+     * 배열에서 특정 조건으로 찾기
+     */
+    find<T>(collection: T[], predicate: ((item: T) => boolean) | string | object): T | undefined;
+    /**
+     * 배열에서 특정 조건으로 매핑
+     */
+    map<T, U>(collection: T[], iteratee: ((item: T) => U) | string | number): U[];
+    /**
+     * 배열에서 특정 조건으로 리듀스
+     */
+    reduce<T, U>(collection: T[], iteratee: (acc: U, value: T, index: number, collection: T[]) => U, accumulator: U): U;
+    /**
+     * 객체 키 순회
+     */
+    keys(object: object): string[];
+    /**
+     * 객체 값 순회
+     */
+    values<T>(object: {
+        [key: string]: T;
+    }): T[];
+    /**
+     * 객체가 비어있는지 확인
+     */
+    isEmpty(value: any): boolean;
+    /**
+     * 객체 병합 (assign과 유사)
+     */
+    assign<T extends object>(target: T, ...sources: Partial<T>[]): T;
+    /**
+     * 객체 키-값 쌍으로 변환
+     */
+    toPairs<T>(object: {
+        [key: string]: T;
+    }): [string, T][];
+    /**
+     * 키-값 쌍에서 객체로 변환
+     */
+    fromPairs<T>(pairs: [string, T][]): {
+        [key: string]: T;
+    };
+    /**
+     * 배열을 청크로 나누기
+     */
+    chunk<T>(array: T[], size: number): T[][];
+    /**
+     * 배열에서 특정 값 제거
+     */
+    without<T>(array: T[], ...values: T[]): T[];
+    /**
+     * 배열 평탄화
+     */
+    flatten<T>(array: (T | T[])[]): any[];
+    /**
+     * 배열 깊이 평탄화
+     */
+    flattenDeep<T>(array: any[]): any[];
+}