@hamjimin/xplat-back 0.1.0 → 0.2.0

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

@@ -0,0 +1,30 @@
+import { DetailSearch, SortQueryData, ColumnMapper } from './query-builder';
+/**
+ * ORMModule - ORM 쿼리 빌더 모듈
+ */
+export declare class ORMModule {
+    /**
+     * WHERE 조건 문자열 생성
+     */
+    getWhereString(columnAlias: string, operator: string, value: any): string | null;
+    /**
+     * 정렬 문자열 생성
+     */
+    getSortString(columnAlias: string, operator: string): string;
+    /**
+     * 상세검색 쿼리 생성 (WHERE 절)
+     */
+    createWhereQuery(detailSearch: DetailSearch, columnMapper?: ColumnMapper): string;
+    /**
+     * 정렬 쿼리 생성 (ORDER BY 절)
+     */
+    createSortQuery(sortData: SortQueryData, columnMapper?: ColumnMapper): string;
+    /**
+     * WHERE 절을 기존 쿼리에 추가
+     */
+    appendWhereClause(query: string, whereQuery: string): string;
+    /**
+     * ORDER BY 절을 기존 쿼리에 추가
+     */
+    appendOrderClause(query: string, orderQuery: string, defaultOrder?: string): string;
+}

package/dist/modules/orm/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORMModule = void 0;
+const query_builder_1 = require("./query-builder");
+/**
+ * ORMModule - ORM 쿼리 빌더 모듈
+ */
+class ORMModule {
+    /**
+     * WHERE 조건 문자열 생성
+     */
+    getWhereString(columnAlias, operator, value) {
+        return (0, query_builder_1.getWhereString)(columnAlias, operator, value);
+    }
+    /**
+     * 정렬 문자열 생성
+     */
+    getSortString(columnAlias, operator) {
+        return (0, query_builder_1.getSortString)(columnAlias, operator);
+    }
+    /**
+     * 상세검색 쿼리 생성 (WHERE 절)
+     */
+    createWhereQuery(detailSearch, columnMapper) {
+        return (0, query_builder_1.createWhereQuery)(detailSearch, columnMapper);
+    }
+    /**
+     * 정렬 쿼리 생성 (ORDER BY 절)
+     */
+    createSortQuery(sortData, columnMapper) {
+        return (0, query_builder_1.createSortQuery)(sortData, columnMapper);
+    }
+    /**
+     * WHERE 절을 기존 쿼리에 추가
+     */
+    appendWhereClause(query, whereQuery) {
+        return (0, query_builder_1.appendWhereClause)(query, whereQuery);
+    }
+    /**
+     * ORDER BY 절을 기존 쿼리에 추가
+     */
+    appendOrderClause(query, orderQuery, defaultOrder = 'ORDER BY 1') {
+        return (0, query_builder_1.appendOrderClause)(query, orderQuery, defaultOrder);
+    }
+}
+exports.ORMModule = ORMModule;

package/dist/modules/orm/query-builder.d.ts

@@ -0,0 +1,68 @@
+/**
+ * ORM 쿼리 빌더 유틸리티
+ *
+ * zium-backend의 ormUtil.ts를 기반으로 작성되었습니다.
+ * searchData를 기준으로 검색 쿼리문을 생성합니다.
+ */
+export interface SearchDataItem {
+    column: string | string[];
+    operator: string;
+    value: any;
+}
+export interface DetailSearch {
+    condition?: 'AND' | 'OR';
+    searchData: SearchDataItem[];
+    type?: string;
+}
+export interface SortDataItem {
+    column: string | string[];
+    operator: 'ASC' | 'DESC';
+}
+export interface SortQueryData {
+    sortData: SortDataItem[];
+}
+/**
+ * 컬럼 alias 매핑 함수 타입
+ * 사용자가 직접 제공하거나 기본 매핑 사용
+ */
+export type ColumnMapper = (column: string, type?: string) => string;
+/**
+ * WHERE 조건 문자열 생성
+ * @param columnAlias 컬럼 alias (예: "member.memberName")
+ * @param operator 연산자 (LIKE, IN, BETWEEN, ISNULL, != 등)
+ * @param value 값
+ * @returns WHERE 조건 문자열
+ */
+export declare function getWhereString(columnAlias: string, operator: string, value: any): string | null;
+/**
+ * 정렬 문자열 생성
+ * @param columnAlias 컬럼 alias
+ * @param operator ASC 또는 DESC
+ * @returns 정렬 문자열
+ */
+export declare function getSortString(columnAlias: string, operator: string): string;
+/**
+ * 상세검색 쿼리 생성 (WHERE 절)
+ * @param detailSearch 검색 조건
+ * @param columnMapper 컬럼 매핑 함수 (선택사항)
+ * @returns WHERE 절 문자열
+ */
+export declare function createWhereQuery(detailSearch: DetailSearch, columnMapper?: ColumnMapper): string;
+/**
+ * 정렬 쿼리 생성 (ORDER BY 절)
+ * @param sortData 정렬 조건
+ * @param columnMapper 컬럼 매핑 함수 (선택사항)
+ * @returns ORDER BY 절 문자열
+ */
+export declare function createSortQuery(sortData: SortQueryData, columnMapper?: ColumnMapper): string;
+/**
+ * WHERE 절을 기존 쿼리에 추가
+ */
+export declare function appendWhereClause(query: string, whereQuery: string): string;
+/**
+ * ORDER BY 절을 기존 쿼리에 추가
+ * @param query 기존 쿼리
+ * @param orderQuery ORDER BY 절
+ * @param defaultOrder 기본 ORDER BY 절 (대체될 문자열)
+ */
+export declare function appendOrderClause(query: string, orderQuery: string, defaultOrder?: string): string;

package/dist/modules/orm/query-builder.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * ORM 쿼리 빌더 유틸리티
+ *
+ * zium-backend의 ormUtil.ts를 기반으로 작성되었습니다.
+ * searchData를 기준으로 검색 쿼리문을 생성합니다.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWhereString = getWhereString;
+exports.getSortString = getSortString;
+exports.createWhereQuery = createWhereQuery;
+exports.createSortQuery = createSortQuery;
+exports.appendWhereClause = appendWhereClause;
+exports.appendOrderClause = appendOrderClause;
+/**
+ * WHERE 조건 문자열 생성
+ * @param columnAlias 컬럼 alias (예: "member.memberName")
+ * @param operator 연산자 (LIKE, IN, BETWEEN, ISNULL, != 등)
+ * @param value 값
+ * @returns WHERE 조건 문자열
+ */
+function getWhereString(columnAlias, operator, value) {
+    const operators = operator.toUpperCase();
+    // PHONE 컬럼 처리 (숫자만 추출)
+    if (columnAlias.includes('PHONE')) {
+        if (value !== null && value !== undefined) {
+            const valueStr = String(value);
+            const hasNumber = /[0-9]/.test(valueStr);
+            if (!hasNumber) {
+                return null; // 숫자가 없는 경우 null 반환하여 조건에서 제외
+            }
+            value = valueStr.replace(/[^0-9]/g, '');
+        }
+    }
+    switch (operators) {
+        case 'LIKE':
+            if (Array.isArray(value)) {
+                // 배열로 들어온 경우 각 값에 대해 LIKE 조건을 생성하고 OR로 연결
+                return `(${value.map((v) => `${columnAlias} LIKE '%${v}%'`).join(' OR ')})`;
+            }
+            else if (typeof value === 'string') {
+                // 문자열로 들어온 경우 "value1,value2" -> ['value1', 'value2']
+                const values = value.split(',').map((v) => v.trim());
+                return `(${values.map((v) => `${columnAlias} LIKE '%${v}%'`).join(' OR ')})`;
+            }
+            else {
+                return `${columnAlias} LIKE '%${value}%'`;
+            }
+        case 'IN':
+            let processedValues;
+            if (Array.isArray(value)) {
+                processedValues = value;
+            }
+            else if (typeof value === 'string') {
+                processedValues = value.split(',').map((v) => v.trim());
+            }
+            else {
+                processedValues = [value];
+            }
+            // 빈 값 제거 및 각 값을 개별적으로 따옴표로 감싸기
+            const sanitizedValues = processedValues
+                .filter((v) => v !== null && v !== undefined && v !== '')
+                .map((v) => {
+                const s = typeof v === 'string' ? v : String(v);
+                return `'${s.replace(/'/g, "''")}'`;
+            });
+            if (sanitizedValues.length === 0) {
+                return `${columnAlias} IN (NULL)`;
+            }
+            return `${columnAlias} IN (${sanitizedValues.join(',')})`;
+        case 'NOTIN':
+            let processedValuesNotIn = [];
+            if (Array.isArray(value)) {
+                processedValuesNotIn = value;
+            }
+            else if (typeof value === 'string') {
+                processedValuesNotIn = value.split(',').map((v) => v.trim());
+            }
+            else {
+                processedValuesNotIn = [value];
+            }
+            const sanitizedValuesNotIn = processedValuesNotIn
+                .filter((v) => v !== null && v !== undefined && v !== '')
+                .map((v) => {
+                const s = typeof v === 'string' ? v : String(v);
+                return `'${s.replace(/'/g, "''")}'`;
+            });
+            if (sanitizedValuesNotIn.length === 0) {
+                return `${columnAlias} NOT IN (NULL)`;
+            }
+            return `${columnAlias} NOT IN (${sanitizedValuesNotIn.join(',')})`;
+        case 'BETWEEN':
+            if (Array.isArray(value) && value.length === 2) {
+                const hasTime = (dateStr) => /\d{2}:\d{2}:\d{2}/.test(dateStr);
+                let startDate = value[0];
+                let endDate = value[1];
+                if (!hasTime(startDate)) {
+                    startDate = `${startDate} 00:00:00`;
+                }
+                if (!hasTime(endDate)) {
+                    endDate = `${endDate} 23:59:59`;
+                }
+                if (startDate === endDate) {
+                    endDate = endDate.replace('00:00:00', '23:59:59');
+                }
+                return `${columnAlias} BETWEEN '${startDate}' AND '${endDate}'`;
+            }
+            return `${columnAlias} = '${value}'`;
+        case 'ISNULL':
+            return `${columnAlias} IS NULL`;
+        case 'ISNOTNULL':
+            return `${columnAlias} IS NOT NULL`;
+        case '!=':
+        case 'NOT EQUAL':
+            return `${columnAlias} != '${value}'`;
+        default:
+            return `${columnAlias} = '${value}'`;
+    }
+}
+/**
+ * 정렬 문자열 생성
+ * @param columnAlias 컬럼 alias
+ * @param operator ASC 또는 DESC
+ * @returns 정렬 문자열
+ */
+function getSortString(columnAlias, operator) {
+    return `${columnAlias} ${operator}`;
+}
+/**
+ * 상세검색 쿼리 생성 (WHERE 절)
+ * @param detailSearch 검색 조건
+ * @param columnMapper 컬럼 매핑 함수 (선택사항)
+ * @returns WHERE 절 문자열
+ */
+function createWhereQuery(detailSearch, columnMapper) {
+    if (!detailSearch || !detailSearch.searchData) {
+        return '';
+    }
+    const { condition = 'AND', searchData, type = '' } = detailSearch;
+    let query = '';
+    if (!Array.isArray(searchData)) {
+        return '';
+    }
+    // 기본 매핑 함수 (컬럼명 그대로 반환)
+    const defaultMapper = (col) => col;
+    const mapper = columnMapper || defaultMapper;
+    // searchData의 각 조건을 처리
+    searchData.forEach((search) => {
+        if (!search.column) {
+            return;
+        }
+        const columns = Array.isArray(search.column) ? search.column : [search.column];
+        const { operator, value } = search;
+        // 각 조건을 괄호로 묶어 처리
+        const conditions = columns
+            .map((col) => {
+            const columnAlias = mapper(col, type);
+            // columnAlias가 원본 column과 같다면 매핑 실패로 판단하고 건너뛰기
+            if (columnAlias === col && columnMapper) {
+                return null;
+            }
+            return getWhereString(columnAlias, operator, value);
+        })
+            .filter((condition) => condition !== null); // null 값 제거
+        // 유효한 조건이 있는 경우에만 쿼리에 추가
+        if (conditions.length > 0) {
+            if (query) {
+                query += ` ${condition} `;
+            }
+            else {
+                query += ' AND ';
+            }
+            query += `(${conditions.join(' OR ')})`;
+        }
+    });
+    return query;
+}
+/**
+ * 정렬 쿼리 생성 (ORDER BY 절)
+ * @param sortData 정렬 조건
+ * @param columnMapper 컬럼 매핑 함수 (선택사항)
+ * @returns ORDER BY 절 문자열
+ */
+function createSortQuery(sortData, columnMapper) {
+    if (!sortData || !sortData.sortData) {
+        return '';
+    }
+    const { sortData: sorts } = sortData;
+    let query = '';
+    if (!Array.isArray(sorts)) {
+        return '';
+    }
+    // 기본 매핑 함수
+    const defaultMapper = (col) => col;
+    const mapper = columnMapper || defaultMapper;
+    // sortData의 각 조건을 처리
+    sorts.forEach((sort) => {
+        if (!sort.column) {
+            return;
+        }
+        const columns = Array.isArray(sort.column) ? sort.column : [sort.column];
+        const { operator } = sort;
+        // 각 컬럼에 대한 정렬 조건 처리
+        const sortConditions = columns
+            .map((col) => {
+            const columnAlias = mapper(col);
+            // columnAlias가 원본 column과 같다면 매핑 실패로 판단하고 건너뛰기
+            if (columnAlias === col && columnMapper) {
+                return null;
+            }
+            return getSortString(columnAlias, operator);
+        })
+            .filter((condition) => condition !== null); // null 값 제거
+        // 유효한 조건이 있는 경우에만 쿼리에 추가
+        if (sortConditions.length > 0) {
+            if (query) {
+                query += ', ';
+            }
+            query += sortConditions.join(', ');
+        }
+    });
+    return query ? ` ORDER BY ${query}` : '';
+}
+/**
+ * WHERE 절을 기존 쿼리에 추가
+ */
+function appendWhereClause(query, whereQuery) {
+    return query.replace('WHERE 1 = 1', `WHERE 1 = 1 ${whereQuery}`);
+}
+/**
+ * ORDER BY 절을 기존 쿼리에 추가
+ * @param query 기존 쿼리
+ * @param orderQuery ORDER BY 절
+ * @param defaultOrder 기본 ORDER BY 절 (대체될 문자열)
+ */
+function appendOrderClause(query, orderQuery, defaultOrder = 'ORDER BY 1') {
+    return query.replace(defaultOrder, orderQuery || defaultOrder);
+}

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

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+/**
+ * RouterModule - 라우터 생성 모듈
+ */
+export declare class RouterModule {
+    /**
+     * 파일 기반 라우터 생성
+     */
+    create(directory: string): Router;
+}

package/dist/modules/router/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterModule = void 0;
+const route_factory_1 = require("./route-factory");
+/**
+ * RouterModule - 라우터 생성 모듈
+ */
+class RouterModule {
+    /**
+     * 파일 기반 라우터 생성
+     */
+    create(directory) {
+        return (0, route_factory_1.createRouter)(directory);
+    }
+}
+exports.RouterModule = RouterModule;

package/dist/modules/router/route-factory.d.ts

@@ -0,0 +1,10 @@
+import express from 'express';
+/**
+ * 파일 경로 기준 동적 라우터 생성
+ *
+ * 디렉토리 구조를 API endpoint로 자동 매핑합니다.
+ *
+ * @param directory - 라우트 파일들이 위치한 루트 디렉토리
+ * @returns Express Router 인스턴스
+ */
+export declare function createRouter(directory: string): express.Router;

package/dist/modules/router/route-factory.js

@@ -0,0 +1,72 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouter = createRouter;
+const express_1 = __importDefault(require("express"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * 파일 경로 기준 동적 라우터 생성
+ *
+ * 디렉토리 구조를 API endpoint로 자동 매핑합니다.
+ *
+ * @param directory - 라우트 파일들이 위치한 루트 디렉토리
+ * @returns Express Router 인스턴스
+ */
+function createRouter(directory) {
+    const router = express_1.default.Router();
+    const files = fs.readdirSync(directory);
+    for (const file of files) {
+        const filePath = path.join(directory, file);
+        if (fs.statSync(filePath).isDirectory()) {
+            // 디렉토리인 경우 재귀적으로 라우터 생성
+            const subRouter = createRouter(filePath);
+            router.use(`/${file}`, subRouter);
+        }
+        else {
+            // 파일인 경우 라우터 생성
+            if (file.endsWith('.ts') || file.endsWith('.js')) {
+                const routePath = `/${file.replace('.ts', '').replace('.js', '')}`;
+                const required = require(filePath);
+                const routeModule = required.default || required;
+                router.use(routePath, routeModule);
+            }
+        }
+    }
+    return router;
+}

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

@@ -0,0 +1,81 @@
+import { S3Config } from './s3';
+/**
+ * StorageModule - 스토리지 관리 모듈
+ */
+export declare class StorageModule {
+    private s3Client;
+    private config;
+    constructor(config?: S3Config);
+    /**
+     * S3 클라이언트 가져오기 (싱글톤)
+     */
+    private getS3Client;
+    /**
+     * S3 클라이언트 재설정
+     */
+    setConfig(config: S3Config): void;
+    /**
+     * 날짜 기반 접두사 생성
+     */
+    getDatePrefix(date?: Date): string;
+    /**
+     * S3 키 생성
+     */
+    buildKey(basePrefix: string, fileName: string, date?: Date): string;
+    /**
+     * 파일 업로드
+     */
+    upload(params: {
+        key: string;
+        body: Buffer | string;
+        bucket: string;
+        contentType?: string;
+    }): Promise<{
+        bucket: string;
+        key: string;
+    }>;
+    /**
+     * PDF 버퍼 업로드
+     */
+    uploadPdf(params: {
+        basePrefix: string;
+        fileName: string;
+        body: Buffer;
+        bucket: string;
+    }): Promise<{
+        bucket: string;
+        key: string;
+    }>;
+    /**
+     * 파일 다운로드
+     */
+    download(params: {
+        key: string;
+        bucket: string;
+        downloadFileName?: string;
+    }): Promise<import("@aws-sdk/client-s3").GetObjectCommandOutput>;
+    /**
+     * Presigned 다운로드 URL 생성
+     */
+    getDownloadUrl(params: {
+        key: string;
+        bucket: string;
+        expiresInSec?: number;
+        downloadFileName?: string;
+    }): Promise<string>;
+    /**
+     * 파일 삭제
+     */
+    delete(params: {
+        key: string;
+        bucket: string;
+    }): Promise<void>;
+    /**
+     * URL에서 키 추출
+     */
+    extractKey(urlOrKey: string, bucket?: string): string;
+    /**
+     * 객체 URL 생성
+     */
+    buildUrl(key: string, bucket?: string, region?: string): string;
+}

package/dist/modules/storage/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageModule = void 0;
+const s3_1 = require("./s3");
+/**
+ * StorageModule - 스토리지 관리 모듈
+ */
+class StorageModule {
+    constructor(config = {}) {
+        this.s3Client = null;
+        this.config = config;
+    }
+    /**
+     * S3 클라이언트 가져오기 (싱글톤)
+     */
+    getS3Client() {
+        if (!this.s3Client) {
+            this.s3Client = (0, s3_1.createS3Client)(this.config);
+        }
+        return this.s3Client;
+    }
+    /**
+     * S3 클라이언트 재설정
+     */
+    setConfig(config) {
+        this.config = config;
+        this.s3Client = null;
+    }
+    /**
+     * 날짜 기반 접두사 생성
+     */
+    getDatePrefix(date) {
+        return (0, s3_1.getDatePrefix)(date);
+    }
+    /**
+     * S3 키 생성
+     */
+    buildKey(basePrefix, fileName, date) {
+        return (0, s3_1.buildS3Key)(basePrefix, fileName, date);
+    }
+    /**
+     * 파일 업로드
+     */
+    async upload(params) {
+        return (0, s3_1.uploadFile)(this.getS3Client(), params);
+    }
+    /**
+     * PDF 버퍼 업로드
+     */
+    async uploadPdf(params) {
+        return (0, s3_1.uploadPdfBuffer)(this.getS3Client(), params);
+    }
+    /**
+     * 파일 다운로드
+     */
+    async download(params) {
+        return (0, s3_1.getObject)(this.getS3Client(), params);
+    }
+    /**
+     * Presigned 다운로드 URL 생성
+     */
+    async getDownloadUrl(params) {
+        return (0, s3_1.getPresignedDownloadUrl)(this.getS3Client(), params);
+    }
+    /**
+     * 파일 삭제
+     */
+    async delete(params) {
+        return (0, s3_1.deleteObjectByKey)(this.getS3Client(), params);
+    }
+    /**
+     * URL에서 키 추출
+     */
+    extractKey(urlOrKey, bucket) {
+        const b = bucket || this.config.bucket || process.env.S3_BUCKET || '';
+        return (0, s3_1.extractKeyFromUrl)(urlOrKey, b);
+    }
+    /**
+     * 객체 URL 생성
+     */
+    buildUrl(key, bucket, region) {
+        const b = bucket || this.config.bucket || process.env.S3_BUCKET || '';
+        return (0, s3_1.buildObjectUrl)(key, b, region);
+    }
+}
+exports.StorageModule = StorageModule;