@hamjimin/xplat-back 0.1.0 → 0.3.0

package/dist/modules/auth/index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthModule = void 0;
+const jwt_1 = require("./jwt");
+const middleware_1 = require("./middleware");
+/**
+ * AuthModule - 인증/인가 모듈
+ */
+class AuthModule {
+    /**
+     * JWT 토큰 생성
+     */
+    generateToken(payload, options) {
+        return (0, jwt_1.generateJWT)(payload, options);
+    }
+    /**
+     * JWT 토큰 검증
+     */
+    verifyToken(token, secret) {
+        return (0, jwt_1.verifyJWT)(token, secret);
+    }
+    /**
+     * Access Token과 Refresh Token 쌍 생성
+     */
+    createTokenPair(payload, accessTokenOptions, refreshTokenOptions) {
+        return (0, jwt_1.createTokenPair)(payload, accessTokenOptions, refreshTokenOptions);
+    }
+    /**
+     * 인증 미들웨어 생성
+     */
+    createMiddleware(options) {
+        return (0, middleware_1.createAuthMiddleware)(options);
+    }
+    /**
+     * 선택적 인증 미들웨어 생성 (토큰이 있으면 검증, 없으면 통과)
+     */
+    createOptionalMiddleware(options) {
+        return (0, middleware_1.createOptionalAuthMiddleware)(options);
+    }
+    /**
+     * 환경변수 기반 토큰 생성 (편의 메서드)
+     */
+    createTokenFromEnv(payload) {
+        const secret = process.env.JWT_SECRET || 'default-secret';
+        const accessTokenExpire = process.env.ACCESS_TOKEN_EXPIRE || '1h';
+        const refreshTokenExpire = process.env.REFRESH_TOKEN_EXPIRE || '7d';
+        return this.createTokenPair(payload, { secret, expiresIn: accessTokenExpire }, { secret, expiresIn: refreshTokenExpire });
+    }
+    /**
+     * 환경변수 기반 인증 미들웨어 생성 (편의 메서드)
+     */
+    createMiddlewareFromEnv(onSuccess, onError) {
+        const secret = process.env.JWT_SECRET || 'default-secret';
+        return this.createMiddleware({
+            secret,
+            onSuccess,
+            onError,
+        });
+    }
+}
+exports.AuthModule = AuthModule;

package/dist/modules/auth/jwt.d.ts

@@ -0,0 +1,40 @@
+/**
+ * JWT 토큰 생성/검증 유틸리티
+ *
+ * zium-backend의 util/jwt.ts를 기반으로 작성되었습니다.
+ */
+export interface TokenPayload {
+    id: string;
+    role?: string;
+    [key: string]: any;
+}
+export interface TokenOptions {
+    secret: string;
+    expiresIn: string | number;
+}
+export interface TokenPair {
+    accessToken: string;
+    refreshToken: string;
+}
+/**
+ * JWT 토큰 생성
+ * @param payload 토큰에 포함될 데이터
+ * @param options 토큰 옵션
+ * @returns JWT 토큰
+ */
+export declare function generateJWT(payload: TokenPayload, options: TokenOptions): string;
+/**
+ * JWT 토큰 검증
+ * @param token 검증할 토큰
+ * @param secret 시크릿 키
+ * @returns 디코딩된 페이로드 또는 null
+ */
+export declare function verifyJWT(token: string, secret: string): TokenPayload | null;
+/**
+ * Access Token과 Refresh Token 쌍 생성
+ * @param payload 토큰에 포함될 데이터
+ * @param accessTokenOptions Access Token 옵션
+ * @param refreshTokenOptions Refresh Token 옵션
+ * @returns 토큰 쌍
+ */
+export declare function createTokenPair(payload: TokenPayload, accessTokenOptions: TokenOptions, refreshTokenOptions: TokenOptions): TokenPair;

package/dist/modules/auth/jwt.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJWT = generateJWT;
+exports.verifyJWT = verifyJWT;
+exports.createTokenPair = createTokenPair;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+/**
+ * JWT 토큰 생성
+ * @param payload 토큰에 포함될 데이터
+ * @param options 토큰 옵션
+ * @returns JWT 토큰
+ */
+function generateJWT(payload, options) {
+    const { secret, expiresIn } = options;
+    return jsonwebtoken_1.default.sign(payload, secret, {
+        expiresIn: typeof expiresIn === 'number' ? expiresIn : expiresIn,
+    });
+}
+/**
+ * JWT 토큰 검증
+ * @param token 검증할 토큰
+ * @param secret 시크릿 키
+ * @returns 디코딩된 페이로드 또는 null
+ */
+function verifyJWT(token, secret) {
+    try {
+        const decoded = jsonwebtoken_1.default.verify(token, secret);
+        return decoded;
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Access Token과 Refresh Token 쌍 생성
+ * @param payload 토큰에 포함될 데이터
+ * @param accessTokenOptions Access Token 옵션
+ * @param refreshTokenOptions Refresh Token 옵션
+ * @returns 토큰 쌍
+ */
+function createTokenPair(payload, accessTokenOptions, refreshTokenOptions) {
+    return {
+        accessToken: generateJWT(payload, accessTokenOptions),
+        refreshToken: generateJWT(payload, refreshTokenOptions),
+    };
+}

package/dist/modules/auth/middleware.d.ts

@@ -0,0 +1,20 @@
+import { Request, Response, NextFunction } from 'express';
+import { TokenPayload } from './jwt';
+export interface AuthMiddlewareOptions {
+    secret: string;
+    tokenName?: string;
+    cookieName?: string;
+    onSuccess?: (req: Request, payload: TokenPayload) => void;
+    onError?: (req: Request, res: Response, error: Error) => void;
+}
+/**
+ * JWT 토큰 검증 미들웨어 생성
+ *
+ * @param options 인증 옵션
+ * @returns Express 미들웨어
+ */
+export declare function createAuthMiddleware(options: AuthMiddlewareOptions): (req: Request, res: Response, next: NextFunction) => void | Response<any, Record<string, any>>;
+/**
+ * 선택적 인증 미들웨어 (토큰이 있으면 검증, 없으면 통과)
+ */
+export declare function createOptionalAuthMiddleware(options: AuthMiddlewareOptions): (req: Request, res: Response, next: NextFunction) => void;

package/dist/modules/auth/middleware.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthMiddleware = createAuthMiddleware;
+exports.createOptionalAuthMiddleware = createOptionalAuthMiddleware;
+const jwt_1 = require("./jwt");
+const api_code_1 = require("../constants/api-code");
+/**
+ * JWT 토큰 검증 미들웨어 생성
+ *
+ * @param options 인증 옵션
+ * @returns Express 미들웨어
+ */
+function createAuthMiddleware(options) {
+    const { secret, tokenName = 'accessToken', cookieName = 'accessToken', onSuccess, onError, } = options;
+    return (req, res, next) => {
+        // 쿠키나 헤더에서 토큰 가져오기
+        let token = req.cookies[cookieName];
+        if (!token && req.headers.authorization) {
+            // Bearer 토큰 형식 지원
+            const authHeader = req.headers.authorization;
+            if (authHeader.startsWith('Bearer ')) {
+                token = authHeader.substring(7);
+            }
+        }
+        if (!token) {
+            const error = new Error('Token not provided');
+            if (onError) {
+                return onError(req, res, error);
+            }
+            return res.status(401).json({
+                ...(0, api_code_1.getApiCode)(1000),
+                message: 'Token not provided',
+            });
+        }
+        // 토큰 검증
+        const payload = (0, jwt_1.verifyJWT)(token, secret);
+        if (!payload) {
+            const error = new Error('Invalid token');
+            if (onError) {
+                return onError(req, res, error);
+            }
+            return res.status(401).json({
+                ...(0, api_code_1.getApiCode)(1000),
+                message: 'Invalid token',
+            });
+        }
+        // 요청 객체에 사용자 정보 추가
+        req.user = payload;
+        req[tokenName] = payload;
+        // 성공 콜백 실행
+        if (onSuccess) {
+            onSuccess(req, payload);
+        }
+        next();
+    };
+}
+/**
+ * 선택적 인증 미들웨어 (토큰이 있으면 검증, 없으면 통과)
+ */
+function createOptionalAuthMiddleware(options) {
+    const { secret, tokenName = 'accessToken', cookieName = 'accessToken', onSuccess, } = options;
+    return (req, res, next) => {
+        // 쿠키나 헤더에서 토큰 가져오기
+        let token = req.cookies[cookieName];
+        if (!token && req.headers.authorization) {
+            const authHeader = req.headers.authorization;
+            if (authHeader.startsWith('Bearer ')) {
+                token = authHeader.substring(7);
+            }
+        }
+        // 토큰이 없으면 그냥 통과
+        if (!token) {
+            return next();
+        }
+        // 토큰 검증
+        const payload = (0, jwt_1.verifyJWT)(token, secret);
+        if (payload) {
+            // 요청 객체에 사용자 정보 추가
+            req.user = payload;
+            req[tokenName] = payload;
+            // 성공 콜백 실행
+            if (onSuccess) {
+                onSuccess(req, payload);
+            }
+        }
+        next();
+    };
+}

package/dist/modules/constants/api-code.d.ts

@@ -0,0 +1,15 @@
+/**
+ * API 응답 코드 정의
+ *
+ * zium-backend의 api_code.ts를 기반으로 작성되었습니다.
+ */
+export interface ApiCode {
+    code: number;
+    msg: string;
+    message?: string;
+}
+export declare const API_CODE: Record<number, ApiCode>;
+/**
+ * API 코드 가져오기
+ */
+export declare function getApiCode(code: number): ApiCode;

package/dist/modules/constants/api-code.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * API 응답 코드 정의
+ *
+ * zium-backend의 api_code.ts를 기반으로 작성되었습니다.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_CODE = void 0;
+exports.getApiCode = getApiCode;
+exports.API_CODE = {
+    // 성공
+    200: { code: 200, msg: '성공' },
+    // Not Found
+    404: { code: 404, msg: '요청 사항을 찾을 수 없습니다' },
+    // 권한 (1000~1999)
+    1000: { code: 1000, msg: '권한이 없습니다' },
+    // 사용자 (2000~2999)
+    2000: { code: 2000, msg: '아이디 또는 비밀번호를 확인해주세요' },
+    2001: { code: 2001, msg: '중복된 아이디 입니다' },
+    2002: { code: 2002, msg: '유효한 EMAIL이 아닙니다' },
+    2003: { code: 2003, msg: '유효한 회원이 아닙니다' },
+    2004: { code: 2004, msg: '비밀번호를 재설정 해주세요' },
+    2005: { code: 2005, msg: '비밀번호가 초기화 되었습니다 EMAIL 확인해주세요' },
+    2006: { code: 2006, msg: '탈퇴한 회원입니다' },
+    2007: { code: 2007, msg: '유효한 이메일이 아닙니다' },
+    2008: { code: 2008, msg: '유효한 비밀번호가 아닙니다' },
+    2009: { code: 2009, msg: '유효한 휴대폰 번호가 아닙니다' },
+    2010: { code: 2010, msg: '카카오 로그인 오류' },
+    2011: { code: 2011, msg: '비밀번호가 틀렸습니다' },
+    2012: { code: 2012, msg: '회원가입 시 문제가 발생했습니다. 관리자에게 문의 해주세요' },
+    2013: { code: 2013, msg: '사용되지 않는 회원(고객)입니다. - 전화번호 중복 -' },
+    // 관리자 (3000 ~ 3999)
+    3000: { code: 3000, msg: '기존 회원입니다.' },
+    3001: { code: 3001, msg: '비 회원입니다.' },
+    3002: { code: 3002, msg: '중복된데이터 입니다.' },
+    3003: { code: 3003, msg: '등록된 상품이 아닙니다.' },
+    // 결제 실패 (4000~4999)
+    4000: { code: 4000, msg: '결제 실패' },
+    // 공용사항 (9000~9999)
+    9000: { code: 9000, msg: '오류가 발생했습니다. 관리자에게 문의 해주세요' },
+    9001: { code: 9001, msg: '유효하지 않은 데이터입니다.' },
+    9002: { code: 9002, msg: '유효하지 않은 컬럼입니다.' },
+    9003: { code: 9003, msg: '잘못된 요청입니다.' },
+};
+/**
+ * API 코드 가져오기
+ */
+function getApiCode(code) {
+    return exports.API_CODE[code] || exports.API_CODE[9000];
+}

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

@@ -0,0 +1,30 @@
+import { ApiCode } from './api-code';
+/**
+ * ConstantsModule - 상수 관리 모듈
+ */
+export declare class ConstantsModule {
+    /**
+     * API 코드 가져오기
+     */
+    getApiCode(code: number): ApiCode;
+    /**
+     * 모든 API 코드 접근
+     */
+    get codes(): Record<number, ApiCode>;
+    /**
+     * 성공 코드
+     */
+    get SUCCESS(): ApiCode;
+    /**
+     * NotFound 코드
+     */
+    get NOT_FOUND(): ApiCode;
+    /**
+     * 권한 없음 코드
+     */
+    get UNAUTHORIZED(): ApiCode;
+    /**
+     * 서버 에러 코드
+     */
+    get SERVER_ERROR(): ApiCode;
+}

package/dist/modules/constants/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantsModule = void 0;
+const api_code_1 = require("./api-code");
+/**
+ * ConstantsModule - 상수 관리 모듈
+ */
+class ConstantsModule {
+    /**
+     * API 코드 가져오기
+     */
+    getApiCode(code) {
+        return (0, api_code_1.getApiCode)(code);
+    }
+    /**
+     * 모든 API 코드 접근
+     */
+    get codes() {
+        return api_code_1.API_CODE;
+    }
+    /**
+     * 성공 코드
+     */
+    get SUCCESS() {
+        return api_code_1.API_CODE[200];
+    }
+    /**
+     * NotFound 코드
+     */
+    get NOT_FOUND() {
+        return api_code_1.API_CODE[404];
+    }
+    /**
+     * 권한 없음 코드
+     */
+    get UNAUTHORIZED() {
+        return api_code_1.API_CODE[1000];
+    }
+    /**
+     * 서버 에러 코드
+     */
+    get SERVER_ERROR() {
+        return api_code_1.API_CODE[9000];
+    }
+}
+exports.ConstantsModule = ConstantsModule;

package/dist/modules/middleware/error-handler.d.ts

@@ -0,0 +1,9 @@
+import { Request, Response, NextFunction } from 'express';
+/**
+ * 에러 핸들러 미들웨어
+ */
+export declare function errorHandler(): (err: Error, req: Request, res: Response, next: NextFunction) => void;
+/**
+ * 404 핸들러
+ */
+export declare function notFoundHandler(): (req: Request, res: Response, next: NextFunction) => void;

package/dist/modules/middleware/error-handler.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = errorHandler;
+exports.notFoundHandler = notFoundHandler;
+const api_code_1 = require("../constants/api-code");
+/**
+ * 에러 핸들러 미들웨어
+ */
+function errorHandler() {
+    return (err, req, res, next) => {
+        console.error('Error:', err);
+        const isProduction = process.env.NODE_ENV === 'production';
+        const errorResponse = {
+            ...(0, api_code_1.getApiCode)(9000),
+            message: isProduction ? 'Internal Server Error' : err.message,
+            ...(isProduction ? {} : { stack: err.stack }),
+        };
+        res.status(500).json(errorResponse);
+    };
+}
+/**
+ * 404 핸들러
+ */
+function notFoundHandler() {
+    return (req, res, next) => {
+        res.status(404).json({
+            ...(0, api_code_1.getApiCode)(404),
+            path: req.path,
+        });
+    };
+}

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

@@ -0,0 +1,30 @@
+import { dataValidator } from './validator';
+/**
+ * MiddlewareModule - 미들웨어 생성 모듈
+ */
+export declare class MiddlewareModule {
+    /**
+     * 요청 로깅 미들웨어 생성
+     */
+    logger(): (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => void;
+    /**
+     * 상세 요청 로깅 미들웨어 생성 (body 포함)
+     */
+    detailedLogger(): (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => void;
+    /**
+     * 에러 핸들러 미들웨어 생성
+     */
+    errorHandler(): (err: Error, req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => void;
+    /**
+     * 404 핸들러 미들웨어 생성
+     */
+    notFound(): (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => void;
+    /**
+     * 데이터 검증 미들웨어 생성
+     */
+    validator(rules: Parameters<typeof dataValidator>[0]): (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => import("express").Response<any, Record<string, any>> | undefined;
+    /**
+     * 필수 필드 검증 미들웨어 생성
+     */
+    requireFields(fields: string[]): (req: import("express").Request, res: import("express").Response, next: import("express").NextFunction) => import("express").Response<any, Record<string, any>> | undefined;
+}

package/dist/modules/middleware/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareModule = void 0;
+const logger_1 = require("./logger");
+const error_handler_1 = require("./error-handler");
+const validator_1 = require("./validator");
+/**
+ * MiddlewareModule - 미들웨어 생성 모듈
+ */
+class MiddlewareModule {
+    /**
+     * 요청 로깅 미들웨어 생성
+     */
+    logger() {
+        return (0, logger_1.requestLogger)();
+    }
+    /**
+     * 상세 요청 로깅 미들웨어 생성 (body 포함)
+     */
+    detailedLogger() {
+        return (0, logger_1.detailedRequestLogger)();
+    }
+    /**
+     * 에러 핸들러 미들웨어 생성
+     */
+    errorHandler() {
+        return (0, error_handler_1.errorHandler)();
+    }
+    /**
+     * 404 핸들러 미들웨어 생성
+     */
+    notFound() {
+        return (0, error_handler_1.notFoundHandler)();
+    }
+    /**
+     * 데이터 검증 미들웨어 생성
+     */
+    validator(rules) {
+        return (0, validator_1.dataValidator)(rules);
+    }
+    /**
+     * 필수 필드 검증 미들웨어 생성
+     */
+    requireFields(fields) {
+        return (0, validator_1.requireFields)(fields);
+    }
+}
+exports.MiddlewareModule = MiddlewareModule;

package/dist/modules/middleware/logger.d.ts

@@ -0,0 +1,11 @@
+import { Request, Response, NextFunction } from 'express';
+/**
+ * 요청 로깅 미들웨어
+ *
+ * zium-backend의 messageCheck를 기반으로 작성되었습니다.
+ */
+export declare function requestLogger(): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * 상세 요청 로깅 미들웨어 (body 포함)
+ */
+export declare function detailedRequestLogger(): (req: Request, res: Response, next: NextFunction) => void;

package/dist/modules/middleware/logger.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestLogger = requestLogger;
+exports.detailedRequestLogger = detailedRequestLogger;
+/**
+ * 요청 로깅 미들웨어
+ *
+ * zium-backend의 messageCheck를 기반으로 작성되었습니다.
+ */
+function requestLogger() {
+    return (req, res, next) => {
+        const start = Date.now();
+        const { method, path, ip } = req;
+        // 응답 완료 후 로깅
+        res.on('finish', () => {
+            const duration = Date.now() - start;
+            const { statusCode } = res;
+            console.log(`[${new Date().toISOString()}] ${method} ${path} ${statusCode} - ${duration}ms - ${ip}`);
+        });
+        next();
+    };
+}
+/**
+ * 상세 요청 로깅 미들웨어 (body 포함)
+ */
+function detailedRequestLogger() {
+    return (req, res, next) => {
+        const start = Date.now();
+        const { method, path, ip, body } = req;
+        // 요청 시작 시 로깅
+        console.log(`[${new Date().toISOString()}] ${method} ${path} - ${ip}`);
+        if (Object.keys(body || {}).length > 0) {
+            console.log('Request Body:', JSON.stringify(body, null, 2));
+        }
+        // 응답 완료 후 로깅
+        res.on('finish', () => {
+            const duration = Date.now() - start;
+            const { statusCode } = res;
+            console.log(`[${new Date().toISOString()}] ${method} ${path} ${statusCode} - ${duration}ms`);
+        });
+        next();
+    };
+}

package/dist/modules/middleware/validator.d.ts

@@ -0,0 +1,13 @@
+import { Request, Response, NextFunction } from 'express';
+/**
+ * 데이터 검증 미들웨어
+ */
+export declare function dataValidator(rules: {
+    body?: Record<string, (value: any) => boolean | string>;
+    query?: Record<string, (value: any) => boolean | string>;
+    params?: Record<string, (value: any) => boolean | string>;
+}): (req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;
+/**
+ * 요청 body 필수 필드 검증
+ */
+export declare function requireFields(fields: string[]): (req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

package/dist/modules/middleware/validator.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataValidator = dataValidator;
+exports.requireFields = requireFields;
+const api_code_1 = require("../constants/api-code");
+/**
+ * 데이터 검증 미들웨어
+ */
+function dataValidator(rules) {
+    return (req, res, next) => {
+        const errors = [];
+        // Body 검증
+        if (rules.body) {
+            for (const [key, validator] of Object.entries(rules.body)) {
+                const value = req.body[key];
+                const result = validator(value);
+                if (typeof result === 'string') {
+                    errors.push(result);
+                }
+                else if (!result) {
+                    errors.push(`${key} is invalid`);
+                }
+            }
+        }
+        // Query 검증
+        if (rules.query) {
+            for (const [key, validator] of Object.entries(rules.query)) {
+                const value = req.query[key];
+                const result = validator(value);
+                if (typeof result === 'string') {
+                    errors.push(result);
+                }
+                else if (!result) {
+                    errors.push(`Query parameter ${key} is invalid`);
+                }
+            }
+        }
+        // Params 검증
+        if (rules.params) {
+            for (const [key, validator] of Object.entries(rules.params)) {
+                const value = req.params[key];
+                const result = validator(value);
+                if (typeof result === 'string') {
+                    errors.push(result);
+                }
+                else if (!result) {
+                    errors.push(`Parameter ${key} is invalid`);
+                }
+            }
+        }
+        if (errors.length > 0) {
+            return res.status(400).json({
+                ...(0, api_code_1.getApiCode)(9001),
+                message: 'Validation failed',
+                errors,
+            });
+        }
+        next();
+    };
+}
+/**
+ * 요청 body 필수 필드 검증
+ */
+function requireFields(fields) {
+    return (req, res, next) => {
+        const missing = [];
+        for (const field of fields) {
+            if (!req.body[field]) {
+                missing.push(field);
+            }
+        }
+        if (missing.length > 0) {
+            return res.status(400).json({
+                ...(0, api_code_1.getApiCode)(9001),
+                message: `Missing required fields: ${missing.join(', ')}`,
+                missing,
+            });
+        }
+        next();
+    };
+}