codeweaver 3.1.3 → 4.0.1

package/src/routers/orders/order.controller.ts

@@ -1,25 +1,26 @@
-import { memoizeAsync, onError, rateLimit, timeout } from "utils-decorators";
 import { OrderDto, OrderCreationDto, ZodOrderDto } from "./dto/order.dto";
-import { ResponseError } from "@/utilities/error-handling";
-import { convert, stringToInteger } from "@/utilities/conversion";
+import { ResponseError } from "@/core/error";
+import { convert, stringToInteger } from "@/core/helpers";
 import { config } from "@/config";
 import { orders } from "@/db";
 import { Order, ZodOrder } from "@/entities/order.entity";
-import { MapAsyncCache } from "@/utilities/cache/memory-cache";
-import { Injectable } from "@/utilities/container";
-import { parallelMap } from "@/utilities/parallel/parallel";
+import { Invalidate, MapAsyncCache, Memoize } from "@/core/cache";
+import { Injectable } from "@/core/container";
+import { parallelMap } from "@/core/parallel";
+import { RateLimit } from "@/core/rate-limit";
+import { ErrorHandler, Timeout } from "@/core/middlewares";
 
-function exceedHandler() {
+async function exceedHandler() {
   const message = "Too much call in allowed window";
   throw new ResponseError(message, 429);
 }
 
-function invalidInputHandler(e: ResponseError) {
+async function invalidInputHandler(e: ResponseError) {
   const message = "Invalid input";
   throw new ResponseError(message, 400, e.message);
 }
 
-const ordersCache = new MapAsyncCache<OrderDto[]>(config.cacheSize);
+const ordersCache = new MapAsyncCache<OrderDto[]>(1);
 const orderCache = new MapAsyncCache<OrderDto>(config.cacheSize);
 
 @Injectable()
@@ -31,9 +32,7 @@ const orderCache = new MapAsyncCache<OrderDto>(config.cacheSize);
 export default class OrderController {
   // constructor(private readonly orderService: OrderService) { }
 
-  @onError({
-    func: invalidInputHandler,
-  })
+  @ErrorHandler(invalidInputHandler)
   /**
    * Validates a string ID and converts it to a number.
    *
@@ -44,9 +43,7 @@ export default class OrderController {
     return stringToInteger(id);
   }
 
-  @onError({
-    func: invalidInputHandler,
-  })
+  @ErrorHandler(invalidInputHandler)
   /**
    * Validates and creates a new Order from the given DTO.
    *
@@ -66,11 +63,12 @@ export default class OrderController {
     return convert(newOrder, ZodOrder);
   }
 
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Invalidate(ordersCache, true)
+  @RateLimit(
+    config.rateLimitTimeSpan,
+    config.rateLimitAllowedCalls,
+    exceedHandler
+  )
   /**
    * Create a new order
    * @param {Order} order - Order creation data
@@ -80,41 +78,35 @@ export default class OrderController {
    */
   public async create(order: Order): Promise<void> {
     orders.push(order);
-    await ordersCache.delete("key");
   }
 
-  @memoizeAsync({
-    cache: ordersCache,
-    keyResolver: () => "key",
-    expirationTimeMs: config.memoizeTime,
-  })
-  @timeout(config.timeout)
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Memoize(ordersCache, () => "key")
+  @Timeout(config.timeout)
+  @RateLimit(
+    config.rateLimitTimeSpan,
+    config.rateLimitAllowedCalls,
+    exceedHandler
+  )
   /**
    * Retrieves all orders
    * @returns List of orders
    */
-  public async getAll(): Promise<OrderDto[]> {
-    return await parallelMap(
-      orders,
-      async (order) => await convert(order, ZodOrderDto)
+  public async getAll(
+    timeoutSignal?: AbortSignal
+  ): Promise<(OrderDto | null)[]> {
+    return await parallelMap(orders, async (order) =>
+      timeoutSignal?.aborted == false
+        ? await convert<Order, OrderDto>(order, ZodOrderDto)
+        : null
     );
   }
 
-  @memoizeAsync({
-    cache: orderCache,
-    keyResolver: (id: number) => id.toString(),
-    expirationTimeMs: config.memoizeTime,
-  })
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Memoize(orderCache)
+  @RateLimit(
+    config.rateLimitTimeSpan,
+    config.rateLimitAllowedCalls,
+    exceedHandler
+  )
   /**
    * Finds an order by its ID
    * @param {number} id - Order ID as string
@@ -128,11 +120,13 @@ export default class OrderController {
     return await convert(order, ZodOrder);
   }
 
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Invalidate(orderCache)
+  @Invalidate(ordersCache, true)
+  @RateLimit(
+    config.rateLimitTimeSpan,
+    config.rateLimitAllowedCalls,
+    exceedHandler
+  )
   /**
    * Cancel an existing order
    * @param {number} id - Order ID to cancel
@@ -145,21 +139,20 @@ export default class OrderController {
     if (order.status != "Processing") {
       throw new ResponseError(
         "Cancellation is not available unless the order is in processing status.",
-        400
+        409
       );
     }
     order.status = "Canceled";
     order.deliveredAt = new Date();
-
-    await orderCache.delete(id.toString());
-    await ordersCache.delete("key");
   }
 
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Invalidate(orderCache)
+  @Invalidate(ordersCache, true)
+  @RateLimit(
+    config.rateLimitTimeSpan,
+    config.rateLimitAllowedCalls,
+    exceedHandler
+  )
   /**
    * Mark an order as delivered
    * @param {number} id - Order ID to mark as delivered
@@ -172,13 +165,10 @@ export default class OrderController {
     if (order.status != "Processing") {
       throw new ResponseError(
         "Delivery is only available when the order is in processing status.",
-        400
+        409
       );
     }
     order.status = "Delivered";
     order.deliveredAt = new Date();
-
-    await orderCache.delete(id.toString());
-    await ordersCache.delete("key");
   }
 }

package/src/routers/products/index.router.ts

@@ -1,7 +1,7 @@
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
 import ProductController from "./product.controller";
-import { resolve } from "@/utilities/container";
+import { resolve } from "@/core/container";
 
 const router = Router();
 const productController = resolve(ProductController);
@@ -201,6 +201,7 @@ router.delete(
   asyncHandler(async (req: Request, res: Response) => {
     const id = await productController.validateId(req.params.id);
     await productController.delete(id);
+    res.status(204).send();
   })
 );
 

package/src/routers/products/product.controller.ts

@@ -1,31 +1,27 @@
-import { memoizeAsync, onError, rateLimit, timeout } from "utils-decorators";
 import {
   ProductCreationDto,
   ProductDto,
   ProductUpdateDto,
   ZodProductDto,
 } from "./dto/product.dto";
-import { MapAsyncCache } from "@/utilities/cache/memory-cache";
-import { convert, stringToInteger } from "@/utilities/conversion";
+import { Invalidate, MapAsyncCache, Memoize } from "@/core/cache";
+import { convert, stringToInteger } from "@/core/helpers";
 import { config } from "@/config";
-import { ResponseError } from "@/utilities/error-handling";
+import { ResponseError } from "@/core/error";
 import { products } from "@/db";
 import { Product, ZodProduct } from "@/entities/product.entity";
-import { Injectable } from "@/utilities/container";
-import assign from "@/utilities/assignment";
-import { parallelMap } from "@/utilities/parallel/parallel";
+import { Injectable } from "@/core/container";
+import { assign } from "@/core/helpers";
+import { parallelMap } from "@/core/parallel";
+import { ErrorHandler, Timeout } from "@/core/middlewares";
+import { RateLimit } from "@/core/rate-limit";
 
-function exceedHandler() {
-  const message = "Too much call in allowed window";
-  throw new ResponseError(message, 429);
-}
-
-function invalidInputHandler(e: ResponseError) {
+async function invalidInputHandler(e: ResponseError) {
   const message = "Invalid input";
   throw new ResponseError(message, 400, e.message);
 }
 
-const productsCache = new MapAsyncCache<ProductDto[]>(config.cacheSize);
+const productsCache = new MapAsyncCache<ProductDto[]>(1);
 const productCache = new MapAsyncCache<ProductDto>(config.cacheSize);
 
 @Injectable()
@@ -37,9 +33,7 @@ const productCache = new MapAsyncCache<ProductDto>(config.cacheSize);
 export default class ProductController {
   // constructor(private readonly productService: ProductService) { }
 
-  @onError({
-    func: invalidInputHandler,
-  })
+  @ErrorHandler(invalidInputHandler)
   /**
    * Validates a string ID and converts it to a number.
    *
@@ -50,9 +44,7 @@ export default class ProductController {
     return stringToInteger(id);
   }
 
-  @onError({
-    func: invalidInputHandler,
-  })
+  @ErrorHandler(invalidInputHandler)
   /**
    * Validates and creates a new Product from the given DTO.
    *
@@ -65,9 +57,7 @@ export default class ProductController {
     return await convert({ ...product, id: products.length + 1 }, ZodProduct);
   }
 
-  @onError({
-    func: invalidInputHandler,
-  })
+  @ErrorHandler(invalidInputHandler)
   /**
    * Validates and creates a new Product from the given DTO.
    *
@@ -80,11 +70,8 @@ export default class ProductController {
     return await convert(product, ZodProduct);
   }
 
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Invalidate(productsCache, true)
+  @RateLimit(config.rateLimitTimeSpan, config.rateLimitAllowedCalls)
   /**
    * Creates a new product with validated data
    * @param {Product} product - Product creation data validated by Zod schema
@@ -94,41 +81,27 @@ export default class ProductController {
    */
   public async create(product: Product): Promise<void> {
     products.push(product);
-    await productsCache.delete("key");
   }
 
-  @memoizeAsync({
-    cache: productsCache,
-    keyResolver: () => "key",
-    expirationTimeMs: config.memoizeTime,
-  })
-  @timeout(config.timeout)
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Memoize(productsCache, () => "key")
+  @Timeout(config.timeout)
+  @RateLimit(config.rateLimitTimeSpan, config.rateLimitAllowedCalls)
   /**
    * Retrieves all products with truncated descriptions
    * @returns List of products with summarized descriptions
    */
-  public async getAll(): Promise<ProductDto[]> {
-    return await parallelMap(
-      products,
-      async (product) => await convert(product, ZodProductDto)
+  public async getAll(
+    timeoutSignal?: AbortSignal
+  ): Promise<(ProductDto | null)[]> {
+    return await parallelMap(products, async (product) =>
+      timeoutSignal?.aborted == false
+        ? await convert<Product, ProductDto>(product, ZodProductDto)
+        : null
     );
   }
 
-  @memoizeAsync({
-    cache: productCache,
-    keyResolver: (id: number) => id.toString(),
-    expirationTimeMs: config.memoizeTime,
-  })
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Memoize(productCache)
+  @RateLimit(config.rateLimitTimeSpan, config.rateLimitAllowedCalls)
   /**
    * Finds a product by its ID
    * @param {number} id - Product ID as string
@@ -142,11 +115,9 @@ export default class ProductController {
     return await convert(product, ZodProduct);
   }
 
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Invalidate(productCache)
+  @Invalidate(productsCache, true)
+  @RateLimit(config.rateLimitTimeSpan, config.rateLimitAllowedCalls)
   /**
    * Updates an existing product
    * @param {number} id - Product ID to update
@@ -162,18 +133,14 @@ export default class ProductController {
     const product = await this.get(id);
     if (product != null) {
       await assign(product, updateData, ZodProduct);
-      await productCache.delete(updateData.id.toString());
-      await productsCache.delete("key");
     } else {
       throw new ResponseError("Product dose not exist.", 404);
     }
   }
 
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Invalidate(productCache)
+  @Invalidate(productsCache, true)
+  @RateLimit(config.rateLimitTimeSpan, config.rateLimitAllowedCalls)
   /**
    * Deletes a product by ID
    * @param {number} id - Product ID to delete
@@ -186,8 +153,6 @@ export default class ProductController {
     if (index == -1) {
       throw new ResponseError("Product dose not exist.", 404);
     }
-    await productCache.delete(id.toString());
-    await productsCache.delete("key");
     products.splice(index, 1)[0];
   }
 }

package/src/routers/users/index.router.ts

@@ -1,7 +1,7 @@
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
 import UserController from "./user.controller";
-import { resolve } from "@/utilities/container";
+import { resolve } from "@/core/container";
 
 const router = Router();
 const userController = resolve(UserController);

package/src/routers/users/user.controller.ts

@@ -1,26 +1,22 @@
 import { UserCreationDto, UserDto, ZodUserDto } from "./dto/user.dto";
-import { memoizeAsync, onError, rateLimit, timeout } from "utils-decorators";
-import { ResponseError } from "@/utilities/error-handling";
-import { convert, stringToInteger } from "@/utilities/conversion";
+import { ResponseError } from "@/core/error";
+import { convert, stringToInteger } from "@/core/helpers";
 import { config } from "@/config";
 import { users } from "@/db";
 import { User, ZodUser } from "@/entities/user.entity";
-import { MapAsyncCache } from "@/utilities/cache/memory-cache";
-import { Injectable } from "@/utilities/container";
-import { parallelMap } from "@/utilities/parallel/parallel";
+import { Invalidate, MapAsyncCache, Memoize } from "@/core/cache";
+import { Injectable } from "@/core/container";
+import { parallelMap } from "@/core/parallel";
+import { ErrorHandler, LogMethod, Timeout } from "@/core/middlewares";
+import { RateLimit } from "@/core/rate-limit";
 
-function exceedHandler() {
-  const message = "Too much call in allowed window";
-  throw new ResponseError(message, 429);
-}
-
-function invalidInputHandler(e: ResponseError) {
+async function invalidInputHandler(e: ResponseError) {
   const message = "Invalid input";
   throw new ResponseError(message, 400, e?.message);
 }
 
-const usersCache = new MapAsyncCache<UserDto[]>(config.cacheSize);
 const userCache = new MapAsyncCache<UserDto>(config.cacheSize);
+const usersCache = new MapAsyncCache<UserDto[]>(1);
 
 @Injectable()
 /**
@@ -31,9 +27,7 @@ const userCache = new MapAsyncCache<UserDto>(config.cacheSize);
 export default class UserController {
   // constructor(private readonly userService: UserService) { }
 
-  @onError({
-    func: invalidInputHandler,
-  })
+  @ErrorHandler(invalidInputHandler)
   /**
    * Validates a string ID and converts it to a number.
    *
@@ -44,9 +38,7 @@ export default class UserController {
     return stringToInteger(id);
   }
 
-  @onError({
-    func: invalidInputHandler,
-  })
+  @ErrorHandler(invalidInputHandler)
   /**
    * Validates and creates a new User from the given DTO.
    *
@@ -57,11 +49,8 @@ export default class UserController {
     return await convert(user, ZodUser);
   }
 
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Invalidate(usersCache, true)
+  @RateLimit(config.rateLimitTimeSpan, config.rateLimitAllowedCalls)
   /**
    * Create a new user
    * @param {User} user - User creation data validated by Zod schema
@@ -71,42 +60,28 @@ export default class UserController {
    */
   public async create(user: User): Promise<void> {
     users.push(user);
-    await usersCache.delete("key");
   }
 
-  @memoizeAsync({
-    cache: usersCache,
-    keyResolver: () => "key",
-    expirationTimeMs: config.memoizeTime,
-  })
-  @timeout(config.timeout)
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Memoize(usersCache, () => "key")
+  @Timeout(config.timeout)
+  @RateLimit(config.rateLimitTimeSpan, config.rateLimitAllowedCalls)
   /**
    * Get all users
    * @returns {Promise<UserDto[]>} List of users with hidden password fields
    * @throws {ResponseError} 500 - When rate limit exceeded
    */
-  public async getAll(): Promise<UserDto[]> {
-    return await parallelMap(
-      users,
-      async (user) => await convert(user, ZodUserDto)
+  public async getAll(
+    timeoutSignal?: AbortSignal
+  ): Promise<(UserDto | null)[]> {
+    return await parallelMap(users, async (user) =>
+      timeoutSignal?.aborted == false
+        ? await convert<User, UserDto>(user!, ZodUserDto)
+        : null
     );
   }
 
-  @memoizeAsync({
-    cache: userCache,
-    keyResolver: (id: number) => id.toString(),
-    expirationTimeMs: config.memoizeTime,
-  })
-  @rateLimit({
-    timeSpanMs: config.rateLimitTimeSpan,
-    allowedCalls: config.rateLimitAllowedCalls,
-    exceedHandler,
-  })
+  @Memoize(userCache)
+  @RateLimit(config.rateLimitTimeSpan, config.rateLimitAllowedCalls)
   /**
    * Get user by ID
    * @param {number} id - User ID as string

package/src/utilities/cache/memory-cache.ts

@@ -1,74 +0,0 @@
-import { AsyncCache } from "utils-decorators";
-
-/**
- * A simple in-memory map-based cache implementing AsyncCache<T>.
- * This is a straightforward wrapper around a Map<string, T>.
- */
-export class MapAsyncCache<T> implements AsyncCache<T> {
-  public constructor(
-    private capacity?: number,
-    private cache?: Map<string, T>
-  ) {
-    this.capacity = this.capacity ?? Number.POSITIVE_INFINITY;
-    this.cache = this.cache ?? new Map<string, T>();
-  }
-
-  /**
-   * Asynchronously set a value by key.
-   * @param key The cache key
-   * @param value The value to cache
-   */
-  async set(key: string, value: T): Promise<void> {
-    if (value != null) {
-      if (this.cache?.has(key)) {
-        this.cache?.set(key, value);
-      } else {
-        if (
-          (this.capacity ?? Number.POSITIVE_INFINITY) > (this.cache?.size ?? 0)
-        ) {
-          this.cache?.set(key, value);
-        }
-      }
-    } else {
-      this.cache?.delete(key);
-    }
-  }
-
-  /**
-   * Asynchronously get a value by key.
-   * - If the key exists, returns the value.
-   * - If the key does not exist, returns undefined cast to T to satisfy the Promise<T> return type.
-   *
-   * Note: Returning undefined may be surprising for callers expecting a strict A/B.
-   * Consider returning `T | undefined` from AsyncCache if you can adjust the interface,
-   * or throw a ResponseError for "not found" depending on your usage.
-   */
-  async get(key: string): Promise<T> {
-    if (this.cache?.has(key)) {
-      return this.cache?.get(key) ?? (null as T);
-    }
-
-    return null as T;
-  }
-
-  /**
-   * Asynchronously delete a value by key.
-   */
-  async delete(key: string): Promise<void> {
-    this.cache?.delete(key);
-  }
-
-  /**
-   * Asynchronously check if a key exists in the cache.
-   */
-  async has(key: string): Promise<boolean> {
-    return this.cache?.has(key) ?? false;
-  }
-
-  /**
-   * Asynchronously clear the cache.
-   */
-  async clear(key: string): Promise<void> {
-    this.cache?.clear();
-  }
-}