my-typescript-library-rahul52us 2.4.9 → 2.5.1

package/src/repository/document.repository.ts

@@ -2111,18 +2111,25 @@ export async function updateComment(id: string, data: Partial<IDocument>) : Prom
   }
 }
 
-export async function updateStatus(data: Partial<IDocument>) : Promise<any>{
+
+export async function updateStatus(
+  data: { documentId: string; key?: string; value: any }
+): Promise<any> {
   try {
+    const { documentId, key = "status", value } = data;
+    if (!documentId) return null;
+    const updatePayload = {
+      [`originalValues.${key}`]: value,
+    };
+
     const result = await Document.updateOne(
-      { documentId: data.documentId },
-      { $set: { "originalValues.status": data.status } }
+      { documentId },
+      { $set: updatePayload }
     );
-    if (result.matchedCount === 0) {
-      return null;
-    } else {
-      return result;
-    }
+
+    return result.matchedCount === 0 ? null : result;
   } catch (err) {
+    console.error("Update failed:", err);
     return null;
   }
 }

package/src/repository/filesystem.repository.ts

@@ -1,134 +1,138 @@
-import mongoose, { connection, mongo } from "mongoose";
+import mongoose, { mongo } from "mongoose";
 import { Readable } from "stream";
 
 import fileSystemSchema from "../repository/schemas/fileSystem.schema";
 const { GridFSBucket } = mongo;
 
-export async function uploadFile(file: any, name: string, type: string) {
+// Core upload logic wrapped as a helper
+async function tryUploadFile(file: any, name: string, type: string) {
   return new Promise((resolve, reject) => {
-      try {
-        const connection = mongoose.connection;
-        const bucket = new GridFSBucket(connection.db);
-
-        const buffer = Buffer.from(file, 'base64');
-        const readableStream = new Readable();
-        readableStream.push(buffer);
-        readableStream.push(null);
-
-        const uploadStream = bucket.openUploadStream(name, {
-          metadata: { contentType: type },
-        });
-
-        readableStream.pipe(uploadStream);
-
-        uploadStream.on("finish", () => {
-          const fileId = uploadStream.id;
-          fileSystemSchema
-            .create({
-              fileId: fileId,
-            })
-            .then((data) => {
-              resolve(data);
-            })
-            .catch((err) => {
-              reject("File upload failed");
-            });
-        });
+    try {
+      const connection = mongoose.connection;
+      const bucket = new GridFSBucket(connection.db);
+
+      const buffer = Buffer.from(file, 'base64');
+      const readableStream = new Readable();
+      readableStream.push(buffer);
+      readableStream.push(null);
+
+      const uploadStream = bucket.openUploadStream(name, {
+        metadata: { contentType: type },
+      });
+
+      readableStream.pipe(uploadStream);
+
+      uploadStream.on("finish", () => {
+        const fileId = uploadStream.id;
+        fileSystemSchema
+          .create({ fileId: fileId })
+          .then((data) => resolve(data))
+          .catch(() => reject("File upload failed"));
+      });
+
+      uploadStream.on("error", () => {
+        reject("Error uploading file");
+      });
+    } catch (err) {
+      reject("Error uploading the file");
+    }
+  });
+}
 
-        uploadStream.on("error", (error) => {
-          reject("Error uploading file");
-        });
-      } catch (err) {
-        reject("Error uploading the file");
+// Public function with retry logic
+export async function uploadFile(file: any, name: string, type: string) {
+  const maxRetries = 3;
+  let attempt = 0;
+  while (attempt < maxRetries) {
+    try {
+      return await tryUploadFile(file, name, type); // success → exit
+    } catch (error) {
+      attempt++;
+      if (attempt >= maxRetries) {
+        throw new Error(`File upload failed after ${maxRetries} attempts`);
       }
-    });
-
-
+      await new Promise((res) => setTimeout(res, 300 * attempt)); // wait before retry
+    }
+  }
 }
 
 export async function getFile(id: string) {
   return new Promise((resolve, reject) => {
-      try {
-          const connection = mongoose.connection;
-          const bucket = new GridFSBucket(connection.db);
-          const downloadStream = bucket.openDownloadStream(new mongoose.Types.ObjectId(id));
+    try {
+      const connection = mongoose.connection;
+      const bucket = new GridFSBucket(connection.db);
+      const downloadStream = bucket.openDownloadStream(new mongoose.Types.ObjectId(id));
+
+      const chunks: Buffer[] = [];
+      let fileSize = 0;
+
+      downloadStream.on("data", (chunk) => {
+        chunks.push(chunk);
+        fileSize += chunk.length;
+      });
+
+      downloadStream.on("error", () => {
+        reject("An error occured while fetching file");
+      });
+
+      downloadStream.on("end", () => {
+        const buffer = Buffer.concat(chunks, fileSize);
+        const downloadData = buffer;
+        const array = new Uint8Array(downloadData);
+        resolve(`[${array}]`);
+      });
+    } catch (err) {
+      reject("Error Getting the file");
+    }
+  });
+}
+
+export async function getFileData(id: string) {
+  return new Promise((resolve, reject) => {
+    try {
+      const connection = mongoose.connection;
+      const bucket = new GridFSBucket(connection.db);
+      const downloadStream = bucket.openDownloadStream(new mongoose.Types.ObjectId(id));
+
+      const chunks: Buffer[] = [];
+      let fileSize = 0;
+
+      connection.db
+        .collection("fs.files")
+        .findOne({ _id: new mongoose.Types.ObjectId(id) })
+        .then((fileInfo) => {
+          if (!fileInfo) return reject("File not found");
 
-          const chunks: Buffer[] = [];
-          let fileSize = 0;
+          const { filename, contentType, length } = fileInfo;
 
           downloadStream.on("data", (chunk) => {
             chunks.push(chunk);
             fileSize += chunk.length;
           });
 
-          downloadStream.on("error", (error) => {
-            reject("An error occured while fetching file")
+          downloadStream.on("error", () => {
+            reject("An error occurred while fetching the file");
           });
 
           downloadStream.on("end", () => {
             const buffer = Buffer.concat(chunks, fileSize);
-
-            // Use the `buffer` variable as needed, e.g., save it to a file or process it further
-            // For example, you can assign it to a variable:
             const downloadData = buffer;
-            const array = new Uint8Array(downloadData)
-            resolve(`[${array}]`)
+            const array = new Uint8Array(downloadData);
+
+            resolve({
+              fileId: id,
+              filename,
+              contentType,
+              fileSize: length,
+              data: array,
+            });
           });
-      } catch (err) {
-          reject("Error Getting the file")
-      }
-  })
+        })
+        .catch(() => {
+          reject("Error fetching file metadata");
+        });
+    } catch (err) {
+      reject("Error Getting the file");
+    }
+  });
 }
-
-export async function getFileData(id: string) {
-    return new Promise((resolve, reject) => {
-        try {
-            const connection = mongoose.connection;
-            const bucket = new GridFSBucket(connection.db);
-            const downloadStream = bucket.openDownloadStream(new mongoose.Types.ObjectId(id));
-
-            const chunks: Buffer[] = [];
-            let fileSize = 0;
-
-            // Fetch the file's metadata from fs.files
-            connection.db.collection('fs.files').findOne({ _id: new mongoose.Types.ObjectId(id) })
-                .then((fileInfo) => {
-                    if (!fileInfo) {
-                        return reject("File not found");
-                    }
-
-                    // Push metadata for the response
-                    const { filename, contentType, length } = fileInfo;
-
-                    downloadStream.on("data", (chunk) => {
-                        chunks.push(chunk);
-                        fileSize += chunk.length;
-                    });
-
-                    downloadStream.on("error", () => {
-                        reject("An error occurred while fetching the file");
-                    });
-
-                    downloadStream.on("end", () => {
-                        const buffer = Buffer.concat(chunks, fileSize);
-                        const downloadData = buffer;
-                        const array = new Uint8Array(downloadData);
-
-                        // Return an object containing file metadata and data
-                        resolve({
-                            fileId: id, // Include file ID
-                            filename: filename,
-                            contentType: contentType,
-                            fileSize: length,
-                            data: array, // Returning as Uint8Array
-                        });
-                    });
-                })
-                .catch(() => {
-                    reject("Error fetching file metadata");
-                });
-        } catch (err) {
-            reject("Error Getting the file");
-        }
-    });
-}

package/src/services/document/document.services.ts

@@ -1410,6 +1410,7 @@ export async function getcountDocumentsWorkflowService(
 
         return {
           ...result.data,
+          _id : workflow?._id,
           workflowName: workflow?.workFlowName
         };
       })