refactor(storage-resize-images): some refactoring (#2362)

* refactor(storage-resize-images): some refactoring

* chore(storage-resize-images): format

* chore(storage-resize-image): modify some test imports and remove some unnecessary code

* chore(storage-resize-images): format

* refactor(storage-resize-images): replacing retry-queue.ts

Author: CorieW

storage-resize-images/functions/__tests__/convert-image.test.ts

@@ -14,7 +14,7 @@ const env = {
 
 mockedEnv(env);
 
-import { convertType } from "../src/resize-image";
+import { convertType } from "../src/util";
 import { config } from "../src/config";
 
 jest.mock("../src/config");
@@ -32,43 +32,78 @@ beforeAll(async () => {
 
 describe("convertType", () => {
   it("converts to png image type", async () => {
-    const buffer = await convertType(bufferJPG, "png");
+    const buffer = await convertType(
+      bufferJPG,
+      "png",
+      config.outputOptions,
+      config.animated
+    );
 
     expect(imageType(buffer).mime).toBe("image/png");
   });
 
   it("converts to jpeg image type", async () => {
-    const buffer = await convertType(bufferPNG, "jpeg");
+    const buffer = await convertType(
+      bufferPNG,
+      "jpeg",
+      config.outputOptions,
+      config.animated
+    );
 
     expect(imageType(buffer).mime).toBe("image/jpeg");
   });
 
   it("converts to webp image type", async () => {
-    const buffer = await convertType(bufferPNG, "webp");
+    const buffer = await convertType(
+      bufferPNG,
+      "webp",
+      config.outputOptions,
+      config.animated
+    );
 
     expect(imageType(buffer).mime).toBe("image/webp");
   });
 
   it("converts to tiff image type", async () => {
-    const buffer = await convertType(bufferPNG, "tiff");
+    const buffer = await convertType(
+      bufferPNG,
+      "tiff",
+      config.outputOptions,
+      config.animated
+    );
 
     expect(imageType(buffer).mime).toBe("image/tiff");
   });
 
   it("converts to gif image type", async () => {
-    const buffer = await convertType(bufferGIF, "gif");
+    const buffer = await convertType(
+      bufferGIF,
+      "gif",
+      config.outputOptions,
+      config.animated
+    );
 
     expect(imageType(buffer).mime).toBe("image/gif");
   });
 
   it("remains jpeg image type when different image type is not supported", async () => {
-    const buffer = await convertType(bufferJPG, "raw");
+    const buffer = await convertType(
+      bufferJPG,
+      "raw",
+      config.outputOptions,
+      config.animated
+    );
 
     expect(imageType(buffer).mime).toBe("image/jpeg");
   });
 
   it("remains gif image type when different image type is not supported", async () => {
-    const buffer = await convertType(bufferGIF, "raw");
+    const buffer = await convertType(
+      bufferGIF,
+      "raw",
+      config.outputOptions,
+      config.animated
+    );
 
     expect(imageType(buffer).mime).toBe("image/gif");
   });

storage-resize-images/functions/__tests__/filters.test.ts

@@ -1,6 +1,5 @@
 import * as path from "path";
 import * as logs from "../src/logs";
-import { supportedContentTypes } from "../src/resize-image";
 import { ObjectMetadata } from "firebase-functions/v1/storage";
 
 jest.mock("../src/config", () => {

storage-resize-images/functions/__tests__/resize.test.ts

@@ -2,7 +2,7 @@ import * as fs from "fs";
 
 import mockedEnv from "mocked-env";
 import sizeOf from "image-size";
-import * as sharp from "sharp";
+import sharp from "sharp";
 
 const environment = {
   LOCATION: "us-central1",
@@ -16,11 +16,12 @@ const environment = {
 let restoreEnv;
 restoreEnv = mockedEnv(environment);
 
+import { resize } from "../src/resize-image";
+
 import {
-  resize,
   supportedContentTypes,
   supportedImageContentTypeMap,
-} from "../src/resize-image";
+} from "../src/global";
 
 import * as path from "path";
 

storage-resize-images/functions/__tests__/retry-queue.test.ts

@@ -1,21 +1,17 @@
-import { RetryQueue } from "../src/retry-queue";
+import PQueue from "p-queue";
 
 describe("RetryQueue", () => {
-  let queue: RetryQueue;
-
   beforeEach(() => {
-    queue = new RetryQueue();
     jest.useRealTimers();
   });
 
   test("should process tasks in order of priority", async () => {
+    // Force sequential execution by overriding concurrency limit
+    const queue = new PQueue({ concurrency: 1, autoStart: false });
+
     jest.useFakeTimers();
     let executionOrder: number[] = [];
 
-    // Force sequential execution by overriding concurrency limit
-    // @ts-ignore - accessing private property for testing
-    queue["concurrencyLimit"] = 1;
-
     // Create three tasks with different priorities
     const task1 = jest.fn().mockImplementation(async () => {
       executionOrder.push(1);
@@ -33,9 +29,12 @@ describe("RetryQueue", () => {
     });
 
     // Set up promises to track task completion
-    const promise2 = queue.enqueue(task2, 2);
-    const promise3 = queue.enqueue(task3, 3);
-    const promise1 = queue.enqueue(task1, 1);
+    const promise1 = queue.add(task2, { priority: 2 });
+    const promise2 = queue.add(task3, { priority: 1 });
+    const promise3 = queue.add(task1, { priority: 3 });
+
+    // Start the queue
+    queue.start();
 
     // Advance timers to allow the sorting to complete
     jest.advanceTimersByTime(10);
@@ -59,13 +58,18 @@ describe("RetryQueue", () => {
   });
 
   test("should handle task failures correctly", async () => {
+    const queue = new PQueue({ concurrency: 3, autoStart: false });
+
     const successTask = jest.fn().mockResolvedValue("success");
     const failureTask = jest.fn().mockRejectedValue(new Error("Task failed"));
 
-    const successPromise = queue.enqueue(successTask, 1);
-    const failurePromise = queue.enqueue(failureTask, 2);
+    const successPromise = queue.add(successTask, { priority: 2 });
+    const failurePromise = queue.add(failureTask, { priority: 1 });
+
+    // Start the queue
+    queue.start();
 
-    // Success task should resolve
+    // Succes, priority: task should resolve
     await expect(successPromise).resolves.toBe("success");
 
     // Failure task should reject
@@ -76,6 +80,8 @@ describe("RetryQueue", () => {
   });
 
   test("should respect concurrency limit", async () => {
+    const queue = new PQueue({ concurrency: 3, autoStart: false });
+
     // Create a mock implementation to track concurrent execution
     let concurrentCount = 0;
     let maxConcurrentCount = 0;
@@ -97,9 +103,12 @@ describe("RetryQueue", () => {
     // Queue multiple slow tasks
     const promises = [];
     for (let i = 0; i < 10; i++) {
-      promises.push(queue.enqueue(createTask(10), (i % 3) + 1)); // Vary priority
+      promises.push(queue.add(createTask(10), { priority: i + 1 }));
     }
 
+    // Start the queue
+    queue.start();
+
     // Wait for all tasks to complete
     await Promise.all(promises);
 
@@ -109,10 +118,9 @@ describe("RetryQueue", () => {
   });
 
   test("should continue processing queue after task completion", async () => {
+    const queue = new PQueue({ concurrency: 1, autoStart: false });
+
     jest.useFakeTimers();
-    // Force sequential execution
-    // @ts-ignore - accessing private property for testing
-    queue["concurrencyLimit"] = 1;
 
     const executionOrder: number[] = [];
 
@@ -135,9 +143,12 @@ describe("RetryQueue", () => {
     };
 
     // Enqueue tasks
-    const promise1 = queue.enqueue(slowTask, 1); // Higher priority
-    const promise2 = queue.enqueue(fastTask1, 2);
-    const promise3 = queue.enqueue(fastTask2, 3);
+    const promise1 = queue.add(slowTask, { priority: 3 }); // Higher priority
+    const promise2 = queue.add(fastTask1, { priority: 2 });
+    const promise3 = queue.add(fastTask2, { priority: 1 });
+
+    // Start the queue
+    queue.start();
 
     // Advance timers to allow sorting to complete
     jest.advanceTimersByTime(10);
@@ -156,18 +167,18 @@ describe("RetryQueue", () => {
   });
 
   test("should handle empty queue gracefully", async () => {
+    const queue = new PQueue({ concurrency: 3 });
     // Just make sure no errors are thrown
     expect(() => {
       // @ts-ignore - accessing private method for testing
-      queue.processQueue();
+      queue.start();
     }).not.toThrow();
   });
 
   test("should handle many tasks with same priority in order of addition", async () => {
+    const queue = new PQueue({ concurrency: 1, autoStart: false });
+
     jest.useFakeTimers();
-    // Force sequential execution
-    // @ts-ignore - accessing private property for testing
-    queue["concurrencyLimit"] = 1;
 
     const executionOrder: number[] = [];
 
@@ -182,9 +193,12 @@ describe("RetryQueue", () => {
     // Queue tasks with same priority
     const promises = [];
     for (let i = 1; i <= 5; i++) {
-      promises.push(queue.enqueue(createNumberedTask(i), 1)); // All same priority
+      promises.push(queue.add(createNumberedTask(i), { priority: 1 }));
     }
 
+    // Start the queue
+    queue.start();
+
     // Advance timers to allow sorting to complete
     jest.advanceTimersByTime(10);
 
@@ -202,20 +216,28 @@ describe("RetryQueue", () => {
   });
 
   test("should handle large number of tasks efficiently", async () => {
+    const queue = new PQueue({ concurrency: 3, autoStart: false });
+
     const taskCount = 50; // Reduced for faster test execution
     const completedTasks: number[] = [];
 
     // Create many tasks
     const promises = [];
     for (let i = 0; i < taskCount; i++) {
       promises.push(
-        queue.enqueue(async () => {
-          completedTasks.push(i);
-          return i;
-        }, i % 10) // Cycle through 10 priority levels
-      );
+        queue.add(
+          async () => {
+            completedTasks.push(i);
+            return i;
+          },
+          { priority: i }
+        )
+      ); // Cycle through 10 priority levels
     }
 
+    // Start the queue
+    queue.start();
+
     // Wait for all tasks to complete
     await Promise.all(promises);
 

storage-resize-images/functions/__tests__/unit/modifyImage.test.ts

@@ -1,4 +1,3 @@
-// import { getModifiedFilePath } from "../../src/resize-image";
 import * as path from "path";
 import { config } from "dotenv";
 
@@ -10,12 +9,6 @@ const envLocalPath = path.resolve(
 config({ path: envLocalPath, debug: true, override: true });
 
 import { getModifiedFilePath } from "../../src/resize-image";
-import { platform } from "os";
-
-const convertToPosixPath = (filePath: string, locale?: "win32" | "posix") => {
-  const sep = locale ? path[locale].sep : path.sep;
-  return filePath.split(sep).join(path.posix.sep);
-};
 
 const oldGetModifiedFilePath = (
   fileDir,