pg-mvc-service 1.0.0

package/dist/clients/Base64Client.js

@@ -0,0 +1,153 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pdf_lib_1 = require("pdf-lib");
+const sharp_1 = __importDefault(require("sharp"));
+class Base64Client {
+    constructor() { }
+    // public encode(text: string): string {
+    //     return Buffer.from(text).toString('base64');
+    // }
+    tryDecode(base64) {
+        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 (_a) {
+            return false;
+        }
+    }
+    getMimeType(data) {
+        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 (_a) {
+            throw new Error('Cannot getMineType because the input is not in base64 format.');
+        }
+    }
+    mergeToPdfBase64(datas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mergedPdf = yield pdf_lib_1.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 = yield pdf_lib_1.PDFDocument.load(buffer);
+                    const pages = yield mergedPdf.copyPages(pdfDoc, pdfDoc.getPageIndices());
+                    pages.forEach(page => mergedPdf.addPage(page));
+                }
+                else {
+                    // convert from image to pdf
+                    const imagePdf = yield this.convertImageToPdf(buffer);
+                    const pdfDoc = yield pdf_lib_1.PDFDocument.load(imagePdf);
+                    const pages = yield mergedPdf.copyPages(pdfDoc, pdfDoc.getPageIndices());
+                    pages.forEach(page => mergedPdf.addPage(page));
+                }
+            }
+            // 結合したPDFをBase64に変換
+            const mergedPdfBytes = yield mergedPdf.save();
+            return Buffer.from(mergedPdfBytes).toString('base64');
+        });
+    }
+    convertImageToPdf(imageBuffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fileType = this.getMimeType(imageBuffer);
+            let optimizedImage;
+            if (fileType === 'image/gif') {
+                // gifの場合はpngに変換して処理
+                optimizedImage = yield (0, sharp_1.default)(imageBuffer)
+                    .png()
+                    .toBuffer();
+            }
+            else {
+                optimizedImage = yield (0, sharp_1.default)(imageBuffer).toBuffer();
+            }
+            // 新しいPDFドキュメントを作成
+            const pdfDoc = yield pdf_lib_1.PDFDocument.create();
+            const page = pdfDoc.addPage();
+            // 画像をPDFに埋め込み
+            let image;
+            if (fileType === 'image/jpeg') {
+                image = yield pdfDoc.embedJpg(optimizedImage);
+            }
+            else {
+                image = yield 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 = yield pdfDoc.save();
+            return Buffer.from(pdfBytes);
+        });
+    }
+}
+exports.default = Base64Client;

package/dist/clients/EncryptClient.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+class EncryptClient {
+    get SecretKey() {
+        if (this.secretKeyHex === undefined) {
+            throw new Error("Please set the secret key.");
+        }
+        return Buffer.from(this.secretKeyHex, 'hex');
+    }
+    get HmacKey() {
+        if (this.hmacKeyBase64 === undefined) {
+            throw new Error("Please set the hmac key.");
+        }
+        return Buffer.from(this.hmacKeyBase64, 'base64');
+    }
+    constructor(params) {
+        this.secretKeyHex = params === null || params === void 0 ? void 0 : params.secretKeyHex;
+        this.hmacKeyBase64 = params === null || params === void 0 ? void 0 : params.hmacKeyBase64;
+    }
+    encryptAndSign(data) {
+        const iv = crypto_1.default.randomBytes(12);
+        const cipher = crypto_1.default.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_1.default.createHmac('sha256', this.HmacKey).update(payload).digest();
+        const signature = this.base64urlEncode(hmac);
+        return `${payload}.${signature}`;
+    }
+    isValidToken(token) {
+        // 形式チェック、.で区切られているか？
+        const [payload, signature] = token.split('.');
+        if (!payload || !signature) {
+            return false;
+        }
+        // 改竄チェック
+        const expectedSig = crypto_1.default.createHmac('sha256', this.HmacKey).update(payload).digest();
+        const expectedSigStr = this.base64urlEncode(expectedSig);
+        if (signature !== expectedSigStr) {
+            return false;
+        }
+        return true;
+    }
+    decrypt(token) {
+        // 形式チェック、.で区切られているか？
+        const [payload, signature] = token.split('.');
+        if (!payload || !signature) {
+            throw new Error('Invalid token format');
+        }
+        // 改竄チェック
+        const expectedSig = crypto_1.default.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_1.default.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'));
+    }
+    base64urlEncode(buffer) {
+        return buffer.toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+    }
+    base64urlDecode(str) {
+        str = str.replace(/-/g, '+').replace(/_/g, '/');
+        while (str.length % 4 !== 0) {
+            str += '=';
+        }
+        return Buffer.from(str, 'base64');
+    }
+}
+exports.default = EncryptClient;

package/dist/clients/StringClient.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+class StringClient {
+    constructor() { }
+    generateUUIDv7() {
+        const timestamp = BigInt(Date.now()) * BigInt(10000) + BigInt(process.hrtime.bigint() % BigInt(10000));
+        const timeHex = timestamp.toString(16).padStart(16, '0');
+        const randomHex = (0, crypto_1.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)}`;
+    }
+}
+exports.default = StringClient;

package/dist/documents/Swagger.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSwagger = void 0;
+const createSwagger = (services, name, url, params = []) => {
+    // *****************************************
+    // Internal method definitions
+    // *****************************************
+    function setYmlByMethod(method, swaggerYmlObj) {
+        if (method in swaggerYmlObj) {
+            swaggerInfo += `    ${method.toLowerCase()}:\n`;
+            swaggerInfo += swaggerYmlObj[method];
+        }
+    }
+    // *****************************************
+    // Execution part
+    // *****************************************
+    const endpontSwaggerYml = {};
+    let tags = [];
+    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;
+};
+exports.createSwagger = createSwagger;

package/dist/exceptions/Exception.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BusinessLogicException = exports.DbConflictException = exports.MaintenanceException = exports.InputErrorException = exports.ForbiddenException = exports.AuthException = void 0;
+class AuthException extends Error {
+    get Id() {
+        return this.id;
+    }
+    constructor(id, message = "") {
+        super(message);
+        this.id = "";
+        this.id = id;
+    }
+}
+exports.AuthException = AuthException;
+class ForbiddenException extends Error {
+}
+exports.ForbiddenException = ForbiddenException;
+class InputErrorException extends Error {
+    get ErrorId() {
+        return this.errorId;
+    }
+    get ErrorLog() {
+        return this.errorLog;
+    }
+    constructor(errorId, message = "", errorLog = "") {
+        super(message);
+        this.errorId = "";
+        this.errorLog = "";
+        this.errorId = errorId;
+        this.errorLog = errorLog;
+    }
+}
+exports.InputErrorException = InputErrorException;
+class MaintenanceException extends Error {
+    constructor(message = "") {
+        super(message);
+    }
+}
+exports.MaintenanceException = MaintenanceException;
+class DbConflictException extends Error {
+    // for 409 Conflict
+    constructor(message = "") {
+        super(message);
+    }
+}
+exports.DbConflictException = DbConflictException;
+class BusinessLogicException extends Error {
+    // for 422 Unprocessable Entity
+    constructor(message = "") {
+        super(message);
+    }
+}
+exports.BusinessLogicException = BusinessLogicException;

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseType = exports.RequestType = exports.createSwagger = exports.ForbiddenException = exports.InputErrorException = exports.AuthException = exports.MaintenanceException = exports.Service = void 0;
+var Service_1 = require("./Service");
+Object.defineProperty(exports, "Service", { enumerable: true, get: function () { return Service_1.Service; } });
+var Exception_1 = require("./exceptions/Exception");
+Object.defineProperty(exports, "MaintenanceException", { enumerable: true, get: function () { return Exception_1.MaintenanceException; } });
+Object.defineProperty(exports, "AuthException", { enumerable: true, get: function () { return Exception_1.AuthException; } });
+Object.defineProperty(exports, "InputErrorException", { enumerable: true, get: function () { return Exception_1.InputErrorException; } });
+Object.defineProperty(exports, "ForbiddenException", { enumerable: true, get: function () { return Exception_1.ForbiddenException; } });
+var Swagger_1 = require("./documents/Swagger");
+Object.defineProperty(exports, "createSwagger", { enumerable: true, get: function () { return Swagger_1.createSwagger; } });
+var RequestType_1 = require("./reqestResponse/RequestType");
+Object.defineProperty(exports, "RequestType", { enumerable: true, get: function () { return RequestType_1.RequestType; } });
+var ResponseType_1 = require("./reqestResponse/ResponseType");
+Object.defineProperty(exports, "ResponseType", { enumerable: true, get: function () { return ResponseType_1.ResponseType; } });

package/dist/models/MigrateDatabase.js

@@ -0,0 +1,138 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrateDatabase = void 0;
+class MigrateDatabase {
+    get DbName() { return this.dbName; }
+    get UserName() { return this.userName; }
+    get Password() {
+        return this.password;
+    }
+    constructor(dbName, userName, pool) {
+        this.password = null;
+        this.dbName = dbName;
+        this.userName = userName;
+        this.pool = pool;
+    }
+    IsExistUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sql = `
+            SELECT count(*) > 0 as is_exist
+            FROM pg_roles
+            WHERE rolname = '${this.UserName}';
+        `;
+            const datas = yield this.pool.query(sql);
+            return datas.rows[0].is_exist;
+        });
+    }
+    CreateUser() {
+        return __awaiter(this, arguments, void 0, function* (password = '') {
+            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};
+        `;
+            yield this.pool.query(sql);
+        });
+    }
+    IsExistDb() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sql = `
+            SELECT count(*) > 0 as is_exist
+            FROM pg_database
+            WHERE datname = '${this.DbName}';
+        `;
+            const datas = yield this.pool.query(sql);
+            return datas.rows[0].is_exist;
+        });
+    }
+    CreateDb() {
+        return __awaiter(this, arguments, void 0, function* (collateType = 'C') {
+            const sql = `
+            CREATE DATABASE ${this.DbName}
+                WITH OWNER = ${this.UserName}
+                ENCODING = 'UTF8'
+                LC_COLLATE = '${collateType}'
+                LC_CTYPE = '${collateType}'
+                CONNECTION LIMIT = -1;
+        `;
+            yield this.pool.query(sql);
+        });
+    }
+    RollbackDbSql() {
+        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);
+    }
+    RollbackUserSql(otherUserName) {
+        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);
+    }
+    trimSpaceLineSql(str) {
+        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;
+    }
+}
+exports.MigrateDatabase = MigrateDatabase;