pg-mvc-service 2.1.0 → 2.1.1

package/src/clients/AwsS3Client.ts

@@ -1,310 +0,0 @@
-import { _Object, DeleteObjectsCommand, GetObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client, ScanRange } from '@aws-sdk/client-s3';
-import { Base64Client } from './Base64Client';
-import { UnprocessableException } from '../exceptions/Exception';
-import axios from 'axios';
-
-type IUploadResponse = {
-    url: string;
-    fileName: string;
-}
-
-export class AwsS3Client {
-    private client: S3Client;
-
-    private readonly bucketName;
-    private readonly region;
-    get UrlPrefix(): string {
-        return `https://${this.bucketName}.s3.${this.region}.amazonaws.com`;
-    }
-
-    constructor(params: {bucketName?: string, region?: string; accessKeyId?: string, secretAccessKey?: string}) {
-        if (params.bucketName === undefined) {
-            throw new Error("Please specify the bucketName.");
-        }
-
-        if (params.region === undefined) {
-            throw new Error("Please specify the region.");
-        }
-
-        if (params.accessKeyId === undefined) {
-            throw new Error("Please specify the accessKeyId.");
-        }
-
-        if (params.secretAccessKey === undefined) {
-            throw new Error("Please specify the secretAccessKey.");
-        }
-
-        this.client = new S3Client({
-            region: params.region,
-            credentials: {
-                accessKeyId: params.accessKeyId,
-                secretAccessKey: params.secretAccessKey
-            }
-        });
-
-        this.region = params.region;
-        this.bucketName = params.bucketName;
-    }
-
-    private makeKey(path: string, fileName?: string): string {
-        path = path.replace(/^\/|\/$/g, '');
-        if ((fileName ?? '').trim().length > 0) {
-            path += '/' + fileName;
-        }
-        return path;
-    }
-
-    public url(path: string, fileName: string = '') {
-        path = path.replace(/^\/|\/$/g, '');
-        let url = `${this.UrlPrefix}`;
-        if (path !== '') {
-            url += '/' + path;
-        }
-
-        if (fileName.trim().length > 0) {
-            url += '/' + fileName;
-        }
-        return url;
-    }
-
-    public async uploadJson(path: string, fileName: string, data: {[key: string]: any}) {
-        const command = new PutObjectCommand({
-            Bucket: this.bucketName,
-            Key: this.makeKey(path, fileName),
-            Body: JSON.stringify(data),
-            ContentType: 'text/plain; charset=utf-8'
-        });
-        await this.client.send(command);
-    }
-
-    public async uploadToPdf(path: string, fileName: string, base64Datas: Array<string>) {
-        const base64Client = new Base64Client();
-        const mergedPdfBase64 = await base64Client.mergeToPdfBase64(base64Datas);
-
-        const command = new PutObjectCommand({
-            Bucket: this.bucketName,
-            Key: this.makeKey(path, fileName),
-            Body: Buffer.from(mergedPdfBase64, 'base64'),
-            ContentEncoding: 'base64',
-            ContentType: 'application/pdf'
-        });
-        await this.client.send(command);
-    }
-
-    public async uploadText(path: string, fileName: string, text: string) {
-        const command = new PutObjectCommand({
-            Bucket: this.bucketName,
-            Key: this.makeKey(path, fileName),
-            Body: text,
-            ContentType: 'text/plain; charset=utf-8'
-        });
-        await this.client.send(command);
-    }
-
-    public async uploadBase64Data(path: string, fileName: string, base64Data: string) : Promise<IUploadResponse> {
-        const base64Client = new Base64Client();
-
-        const type = base64Client.getMimeType(base64Data);
-        const extension = {
-            'image/png': '.png',
-            'image/jpeg': '.jpeg',
-            'image/gif': '.gif',
-            'application/pdf': '.pdf'
-        }[type];
-        if (fileName.endsWith(extension) === false) {
-            fileName += extension;
-        }
-
-        const key = this.makeKey(path, fileName);
-        const command = new PutObjectCommand({
-            Bucket: this.bucketName,
-            Key: key,
-            Body: Buffer.from(base64Data, 'base64'),
-            ContentEncoding: 'base64',
-            ContentType: type
-        });
-        await this.client.send(command);
-        
-        return {
-            url: `${this.UrlPrefix}/${key}`,
-            fileName: fileName
-        }
-    }
-
-    public async uploadFromUrl(path: string, fileName: string, url: string): Promise<IUploadResponse> {
-        try {
-            // URLからデータを取得
-            const response = await axios.get(url, {
-                responseType: 'arraybuffer',
-                timeout: 30000,
-            });
-
-            // Content-Typeを取得
-            const contentType = response.headers['content-type'] || 'application/octet-stream';
-            
-            const key = this.makeKey(path, fileName);
-            const command = new PutObjectCommand({
-                Bucket: this.bucketName,
-                Key: key,
-                Body: Buffer.from(response.data),
-                ContentType: contentType,
-                ContentLength: response.data.length
-            });
-            
-            await this.client.send(command);
-            
-            // アップロードされたファイルのURLを返す
-            return {
-                url: this.url(path, fileName),
-                fileName: fileName
-            }
-        } catch (error) {
-            if (axios.isAxiosError(error)) {
-                if (error.response) {
-                    throw new UnprocessableException(`Failed to download from URL. HTTP ${error.response.status}: ${error.response.statusText}`);
-                } else if (error.request) {
-                    throw new UnprocessableException('Failed to connect to the URL. Please check if the URL is accessible.');
-                } else {
-                    throw new UnprocessableException('Invalid URL format.');
-                }
-            }
-            throw new UnprocessableException('Failed to upload from URL.');
-        }
-    }
-
-    public async uploadStackText(path: string, fileName: string, text: string) {
-        let preText = await this.getText(path, fileName);
-        if (typeof preText === 'string') {
-            text = preText + '\n' + text;
-        }
-
-        await this.uploadText(path, fileName, text);
-    }
-
-    public async getText(path: string, fileName: string) : Promise<string | null> {
-        try {
-            const command = new GetObjectCommand({
-                Bucket: this.bucketName,
-                Key: this.makeKey(path, fileName),
-            });
-            const res = await this.client.send(command);
-
-            if (res.Body === undefined) {
-                throw new Error(`Failed to get text data. Response body is undefined.`);
-            }
-
-            if (res.ContentType?.startsWith('text/') === false) {
-                throw new Error(`Cannot get text data from non-text file. ContentType: ${res.ContentType}`);
-            }
-
-            // v3ではBodyがReadableStreamなので、変換が必要
-            const chunks: Uint8Array[] = [];
-            if (res.Body && typeof res.Body === 'object' && 'getReader' in res.Body) {
-                // ReadableStreamの場合
-                const stream = res.Body as ReadableStream;
-                const reader = stream.getReader();
-                
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) break;
-                    chunks.push(value);
-                }
-            } else {
-                // Node.js Readableの場合
-                for await (const chunk of res.Body as any) {
-                    chunks.push(chunk);
-                }
-            }
-            
-            const buffer = Buffer.concat(chunks);
-            return buffer.toString('utf-8');
-        } catch (ex: unknown) {
-            if (ex instanceof Error && ex.name === 'NoSuchKey') {
-                return null;
-            }
-            throw ex;
-        }
-    }
-
-    public async getFilesInDir(path: string): Promise<Array<_Object>> {
-        const listCommand = new ListObjectsV2Command({
-            Bucket: this.bucketName,
-            Prefix: this.makeKey(path),
-        });
-
-        const data = await this.client.send(listCommand);
-        return data.Contents ?? [];
-    }
-
-    public async getDataFronJson<T = any>(path: string, fileName: string): Promise<T> {
-        const command = new GetObjectCommand({
-            Bucket: this.bucketName,
-            Key: this.makeKey(path, fileName),
-        });
-        const res = await this.client.send(command);
-
-        if (res.Body === undefined) {
-            throw new Error(`Failed to get JSON data. Response body is undefined.`);
-        }
-
-        if (res.ContentType !== 'application/json') {
-            throw new Error(`Cannot get JSON data from non-JSON file. ContentType: ${res.ContentType}`);
-        }
-
-        // v3ではBodyがReadableなので、変換が必要
-        const chunks: Uint8Array[] = [];
-        for await (const chunk of res.Body as any) {
-            chunks.push(chunk);
-        }
-        
-        const buffer = Buffer.concat(chunks);
-        const jsonString = buffer.toString('utf-8');
-        return JSON.parse(jsonString) as T;
-    }
-
-    public async deleteFile(path: string, fileName: string): Promise<void> {
-        const key = this.makeKey(path, fileName);
-        const command = new DeleteObjectsCommand({
-            Bucket: this.bucketName,
-            Delete: {
-                Objects: [{ Key: key }]
-            }
-        });
-        await this.client.send(command);
-    }
-
-    public async deleteDir(path: string): Promise<void> {
-        const files = await this.getFilesInDir(path);
-        if (files.length > 0) {
-            const deleteCommand = new DeleteObjectsCommand({
-                Bucket: this.bucketName,
-                Delete: {
-                    Objects: files.map((file) => ({ Key: file.Key })),
-                },
-            });
-            await this.client.send(deleteCommand);
-        }
-    }
-
-    public async deleteFromUrl(url: string, isFileUrl: boolean = true): Promise<void> {
-        const path = url.replace(this.UrlPrefix + '/', '');
-        if (url === path) {
-            throw new UnprocessableException('The specified URL cannot be deleted because the bucket and region do not match.');
-        }
-
-        if (path.trim() === "") {
-            throw new UnprocessableException('This URL is invalid.');
-        }
-
-        if (isFileUrl) {
-            const pathSplits = path.split('/');
-            const file = pathSplits.pop();
-            if (file === undefined) {
-                throw new UnprocessableException('This URL is invalid.');
-            }
-            await this.deleteFile(pathSplits.join('/'), file);
-        } else {
-            await this.deleteDir(path);
-        }
-    }
-}

package/src/clients/Base64Client.ts

@@ -1,305 +0,0 @@
-import axios from 'axios';
-import { PDFDocument } from 'pdf-lib';
-import sharp from 'sharp';
-import { ValidateStringUtil } from 'type-utils-n-daira';
-
-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 class Base64Client {
-    public readonly PREFIX_JPEG_DATA = '/9j/';
-    public readonly PREFIX_PNG_DATA = 'iVBORw0KGgo';
-
-    constructor() { }
-
-    // public encode(text: string): string {
-    //     return Buffer.from(text).toString('base64');
-    // }
-
-    public tryDecode(base64: string): Buffer | 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): 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);
-    }
-
-    public isJpeg(value: any): value is string {
-        if (ValidateStringUtil.isBase64(value) === false) {
-            return false
-        }
-
-        if (value.startsWith('data:')) {
-            if (value.startsWith('data:image/jpeg,') === false && value.startsWith('data:image/jpg,') === false) {
-                return false;
-            }
-
-            const valueParts = value.split(',');
-            if (valueParts.length !== 2) {
-                return false;
-            }
-
-            return valueParts[1].startsWith(this.PREFIX_JPEG_DATA);
-        }
-
-        return value.startsWith(this.PREFIX_JPEG_DATA);
-    }
-
-    public isPng(value: any): value is string {
-        if (ValidateStringUtil.isBase64(value) === false) {
-            return false
-        }
-
-        if (value.startsWith('data:')) {
-            if (value.startsWith('data:image/png,') === false) {
-                return false;
-            }
-
-            const valueParts = value.split(',');
-            if (valueParts.length !== 2) {
-                return false;
-            }
-
-            return valueParts[1].startsWith(this.PREFIX_PNG_DATA);
-        }
-
-        return value.startsWith(this.PREFIX_PNG_DATA);
-    }
-
-    public async tryConvertToPng(base64Value: any): Promise<string | false> {
-        if (ValidateStringUtil.isBase64(base64Value) === false) {
-            return false;
-        }
-
-        const base64Data = base64Value.startsWith('data:') ? base64Value.split(',')[1] : base64Value;
-        if (this.isPng(base64Data)) {
-            return base64Data;
-        } else if (this.isJpeg(base64Data)) {
-            const buffer = Buffer.from(base64Data, 'base64');
-            try {
-                const pngBuffer = await sharp(buffer)
-                    .ensureAlpha().png().toBuffer();
-                return pngBuffer.toString('base64');
-            } catch (e) {
-                return false;
-            }
-        }
-
-        return false;
-    }
-
-    public async resizeImage(base64Data: string, toSize: {w: number} | {h: number} | {w: number; h: number; func: 'max' | 'min'}| {rate: number}): Promise<string> {
-        if (ValidateStringUtil.isBase64(base64Data) === false) {
-            throw new Error("The specified data is not in base64 format");
-        }
-
-        const imageBuffer = Buffer.from(base64Data, 'base64');
-        const metadata = await sharp(imageBuffer).metadata();
-        const { width, height, format } = metadata;
-        if (width === undefined || height === undefined) {
-            throw new Error("Failed to retrieve image dimensions");
-        }
-        
-        let rate = 1;
-        if ('rate' in toSize) {
-            rate = toSize.rate;
-        } else if ('w' in toSize && 'h' in toSize && 'func' in toSize) {
-            const wRate = toSize.w / width;
-            const hRate = toSize.h / height;
-            switch (toSize.func) {
-                case 'max':
-                    rate = Math.max(wRate, hRate);
-                    break;
-                case 'min':
-                    rate = Math.min(wRate, hRate);
-                    break;
-            }
-
-        } else if ('w' in toSize) {
-            rate = toSize.w / width;
-        } else if ('h' in toSize) {
-            rate = toSize.h / height;
-        }
-
-        // 画像は1倍より大きくできないので
-        if (rate >= 1 || rate <= 0) {
-            return base64Data;
-        }
-
-        let resizedImage: Buffer;
-
-        // フォーマットに応じて処理を分岐
-        const targetWidth = Math.round(width * rate);
-        const targetHeight = Math.round(height * rate);
-        if (format === 'png') {
-            resizedImage = await sharp(imageBuffer)
-                .resize(targetWidth, targetHeight, {
-                    fit: 'inside',
-                    withoutEnlargement: true
-                })
-                .png({ quality: 90 })
-                .toBuffer();
-        } else {
-            // JPEG、その他のフォーマット
-            resizedImage = await sharp(imageBuffer)
-                .resize(targetWidth, targetHeight, {
-                    fit: 'inside',
-                    withoutEnlargement: true
-                })
-                .jpeg({ quality: 90 })
-                .toBuffer();
-        }
-
-        return resizedImage.toString('base64');
-    }
-
-    public async fetchImageAsBase64(imageUrl: string): Promise<string> {
-        const res = await axios.get(imageUrl, {
-            responseType: 'arraybuffer'  // これを追加
-        });
-
-        // Content-Typeをチェック
-        const contentType = res.headers['content-type'];
-        if (!contentType?.startsWith('image/')) {
-            throw new Error(`Invalid content type: ${contentType}. Expected image/*`);
-        }
-
-        // ArrayBufferをBufferに変換してBase64にエンコード
-        const buffer = Buffer.from(res.data);
-        return buffer.toString('base64');
-    }
-}