chore: lint issues

Author: sinedied

packages/burger-api/src/blob-service.ts

@@ -19,6 +19,7 @@ export class BlobService {
       BlobService.instance = new BlobService();
       await BlobService.instance.initialize();
     }
+
     return BlobService.instance;
   }
 
@@ -70,11 +71,11 @@ export class BlobService {
       const blobClient = this.containerClient.getBlobClient(firstImageName);
       const imageExists = await blobClient.exists();
 
-      if (!imageExists) {
+      if (imageExists) {
+        console.log('Images already exist in blob storage');
+      } else {
         console.log('First image not found in blob storage. Uploading all images...');
         await this.uploadAllImages();
-      } else {
-        console.log('Images already exist in blob storage');
       }
     } catch (error) {
       console.error('Error checking image existence:', error);
@@ -91,16 +92,16 @@ export class BlobService {
 
     try {
       // Path to the images directory
-      const imagesDir = path.join(process.cwd(), 'data', 'images');
+      const imagesDirectory = path.join(process.cwd(), 'data', 'images');
 
       // Get all jpg files in the directory
-      const imageFiles = (await fs.readdir(imagesDir)).filter((file) => file.endsWith('.jpg'));
+      const imageFiles = (await fs.readdir(imagesDirectory)).filter((file) => file.endsWith('.jpg'));
 
       console.log(`Found ${imageFiles.length} images to upload`);
 
       // Upload each image
       for (const imageFile of imageFiles) {
-        const filePath = path.join(imagesDir, imageFile);
+        const filePath = path.join(imagesDirectory, imageFile);
         const fileContent = await fs.readFile(filePath);
 
         const blockBlobClient = this.containerClient.getBlockBlobClient(imageFile);
@@ -128,7 +129,7 @@ export class BlobService {
   public async getBlob(blobName: string): Promise<Buffer | undefined> {
     // Check if we should use local fallback
     if (this.useLocalFallback) {
-      return await this.getLocalFile(blobName);
+      return this.getLocalFile(blobName);
     }
 
     // Use Azure Blob Storage when available
@@ -223,18 +224,29 @@ export class BlobService {
 
     switch (extension) {
       case 'jpg':
-      case 'jpeg':
+      case 'jpeg': {
         return 'image/jpeg';
-      case 'png':
+      }
+
+      case 'png': {
         return 'image/png';
-      case 'gif':
+      }
+
+      case 'gif': {
         return 'image/gif';
-      case 'webp':
+      }
+
+      case 'webp': {
         return 'image/webp';
-      case 'svg':
+      }
+
+      case 'svg': {
         return 'image/svg+xml';
-      default:
+      }
+
+      default: {
         return 'application/octet-stream';
+      }
     }
   }
 }

packages/burger-api/src/db-service.ts

@@ -1,26 +1,26 @@
 import path from 'node:path';
-import { ToppingCategory } from './topping';
-import { Burger } from './burger';
-import { Topping } from './topping';
-import { Order, OrderStatus } from './order';
 import { Container, CosmosClient, Database } from '@azure/cosmos';
 import { DefaultAzureCredential } from '@azure/identity';
+import dotenv from 'dotenv';
 import burgersData from '../data/burgers.json';
 import toppingsData from '../data/toppings.json';
-import dotenv from 'dotenv';
+import { ToppingCategory, Topping } from './topping.js';
+import { Burger } from './burger.js';
+import { Order, OrderStatus } from './order.js';
 
 // Env file is located in the root of the repository
 dotenv.config({ path: path.join(process.cwd(), '../../.env') });
 
 // Helper to strip properties starting with underscore from an object
-function stripUnderscoreProps<T extends object>(obj: T): T {
-  if (!obj || typeof obj !== 'object') return obj;
-  const result: { [key: string]: any } = {};
-  for (const key of Object.keys(obj)) {
+function stripUnderscoreProperties<T extends Record<string, unknown>>(object: T): T {
+  if (!object || typeof object !== 'object') return object;
+  const result: Record<string, any> = {};
+  for (const key of Object.keys(object)) {
     if (!key.startsWith('_')) {
-      result[key] = (obj as any)[key];
+      result[key] = (object as any)[key];
     }
   }
+
   return result as T;
 }
 
@@ -33,10 +33,12 @@ function stripUserId<T extends Order | Order[] | undefined>(orderOrOrders: T): T
       return rest as Order;
     }) as T;
   }
+
   if (orderOrOrders && typeof orderOrOrders === 'object') {
-    const { userId, ...rest } = orderOrOrders as Order;
+    const { userId, ...rest } = orderOrOrders;
     return rest as T;
   }
+
   return orderOrOrders;
 }
 
@@ -62,6 +64,7 @@ export class DbService {
       await DbService.instance.initializeCosmosDb();
       DbService.instance.initializeLocalData();
     }
+
     return DbService.instance;
   }
 
@@ -180,25 +183,27 @@ export class DbService {
           query: 'SELECT * FROM c',
         };
         const { resources } = await this.burgersContainer!.items.query(querySpec).fetchAll();
-        return (resources as Burger[]).map(stripUnderscoreProps);
+        return (resources as Burger[]).map(stripUnderscoreProperties);
       } catch (error) {
         console.error('Error fetching burgers from Cosmos DB:', error);
         return [...this.localBurgers];
       }
     }
+
     return [...this.localBurgers];
   }
 
   async getBurger(id: string): Promise<Burger | undefined> {
     if (this.isCosmosDbInitialized) {
       try {
         const { resource } = await this.burgersContainer!.item(id, id).read();
-        return resource ? stripUnderscoreProps(resource as Burger) : undefined;
+        return resource ? stripUnderscoreProperties(resource as Burger) : undefined;
       } catch (error) {
         console.error(`Error fetching burger ${id} from Cosmos DB:`, error);
         return this.localBurgers.find((burger) => burger.id === id);
       }
     }
+
     return this.localBurgers.find((burger) => burger.id === id);
   }
 
@@ -210,25 +215,27 @@ export class DbService {
           query: 'SELECT * FROM c',
         };
         const { resources } = await this.toppingsContainer!.items.query(querySpec).fetchAll();
-        return (resources as Topping[]).map(stripUnderscoreProps);
+        return (resources as Topping[]).map(stripUnderscoreProperties);
       } catch (error) {
         console.error('Error fetching toppings from Cosmos DB:', error);
         return [...this.localToppings];
       }
     }
+
     return [...this.localToppings];
   }
 
   async getTopping(id: string): Promise<Topping | undefined> {
     if (this.isCosmosDbInitialized) {
       try {
         const { resource } = await this.toppingsContainer!.item(id, id).read();
-        return resource ? stripUnderscoreProps(resource as Topping) : undefined;
+        return resource ? stripUnderscoreProperties(resource as Topping) : undefined;
       } catch (error) {
         console.error(`Error fetching topping ${id} from Cosmos DB:`, error);
         return this.localToppings.find((topping) => topping.id === id);
       }
     }
+
     return this.localToppings.find((topping) => topping.id === id);
   }
 
@@ -257,14 +264,16 @@ export class DbService {
             query: 'SELECT * FROM c',
           };
         }
+
         const { resources } = await this.ordersContainer!.items.query(querySpec).fetchAll();
-        return stripUserId((resources as Order[]).map(stripUnderscoreProps));
+        return stripUserId((resources as Order[]).map(stripUnderscoreProperties));
       } catch (error) {
         console.error('Error fetching orders from Cosmos DB:', error);
         const orders = userId ? this.localOrders.filter((order) => order.userId === userId) : this.localOrders;
         return stripUserId(orders);
       }
     }
+
     const orders = userId ? this.localOrders.filter((order) => order.userId === userId) : this.localOrders;
     return stripUserId(orders);
   }
@@ -275,10 +284,11 @@ export class DbService {
         const { resource } = await this.ordersContainer!.item(id, id).read();
         if (!resource) return undefined;
 
-        const order = stripUnderscoreProps(resource as Order);
+        const order = stripUnderscoreProperties(resource as Order);
         if (userId && order.userId !== userId) {
           return undefined;
         }
+
         return stripUserId(order);
       } catch (error) {
         console.error(`Error fetching order ${id} from Cosmos DB:`, error);
@@ -287,28 +297,32 @@ export class DbService {
         if (userId && order.userId !== userId) {
           return undefined;
         }
+
         return stripUserId(order);
       }
     }
+
     const order = this.localOrders.find((order) => order.id === id);
     if (!order) return undefined;
     if (userId && order.userId !== userId) {
       return undefined;
     }
+
     return stripUserId(order);
   }
 
   async createOrder(order: Order): Promise<Order> {
     if (this.isCosmosDbInitialized) {
       try {
         const { resource } = await this.ordersContainer!.items.create(order);
-        return stripUserId(stripUnderscoreProps(resource as Order));
+        return stripUserId(stripUnderscoreProperties(resource as Order));
       } catch (error) {
         console.error('Error creating order in Cosmos DB:', error);
         this.localOrders.push(order);
         return stripUserId(order);
       }
     }
+
     this.localOrders.push(order);
     return stripUserId(order);
   }
@@ -325,7 +339,7 @@ export class DbService {
 
         const updatedOrder = { ...existingOrder, status };
         const { resource } = await this.ordersContainer!.item(id, id).replace(updatedOrder);
-        return stripUserId(stripUnderscoreProps(resource as Order));
+        return stripUserId(stripUnderscoreProperties(resource as Order));
       } catch (error) {
         console.error(`Error updating order ${id} in Cosmos DB:`, error);
         const orderIndex = this.localOrders.findIndex((order) => order.id === id);
@@ -340,6 +354,7 @@ export class DbService {
         return stripUserId(this.localOrders[orderIndex]);
       }
     }
+
     const orderIndex = this.localOrders.findIndex((order) => order.id === id);
     if (orderIndex === -1) return undefined;
 
@@ -378,6 +393,7 @@ export class DbService {
         return true;
       }
     }
+
     const orderIndex = this.localOrders.findIndex((order) => order.id === id);
     if (orderIndex === -1) return false;
 
@@ -398,7 +414,7 @@ export class DbService {
 
         const updatedOrder = { ...existingOrder, ...updates };
         const { resource } = await this.ordersContainer!.item(id, id).replace(updatedOrder);
-        return stripUserId(stripUnderscoreProps(resource as Order));
+        return stripUserId(stripUnderscoreProperties(resource as Order));
       } catch (error) {
         console.error(`Error updating order ${id} in Cosmos DB:`, error);
         const orderIndex = this.localOrders.findIndex((order) => order.id === id);
@@ -408,6 +424,7 @@ export class DbService {
         return stripUserId(this.localOrders[orderIndex]);
       }
     }
+
     const orderIndex = this.localOrders.findIndex((order) => order.id === id);
     if (orderIndex === -1) return undefined;
 
@@ -456,7 +473,7 @@ export class DbService {
 
     try {
       const { resource } = await this.usersContainer.item(id, id).read();
-      return !!resource;
+      return Boolean(resource);
     } catch (error) {
       console.error('Error checking user existence:', error);
       return false;

packages/burger-api/src/functions/burgers-get.ts

@@ -1,6 +1,6 @@
 import { app, type HttpRequest, type InvocationContext } from '@azure/functions';
-import { DbService } from '../db-service';
-import { Burger } from '../burger';
+import { DbService } from '../db-service.js';
+import { Burger } from '../burger.js';
 
 function transformBurgerImageUrl(burger: Burger, request: HttpRequest): Burger {
   const url = new URL(request.url);
@@ -16,7 +16,7 @@ app.http('burgers-get', {
   methods: ['GET'],
   authLevel: 'anonymous',
   route: 'burgers',
-  handler: async (request: HttpRequest, context: InvocationContext) => {
+  async handler(request: HttpRequest, context: InvocationContext) {
     context.log('Processing request to get all burgers...');
 
     const dataService = await DbService.getInstance();
@@ -36,8 +36,8 @@ app.http('burger-get-by-id', {
   methods: ['GET'],
   authLevel: 'anonymous',
   route: 'burgers/{id}',
-  handler: async (request: HttpRequest, _context: InvocationContext) => {
-    const id = request.params.id;
+  async handler(request: HttpRequest, _context: InvocationContext) {
+    const { id } = request.params;
     const dataService = await DbService.getInstance();
     const burger = await dataService.getBurger(id);
 

packages/burger-api/src/functions/images-get.ts

@@ -1,15 +1,15 @@
 import { app, type HttpRequest, type InvocationContext } from '@azure/functions';
-import { BlobService } from '../blob-service';
+import { BlobService } from '../blob-service.js';
 
 app.http('images-get', {
   methods: ['GET'],
   authLevel: 'anonymous',
   route: 'images/{*filepath}',
-  handler: async (request: HttpRequest, context: InvocationContext) => {
+  async handler(request: HttpRequest, context: InvocationContext) {
     context.log('Processing image retrieval request...');
     context.log('Request path:', request.params.filepath);
 
-    const filepath = request.params.filepath;
+    const { filepath } = request.params;
 
     if (!filepath) {
       return {

packages/burger-api/src/functions/openapi-get.ts

@@ -1,7 +1,7 @@
-import { app, type HttpRequest, type InvocationContext } from '@azure/functions';
 import process from 'node:process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { app, type HttpRequest, type InvocationContext } from '@azure/functions';
 import yaml from 'js-yaml';
 import dotenv from 'dotenv';
 
@@ -12,7 +12,7 @@ app.http('openapi-get', {
   methods: ['GET'],
   authLevel: 'anonymous',
   route: 'openapi',
-  handler: async (request: HttpRequest, context: InvocationContext) => {
+  async handler(request: HttpRequest, context: InvocationContext) {
     context.log('Processing request to get OpenAPI specification...');
 
     try {
@@ -40,8 +40,8 @@ app.http('openapi-get', {
             },
             status: 200,
           };
-        } catch (err) {
-          context.error('YAML to JSON conversion failed:', err);
+        } catch (error) {
+          context.error('YAML to JSON conversion failed:', error);
           return {
             jsonBody: { error: 'YAML to JSON conversion failed.' },
             status: 500,