Add image upload and deletion utilities with tests

Author: i-am-that-guy

bun.lock

@@ -9,12 +9,12 @@
   "scripts": {
     "test": "jest",
     "apidoc": "apidoc -c apidoc.json",
-    "start" : "bun run src/server.ts",
+    "start": "bun src/server.ts",
     "lint": "eslint src/",
     "format": "prettier --write src/",
     "lint:fix": "eslint src/ --fix",
     "precommit": "lint-staged",
-    "migrate:first":"bunx prisma migrate dev --name init",
+    "migrate:first": "bunx prisma migrate dev --name init",
     "migrate": "bunx prisma migrate dev",
     "generate": "bunx prisma generate"
   },
@@ -54,6 +54,7 @@
     "@types/jest": "^30.0.0",
     "@types/multer": "^2.0.0",
     "@types/node": "^24.0.13",
+    "@types/uuid": "^10.0.0",
     "apidoc": "^1.2.0",
     "body-parser": "^2.2.0",
     "cors": "^2.8.5",
@@ -63,7 +64,8 @@
     "jest": "^30.0.4",
     "multer": "^2.0.1",
     "ts-jest": "^29.4.0",
-    "ts-node": "^10.9.2"
+    "ts-node": "^10.9.2",
+    "uuid": "^11.1.0"
   },
   "private": true
 }

package.json

@@ -13,7 +13,7 @@ import path from 'path'
 // Initialize Supabase client for storage operations
 export const supabase = createClient(
   config.DIRECT_URL,
-  config.SUPABASE_ANON_KEY
+  config.SUPABASE_SERVICE_ROLE_KEY
 )
 
 const app = express()

src/app.ts

@@ -2,6 +2,6 @@ export default {
   PORT: process.env.PORT,
   DATABASE_URL: process.env.DATABASE_URL!,
   DIRECT_URL: process.env.DIRECT_URL!,
-  SUPABASE_ANON_KEY: process.env.SUPABASE_ANON_KEY!,
+  SUPABASE_SERVICE_ROLE_KEY: process.env.SUPABASE_SERVICE_ROLE_KEY!,
   ALLOWED_ORIGINS: process.env.ALLOWED_ORIGINS || '*'
 }

src/config/index.ts

@@ -0,0 +1,76 @@
+import { SupabaseClient } from '@supabase/supabase-js'
+import { v4 as uuidv4 } from 'uuid'
+import { ApiError } from './apiError'
+
+type MulterFile = Express.Multer.File
+
+export async function uploadImage(
+  supabase: SupabaseClient,
+  file: MulterFile,
+  folder: string, 
+  fileName?: string
+): Promise<string> {
+  // 1) Determine file extension
+    const mime = file.mimetype // e.g. 'image/jpeg'
+    if (!mime) {
+        throw new ApiError('File type is missing', 400)
+    }
+  // Validate MIME type against allowed image types
+    const allowedTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/webp']
+    if (!allowedTypes.includes(mime)) {
+        throw new ApiError('Invalid file type. Only JPEG, PNG, GIF, and WebP images are allowed.', 400)
+    }
+  
+  const ext = mime.split('/')[1]
+
+  // 2) Create filename
+const filename = fileName ? fileName : `${uuidv4()}.${ext}`
+
+  // 3) Build full path inside the bucket
+  const filePath = `${folder}/${filename}`
+
+  // 4) Perform the upload (upsert: true will overwrite same path if it exists)
+  const { error: uploadError } = await supabase
+    .storage
+    .from('images')
+    .upload(filePath, file.buffer, {
+      contentType: file.mimetype,
+      upsert: true,
+    })
+
+  if (uploadError) {
+    throw new ApiError(`Image upload failed: ${uploadError.message}`, 500)
+  }
+
+  // 5) Generate a public URL
+  const { data: urlData } = supabase
+    .storage
+    .from('images')
+    .getPublicUrl(filePath)
+
+  if (!urlData?.publicUrl) {
+    throw new ApiError('Failed to get public URL', 500)
+  }
+
+  return urlData.publicUrl
+}
+
+export async function deleteImage(
+  supabase: SupabaseClient,
+  fileUrl: string
+): Promise<void> {
+  const url = new URL(fileUrl);
+  const pathParts = url.pathname.split('/'); // ['', 'storage', 'v1', 'object', 'public', 'images', ...filePathParts]
+  const filePath = pathParts.slice(6).join('/'); // 'images/...'
+  if (!filePath) {
+    throw new ApiError('Invalid file URL', 400)
+  }
+  const { error: deleteError } = await supabase
+    .storage
+    .from('images')
+    .remove([filePath])
+
+  if (deleteError) {
+    throw new ApiError(`Image deletion failed: ${deleteError.message}`, 500)
+  }
+}

src/utils/imageUtils.ts

@@ -0,0 +1,103 @@
+import { uploadImage, deleteImage } from '../src/utils/imageUtils';
+import { SupabaseClient, PostgrestError } from '@supabase/supabase-js';
+import { ApiError } from '../src/utils/apiError';
+import { v4 as uuidv4 } from 'uuid';
+
+jest.mock('uuid');
+const mockedUuid = uuidv4 as jest.Mock;
+mockedUuid.mockReturnValue('test-uuid');
+
+describe('imageUtils', () => {
+  let mockSupabase: Partial<SupabaseClient>;
+  let storageMock: any;
+
+  const dummyFile = {
+    buffer: Buffer.from('test'),
+    mimetype: 'image/png',
+  } as Express.Multer.File;
+
+  beforeEach(() => {
+    storageMock = {
+      from: jest.fn().mockReturnThis(),
+      upload: jest.fn(),
+      getPublicUrl: jest.fn(),
+      remove: jest.fn(),
+    };
+
+    mockSupabase = {
+      storage: storageMock,
+    };
+  });
+
+  describe('uploadImage', () => {
+    it('uploads an image successfully and returns public URL', async () => {
+      storageMock.upload.mockResolvedValue({ error: null });
+      storageMock.getPublicUrl.mockReturnValue({ data: { publicUrl: 'https://public.url/file.png' } });
+
+      const url = await uploadImage(mockSupabase as SupabaseClient, dummyFile, 'test-folder');
+      expect(storageMock.from).toHaveBeenCalledWith('images');
+      expect(storageMock.upload).toHaveBeenCalledWith('test-folder/test-uuid.png', dummyFile.buffer, {
+        contentType: dummyFile.mimetype,
+        upsert: true,
+      });
+      expect(url).toBe('https://public.url/file.png');
+    });
+
+    it('throws ApiError for missing mimetype', async () => {
+      const badFile = { ...dummyFile, mimetype: '' };
+      await expect(
+        uploadImage(mockSupabase as SupabaseClient, badFile as any, 'folder')
+      ).rejects.toThrow(ApiError);
+    });
+
+    it('throws ApiError for invalid mimetype', async () => {
+      const badFile = { ...dummyFile, mimetype: 'text/plain' };
+      await expect(
+        uploadImage(mockSupabase as SupabaseClient, badFile as any, 'folder')
+      ).rejects.toThrow(ApiError);
+    });
+
+    it('throws ApiError when upload fails', async () => {
+      storageMock.upload.mockResolvedValue({ error: { message: 'fail' } as PostgrestError });
+      await expect(
+        uploadImage(mockSupabase as SupabaseClient, dummyFile, 'folder')
+      ).rejects.toThrow(/Image upload failed/);
+    });
+
+    it('throws ApiError when publicUrl missing', async () => {
+      storageMock.upload.mockResolvedValue({ error: null });
+      storageMock.getPublicUrl.mockReturnValue({ data: { publicUrl: '' } });
+      await expect(
+        uploadImage(mockSupabase as SupabaseClient, dummyFile, 'folder')
+      ).rejects.toThrow(/Failed to get public URL/);
+    });
+  });
+
+  describe('deleteImage', () => {
+    it('deletes an image successfully', async () => {
+      const publicUrl = 'https://xyz.supabase.co/storage/v1/object/public/images/folder/file.png';
+      storageMock.remove.mockResolvedValue({ error: null });
+
+      await expect(
+        deleteImage(mockSupabase as SupabaseClient, publicUrl)
+      ).resolves.toBeUndefined();
+      expect(storageMock.from).toHaveBeenCalledWith('images');
+      expect(storageMock.remove).toHaveBeenCalledWith(['folder/file.png']);
+    });
+
+    it('throws ApiError for invalid URL', async () => {
+      await expect(
+        deleteImage(mockSupabase as SupabaseClient, 'https://invalid.url')
+      ).rejects.toThrow(ApiError);
+    });
+
+    it('throws ApiError when delete fails', async () => {
+      const publicUrl = 'https://xyz.supabase.co/storage/v1/object/public/images/folder/file.png';
+      storageMock.remove.mockResolvedValue({ error: { message: 'delete fail' } as PostgrestError });
+
+      await expect(
+        deleteImage(mockSupabase as SupabaseClient, publicUrl)
+      ).rejects.toThrow(/Image deletion failed/);
+    });
+  });
+});