node-server-engine 1.2.4 → 1.2.5

package/src/middleware/multiPartFileUploader/multiPartFileUploader.ts

@@ -0,0 +1,184 @@
+import express from 'express';
+import multer from 'multer';
+import fs from 'fs-extra';
+import path from 'path';
+import { reportDebug, reportError } from 'utils';
+
+const TEMP_DIR: string =
+  process.env.TEMP_CHUNK_FOLDER || './uploads/temp_chunks';
+
+const namespace = 'engine:middleware:multiPartFileUploader';
+
+fs.ensureDirSync(TEMP_DIR);
+
+const storage = multer.memoryStorage();
+
+async function multiPartFileUploader(
+  req: express.Request,
+  res: express.Response,
+  next: express.NextFunction
+): Promise<void> {
+  try {
+    const uploadSingle = multer({ storage }).single('file');
+
+    uploadSingle(req, res, async (err) => {
+      if (err) {
+        reportError('Error uploading chunk');
+        return next(err);
+      }
+
+      const { filename, totalChunks, chunkIndex, uniqueID } = req.body;
+
+      if (
+        !filename ||
+        !totalChunks ||
+        chunkIndex === undefined ||
+        !uniqueID ||
+        !req.file
+      ) {
+        req.body.uploadDetails = {
+          status: 'failed',
+          message: 'Missing required fields',
+          details: {
+            filename,
+            totalChunks,
+            chunkIndex,
+            uniqueID,
+            receivedChunk: !!req.file
+          }
+        };
+        reportDebug({
+          namespace,
+          message: `Missing required fields`,
+          data: {
+            status: 'failed',
+            details: {
+              filename,
+              totalChunks,
+              chunkIndex,
+              uniqueID
+            }
+          }
+        });
+        return next();
+      }
+
+      const sessionFolder = path.join(TEMP_DIR, uniqueID);
+      fs.ensureDirSync(sessionFolder);
+
+      const chunkPath = path.join(
+        sessionFolder,
+        `${filename}.part${chunkIndex}`
+      );
+
+      try {
+        await fs.writeFile(chunkPath, req.file.buffer);
+      } catch (writeErr) {
+        reportError(
+          `Failed to write chunk ${chunkIndex}: ${(writeErr as Error).message}`
+        );
+        return next(writeErr);
+      }
+
+      const uploadedChunks = await fs.readdir(sessionFolder);
+
+      if (uploadedChunks.length === parseInt(totalChunks, 10)) {
+        reportDebug({
+          namespace,
+          message: `All chunks uploaded. Merging file...`
+        });
+
+        try {
+          await mergeChunks(filename, totalChunks, sessionFolder);
+        } catch (mergeErr) {
+          reportError(`File merging failed: ${(mergeErr as Error).message}`);
+          return next(mergeErr);
+        }
+
+        const finalFilePath = path.join(sessionFolder, filename);
+
+        if (!fs.existsSync(finalFilePath)) {
+          reportError('File merging failed: File does not exist');
+          return next(new Error('File merging failed'));
+        }
+
+        req.body.uploadDetails = {
+          status: 'completed',
+          message: 'File uploaded and merged successfully',
+          details: { filename, uniqueID }
+        };
+        reportDebug({
+          namespace,
+          message: `File merged successfully`,
+          data: {
+            status: 'completed',
+            details: { filename, uniqueID }
+          }
+        });
+
+        return next();
+      }
+
+      reportDebug({
+        namespace,
+        message: `Chunk uploaded successfully`,
+        data: {
+          filename,
+          uniqueID,
+          chunkIndex,
+          totalChunks
+        }
+      });
+
+      req.body.uploadDetails = {
+        status: 'pending',
+        message: 'Chunk uploaded successfully',
+        details: { filename, uniqueID, chunkIndex, totalChunks }
+      };
+
+      return next();
+    });
+  } catch (error) {
+    reportError(
+      `Failed to upload or process chunk: ${(error as Error).message}`
+    );
+    next(error);
+  }
+}
+
+async function mergeChunks(
+  filename: string,
+  totalChunks: string | number,
+  sessionFolder: string
+): Promise<void> {
+  const finalFilePath = path.join(sessionFolder, filename);
+  const writeStream = fs.createWriteStream(finalFilePath);
+
+  for (let i = 0; i < parseInt(totalChunks as string, 10); i++) {
+    const partPath = path.join(sessionFolder, `${filename}.part${i}`);
+
+    try {
+      const chunkData = await fs.readFile(partPath);
+      writeStream.write(chunkData);
+    } catch (error) {
+      reportError(`Error reading chunk ${i}: ${(error as Error).message}`);
+      throw error;
+    }
+
+    fs.remove(partPath).catch((err: Error) =>
+      reportError(`Error removing part ${partPath}: ${err.message}`)
+    );
+  }
+
+  writeStream.end();
+
+  return new Promise<void>((resolve, reject) => {
+    writeStream.on('finish', () => resolve(undefined));
+    writeStream.on('error', (error) => {
+      reportError(`Error merging chunks: ${(error as Error).message}`);
+      reject(error);
+    });
+  });
+}
+
+export { multiPartFileUploader };

package/src/utils/createHttpServer/createHttpServer.ts

@@ -1,6 +1,5 @@
 import fs from 'fs';
-import { RequestListener, Server } from 'http';
-import { createServer as createServerHttp2 } from 'http';
+import { createServer, RequestListener, Server } from 'http';
 import {
   createServer as createSecureServer,
   Server as SecureServer
@@ -30,6 +29,6 @@ export function createHttpServer(
       handler
     );
   } else {
-    return createServerHttp2(handler);
+    return createServer(handler);
   }
 }

package/src/utils/geminiFileUpload/geminiFileUpload.ts

@@ -0,0 +1,98 @@
+import { GoogleAIFileManager } from '@google/generative-ai/server';
+import fs from 'fs';
+import path from 'path';
+import tmp from 'tmp';
+import { reportError, reportDebug } from 'utils/report';
+
+const namespace = 'engine:utils:geminiFileUpload';
+
+const apiKey = process.env.GOOGLE_AI_KEY;
+if (!apiKey) {
+  throw new Error('GOOGLE_AI_KEY is not set in environment variables');
+}
+
+const fileManager = new GoogleAIFileManager(apiKey);
+
+export async function geminiFileUpload(
+  buffer: Buffer,
+  mimeType: string,
+  originalName: string
+): Promise<
+  | { success: true; originalname: string; fileUri: string; mimeType: string }
+  | { success: false; error: unknown }
+> {
+  let tempFile;
+  try {
+    // 1. Create Temp File
+    tempFile = tmp.fileSync({ postfix: path.extname(originalName) });
+    fs.writeFileSync(tempFile.name, buffer);
+
+    // 2. Upload File
+    const uploadResult = await fileManager.uploadFile(tempFile.name, {
+      mimeType,
+      displayName: originalName
+    });
+
+    if (!uploadResult || !uploadResult.file) {
+      throw new Error('Upload failed: No file returned');
+    }
+
+    const file = uploadResult.file;
+    reportDebug({
+      namespace,
+      message: 'Uploaded file successfully',
+      data: { displayName: file.displayName, name: file.name }
+    });
+
+    reportDebug({
+      namespace,
+      message: 'Waiting for file processing...'
+    });
+
+    // 3. Poll Until File is Processed
+    let geminiFile = await fileManager.getFile(file.name);
+    while (geminiFile?.state === 'PROCESSING') {
+      process.stdout.write('.');
+      await new Promise((resolve) => setTimeout(resolve, 10000));
+      geminiFile = await fileManager.getFile(file.name);
+    }
+
+    if (!geminiFile || geminiFile.state !== 'ACTIVE') {
+      const errorMessage = `File processing failed for ${file.name}`;
+      reportError(errorMessage);
+      return { success: false, error: new Error(errorMessage) };
+    }
+
+    reportDebug({
+      namespace,
+      message: 'File is ready'
+    });
+
+    return {
+      success: true,
+      originalname: file.name,
+      fileUri: file.uri,
+      mimeType: file.mimeType
+    };
+  } catch (error) {
+    reportError({
+      namespace,
+      message: 'Error during Gemini file upload and processing',
+      error
+    });
+    return { success: false, error };
+  } finally {
+    // Ensure cleanup of temp file
+    if (tempFile) {
+      try {
+        tempFile.removeCallback();
+      } catch (cleanupError) {
+        reportError({
+          namespace,
+          message: 'Error cleaning up temp file',
+          error: cleanupError
+        });
+      }
+    }
+  }
+}

package/src/utils/geminiFileUpload/index.ts

@@ -0,0 +1 @@
+export * from './geminiFileUpload';

package/src/utils/index.ts

@@ -23,3 +23,6 @@ export * from './sendEmail';
 
 // String manipulation
 export * from './trimPathSlash';
+
+// File Upload
+export * from './geminiFileUpload';