@resolveio/server-lib 22.3.219 → 22.3.221

package/src/methods/aws.ts

@@ -0,0 +1,649 @@
+import { GetObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import axios from 'axios';
+import SimpleSchema from 'simpl-schema';
+import { Files } from '../collections/file.collection';
+import { AWS, MethodManager } from '../managers/method.manager';
+import { ResolveIOServer } from '../resolveio-server-app';
+import { objectIdHexString } from '../util/common';
+let fs = require('fs');
+let path = require('path');
+let pdfCnt = 1000000;
+
+const NON_PDF_CONTENT_TYPES = {
+	'.csv': 'text/csv; charset=utf-8',
+	'.css': 'text/css; charset=utf-8',
+	'.env': 'text/plain; charset=utf-8',
+	'.gz': 'application/gzip',
+	'.html': 'text/html; charset=utf-8',
+	'.json': 'application/json',
+	'.js': 'application/javascript',
+	'.md': 'text/markdown; charset=utf-8',
+	'.tar': 'application/x-tar',
+	'.tgz': 'application/gzip',
+	'.ts': 'application/typescript',
+	'.txt': 'text/plain; charset=utf-8',
+	'.xml': 'application/xml',
+	'.yaml': 'application/yaml',
+	'.yml': 'application/yaml',
+	'.zip': 'application/zip'
+};
+
+function inferNonPDFContentType(fileName: string): string {
+	if (!fileName) {
+		return 'application/octet-stream';
+	}
+
+	const normalized = fileName.toLowerCase();
+	if (normalized.endsWith('.tar.gz')) {
+		return 'application/gzip';
+	}
+
+	const extension = path.extname(normalized);
+	return NON_PDF_CONTENT_TYPES[extension] || 'application/octet-stream';
+}
+
+export function loadAWSMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		uploadFileAndSave: {
+			check: new SimpleSchema({
+				fileName: {
+					type: String
+				},
+				fileData: {
+					type: String
+				},
+				fileSize: {
+					type: Number
+				},
+				fileOrder: {
+					type: Number
+				},
+				fileType: {
+					type: String
+				},
+				compress: {
+					type: Boolean
+				}
+			}),
+			// eslint-disable-next-line no-unused-vars
+			function: async function(fileName: string, fileData: string, fileSize: number, fileOrder: number, fileType: string, compress: Boolean) {
+				if (!fileName) {
+					throw new Error("Invalid File Name provided");
+				}
+
+				let key = 'uploads/' + Date.now() + '-' + (pdfCnt++) + '-' + fileName;
+				let s3 = (<AWS>this.getAWS()).s3();
+				const maxRetries = 3;
+				let attempt = 0;
+
+				while (attempt <= maxRetries) {
+					try {
+						let res = await s3.putObject({
+							Bucket: process.env.AWS_S3_BUCKET,
+							Key: key,
+							Body: Buffer.from(fileData.replace('data:' + fileData.split(',')[0].split(':')[1].split(';')[0] + ';base64,', ''), 'base64'), 
+							ACL: 'private', 
+							ContentType: fileData.split(',')[0].split(':')[1].split(';')[0], 
+							ContentDisposition: 'inline'
+						});
+
+						if (res) {
+							return Files.create({
+								_id: objectIdHexString(), __v: 0, name: fileName, size: fileSize, key: key, order: fileOrder, type: fileType
+							});
+						}
+						else {
+							return null;
+						}
+					}
+					catch (err) {
+						attempt++;
+						if (attempt <= maxRetries) {
+							const backoff = Math.pow(2, attempt) * 1000;
+							console.warn(`Attempt ${attempt} failed. Retrying in ${backoff / 1000} seconds...`);
+							// eslint-disable-next-line no-restricted-syntax
+							await new Promise(resolve => setTimeout(resolve, backoff));
+						} 
+						else {
+							throw new Error(`Error in AWS Upload File And Save: Failed to upload after ${maxRetries} attempts: ${err.message}`);
+						}
+					}
+				}
+
+				return null;
+			}
+		},
+			uploadPDFBufferAndSave: {
+			check: new SimpleSchema({
+				fileName: {
+					type: String
+				},
+				fileDataBuffer: {
+					type: Buffer
+				},
+				fileSize: {
+					type: Number
+				},
+				fileOrder: {
+					type: Number
+				},
+				fileType: {
+					type: String
+				}
+				}),
+				function: async function(fileName: string, fileDataBuffer: any, fileSize: number, fileOrder: number, fileType: string) {
+					if (!fileName) {
+						throw new Error("Invalid File Name provided");
+					}
+
+				let key = 'uploads/' + Date.now() + '-' + (pdfCnt++) + '-' + fileName;
+				let s3 = (<AWS>this.getAWS()).s3();
+				const maxRetries = 3;
+				let attempt = 0;
+
+				while (attempt <= maxRetries) {
+					try {
+						let res = await s3.putObject({
+							Bucket: process.env.AWS_S3_BUCKET,
+							Key: key,
+							Body: fileDataBuffer,
+							ACL: 'private',
+							ContentType: 'application/pdf',
+							ContentDisposition: 'inline'
+						});
+
+						if (res) {
+							return Files.create({
+								_id: objectIdHexString(), __v: 0, name: fileName, size: fileSize, key: key, order: fileOrder, type: fileType
+							});
+						}
+						else {
+							return null;
+						}
+					}
+					catch (err) {
+						attempt++;
+						if (attempt <= maxRetries) {
+							const backoff = Math.pow(2, attempt) * 1000;
+							console.warn(`Attempt ${attempt} failed. Retrying in ${backoff / 1000} seconds...`);
+							// eslint-disable-next-line no-restricted-syntax
+							await new Promise(resolve => setTimeout(resolve, backoff));
+						}
+						else {
+							throw new Error(`Error in AWS Upload PDF Buffer And Save: Failed to upload after ${maxRetries} attempts: ${err.message}`);
+						}
+					}
+				}
+
+				return null;
+			}
+		},
+		uploadNonPDFFileAndSave: {
+			check: new SimpleSchema({	
+				fileName: {	
+					type: String	
+				},	
+				fileData: {	
+					type: String	
+				},	
+				fileSize: {	
+					type: Number	
+				},	
+				fileOrder: {	
+					type: Number	
+				},	
+				fileType: {	
+					type: String	
+				}	
+			}),	
+			function: async function(fileName: string, fileData: string, fileSize: number, fileOrder: number, fileType: string) {	
+				if (!fileName) {
+					throw new Error("Invalid File Name provided");
+				}
+
+				let key = 'uploads/' + Date.now() + '-' + fileName;	
+
+				let s3 = (<AWS>this.getAWS()).s3();
+				
+				try {
+					const contentType = inferNonPDFContentType(fileName);
+					let res = await s3.putObject({
+						Bucket: process.env.AWS_S3_BUCKET, 
+						Key: key, 
+						Body: Buffer.from(fileData), 
+						ACL: 'private', 
+						ContentType: contentType, 
+						ContentDisposition: 'inline'
+					});
+
+					if (res) {
+						return Files.create({	
+							_id: objectIdHexString(), __v: 0, name: fileName, size: fileSize, key: key, order: fileOrder, type: fileType
+						});
+					}
+					else {
+						return null;
+					}
+				}
+				catch (err) {
+					err.mesage = 'Error In AWS Upload Non PDF File And Save: ' + err.mesage;
+					throw err;
+				}
+			}	
+		},
+		uploadNonPDFBufferAndSave: {
+			check: new SimpleSchema({	
+				fileName: {	
+					type: String	
+				},	
+				fileDataBuffer: {	
+					type: Buffer
+				},	
+				fileSize: {	
+					type: Number	
+				},	
+				fileOrder: {	
+					type: Number	
+				},	
+				fileType: {	
+					type: String	
+				}	
+			}),	
+			function: async function(fileName: string, fileDataBuffer, fileSize: number, fileOrder: number, fileType: string) {	
+				if (!fileName) {
+					throw new Error("Invalid File Name provided");
+				}
+
+				let key = 'uploads/' + Date.now() + '-' + fileName;	
+				
+				let s3 = (<AWS>this.getAWS()).s3();
+
+				try {
+					const contentType = inferNonPDFContentType(fileName);
+					let res = await s3.putObject({
+						Bucket: process.env.AWS_S3_BUCKET, 
+						Key: key, 
+						Body: fileDataBuffer, 
+						ACL: 'private', 
+						ContentType: contentType, 
+						ContentDisposition: 'inline'
+					});
+
+					if (res) {
+						return Files.create({	
+							_id: objectIdHexString(), __v: 0, name: fileName, size: fileSize, key: key, order: fileOrder, type: fileType
+						});
+					}	
+					else {
+						return null;
+					}
+				}
+				catch (err) {
+					err.mesage = 'Error In AWS Upload Non PDF Buffer And Save: ' + err.mesage;
+					throw err;
+				}
+			}	
+		},
+		uploadNonPDFStreamAndSave: {
+			check: new SimpleSchema({	
+				fileName: {	
+					type: String	
+				},	
+				fileData: {	
+					type: String	
+				},	
+				fileOrder: {	
+					type: Number	
+				},	
+				fileType: {	
+					type: String	
+				}	
+			}),	
+			function: async function(fileName: string, fileData: string, fileOrder: number, fileType: string) {	
+				if (!fileName) {
+					throw new Error("Invalid File Name provided");
+				}
+						
+				let key = 'uploads/' + Date.now() + '-' + fileName;	
+						
+				let s3 = (<AWS>this.getAWS()).s3();
+				
+				try {
+					const contentType = inferNonPDFContentType(fileName);
+					let res = await s3.putObject({
+						Bucket: process.env.AWS_S3_BUCKET, 
+						Key: key, 
+						Body: fs.createReadStream(fileData), 
+						ACL: 'private', 
+						ContentType: contentType, 
+						ContentDisposition: 'inline'
+					});
+
+					if (res) {
+						return Files.create({	
+							_id: objectIdHexString(), __v: 0, name: fileName, size: 1, key: key, order: fileOrder, type: fileType
+						});
+					}
+					else {
+						return null;
+					}
+				}
+				catch (err) {
+					err.mesage = 'Error In AWS Upload Non PDF Stream And Save: ' + err.mesage;
+					throw err;
+				}
+			}	
+		},
+		deleteFiles: {
+			check: new SimpleSchema({
+				keys: {
+					type: Array
+				},
+				'keys.$': {
+					type: String
+				}
+			}),
+			function: async function(keys: string[]) {
+				if (!Array.isArray(keys) || keys.length === 0) {
+					return 0;
+				}
+
+				let files = await Files.find({key: {$in: keys}});
+	
+				let deleteCnt = files.length;
+	
+				for (let file of files) {
+					await Files.deleteOne({_id: file._id});
+					
+					let s3 = (<AWS>this.getAWS()).s3();
+					
+					try {
+						let res = await s3.deleteObject({
+							Bucket: process.env.AWS_S3_BUCKET, 
+							Key: file.key
+						});
+
+						if (res) {
+							deleteCnt--;
+							if (!deleteCnt) {
+								return files.length;
+							}
+						}
+					}
+					catch (err) {
+						err.mesage = 'Error In AWS Delete Files: ' + err.mesage;
+						throw err;
+					}
+				}
+
+				return 0;
+			}
+		},
+		deleteFile: {
+			check: new SimpleSchema({
+				key: {
+					type: String
+				}
+			}),
+			function: async function(key: string) {		
+				let file = await Files.findOne({key: key});
+	
+				if (file) {
+					try {
+						await Files.deleteOne({_id: file._id});
+					}
+					catch (err) {
+						err.mesage = 'Error In AWS Delete File (Resolve Side): ' + err.mesage;
+						throw err;
+					}
+				}
+
+				let s3 = (<AWS>this.getAWS()).s3();
+				
+				try {
+					let res = await s3.deleteObject({
+						Bucket: process.env.AWS_S3_BUCKET,
+						Key: key
+					});
+					
+					return res;
+				}
+				catch (err) {
+					err.mesage = 'Error In AWS Delete File (AWS Side): ' + err.mesage;
+					throw err;
+				}
+			}
+		},
+		deleteFileWithId: {
+			check: new SimpleSchema({
+				id_file: {
+					type: String
+				}
+			}),
+			function: async function(id_file: string) {
+				let file = await Files.findOne({_id: id_file});
+	
+				if (!file) {
+					throw new Error('Error in AWS Delete File With ID: Could not find file');
+				}
+
+				try {
+					await Files.deleteOne({_id: file._id});
+				}
+				catch (err) {
+					err.mesage = 'Error In AWS Delete File With ID (Resolve Side): ' + err.mesage;
+					throw err;
+				}
+	
+				let s3 = (<AWS>this.getAWS()).s3();
+				
+				try {
+					let res = await s3.deleteObject({
+						Bucket: process.env.AWS_S3_BUCKET,
+						Key: file.key
+					});
+
+					return res;
+				}
+				catch (err) {
+					err.mesage = 'Error In AWS Delete File With ID (AWS Side): ' + err.mesage;
+					throw err;
+				}
+			}
+		},
+		getSignedUrlsAndFilesWithId: {
+			check: new SimpleSchema({
+				ids: {
+					type: Array
+				},
+				'ids.$': {
+					type: String
+				},
+				expires: {
+					type: Number
+				}
+			}),
+			function: async function(ids: string[], expires: number) {
+				let res = [];
+
+				let files = await Files.find({_id: {$in: ids}});
+				
+				for (let i = 0; i < files.length; i++) {
+					let file = files[i];
+					let s3 = (<AWS>this.getAWS()).s3();
+					let getCommand = new GetObjectCommand({
+						Bucket: process.env.AWS_S3_BUCKET, 
+						Key: file.key
+					});
+					res.push(await getSignedUrl(s3, getCommand, {expiresIn: expires}));
+				}
+				
+				return {res: res, fileArray: files.map(a => a.name)};
+			}
+		},
+		getSignedUrlWithId: {
+			check: new SimpleSchema({
+				id_file: {
+					type: String
+				},
+				expires: {
+					type: Number
+				}
+			}),
+			function: async function(id_file: string, expires: number) {
+				let file = await Files.findOne({_id: id_file});
+
+				let s3 = (<AWS>this.getAWS()).s3();
+				let getCommand = new GetObjectCommand({
+					Bucket: process.env.AWS_S3_BUCKET, 
+					Key: file.key
+				});
+				
+				return getSignedUrl(s3, getCommand, {expiresIn: expires});
+			}
+		},
+		getSignedUrlUSEast1BucketAndKey: {
+			check: new SimpleSchema({
+				bucket: {
+					type: String
+				},
+				key: {
+					type: String
+				},
+				expires: {
+					type: Number
+				}
+			}),
+			function: function(bucket: string, key: string, expires: number) {
+				let s3 = (<AWS>this.getAWS()).s3USEast1();
+				let getCommand = new GetObjectCommand({
+					Bucket: bucket, 
+					Key: key
+				});
+				
+				return getSignedUrl(s3, getCommand, {expiresIn: expires});
+			}
+		},
+		getSignedUrl: {
+			check: new SimpleSchema({
+				key: {
+					type: String
+				},
+				expires: {
+					type: Number
+				}
+			}),
+			bypassLogs: true,
+			function: function(key: string, expires: number) {
+				let s3 = (<AWS>this.getAWS()).s3();
+				let getCommand = new GetObjectCommand({
+					Bucket: process.env.AWS_S3_BUCKET, 
+					Key: key
+				});
+				
+				return getSignedUrl(s3, getCommand, {expiresIn: expires});
+			}
+		},
+		getSignedUrls: {
+			check: new SimpleSchema({
+				keys: {
+					type: Array
+				},
+				'keys.$': {
+					type: String
+				},
+				expires: {
+					type: Number
+				}
+			}),
+			bypassLogs: true,
+			function: async function(keys: string[], expires: number) {
+				let res = [];
+
+				for (let i = 0; i < keys.length; i++) {
+					let key = keys[i];
+					let s3 = (<AWS>this.getAWS()).s3();
+					let getCommand = new GetObjectCommand({
+						Bucket: process.env.AWS_S3_BUCKET, 
+						Key: key
+					});
+
+					res.push(await getSignedUrl(s3, getCommand, {expiresIn: expires}));
+				}
+
+				return res;
+			}
+		},
+		getDataURIfromURL: {
+			check: new SimpleSchema({
+				url: {
+					type: String
+				}
+			}),
+			bypassLogs: true,
+			function: async function(url: string) {
+				const response = await axios.get(url, {
+					responseType: 'arraybuffer'
+				});
+			
+				if (response.status !== 200) {
+					throw new Error(`Error in Get Data URI From URL: Failed to fetch URL, status: ${response.status}`);
+				}
+			
+				const contentType = response.headers['content-type'];
+				const dataBase64 = Buffer.from(response.data).toString('base64');
+				return `data:${contentType};base64,${dataBase64}`;
+			}
+		},
+		emailFile: {
+			check: new SimpleSchema({
+				id_file: {
+					type: String
+				},
+				email: {
+					type: String
+				},
+                additional_message: {
+                    type: String
+                }
+			}),
+			function: async function(id_file: string, email: string, additional_message) {
+				let file = await Files.findById(id_file);
+
+				if (!file) {
+					throw new Error('Error in AWS Email File: Could not find file');
+				}
+
+				try {
+					let resPDF = await this.callMethod('getSignedUrl', file.key, 259200);
+					
+					if (resPDF) {
+						if (file.size < 5000000) {
+							let emailMessage = 'Attached is the file requested for email.\n' + (additional_message !== '' ? '\nAdditional Message:\n' + additional_message + '\n' : '') ;
+
+							await this.sendEmail(email, ResolveIOServer.getClientName() + ' File - ' + file.name, emailMessage, '', [{
+								filename: file.name,
+								path: resPDF
+							}], null, '');
+						}
+						else {
+							let emailMessage = 'Please click the link to the requested file.\n' + (additional_message !== '' ? '\nAdditional Message:\n' + additional_message + '\n' : '') ;
+							
+							await this.sendEmail(email, ResolveIOServer.getClientName() + ' File - ' + file.name, emailMessage + resPDF, '', null, null, '');
+						}
+
+						return true;
+					}
+					else {
+						throw new Error('Error in AWS Email File: Could not get file URL');
+					}
+				}
+				catch (err) {
+					err.mesage = 'Error In AWS Email File: ' + err.mesage;
+					throw err;
+				}
+			}
+		}
+	});
+}