pg-mvc-service 2.0.43 → 2.0.44

package/index.d.ts

@@ -0,0 +1,189 @@
+import { AxiosResponse } from "axios";
+import { Request, Response } from 'express';
+import { Pool, PoolClient } from 'pg';
+import { ErrorMessageType, IncomingHttpHeaders } from './src/reqestResponse/RequestType';
+import { ArrayType, EnumType, ObjectType, PrimitiveType } from './src/reqestResponse/ReqResType';
+
+import { MethodType } from './src/Service';
+export { MethodType } from './src/Service';
+
+import { Base64Client } from './src/clients/Base64Client';
+import { StringClient } from './src/clients/StringClient';
+import { EncryptClient } from './src/clients/EncryptClient';
+
+import { AwsS3Client } from './src/clients/AwsS3Client';
+export { AwsS3Client } from './src/clients/AwsS3Client';
+
+// models class
+import ValidateClient from './src/models/ValidateClient';
+
+import { TableModel } from "./src/models/TableModel";
+export { TableModel } from "./src/models/TableModel";
+
+export { TColumnAttribute, TColumnType, TColumnArrayType, TColumn, TColumnDetail, TOperator, TColumnInfo, TQuery, TSelectExpression, TAggregateFuncType, TCondition, TNestedCondition, TSortKeyword, TKeyFormat } from './src/models/Type';
+
+export { DayType, MonthType, DateType, HourType, MinuteSecondType } from './src/cron/CronType';
+export { BaseCron } from "./src/cron/BaseCron";
+export { runCron } from "./src/cron/CronExecuter";
+
+declare module 'pg-mvc-service' {
+    export class Service {
+        protected readonly method: MethodType;
+        get Method(): MethodType;
+        protected readonly endpoint: string;
+        get Endpoint(): string;
+        protected readonly apiCode: string;
+        get ApiCode(): string;
+        protected readonly summary: string;
+        get Summary(): string;
+        protected readonly apiUserAvailable: string;
+        get ApiUserAvailable(): string;
+        protected readonly request: RequestType;
+        get AuthToken(): string;
+        protected readonly response: ResponseType;
+        protected readonly isTest: boolean;
+        protected readonly tags: Array<string>;
+        get Tags(): Array<string>;
+
+        protected readonly req: Request;
+        protected readonly res: Response;
+        constructor(request: Request, response: Response);
+
+        public inintialize(): void;
+
+        protected dbUser?: string;
+        protected dbHost?: string;
+        protected dbName?: string;
+        protected dbPassword?: string;
+        protected dbPort?: number;
+        protected dbIsSslConnect?: boolean;
+        protected checkMaintenance(): Promise<void>;
+        protected middleware(): Promise<void>;
+
+        public resSuccess(): void;
+        public handleException(ex: any): void;
+        protected outputErrorLog(ex: any): Promise<void>;
+
+        protected get Pool(): Pool;
+        protected get Client(): PoolClient;
+
+        public startConnect(): Promise<void>;
+        public commit(): Promise<void>;
+        public rollback(): Promise<void>;
+        public release(): Promise<void>;
+
+        get S3Client(): AwsS3Client;
+        get Base64Client(): Base64Client;
+        get StringClient(): StringClient;
+        get EncryptClient(): EncryptClient;
+
+        public requestApi<TRequest=Record<string, any>, TResponse={[key: string]: any}>(
+            method: MethodType, url: string, params: TRequest, header: {[key: string]: any}): Promise<AxiosResponse<TResponse>>;
+    }
+
+    export interface IParams {
+        in: 'header' | 'path',
+        name: string,
+        require?: boolean,
+        description?: string,
+        example?: string
+    }
+    export function createSwagger(services: Service[], name: string, url: string, params: Array<IParams>): string;
+
+    export type PropertyType =  PrimitiveType | ObjectType | ArrayType | EnumType;
+
+    export class RequestType {
+        constructor();
+
+        protected properties: { [key: string]: PropertyType; };
+        protected paramProperties: Array<(PrimitiveType | EnumType) & { key: string }>;
+        protected readonly ERROR_MESSAGE: ErrorMessageType;
+
+        protected throwException(code: string, message: string): never;
+
+        public setRequest(request: Request): void;
+        get Data(): { [key: string]: any };
+        get Headers(): IncomingHttpHeaders;
+        get Params(): { [key: string]: any };
+        get RemoteAddress(): string | undefined;
+        get Authorization(): string | null;
+    }
+
+    export class ResponseType {
+        public Data: { [key: string]: any };
+
+        protected properties: { [key: string]: PropertyType; };
+        get ResponseData(): { [key: string]: any };
+    }
+
+    export class AuthException extends Error {
+        private id: string;
+        get Id(): string;
+        constructor(id: string, message?: string);
+    }
+
+    export class ForbiddenException extends Error {
+    }
+
+    export class InputErrorException extends Error {
+        private errorId: string;
+        get ErrorId(): string;
+        private errorLog: string;
+        get ErrorLog(): string;
+        constructor(errorId: string, message?: string, errorLog?: string);
+    }
+
+    export class MaintenanceException extends Error {
+        constructor(message?: string);
+    }
+
+    export class DbConflictException extends Error {
+        private errorId: string;
+        get ErrorId(): string;
+        constructor(errorId: string, message?: string);
+    }
+
+    export class NotFoundException extends Error {
+        private errorId: string;
+        get ErrorId(): string;
+        constructor(errorId: string, message?: string);
+    }
+
+    export class UnprocessableException extends Error {
+        private errorId: string;
+        get ErrorId(): string;
+        constructor(errorId: string, message?: string);
+    }
+
+    export function createTableDoc(models: Array<TableModel>, serviceName?: string): string;
+    export function migrate(migrates: Array<MigrateTable>, poolParam: {
+        host: string, user: string, dbName: string, password: string, port?: number, isSsl?: boolean
+    }): Promise<void>;
+    export function rollback(toNumber: number, poolParam: {
+        host: string, user: string, dbName: string, password: string, port?: number, isSsl?: boolean
+    }): Promise<void>;
+    export class MigrateTable {
+        protected readonly migrateSql: string;
+        protected readonly rollbackSql: string;
+        protected readonly addGrantTables: Array<string>;
+        protected readonly user: string;
+
+        constructor();
+        constructor(user: string);
+    }
+
+    export class MigrateDatabase {
+        constructor(dbName: string, userName: string, pool: Pool);
+    
+        get DbName(): string;
+        get UserName(): string;
+        get Password(): string | null;
+    
+        public IsExistUser(): Promise<boolean>;
+        public CreateUser(password?: string): Promise<void>;
+        public IsExistDb(): Promise<boolean>;
+        public CreateDb(collateType?: string): Promise<void>;
+        public RollbackDbSql(): string;
+        public RollbackUserSql(otherUserName: string): string;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pg-mvc-service",
-  "version": "2.0.43",
+  "version": "2.0.44",
   "description": "",
   "homepage": "https://github.com/n-daira/npm-pack_mvc-service#readme",
   "bugs": {
@@ -14,10 +14,6 @@
   "author": "Sho Nakadaira",
   "type": "commonjs",
   "main": "dist/index.js",
-  "files": [
-    "dist",
-    "dist/assets"
-  ],
   "scripts": {
     "build": "rm -rf dist/* && tsc && npm run copy-assets",
     "copy-assets": "copyfiles -u 2 src/assets/* dist/assets",

package/src/PoolManager.ts

@@ -0,0 +1,48 @@
+// PoolManager.ts
+import { Pool } from 'pg';
+
+export default class PoolManager {
+    private static poolMap: Record<string, Pool> = {};
+
+    static getPool(user: string, host: string, database: string, password: string, port: number | string, isSslConnect: boolean): Pool {
+        const key = `${user}@${host}/${database}`;
+        if (!this.poolMap[key]) {
+            this.poolMap[key] = new Pool({
+                user: user,
+                host: host,
+                database: database,
+                password: password,
+                port: Number(port),
+                ssl: isSslConnect ? {
+                    rejectUnauthorized: false
+                    } : false
+            });
+        }
+    
+        return this.poolMap[key];
+    }
+  
+static async shutdownAll(): Promise<void> {
+    for (const [key, pool] of Object.entries(this.poolMap)) {
+        try {
+            await pool.end();
+            console.log(`Closed pool: ${key}`);
+        } catch (e) {
+            console.error(`Error closing pool ${key}`, e);
+        }
+        }
+    }
+}
+  
+// ✅ 自動実行されるシャットダウン登録
+process.on('SIGINT', async () => {
+    console.log('🔌 SIGINT received. Closing all pools...');
+    await PoolManager.shutdownAll();
+    process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+    console.log('🔌 SIGTERM received. Closing all pools...');
+    await PoolManager.shutdownAll();
+    process.exit(0);
+});

package/src/Service.ts

@@ -0,0 +1,276 @@
+import axios, { AxiosResponse } from "axios";
+import { Request, Response } from 'express';
+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';
+
+export type MethodType = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+export class Service {
+    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 isTest: boolean = process.env.NODE_ENV === 'test';
+    protected readonly tags: Array<string> = [];
+    get Tags(): Array<string> { return this.tags; }
+
+    protected readonly req: Request;
+    protected readonly res: Response;
+    constructor(request: Request, response: Response) {
+        this.req = request;
+        this.res = response;
+    }
+
+    public async inintialize(): Promise<void> {
+        this.request.setRequest(this.req);
+        await this.checkMaintenance();
+        await this.middleware();
+    }
+
+    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.res.status(200).json(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.res.status(401).json({
+                message : "Authentication expired. Please login again."
+            });
+            return;
+        } else if (ex instanceof ForbiddenException) {
+            this.res.status(403).json({
+                message : 'Forbidden error'
+            });
+            return;
+        } else if (ex instanceof InputErrorException) {
+            this.res.status(400).json({
+                errorCode : `${this.apiCode}-${ex.ErrorId}`,
+                errorMessage : ex.message
+            });
+            return;
+        } else if (ex instanceof DbConflictException) {
+            this.res.status(409).json({
+                errorCode : `${this.apiCode}-${ex.ErrorId}`,
+                errorMessage : ex.message
+            });
+            return;
+        } else if (ex instanceof UnprocessableException) {
+            this.res.status(422).json({
+                errorCode : `${this.apiCode}-${ex.ErrorId}`,
+                errorMessage : ex.message
+            });
+            return;
+        } else if (ex instanceof MaintenanceException) {
+            this.res.status(503).json({
+                errorMessage : ex.message
+            });
+            return;
+        } else if (ex instanceof NotFoundException) {
+            this.res.status(404).json({
+                errorCode : `${this.apiCode}-${ex.ErrorId}`,
+                errorMessage : ex.message
+            });
+            return;
+        }
+
+        if (this.isTest) {
+            this.res.status(500).json({
+                message : ex.stack
+            });
+        } else {
+            this.res.status(500).json({
+                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();
+        }
+
+        if (this.isTest) {
+            // In tests, the connection is terminated because it is shut down every time
+            await this.Pool.end();
+        }
+    }
+
+    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

@@ -0,0 +1,146 @@
+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);
+    }
+}