pg-mvc-service 1.0.0

package/src/clients/Base64Client.ts

@@ -0,0 +1,155 @@
+import { PDFDocument } from 'pdf-lib';
+import sharp from 'sharp';
+
+export type TPng = 'image/png';
+export type TJpeg = 'image/jpeg';
+export type TGif = 'image/gif';
+export type TImage = TPng | TJpeg | TGif;
+
+export type TPdf = 'application/pdf';
+export type TJson = 'application/json';
+
+export default class Base64Client {
+    constructor() { }
+
+    // public encode(text: string): string {
+    //     return Buffer.from(text).toString('base64');
+    // }
+
+    public tryDecode(base64: string): Buffer<ArrayBuffer> | false {
+        try {
+            // Data URLのパターンをチェック
+            if (base64.startsWith('data:')) {
+                const matches = base64.match(/^data:([A-Za-z-+/]+);base64,(.+)$/);
+                if (!matches || matches.length !== 3) {
+                    return false;
+                }
+                // base64部分のみを取得
+                base64 = matches[2];
+            }
+
+            if (base64.length % 4 !== 0) {
+                return false;
+            }
+
+            const regex = /^[A-Za-z0-9+/]*={0,2}$/;
+            if (!regex.test(base64)) {
+                return false;
+            }
+
+            return Buffer.from(base64, 'base64');
+        } catch {
+            return false;
+        }
+    }
+
+    public getMimeType(data: string | Buffer<ArrayBuffer>): TImage | TPdf {
+        try {
+            let buffer;
+            if (typeof data === 'string') {
+                // Data URLのパターンをチェック
+                if (data.startsWith('data:')) {
+                    const matches = data.match(/^data:([A-Za-z-+/]+);base64,(.+)$/);
+                    if (!matches || matches.length !== 3) {
+                        throw new Error('Invalid Data URL format');
+                    }
+                    // base64部分のみを取得
+                    data = matches[2];
+                }
+                buffer = this.tryDecode(data);
+            } else {
+                buffer = data;
+            }
+
+            if (buffer === false) {
+                throw new Error('Cannot getMineType because the input is not in base64 format.');
+            }
+
+            const header = buffer.subarray(0, 4);
+            if (header[0] === 0x25 && header[1] === 0x50 && header[2] === 0x44 && header[3] === 0x46) {
+                return 'application/pdf';
+            } else if (header[0] === 0x89 && header[1] === 0x50 && header[2] === 0x4E && header[3] === 0x47) {
+                return 'image/png';
+            } else if (header[0] === 0xFF && header[1] === 0xD8) {
+                return 'image/jpeg';
+            } else if (header[0] === 0x47 && header[1] === 0x49 && header[2] === 0x46 && header[3] === 0x38) {
+                return 'image/gif';
+            }
+
+            throw new Error('Cannot getMimeType because the file type is not PDF, PNG, JPEG, or GIF.');
+        } catch {
+            throw new Error('Cannot getMineType because the input is not in base64 format.');
+        }
+    }
+
+    public async mergeToPdfBase64(datas: string[]): Promise<string> {
+        const mergedPdf = await PDFDocument.create();
+
+        for (const data of datas) {
+            const buffer = this.tryDecode(data);
+            if (buffer === false) {
+                throw new Error('Cannot mergeToPdf because the input is not in base64 format.');
+            }
+
+            const fileType = this.getMimeType(buffer);
+            if (fileType === 'application/pdf') {
+                const pdfDoc = await PDFDocument.load(buffer);
+                const pages = await mergedPdf.copyPages(pdfDoc, pdfDoc.getPageIndices());
+                pages.forEach(page => mergedPdf.addPage(page));
+            } else {
+                // convert from image to pdf
+                const imagePdf = await this.convertImageToPdf(buffer);
+                const pdfDoc = await PDFDocument.load(imagePdf);
+                const pages = await mergedPdf.copyPages(pdfDoc, pdfDoc.getPageIndices());
+                pages.forEach(page => mergedPdf.addPage(page));
+            }
+        }
+
+        // 結合したPDFをBase64に変換
+        const mergedPdfBytes = await mergedPdf.save();
+        return Buffer.from(mergedPdfBytes).toString('base64');
+    }
+
+    private async convertImageToPdf(imageBuffer: Buffer): Promise<Buffer> {
+        const fileType = this.getMimeType(imageBuffer);
+
+        let optimizedImage;
+        if (fileType === 'image/gif') {
+            // gifの場合はpngに変換して処理
+            optimizedImage = await sharp(imageBuffer)
+                .png()
+                .toBuffer();
+        } else {
+            optimizedImage = await sharp(imageBuffer).toBuffer();
+        }
+
+        // 新しいPDFドキュメントを作成
+        const pdfDoc = await PDFDocument.create();
+        const page = pdfDoc.addPage();
+
+        // 画像をPDFに埋め込み
+        
+        let image;
+        if (fileType === 'image/jpeg') {
+            image = await pdfDoc.embedJpg(optimizedImage);
+        } else {
+            image = await pdfDoc.embedPng(optimizedImage);
+        }
+        const { width, height } = image.scale(1);
+        
+        // ページサイズを画像に合わせる
+        page.setSize(width, height);
+        
+        // 画像を描画
+        page.drawImage(image, {
+            x: 0,
+            y: 0,
+            width,
+            height,
+        });
+
+        // PDFをバッファに変換
+        const pdfBytes = await pdfDoc.save();
+        return Buffer.from(pdfBytes);
+    }
+}

package/src/clients/EncryptClient.ts

@@ -0,0 +1,100 @@
+import crypto from 'crypto';
+
+export default 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,14 @@
+import { randomBytes } from 'crypto';
+
+export default 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)}`;
+    }
+}

package/src/documents/Swagger.ts

@@ -0,0 +1,111 @@
+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 splitEndpont = service.Endpoint.split('/');
+        let tagName = splitEndpont[0];
+        if (tagName === '' && splitEndpont.length > 1) {
+            tagName = splitEndpont[1];;
+        }
+    
+        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.includes('{') && path.includes('}')) {
+                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,54 @@
+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;
+    }
+
+    private errorLog: string = "";
+    get ErrorLog(): string {
+        return this.errorLog;
+    }
+
+    constructor(errorId: string, message: string = "", errorLog: string = "") {
+        super(message);
+        this.errorId = errorId;
+        this.errorLog = errorLog;
+    }
+}
+
+export class MaintenanceException extends Error {
+
+    constructor(message: string = "") {
+        super(message);
+    }
+}
+
+export class DbConflictException extends Error {
+    // for 409 Conflict
+    constructor(message: string = "") {
+        super(message);
+    }
+}
+
+export class BusinessLogicException extends Error {
+    // for 422 Unprocessable Entity
+    constructor(message: string = "") {
+        super(message);
+    }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export { Service } from './Service';
+export { MaintenanceException, AuthException, InputErrorException, ForbiddenException } from './exceptions/Exception';
+export { createSwagger } from './documents/Swagger';
+
+export { RequestType } from './reqestResponse/RequestType';
+export { ResponseType } from './reqestResponse/ResponseType';
+export { PropertyType } from './reqestResponse/ReqResType';

package/src/models/MigrateDatabase.ts

@@ -0,0 +1,135 @@
+import { Pool } from "pg";
+
+export class MigrateDatabase {
+
+    private dbName: string;
+    get DbName(): string { return this.dbName; }
+    private userName: string;
+    get UserName(): string { return this.userName; }
+    private password: string | null = null;
+    get Password(): string | null {
+        return this.password;
+    }
+    private pool: Pool;
+
+    constructor (dbName: string, userName: string, pool: Pool) {
+        this.dbName = dbName;
+        this.userName = userName;
+        this.pool = pool;
+    }
+
+    public async IsExistUser(): Promise<boolean> {
+        const sql = `
+            SELECT count(*) > 0 as is_exist
+            FROM pg_roles
+            WHERE rolname = '${this.UserName}';
+        `;
+        const datas = await this.pool.query(sql);
+        return datas.rows[0].is_exist;
+    }
+
+    public async CreateUser(password: string = ''): Promise<void> {
+        if (password.trim() === '') {
+            password = '';
+
+            const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@$%^&*_+|;:.<>?';
+            for (let i = 0; i < 36; i++) {
+                const randomIndex = Math.floor(Math.random() * characters.length);
+                password += characters[randomIndex];
+            }
+        }
+        this.password = password;
+
+        const sql = `
+            DO $$
+            BEGIN
+                IF NOT EXISTS (
+                    SELECT FROM pg_catalog.pg_roles WHERE rolname = '${this.UserName}'
+                ) THEN
+                    CREATE USER ${this.UserName} WITH PASSWORD '${password}';
+                END IF;
+            END
+            $$;
+
+            GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO ${this.UserName};
+
+            ALTER DEFAULT PRIVILEGES IN SCHEMA public
+            GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO ${this.UserName};
+        `;
+        await this.pool.query(sql);
+    }
+
+    public async IsExistDb(): Promise<boolean> {
+        const sql = `
+            SELECT count(*) > 0 as is_exist
+            FROM pg_database
+            WHERE datname = '${this.DbName}';
+        `;
+        const datas = await this.pool.query(sql);
+        return datas.rows[0].is_exist;
+    }
+
+    public async CreateDb(collateType: string = 'C'): Promise<void> {
+        const sql = `
+            CREATE DATABASE ${this.DbName}
+                WITH OWNER = ${this.UserName}
+                ENCODING = 'UTF8'
+                LC_COLLATE = '${collateType}'
+                LC_CTYPE = '${collateType}'
+                CONNECTION LIMIT = -1;
+        `;
+        await this.pool.query(sql);
+    }
+
+    public RollbackDbSql(): string {
+        const sql = `
+            -- ${this.DbName}データベースに接続しているすべてのセッションを強制終了
+            SELECT pg_terminate_backend(pid)
+            FROM pg_stat_activity
+            WHERE datname = '${this.DbName}';
+
+            -- DB削除
+            DROP DATABASE IF EXISTS ${this.DbName};`;
+        return this.trimSpaceLineSql(sql);
+    }
+
+    public RollbackUserSql(otherUserName: string): string {
+        const sql = `
+            -- 1. すべてのセッションを強制終了
+            SELECT pg_terminate_backend(pg_stat_activity.pid)
+            FROM pg_stat_activity
+            WHERE usename = '${this.UserName}';
+
+            -- 2. 所有オブジェクトを ${otherUserName} に移行
+            REASSIGN OWNED BY ${this.UserName} TO ${otherUserName};
+
+            -- 2. すべての権限を削除
+            DROP OWNED BY ${this.UserName} CASCADE;
+
+            -- 3. ロールを削除
+            DROP ROLE IF EXISTS ${this.UserName};`;
+        return this.trimSpaceLineSql(sql);
+    }
+
+    private trimSpaceLineSql(str: string) {
+        const splitLines = str.split('\n');
+        let sql = '';
+        for (let line of splitLines) {
+            line = line.replace(/\s+/g, ' ').trim(); // 複数のスペースを一つに置き換え
+
+            if (line.startsWith('--') && sql[sql.length - 1] != '\n') {
+                line = '\n' + line;
+            }
+
+            if (line.length > 0) {
+                if (line.includes('--') === false) {
+                    sql += line + ' ';
+                } else {
+                    sql += line + '\n';
+                }
+            }
+        }
+
+        return sql;
+    }
+}