codeweaver 1.0.15 → 2.0.0

package/src/utilities/error-handling.ts

@@ -0,0 +1,120 @@
+import { Response } from "express";
+import { ReturnInfo, ResponseError } from "./types";
+
+/**
+ * Sends a standardized HTTP error response.
+ *
+ * This function sets the response status from the provided error (defaulting to 500)
+ * and serializes the error object as JSON.
+ *
+ * @param res - Express Response object to send the error on
+ * @param error - Error details to return to the client (must include status or default will be 500)
+ */
+export function sendHttpError(res: Response, error: ResponseError): void {
+  res.status(error.status ?? 500).json(error);
+}
+
+/**
+ * Executes a function and captures a potential error as a ReturnInfo tuple.
+ *
+ * Returns a two-element tuple: [value, error]
+ * - value: the function result if it succeeds; null if an exception is thrown
+ * - error: the caught Error wrapped as a ResponseError (or the provided error) if the function throws; null if the function succeeds
+ *
+ * This utility helps avoid try/catch blocks at call sites by returning both the
+ * result and any error in a single value.
+ *
+ * @template T
+ * @param func - The function to execute
+ * @param error - The error object to return when an exception occurs (typically a ResponseError). If no error is provided, null is used.
+ * @returns ReturnInfo<T> A tuple: [value or null, error or null]
+ */
+export function tryCatch<T>(
+  func: () => T,
+  error: ResponseError | null
+): ReturnInfo<T> {
+  try {
+    return [func(), null];
+  } catch {
+    return [null, error];
+  }
+}
+
+/**
+ * Parses a string input into a number (ID) with basic validation.
+ *
+ * If parsing fails, this function throws a ResponseError describing the invalid input.
+ *
+ * @param input - The string to parse as an integer ID
+ * @returns The parsed number
+ * @throws {ResponseError} When the input cannot be parsed as an integer
+ */
+export function parseId(input: string): number {
+  try {
+    // parseInt may yield NaN for non-numeric input; this example mirrors the original behavior
+    // If you want stricter validation, you can check isNaN and throw a more explicit error.
+    return parseInt(input);
+  } catch {
+    throw new ResponseError(
+      input,
+      400,
+      "Wrong input",
+      "The id parameter must be an integer number."
+    );
+  }
+}
+
+/**
+ * Creates a successful result from a ReturnInfo tuple.
+ *
+ * Given a ReturnInfo<T> of the form [value, error], this returns the value
+ * when the operation succeeded, or null when there was an error.
+ *
+ * @template T
+ * @param input - The ReturnInfo tuple
+ * @returns The successful value of type T, or null if there was an error
+ */
+export function successfulResult<T>(input: ReturnInfo<T>): T | null {
+  return input[0];
+}
+
+/**
+ * Normalizes and wraps an error into the common ReturnInfo shape.
+ *
+ * The function accepts a ReturnInfo-shaped input and extracts the error portion.
+ * If a non-Error value is provided, you should wrap it as a ResponseError beforehand.
+ * If the error is already a ResponseError, it is returned as-is.
+ *
+ * @template T
+ * @param responseError - The error to wrap, either as a ResponseError or as a ReturnInfo<T> where the error is at index 1
+ * @returns The extracted or wrapped ResponseError, or null if there is no error
+ */
+export function error<T>(responseError: ReturnInfo<T>): ResponseError | null {
+  return responseError[1];
+}
+
+/**
+ * Determines whether a ReturnInfo value represents a successful operation.
+ *
+ * A result is considered successful when there is no error (i.e., the error portion is null).
+ *
+ * @template T
+ * @param result - The ReturnInfo tuple [value | null, error | null]
+ * @returns true if there is no error; false otherwise
+ */
+export function isSuccessful<T>(result: ReturnInfo<T>): boolean {
+  return result[1] === null;
+}
+
+/**
+ * Indicates whether a ReturnInfo value represents an error.
+ *
+ * This is the logical negation of isSuccess for a given ReturnInfo.
+ *
+ * @template T
+ * @param result - The ReturnInfo tuple [value | null, error | null]
+ * @returns true if an error is present (i.e., error is not null); false otherwise
+ */
+export function hasError<T>(result: ReturnInfo<T>): boolean {
+  return result[1] !== null;
+}

package/src/utilities/types.ts

@@ -0,0 +1,23 @@
+/**
+ * Represents a standardized error response structure for API endpoints
+ * @class
+ * @property {number} [status] - HTTP status code
+ * @property {string} [name] - Error name/type
+ * @property {string} message - Human-readable error message
+ * @property {string} [stack] - Error stack trace (development only)
+ * @property {string} [details] - Additional error details
+ */
+export class ResponseError extends Error {
+  public constructor(
+    public message: string,
+    public status?: number,
+    public details?: string,
+    public code?: string,
+    public stack?: string
+  ) {
+    super(message);
+  }
+}
+
+export type ReturnInfo<T> = [T | null, ResponseError | null];
+export type AsyncReturnInfo<T> = Promise<[T | null, ResponseError | null]>;

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "ESNext",
+    "target": "ES2023",
     "module": "commonjs",
     "outDir": "./dist",
     "strict": true,
@@ -8,8 +8,11 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
+    "emitDecoratorMetadata": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
   },
-  "include": ["src/**/*.ts", "src/**/*.js", "command.js"],
+  "include": ["**/*.ts", "**/*.js"],
   "exclude": ["node_modules"]
 }

package/tsconfig.paths.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["dist/*"]
+    }
+  }
+}

package/src/app.ts

@@ -1,95 +0,0 @@
-import express from "express";
-import fs from "fs";
-import path from "path";
-import config from "./config";
-
-// Function to load routers recursively
-function loadRouters(routerPath: string, basePath: string = "") {
-  fs.readdirSync(routerPath).forEach((file) => {
-    // Check if the filename should be excluded based on certain criteria
-    if (
-      // Exclude files that start with an underscore (_)
-      file.startsWith("_") ||
-      // Exclude files that start with an at symbol (@)
-      file.startsWith("@") ||
-      // Exclude JavaScript controller files
-      file.endsWith(".controller.js") ||
-      // Exclude TypeScript controller files
-      file.endsWith(".controller.ts") ||
-      // Exclude JavaScript service files
-      file.endsWith(".service.js") ||
-      // Exclude TypeScript service files
-      file.endsWith(".service.ts") ||
-      // Exclude JavaScript middleware files
-      file.endsWith(".middleware.js") ||
-      // Exclude TypeScript middleware files
-      file.endsWith(".middleware.ts") ||
-      // Exclude JavaScript error middleware files
-      file.endsWith(".error.js") ||
-      // Exclude TypeScript error middleware files
-      file.endsWith(".error.ts") ||
-      // Exclude JavaScript service files
-      file.endsWith(".decorator.js") ||
-      // Exclude TypeScript service files
-      file.endsWith(".decorator.ts") ||
-      // Exclude JavaScript DTO files
-      file.endsWith(".dto.js") ||
-      // Exclude TypeScript DTO files
-      file.endsWith(".dto.ts") ||
-      // Exclude JavaScript test specification files
-      file.endsWith(".spec.js") ||
-      // Exclude TypeScript test specification files
-      file.endsWith(".spec.ts")
-    )
-      // If any of the above conditions are true, exit the function early
-      return;
-
-    const fullPath = path.join(routerPath, file);
-
-    // Construct a route path by combining the base path with the filename
-    const routePath = path
-      // Join the base path and the filename, removing the file extension (.js or .ts)
-      .join(basePath, file.replace(/(\.js|\.ts)/g, ""))
-      // Replace all backslashes with forward slashes for consistent file path formatting
-      .replaceAll("\\", "/")
-      // Remove the trailing '/index' if it exists, to clean up the route
-      .replace(/\/?index$/g, "");
-
-    if (fs.lstatSync(fullPath).isDirectory()) {
-      // If the file is a directory, call the function again
-      loadRouters(fullPath, routePath);
-    } else if (file.endsWith(".ts") || file.endsWith(".js")) {
-      // Import the router module and mount it to the app
-      const router = require(fullPath);
-      app.use("/" + routePath, router);
-      console.log(`Mounted ${file} at ${"/" + routePath}`);
-    }
-  });
-}
-
-const app = express();
-app.use(express.json());
-app.use(express.urlencoded({ extended: true }));
-
-//app.use(cors());
-
-// Automatically import all routers from the /src/routers directory
-const routersPath = path.join(__dirname, "/routers");
-loadRouters(routersPath);
-
-// Swagger setup
-if (config.devMode) {
-  const swaggerJsDoc = require("swagger-jsdoc");
-  const swaggerUi = require("swagger-ui-express");
-  const swaggerDocs = swaggerJsDoc(config.swaggerOptions);
-  app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(swaggerDocs));
-}
-
-// Start the server
-app.listen(config.port, () => {
-  console.log(`Server is running on http://localhost:${config.port}`);
-  if (config.devMode)
-    console.log(
-      `Swagger UI is available at http://localhost:${config.port}/api-docs`
-    );
-});

package/src/routers/orders/index.ts

@@ -1,40 +0,0 @@
-import { Router, Request, Response } from "express";
-import asyncHandler from "express-async-handler";
-
-const router = Router();
-
-/**
- * @swagger
- * /orders:
- *   get:
- *     summary: Get order home
- *     description: Returns the order home page.
- *     responses:
- *       200:
- *         description: Order home page
- */
-router.get(
-  "/",
-  asyncHandler(async (req: Request, res: Response) => {
-    res.send("Order Home");
-  })
-);
-
-/**
- * @swagger
- * /orders/history:
- *   get:
- *     summary: Get order history
- *     description: Returns order history.
- *     responses:
- *       200:
- *         description: Order history
- */
-router.get(
-  "/history",
-  asyncHandler(async (req: Request, res: Response) => {
-    res.send("Order History");
-  })
-);
-
-export = router;

package/src/routers/products/index.ts

@@ -1,167 +0,0 @@
-import { Router, Request, Response } from "express";
-import asyncHandler from "express-async-handler";
-
-const router = Router();
-
-// Array to store products (as a mock database)
-const products = [
-  { id: 1, name: "Product1" },
-  { id: 2, name: "Product2" },
-  { id: 3, name: "Product3" },
-  { id: 4, name: "Product4" },
-  { id: 5, name: "Product5" },
-  { id: 6, name: "Product6" },
-  { id: 7, name: "Product7" },
-  { id: 8, name: "Product8" },
-  { id: 9, name: "Product9" },
-];
-
-// CRUD Routes
-
-/**
- * @swagger
- * /products:
- *   post:
- *     summary: Create an product
- *     description: Create a new product.
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             properties:
- *               name:
- *                 type: string
- *               description:
- *                 type: string
- *     responses:
- *       201:
- *         description: product created
- */
-router.post(
-  "/",
-  asyncHandler(async (req: Request, res: Response) => {
-    const product = { id: products.length + 1, name: req.body.name };
-    products.push(product);
-    res.status(201).json(product);
-  })
-);
-
-/**
- * @swagger
- * /products:
- *   get:
- *     summary: Get all products
- *     responses:
- *       200:
- *         description: A list of products
- */
-router.get(
-  "/",
-  asyncHandler(async (req: Request, res: Response) => {
-    res.json(products);
-  })
-);
-
-/**
- * @swagger
- * /products/{id}:
- *   get:
- *     summary: Get an product by ID
- *     parameters:
- *       - name: id
- *         in: path
- *         required: true
- *         description: The ID of the product
- *         schema:
- *           type: integer
- *     responses:
- *       200:
- *         description: An product object
- *       404:
- *         description: product not found
- */
-router.get(
-  "/:id",
-  asyncHandler(async (req: Request, res: Response) => {
-    const product = products.find((i) => i.id === parseInt(req.params.id));
-    if (!product) res.status(404).send("product not found");
-    else res.json(product);
-  })
-);
-
-/**
- * @swagger
- * /products/{id}:
- *   put:
- *     summary: Update an product
- *     parameters:
- *       - name: id
- *         in: path
- *         required: true
- *         description: The ID of the product to update
- *         schema:
- *           type: integer
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             properties:
- *               name:
- *                 type: string
- *               description:
- *                 type: string
- *     responses:
- *       200:
- *         description: product updated
- *       404:
- *         description: product not found
- */
-router.put(
-  "/:id",
-  asyncHandler(async (req: Request, res: Response) => {
-    const product = products.find((i) => i.id === parseInt(req.params.id));
-    if (!product) res.status(404).send("product not found");
-    else {
-      Object.assign(product, { id: req.body.id, name: req.body.name });
-      res.json(product);
-    }
-  })
-);
-
-/**
- * @swagger
- * /products/{id}:
- *   delete:
- *     summary: Delete an product
- *     parameters:
- *       - name: id
- *         in: path
- *         required: true
- *         description: The ID of the product to delete
- *         schema:
- *           type: integer
- *     responses:
- *       204:
- *         description: product deleted
- *       404:
- *         description: product not found
- */
-router.delete(
-  "/:id",
-  asyncHandler(async (req: Request, res: Response) => {
-    const productIndex = products.findIndex(
-      (i) => i.id === parseInt(req.params.id)
-    );
-    if (productIndex === -1) res.status(404).send("product not found");
-    else {
-      products.splice(productIndex, 1);
-      res.status(204).send();
-    }
-  })
-);
-
-export = router;

package/src/routers/users/index.ts

@@ -1,81 +0,0 @@
-import { Router, Request, Response } from "express";
-import asyncHandler from "express-async-handler";
-import UserController from "./user.controller";
-
-const router = Router();
-const userController = new UserController();
-
-/**
- * @swagger
- * /users:
- *   post:
- *     summary: Create a user
- *     description: Create a new user.
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required:
- *               - username
- *               - email
- *               - password
- *             properties:
- *               username:
- *                 type: string
- *               email:
- *                 type: string
- *               password:
- *                 type: string
- *             example: # Sample object
- *               username: JessicaSmith
- *               email: william.howard.taft@my-own-personal-domain.com
- *               password: password123
- *     responses:
- *       201:
- *         description: product created
- */
-router.post(
-  "/",
-  asyncHandler(async (req: Request, res: Response) => {
-    const result = await userController.createUser(req.body);
-    res.status(201).json({ message: result });
-  })
-);
-
-/**
- * @swagger
- * /user:
- *   get:
- *     summary: Get user home
- *     description: Returns the user home page.
- *     responses:
- *       200:
- *         description: User home page
- */
-router.get(
-  "/",
-  asyncHandler(async (req: Request, res: Response) => {
-    res.send("User Home");
-  })
-);
-
-/**
- * @swagger
- * /user/profile:
- *   get:
- *     summary: Get user profile
- *     description: Returns user profile information.
- *     responses:
- *       200:
- *         description: User profile information
- */
-router.get(
-  "/profile",
-  asyncHandler(async (req: Request, res: Response) => {
-    res.send("User Profile");
-  })
-);
-
-export = router;