just-another-http-api 1.0.5 → 1.2.1

package/src/upload.js

@@ -0,0 +1,146 @@
+const multer = require ( 'fastify-multer' );
+const os = require ( 'os' );
+const crypto = require ( 'crypto' );
+const fs = require ( 'fs' );
+const path = require ( 'path' );
+const { Upload } = require ( '@aws-sdk/lib-storage' );
+const { PassThrough } = require ( 'stream' );
+
+let upload;
+
+exports.initialiseUploads = async ( app, config ) => {
+    if ( config?.uploads?.enabled ) {
+        try {
+            app.register ( multer.contentParser );
+        }
+        catch ( error ) {
+            console.error ( 'Error registering multer content parser:', error );
+            throw error;
+        }
+    }
+};
+
+exports.handleUpload = ( handlerConfig, globalConfig ) => {
+    let storage;
+    try {
+        switch ( handlerConfig?.upload?.storageType || globalConfig.uploads.storageType ) {
+            case 's3':
+                storage = s3Storage ( handlerConfig, globalConfig );
+                break;
+            case 'filesystem':
+                const uploadDir = globalConfig.uploads.localUploadDirectory || os.tmpdir ();
+                ensureDirectoryExists ( uploadDir );
+                storage = multer.diskStorage ( {
+                    destination: ( req, file, cb ) => cb ( null, uploadDir ),
+                    filename: ( req, file, cb ) => cb ( null, crypto.randomUUID () + path.extname ( file.originalname ) )
+                } );
+                break;
+            case 'memory':
+            default:
+                storage = multer.memoryStorage ();
+                break;
+        }
+    }
+    catch ( error ) {
+        console.error ( 'Error setting up storage:', error );
+        throw error;
+    }
+
+    upload = multer ( {
+        storage,
+        limits: {
+            fileSize: handlerConfig.upload.maxFileSize,
+            files: handlerConfig.upload.maxFiles
+        }
+    } );
+
+    return async ( req, reply ) => {
+        const fieldName = handlerConfig?.upload?.requestFileKey || 'file';
+
+        const multerHandler = handlerConfig.upload.maxFiles > 1 ? upload.array ( fieldName, handlerConfig.upload.maxFiles ) : upload.single ( fieldName );
+        
+        return new Promise ( ( resolve, reject ) => {
+            multerHandler ( req, reply.raw, ( err ) => {
+                if ( err ) {
+                    console.error ( 'Multer error:', err );
+                    reply.code ( 500 ).send ( err );
+                    reject ( err );
+                }
+                else {
+                    resolve ();
+                }
+            } );
+        } );
+    };
+};
+
+function ensureDirectoryExists ( dir ) {
+    try {
+        if ( !fs.existsSync ( dir ) ) {
+            fs.mkdirSync ( dir, { recursive: true } );
+        }
+    }
+    catch ( error ) {
+        console.error ( `Error ensuring directory ${dir} exists:`, error );
+        throw error;
+    }
+}
+
+const s3Storage = ( handlerConfig, globalConfig ) => {
+    const _handleFile = function ( req, file, cb ) {
+        const passThroughStream = new PassThrough ();
+        const filename = crypto.randomUUID () + path.extname ( file.originalname );
+        const Key = [ globalConfig.uploads.s3UploadDirectory, handlerConfig?.upload?.subDirectory, filename ].filter ( Boolean ).join ( '/' );
+
+        const params = {
+            Bucket: globalConfig.uploads.s3UploadBucket,
+            Key,
+            Body: passThroughStream,
+            ContentType: file.mimetype,
+            ACL: handlerConfig?.upload?.s3ACL || 'public-read'
+        };
+
+        const upload = new Upload ( {
+            client: globalConfig.uploads.s3Client,
+            params
+        } );
+
+        upload.done ()
+            .then ( () => cb ( null, {
+                path: params.Key,
+                size: file.size
+            } ) )
+            .catch ( error => {
+                console.log ( 'ERROR UPLOADING FILE', error );
+                _removeFile ( req, { Key, Bucket: params.Bucket }, () => cb ( error ) );
+            } );
+
+        file.stream.pipe ( passThroughStream );
+    };
+
+    const _removeFile = function ( req, file, cb ) {
+        if ( !file || !file.Key || !file.Bucket ) {
+            console.log ( 'No file information available for deletion' );
+            cb ();
+            
+            return;
+        }
+
+        const deleteParams = {
+            Bucket: file.Bucket,
+            Key: file.Key
+        };
+
+        globalConfig.uploads.s3Client.send ( new DeleteObjectCommand ( deleteParams ) )
+            .then ( () => {
+                console.log ( `File deleted: ${file.Key}` );
+                cb ();
+            } )
+            .catch ( error => {
+                console.log ( `Error deleting file: ${file.Key}`, error );
+                cb ( error );
+            } );
+    };
+
+    return { _handleFile, _removeFile };
+};

package/utils/response.js

@@ -0,0 +1,48 @@
+/**
+ * Generate a standardized response object.
+ * 
+ * @param {object} options - The options for the response.
+ * @param {string} [options.json] - Sends JSON as the response body.
+ * @param {string} [options.html] - Sends HTML as the response body.
+ * @param {string} [options.text] - Sends plain text as the response body.
+ * @param {object} [options.file] - Sends a file as the response.
+ * @param {object} [options.redirect] - Redirects to a specified URL.
+ * @param {object} [options.headers={}] - Sets the headers for the response.
+ * @param {number} [options.code] - The HTTP status code for the response.
+ * @param {object} [options.error={message, code=500}] - Error response with message and code.
+ * @returns {object} An object containing the response data.
+ */
+function createResponse ( options = {} ) {
+    const response = {
+        headers: options.headers || {},
+        code: options.code || 200,
+    };
+
+    if ( 'json' in options ) {
+        response.json = options.json;
+        response.headers[ 'Content-Type' ] = 'application/json';
+    }
+    else if ( 'html' in options ) {
+        response.html = options.html;
+        response.headers[ 'Content-Type' ] = 'text/html';
+    }
+    else if ( 'text' in options ) {
+        response.text = options.text;
+        response.headers[ 'Content-Type' ] = 'text/plain';
+    }
+    else if ( 'file' in options ) {
+        response.file = options.file; // Assuming this is a buffer or stream
+    }
+    else if ( 'redirect' in options ) {
+        response.redirect = options.redirect;
+    }
+    else if ( options.error ) {
+        response.error = options.error;
+        response.code = options.error.code || 500;
+        response.headers[ 'Content-Type' ] = 'application/json';
+    }
+
+    return response;
+}
+
+module.exports = createResponse;