pg-mvc-service 2.0.43 → 2.0.45

package/src/clients/EncryptClient.ts

@@ -0,0 +1,100 @@
+import crypto from 'crypto';
+
+export class EncryptClient {
+    private secretKeyHex?: string;
+    get SecretKey(): Buffer<ArrayBuffer> { 
+        if (this.secretKeyHex === undefined) {
+            throw new Error("Please set the secret key.");
+        }
+        return Buffer.from(this.secretKeyHex, 'hex');
+    }
+    private hmacKeyBase64?: string;
+    get HmacKey(): Buffer<ArrayBuffer> { 
+        if (this.hmacKeyBase64 === undefined) {
+            throw new Error("Please set the hmac key.");
+        }
+        return Buffer.from(this.hmacKeyBase64, 'base64');
+    }
+
+    constructor(params: {secretKeyHex?: string, hmacKeyBase64?: string}) {
+        this.secretKeyHex = params?.secretKeyHex;
+        this.hmacKeyBase64 = params?.hmacKeyBase64;
+    }
+
+    public encryptAndSign(data: string | {[key: string]: any}): string {
+        const iv = crypto.randomBytes(12);
+        const cipher = crypto.createCipheriv('aes-256-gcm', this.SecretKey, iv);
+        
+        const plaintext = typeof data === 'string' ? data : JSON.stringify(data);
+        const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+        const authTag = cipher.getAuthTag();
+        
+        const combined = Buffer.concat([iv, authTag, encrypted]);
+        const payload = this.base64urlEncode(combined);
+        
+        const hmac = crypto.createHmac('sha256', this.HmacKey).update(payload).digest();
+        const signature = this.base64urlEncode(hmac);
+        
+        return `${payload}.${signature}`;
+    }
+
+    public isValidToken(token: string): boolean {
+        // 形式チェック、.で区切られているか？
+        const [payload, signature] = token.split('.');
+        if (!payload || !signature) {
+            return false;
+        }
+
+        // 改竄チェック
+        const expectedSig = crypto.createHmac('sha256', this.HmacKey).update(payload).digest();
+        const expectedSigStr = this.base64urlEncode(expectedSig);
+
+        if (signature !== expectedSigStr) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public decrypt<T>(token: string): T {
+        // 形式チェック、.で区切られているか？
+        const [payload, signature] = token.split('.');
+        if (!payload || !signature) {
+            throw new Error('Invalid token format');
+        }
+
+        // 改竄チェック
+        const expectedSig = crypto.createHmac('sha256', this.HmacKey).update(payload).digest();
+        const expectedSigStr = this.base64urlEncode(expectedSig);
+        if (signature !== expectedSigStr){
+            throw new Error('The token appears to have been tampered with');
+        }
+
+        const combined = this.base64urlDecode(payload);
+        const iv = combined.subarray(0, 12);
+        const authTag = combined.subarray(12, 28);
+        const encrypted = combined.subarray(28);
+        
+        const decipher = crypto.createDecipheriv('aes-256-gcm', this.SecretKey, iv);
+        decipher.setAuthTag(authTag);
+        
+        const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+        return JSON.parse(decrypted.toString('utf8')) as T;
+    }
+
+
+    private base64urlEncode(buffer: Buffer): string {
+        return buffer.toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+    }
+    
+    private base64urlDecode(str: string): Buffer {
+        str = str.replace(/-/g, '+').replace(/_/g, '/');
+        while (str.length % 4 !== 0) {
+            str += '=';
+        }
+        return Buffer.from(str, 'base64');
+    }
+}

package/src/clients/StringClient.ts

@@ -0,0 +1,19 @@
+import { randomBytes } from 'crypto';
+import StringUtil from '../Utils/StringUtil';
+
+export class StringClient {
+    constructor() { }
+
+    public generateUUIDv7(): string {
+        const timestamp = BigInt(Date.now()) * BigInt(10000) + BigInt(process.hrtime.bigint() % BigInt(10000));
+        const timeHex = timestamp.toString(16).padStart(16, '0');
+    
+        const randomHex = randomBytes(8).toString('hex');
+    
+        return `${timeHex.slice(0, 8)}-${timeHex.slice(8, 12)}-7${timeHex.slice(13, 16)}-${randomHex.slice(0, 4)}-${randomHex.slice(4)}`;
+    }
+
+    public isUUID(value: any) {
+        return StringUtil.isUUID(value);
+    }
+}

package/src/cron/BaseCron.ts

@@ -0,0 +1,122 @@
+import { Pool, PoolClient } from "pg";
+import { DateType, DayType, HourType, MinuteSecondType, MonthType } from "./CronType";
+import PoolManager from "../PoolManager";
+import { AwsS3Client } from "../clients/AwsS3Client";
+import { Base64Client } from "../clients/Base64Client";
+
+export class BaseCron {
+
+    protected readonly isTest: boolean = process.env.NODE_ENV === 'test';
+    protected dbUser?: string = this.isTest ? process.env.TEST_DB_USER : process.env.DB_USER;
+    protected dbHost?: string = this.isTest ? process.env.TEST_DB_HOST : process.env.DB_HOST;
+    protected dbName?: string = this.isTest ? process.env.TEST_DB_DATABASE : process.env.DB_DATABASE;
+    protected dbPassword?: string = this.isTest ? process.env.TEST_DB_PASSWORD : process.env.DB_PASSWORD;
+    protected dbPort?: string | number = this.isTest ? process.env.TEST_DB_PORT : process.env.DB_PORT;
+    protected dbIsSslConnect: boolean = (this.isTest ? process.env.TEST_DB_IS_SSL : process.env.DB_IS_SSL) === 'true';
+
+    private isExecuteRollback: boolean = false;
+    private pool?: Pool;
+    private client?: PoolClient;
+    protected get Client(): PoolClient { 
+        if (this.client === undefined) {
+            throw new Error("Please call this.PoolClient after using the setClient method.");
+        }
+        return this.client;
+    }
+
+    protected async commit(): Promise<void> {
+        await this.Client.query('COMMIT');
+        this.isExecuteRollback = false;
+    }
+
+    protected async rollback(): Promise<void> {
+        if (this.isExecuteRollback) {
+            await this.Client.query('ROLLBACK');
+        }
+        this.isExecuteRollback = false;
+    }
+
+    // **********************************************************************
+    // こちらのメソッド、プロパティを各サブクラスで設定してください
+    // **********************************************************************
+    protected cronCode: string = '';
+    protected minute: MinuteSecondType | '*' = '*';
+    protected hour: HourType | '*' = '*';
+    protected date: DateType | '*' = '*';
+    protected month: MonthType | '*' = '*';
+    protected day: DayType | '*' = '*';
+    public async run() { }
+
+    // **********************************************************************
+    // ベースクラスで設定
+    // **********************************************************************
+    get CronSchedule(): string {
+        let schedule = '';
+        schedule += this.minute.toString() + ' ';
+        schedule += this.hour.toString() + ' ';
+        schedule += this.date.toString() + ' ';
+        schedule += this.month.toString() + ' ';
+        schedule += this.day.toString();
+        return schedule;
+    }
+    get CronCode(): string { return this.cronCode; }
+
+    public async setUp() {
+        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");
+        }
+
+        this.pool = PoolManager.getPool(this.dbUser, this.dbHost, this.dbName, this.dbPassword, this.dbPort, this.dbIsSslConnect);
+        this.pool.query(`SET TIME ZONE '${process.env.TZ ?? 'Asia/Tokyo'}';`);
+        this.client = await this.pool.connect();
+        await this.Client.query('BEGIN');
+        this.isExecuteRollback = true;
+    }
+
+    public async tearDown() {
+        try {
+            if (this.isExecuteRollback === false) {
+                await this.rollback();
+            }
+        } finally {
+            // クライアント接続をリリース
+            if (this.client) {
+                this.client.release();
+                this.client = undefined;
+            }
+        }
+    }
+
+    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;
+    }
+}

package/src/cron/CronExecuter.ts

@@ -0,0 +1,34 @@
+const cron = require('node-cron');
+import fs from 'fs';
+import path from 'path';
+import { BaseCron } from "./BaseCron";
+
+export const runCron = async (dir: string, logCallback?: (ex: Error) => Promise<void>) => {
+    const files = fs.readdirSync(dir);
+    for (let file of files) {
+        if (['BaseCron.ts'].includes(file)) {
+            continue;
+        }
+
+        const filePath = path.join(dir, file);
+        const module = await import(filePath);
+        const cronClass = module.default;
+        const cronInstance: BaseCron = new cronClass();
+
+        cron.schedule(cronInstance.CronSchedule, async () => {
+            try {
+                await cronInstance.setUp();
+                await cronInstance.run();
+            } catch (ex: unknown) {
+                if (logCallback !== undefined && ex instanceof Error) {
+                    await logCallback(ex).
+                        catch(() => {
+                            // ログ送信時にエラーになっても握りつぶす
+                        });
+                }
+            } finally {
+                await cronInstance.tearDown();
+            }
+        });
+    }
+}

package/src/cron/CronType.ts

@@ -0,0 +1,25 @@
+export type DayType = 
+         1 |  2 |  3 |  4 |  5 |  6 |  7
+
+export type MonthType = 
+         1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9 | 
+   10 | 11 | 12
+
+export type DateType = 
+         1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9 | 
+   10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 |
+   20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 
+   30 | 31
+
+export type HourType = 
+     0 |  1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9 | 
+    10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 |
+    20 | 21 | 22 | 23
+
+export type MinuteSecondType = 
+    0 |  1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9 | 
+   10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 |
+   20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 
+   30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 |
+   40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 |
+   50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59

package/src/documents/Swagger.ts

@@ -0,0 +1,105 @@
+import { Service } from '../Service';
+
+
+export interface IParams {
+    in: 'header' | 'path',
+    name: string,
+    require?: boolean,
+    description?: string,
+    example?: string
+}
+
+export const createSwagger = (services: Service[], name: string, url: string, params: Array<IParams> = []): string => {
+    // *****************************************
+    // Internal method definitions
+    // *****************************************
+    function setYmlByMethod(method: string, swaggerYmlObj: {[key: string]: string}) {
+        if (method in swaggerYmlObj) {
+            swaggerInfo += `    ${method.toLowerCase()}:\n`;
+            swaggerInfo += swaggerYmlObj[method];    
+        }
+    }
+    // *****************************************
+    // Execution part
+    // *****************************************
+    const endpontSwaggerYml: {[keyEndpoint: string]: {[keyMethod: string]: string}} = {};
+    let tags: Array<string> = [];
+
+    for (const service of services) {
+        if (service.Endpoint in endpontSwaggerYml === false) {
+            endpontSwaggerYml[service.Endpoint] = {};
+        }
+        let yml = "";
+    
+        const apiTags = service.Tags;
+        if (apiTags.length > 0) {
+            tags = [ ...tags, ...apiTags];
+            yml += `      tags:\n`;
+            for (const tag of apiTags) {
+                yml += `        - ${tag}\n`;
+            }
+        }
+        yml += `      summary: ${service.Summary}\n`;
+
+        const croneParams = [...params];
+        for (const path of service.Endpoint.split('/')) {
+            if (path.startsWith('{') && path.endsWith('}')) {
+                const key = path.replace('{', '').replace('}', '');
+                croneParams.push({
+                    in: 'path',
+                    name: key,
+                    require: true,
+                    description: key,
+                });
+            }
+        }
+
+        if (croneParams.length > 0) {
+            yml += `      parameters:\n`;
+            for (const param of croneParams) {
+                yml += `        - in: ${param.in}\n`;
+                yml += `          name: ${param.name}\n`;
+                yml += `          required: ${param.require === true ? 'true' : 'false'}\n`;
+                if (param.description !== undefined) {
+                    yml += `          description: |\n            ${param.description}\n`;
+                }
+                if (param.example !== undefined) {
+                    yml += `          example: ${param.example}\n`;
+                }
+                yml += `          schema:\n`;
+                yml += `            type: string\n`;
+            }
+        }
+
+        yml += service.Request.createSwagger(service.Method);
+        yml += service.Response.createSwagger();
+    
+        endpontSwaggerYml[service.Endpoint][service.Method] = yml;
+    }
+
+    let swaggerInfo = `openapi: 3.0.0
+info:
+  title: Your API Documentation
+  version: 1.0.0
+  description: API documentation for your service
+servers:
+  - url: ${url}
+    description: ${name} API IF定義書
+tags:\n`;
+    for (const tag of tags) {
+        swaggerInfo += `  - name: ${tag}\n`;
+    }
+    swaggerInfo += 'paths:\n'
+
+    for (const keyEndpoint in endpontSwaggerYml) {
+        swaggerInfo += `  ${keyEndpoint}:\n`;
+
+        setYmlByMethod('GET', endpontSwaggerYml[keyEndpoint]);
+        setYmlByMethod('POST', endpontSwaggerYml[keyEndpoint]);
+        setYmlByMethod('PUT', endpontSwaggerYml[keyEndpoint]);
+        setYmlByMethod('PATCH', endpontSwaggerYml[keyEndpoint]);
+        setYmlByMethod('DELETE', endpontSwaggerYml[keyEndpoint]);
+    }
+
+    return swaggerInfo;
+}

package/src/exceptions/Exception.ts

@@ -0,0 +1,72 @@
+export class AuthException extends Error {
+    private id: string = "";
+    get Id(): string {
+        return this.id;
+    }
+
+    constructor(id: string, message: string = "") {
+        super(message);
+        this.id = id;
+    }
+}
+
+export class ForbiddenException extends Error {
+}
+
+export class InputErrorException extends Error {
+    private errorId: string = "";
+    get ErrorId(): string {
+        return this.errorId;
+    }
+
+    constructor(errorId: string, message: string = "") {
+        super(message);
+        this.errorId = errorId;
+    }
+}
+
+export class MaintenanceException extends Error {
+
+    constructor(message: string = "") {
+        super(message);
+    }
+}
+
+export class NotFoundException extends Error {
+    // for 404 Not Found
+    private errorId: string = "";
+    get ErrorId(): string {
+        return this.errorId;
+    }
+
+    constructor(errorId: string, message: string = "") {
+        super(message);
+        this.errorId = errorId;
+    }
+}
+
+export class DbConflictException extends Error {
+    // for 409 Conflict
+    private errorId: string = "";
+    get ErrorId(): string {
+        return this.errorId;
+    }
+
+    constructor(errorId: string, message: string = "") {
+        super(message);
+        this.errorId = errorId;
+    }
+}
+
+export class UnprocessableException extends Error {
+    // for 422 Unprocessable Entity
+    private errorId: string = "";
+    get ErrorId(): string {
+        return this.errorId;
+    }
+
+    constructor(errorId: string, message: string = "") {
+        super(message);
+        this.errorId = errorId;
+    }
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+export { Service } from './Service';
+export { MaintenanceException, AuthException, InputErrorException, ForbiddenException, DbConflictException, UnprocessableException, NotFoundException } from './exceptions/Exception';
+export { createSwagger } from './documents/Swagger';
+export { AwsS3Client } from './clients/AwsS3Client';
+export { Base64Client } from './clients/Base64Client';
+export { StringClient } from './clients/StringClient';
+export { EncryptClient } from './clients/EncryptClient';
+
+export { RequestType } from './reqestResponse/RequestType';
+export { ResponseType } from './reqestResponse/ResponseType';
+export { PropertyType } from './reqestResponse/ReqResType';
+
+// models
+export { TableModel } from './models/TableModel';
+export { createTableDoc } from './models/TableDoc';
+export { MigrateTable } from './models/MigrateTable';
+export { MigrateDatabase } from './models/MigrateDatabase';
+export { migrate, rollback } from './models/MigrateRollback';
+
+// cron
+export { DayType, MonthType, DateType, HourType, MinuteSecondType } from './cron/CronType';
+export { BaseCron } from './cron/BaseCron';
+export { runCron } from './cron/CronExecuter';

package/src/models/ExpressionClient.ts

@@ -0,0 +1,72 @@
+import { TableModel } from "./TableModel";
+import { TColumnInfo } from "./Type";
+
+export default class ExpressionClient {
+    private model: TableModel;
+    constructor(model: TableModel) {
+        this.model = model;
+    }
+
+    public toSqlStringValue(value: any): string {
+        if (typeof value === 'string' || typeof value === 'number') {
+            return `'${value}'`;
+        }
+
+        throw new Error('Please enter a value of type string or number.');
+    }
+
+    public toSqlNumberValue(value: any): string {
+        if (typeof value === 'number') {
+            return value.toString();
+        } else if (typeof value === 'string') {
+            if (value.trim() !== "" || isNaN(Number(value)) === false) {
+                return value;
+            }
+        }
+
+        throw new Error('Please enter a value of type number or a string of half-width digits.');
+    }
+
+    public createCaseFromObject(column: string | TColumnInfo, obj: {[key: string | number]: string | number | boolean | null}, elseValue: string | number | boolean | null): string {
+        const columnInfo = typeof column === 'string' ? this.model.getColumn(column) : column.model.getColumn(column.name);
+        if (columnInfo.type !== 'string' && columnInfo.type !== 'integer') {
+            throw new Error('This method cannot be used for columns other than integer, real, or string.');
+        }
+
+        const whenExpression = Object.entries(obj).map(([key, value]) => {
+            let expression = `WHEN ${columnInfo.expression} = `;
+            // 今は文字列と数値だけだが、他のも対応しないといけないかも
+            if (columnInfo.type === 'string') {
+                expression += this.toSqlStringValue(key);
+            } else {
+                expression += this.toSqlNumberValue(key);
+            }
+            expression += ` THEN `;
+
+            if (value === null) {
+                expression += 'null';
+            } else if (typeof value === 'string') {
+                expression += this.toSqlStringValue(value);
+            } else if (typeof value === 'boolean') {
+                expression += `${value}`;                
+            } else {
+                expression += `${value}`;
+            }
+
+            return expression;
+        });
+
+        let elseExpression = `ELSE `;
+        if (elseValue === null) {
+            elseExpression += 'null';
+        } else if (typeof elseValue === 'string') {
+            elseExpression += this.toSqlStringValue(elseValue);
+        } else if (typeof elseValue === 'boolean') {
+            elseExpression += `${elseValue}`;                
+        } else {
+            elseExpression += `${elseValue}`;
+        }
+
+        return `CASE ${whenExpression.join(' ')} ${elseExpression} END`;
+    }
+}