pg-mvc-service 2.1.0 → 2.1.1

package/src/Service.ts

@@ -1,307 +0,0 @@
-import axios, { AxiosResponse } from "axios";
-import { Request, Response } from 'express';
-import { Hono, Context } from 'hono' // Context を追加
-import { Pool, type PoolClient } from 'pg';
-import { MaintenanceException, AuthException, InputErrorException, ForbiddenException, DbConflictException, UnprocessableException, NotFoundException } from './exceptions/Exception';
-import { RequestType } from './reqestResponse/RequestType';
-import { ResponseType } from './reqestResponse/ResponseType';
-import { AwsS3Client } from './clients/AwsS3Client';
-import { Base64Client } from './clients/Base64Client';
-import { StringClient } from './clients/StringClient';
-import { EncryptClient } from './clients/EncryptClient';
-import PoolManager from './PoolManager';
-
-type TStatusCode = 200 | 201 | 400 | 401 | 403 | 404 | 409 | 422 | 500 | 503;
-
-export type MethodType = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-export interface IError {
-    status: TStatusCode, 
-    code: string;
-    description: string; 
-}
-
-
-export class Service {
-    protected readonly module: 'express' | 'hono' = 'express';
-    protected readonly method: MethodType = 'GET';
-    get Method(): MethodType { return this.method; }
-    protected readonly endpoint: string = '';
-    get Endpoint(): string { return this.endpoint + this.request.paramPath; }
-    protected readonly apiCode: string = '';
-    get ApiCode(): string { return this.apiCode; }
-    protected readonly summary: string = '';
-    get Summary(): string { return `${this.ApiCode !== '' ? this.apiCode + ': ' : ''}${this.summary}`; }
-    protected readonly apiUserAvailable: string = '';
-    get ApiUserAvailable(): string { return this.apiUserAvailable; }
-    protected readonly request: RequestType = new RequestType();
-    get Request(): RequestType { return this.request }; // swaggerで必要なので、ここだけ宣言
-    get AuthToken(): string { return this.request.Authorization ?? ''; }
-    protected readonly response: ResponseType = new ResponseType();
-    get Response(): ResponseType { return this.response }; // swaggerで必要なので、ここだけ宣言
-    protected readonly tags: Array<string> = [];
-    get Tags(): Array<string> { return this.tags; }
-    protected readonly errorList: Array<IError> = [];
-    get ErrorList(): Array<IError> {
-        return [...this.errorList, {
-            status: 500,
-            code: '',
-            description: 'サーバー内部エラー（予期せぬエラー）'
-        }];
-    }
-
-    protected readonly req?: Request;
-    protected readonly res?: Response;
-    protected readonly c?: Context;
-    protected setResponse(status: TStatusCode, data: any) {
-        if (this.module === 'express') {
-            this.res?.status(status).json(data);
-        } else {
-            this.c?.json(data, status)
-        }
-    }
-
-    constructor(request: Request, response: Response);
-    constructor(c: Context);
-    constructor(param1: Request | Context, param2?: Response) {
-        if (param2 !== undefined) {
-            // Express の場合: (request, response)
-            this.module = 'express';
-            this.req = param1 as Request;
-            this.res = param2;
-        } else {
-            // Hono の場合: (c)
-            this.module = 'hono';
-            this.c = param1 as Context;
-        }
-    }
-
-    public async inintialize(): Promise<void> {
-        if (this.module === "express") {
-            await this.request.setRequest(this.module, this.req as Request);
-        } else {
-            await this.request.setRequest(this.module, this.c as Context);
-        }
-
-        await this.checkMaintenance();
-        await this.middleware();
-    }
-    // Context<{ Bindings: Bindings }>
-
-    protected dbUser?: string = process.env.DB_USER;
-    protected dbHost?: string = process.env.DB_HOST;
-    protected dbName?: string = process.env.DB_DATABASE;
-    protected dbPassword?: string = process.env.DB_PASSWORD;
-    protected dbPort?: string | number = process.env.DB_PORT;
-    protected dbIsSslConnect: boolean = process.env.DB_IS_SSL === 'true';
-    private setPool(): Pool {
-        if (this.dbUser === undefined) {
-            throw new Error("Database user is not configured");
-        }
-        if (this.dbHost === undefined) {
-            throw new Error("Database host is not configured");
-        }
-        if (this.dbName === undefined) {
-            throw new Error("Database name is not configured");
-        }
-        if (this.dbPassword === undefined) {
-            throw new Error("Database password is not configured");
-        }
-        if (this.dbPort === undefined) {
-            throw new Error("Database port is not configured");
-        }
-
-        try {
-            return PoolManager.getPool(this.dbUser, this.dbHost, this.dbName, this.dbPassword, this.dbPort, this.dbIsSslConnect);
-        } catch (ex) {
-            throw new Error("Failed to connect to the database. Please check the connection settings.");
-        }
-    }
-    protected async checkMaintenance(): Promise<void> { }
-    protected async middleware(): Promise<void>{ }
-
-    public resSuccess(): void {
-        this.setResponse(200, this.response.ResponseData);
-    }
-
-    protected async outputErrorLog(ex: any): Promise<void>{ }
-    public handleException(ex: any): void {
-        // To avoid slowing down the response, make this asynchronous
-        this.outputErrorLog(ex).catch((ex) => {
-            console.error(ex);
-        });
-
-        if (ex instanceof AuthException) {
-            this.setResponse(401, {
-                message : "Authentication expired. Please login again."
-            });
-            return;
-        } else if (ex instanceof ForbiddenException) {
-            this.setResponse(403, {
-                message : 'Forbidden error'
-            });
-            return;
-        } else if (ex instanceof InputErrorException) {
-            this.setResponse(400, {
-                errorCode : `${this.apiCode}-${ex.ErrorId}`,
-                errorMessage : ex.message
-            });
-            return;
-        } else if (ex instanceof DbConflictException) {
-            this.setResponse(409, {
-                errorCode : `${this.apiCode}-${ex.ErrorId}`,
-                errorMessage : ex.message
-            });
-            return;
-        } else if (ex instanceof UnprocessableException) {
-            this.setResponse(422, {
-                errorCode : `${this.apiCode}-${ex.ErrorId}`,
-                errorMessage : ex.message
-            });
-            return;
-        } else if (ex instanceof MaintenanceException) {
-            this.setResponse(503, {
-                errorMessage : ex.message
-            });
-            return;
-        } else if (ex instanceof NotFoundException) {
-            this.setResponse(404, {
-                errorCode : `${this.apiCode}-${ex.ErrorId}`,
-                errorMessage : ex.message
-            });
-            return;
-        }
-
-        this.setResponse(500, {
-            message : 'Internal server error'
-        });
-
-        return;
-    }
-
-    private pool?: Pool;
-    protected get Pool(): Pool {
-        if (this.pool === undefined) {
-            this.pool = this.setPool();
-            this.pool.query(`SET TIME ZONE '${process.env.TZ ?? 'Asia/Tokyo'}';`);
-        }
-        return this.pool; 
-    }
-    private client?: PoolClient;
-    private isExecuteRollback: boolean = false;
-    protected get Client(): PoolClient { 
-        if (this.client === undefined) {
-            throw new Error("Please call this.PoolClient after using the startConnect method.");
-        }
-        return this.client;
-    }
-
-    public async startConnect(): Promise<void> {
-        this.client = await this.Pool.connect();
-        await this.Client.query('BEGIN');
-        this.isExecuteRollback = true;
-    }
-
-    public async commit(): Promise<void> {
-        await this.Client.query('COMMIT');
-        this.isExecuteRollback = false;
-    }
-
-    public async rollback(): Promise<void> {
-        if (this.isExecuteRollback) {
-            await this.Client.query('ROLLBACK');
-        }
-        this.isExecuteRollback = false;
-    }
-
-    public async release(): Promise<void> {
-        await this.rollback();
-        if (this.client !== undefined) {
-            await this.client.release();
-        }
-    }
-
-    private s3Client?: AwsS3Client;
-    get S3Client(): AwsS3Client {
-        if (this.s3Client === undefined) {
-            this.s3Client = new AwsS3Client({
-                bucketName: process.env.S3_BUCKET_NAME,
-                region: process.env.S3_REGION,
-                accessKeyId: process.env.S3_ACCESS_KEY_ID,
-                secretAccessKey: process.env.S3_SECRET_ACCESS_KEY
-            });
-        }
-        return this.s3Client;
-    }
-
-    private base64Client? : Base64Client;
-    get Base64Client(): Base64Client {
-        if (this.base64Client === undefined) {
-            this.base64Client = new Base64Client();
-        }
-        return this.base64Client;
-    }
-
-    private stringClient? : StringClient;
-    get StringClient(): StringClient {
-        if (this.stringClient === undefined) {
-            this.stringClient = new StringClient();
-        }
-        return this.stringClient;
-    }
-
-    private encryptClient?: EncryptClient;
-    get EncryptClient(): EncryptClient {
-        if (this.encryptClient === undefined) {
-            this.encryptClient = new EncryptClient({
-                secretKeyHex: process.env.SECRET_KEY_HEX,
-                hmacKeyBase64: process.env.HMAC_KEY_BASE64
-            });
-        }
-
-        return this.encryptClient;
-    }
-
-    public async requestApi<TRequest=Record<string, any>, TResponse={[key: string]: any}>(
-        method: MethodType, url: string, params: TRequest, header: {[key: string]: any}): Promise<AxiosResponse<TResponse>> {
-
-        // GET,DELETEのparamをURLクエリに
-        if (method === 'GET' || method === 'DELETE') {
-            for (const [key, value] of Object.entries(params as Record<string, any>)) {
-                if (value === undefined || value === null) {
-                    continue;
-                }
-
-                if (Array.isArray(value)) {
-                    for (const arrayValue of value) {
-                        url += url.includes('?') ? '&' : '?';
-                        url += `${key}=${arrayValue.toString()}`;
-                    }
-                } else {
-                    url += url.includes('?') ? '&' : '?';
-                    url += `${key}=${value.toString()}`;
-                }
-            }
-        }
-
-        try {
-            switch (method) {
-                case 'GET':
-                    return await axios.get(url, header === undefined ? {} : { headers: header });
-                case 'POST':
-                    return await axios.post(url, params, header === undefined ? {} : { headers: header });
-                case 'PUT':
-                    return await axios.put(url, params, header === undefined ? {} : { headers: header });
-                case 'DELETE':
-                    return await axios.delete(url, header === undefined ? {} : { headers: header });
-                case 'PATCH':
-                    return await axios.patch(url, params, header === undefined ? {} : { headers: header });
-            }
-        } catch (ex) {
-            let response = (ex as any).response as AxiosResponse<TResponse>;
-            if (response && [400, 401, 403, 404, 409, 422].includes(response.status)) {
-                return response;
-            }
-            throw ex;
-        }
-    }
-}

package/src/Utils/DateTimeUtil.ts

@@ -1,146 +0,0 @@
-export default class DateTimeUtil {
-
-    /**
-     * Checks if the value is a valid date-time format
-     * 値が有効な日付時間形式かどうかを確認します
-     * @param value - 検証する値, The value to be validated
-     * @returns {boolean} - 値が有効な日付時間形式であるかどうか, Whether the value is a valid date-time format
-     */
-    private static isErrorDateTime(value: string): boolean {
-        try {
-            const [datePart, timePart] = value.split(' ');
-            const [year, month, day] = datePart.split('-').map(Number);
-            let [hour, minute, sec] = [0, 0, 0];
-            if (timePart !== undefined) {
-                [hour, minute, sec] = timePart.split(':').map(Number);
-            }
-            
-            const date = new Date(year, month - 1, day, hour, minute, sec);
-            return year !== date.getFullYear() || 
-                   month !== date.getMonth() + 1 || 
-                   day !== date.getDate() ||
-                   hour !== date.getHours() ||
-                   minute !== date.getMinutes() ||
-                   sec !== date.getSeconds()
-        } catch (error) {
-            return true;
-        }
-    }
-
-    /**
-     * Generates a Date object from a string.
-     * 文字列からDateオブジェクトを生成します。
-     * @param dateString A string representing the date and time (e.g., "2023-10-05 14:30:00")
-     * 日付と時間を表す文字列（例: "2023-10-05 14:30:00"）
-     * @returns Date object
-     * Dateオブジェクト
-     */
-    static toDateFromString(dateString: string): Date {
-        const [datePart, timePart] = dateString.split(' ');
-        const [year, month, day] = datePart.split('-').map(Number);
-        let [hours, minutes, seconds] = [0, 0, 0];
-        if (timePart !== undefined) {
-            [hours, minutes, seconds] = timePart.split(':').map(Number);
-        }
-        return new Date(year, month - 1, day, hours, minutes, seconds);
-    }
-
-    /**
-     * Formats the specified date.
-     * 指定された日付をフォーマットします。
-     * @param date The date object to be formatted.
-     * フォーマットする対象の日付オブジェクト
-     * @param type A string specifying the type of format.
-     * フォーマットの種類を指定する文字列
-     * @returns A formatted date string.
-     * フォーマットされた日付文字列
-     */
-    static toStringFromDate(date: Date, type: 'datetime' | 'date' | 'time'): string {
-
-        const year = date.getFullYear().toString().padStart(4, '0');
-        const month = (date.getMonth() + 1).toString().padStart(2, '0');
-        const day = date.getDate().toString().padStart(2, '0');
-        const hour = date.getHours().toString().padStart(2, '0');
-        const minute = date.getMinutes().toString().padStart(2, '0');
-        const second = date.getSeconds().toString().padStart(2, '0');
-
-        switch (type) {
-            case 'datetime':
-                return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
-            case 'date':
-                return `${year}-${month}-${day}`;
-            case 'time':
-                return `${hour}:${minute}:${second}`;
-            default:
-                throw new Error('Invalid type');
-        }
-    }
-
-    /**
-     * Validates if the given value is in the format YYYY-MM-DD
-     * 与えられた値がYYYY-MM-DD形式であるかどうかを検証します
-     * @param value - The value to be validated, 検証する値
-     * @returns {boolean} - Whether the value is in the format YYYY-MM-DD, 値がYYYY-MM-DD形式であるかどうか
-     */
-    static isYYYYMMDD(value: any) {
-        if (typeof value !== 'string') {
-            return false;
-        }
-
-        const pattern = new RegExp('^\\d{4}-\\d{2}-\\d{2}$');
-        if (pattern.test(value) === false) {
-            return false;
-        }
-
-        return this.isErrorDateTime(value) === false;
-    }
-
-    /**
-     * Validates if the given value is in the format YYYY-MM-DD hh:mm:ss
-     * 与えられた値がYYYY-MM-DD hh:mm:ss形式であるかどうかを検証します
-     * @param value - The value to be validated, 検証する値
-     * @returns {boolean} - Whether the value is in the format YYYY-MM-DD hh:mm:ss, 値がYYYY-MM-DD hh:mm:ss形式であるかどうか
-     */
-    static isYYYYMMDDhhmiss(value: any) {
-        if (typeof value !== 'string') {
-            return false;
-        }
-
-        const pattern = new RegExp('^\\d{4}-\\d{2}-\\d{2}[ T]\\d{2}:\\d{2}:\\d{2}$');
-        if (pattern.test(value) === false) {
-            return false;
-        }
-
-        return this.isErrorDateTime(value) === false;
-    }
-
-    /**
-     * Validates if the given value is in the format YYYY-MM-DD hh:mm:ss
-     * 与えられた値がYYYY-MM-DD hh:mm:ss形式であるかどうかを検証します
-     * @param value - The value to be validated, 検証する値
-     * @returns {boolean} - Whether the value is in the format YYYY-MM-DD hh:mm:ss, 値がYYYY-MM-DD hh:mm:ss形式であるかどうか
-     */
-    static isHHMM(value: any) {
-        if (typeof value !== 'string') {
-            return false;
-        }
-
-        const pattern = new RegExp('^(?:[01]\\d|2[0-3]):[0-5]\\d$');
-        return pattern.test(value);
-    }
-
-    /**
-     * Validates if the given value is in the format HH:MM:SS
-     * 与えられた値がHH:MM:SS形式であるかどうかを検証します
-     * @param value - The value to be validated, 検証する値
-     * @returns {boolean} - Whether the value is in the format HH:MM:SS, 値がHH:MM:SS形式であるかどうか
-     */
-    static isHHMMSS(value: any) {
-        if (typeof value !== 'string') {
-            return false;
-        }
-
-        const pattern = new RegExp('^(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d$');
-        return pattern.test(value);
-    }
-}

package/src/Utils/NumberUtil.ts

@@ -1,23 +0,0 @@
-export default class NumberUtil {
-    /**
-     * Checks if the given value is a number.
-     * 与えられた値が数値であるかどうかを確認します。
-     * @param value - The value to be checked. ���認する値。
-     * @returns {boolean} - Whether the value is a number. ��が数値であるかどうか。
-     */
-    static isNumber(value: any) {
-        if (value == null) {
-            return false;
-        } else if (value instanceof Date) { 
-            return false;
-        } else if (value instanceof Array) {
-            return false;
-        } else if (typeof(value) == 'string') {
-            if (value == "") {
-                return false;
-            }
-        }
-
-        return isNaN(Number(value)) == false;
-    }
-}

package/src/Utils/StringUtil.ts

@@ -1,33 +0,0 @@
-export default class StringUtil {
-    /**
-     * Validates if the given value is a valid UUID
-     * 与えられた値が有効なUUIDであるかどうかを検証します
-     * @param value - The value to be validated, 検証する値
-     * @returns {boolean} - Whether the value is a valid UUID, 値が有効なUUIDであるかどうか
-     */
-    static isUUID(value: any) {
-        if (typeof value !== 'string') {
-            return false;
-        }
-
-        const pattern = new RegExp('^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$');
-        return pattern.test(value);
-    }
-
-    /**
-     * 小文字スネークからキャピタルケースに変換
-     * @param {string} value スネーク文字列
-     * @returns キャピタル文字列
-     */
-    static formatFromSnakeToCamel(value: string) {
-        const regex = /_[a-z]/g;
-        let capital = value.replace(regex,
-            function(matchChar) {
-                return String.fromCharCode(matchChar.charCodeAt(1) - 0x20);
-            }
-        );
-    
-        // "_1"や"_@"のパターンを考慮して、_を省く（この使い方はあまりないと思いますが...）
-        return capital.replaceAll("_", "");
-    }
-}