most types are defined.

Author: darkwaves-ofc

src/config.ts

@@ -4,7 +4,7 @@ import * as dotenv from "dotenv";
 
 dotenv.config();
 
-interface Config {
+export interface Config {
   mongourl: string | undefined;
   website: {
     links: string[];
@@ -52,4 +52,4 @@ const config: Config = {
   },
 };
 
-export = config;
+export default config;

src/handlers/initDatabase.ts

@@ -275,7 +275,7 @@ export = class DatabaseInitializer {
       let schemaDb = await dashboardDataDb.findOne({ _id: id }).catch(() => {});
       if (schemaDb) continue;
       schemaDb = await new dashboardDataDb(
-        this.convertIdsRecursive(schema),
+        this.convertIdsRecursive(schema)
       ).save();
     }
   }

src/index.ts

@@ -51,7 +51,7 @@ function getIPv4Addresses(): string | undefined {
   Object.keys(networkInterfaces).forEach((interfaceName) => {
     const interfaceInfo: any = networkInterfaces[interfaceName];
 
-    interfaceInfo.forEach((info:any) => {
+    interfaceInfo.forEach((info: any) => {
       if (info.family === "IPv4" && info.internal === false) {
         ipv4Address = info.address;
       }
@@ -103,7 +103,7 @@ new Promise<void>((resolve) => {
       }
     }
 
-    const allips = client.config.website.links.map((val:any) => {
+    const allips = client.config.website.links.map((val: any) => {
       return (val = `${val}:${client.config.website.port}`);
     });
 

src/routes/v1/user/post.ts

@@ -1,9 +1,10 @@
 import express, { Request, Response, Router } from "express";
 import userDataDb from "../../../schema/userData";
 import bcrypt from "bcrypt";
+import { AppTypes } from "../../../structures/App";
 
 class Route {
-  constructor(client: any) {
+  constructor(client: AppTypes) {
     const router: Router = express.Router();
 
     router.post("/user/auth", async (req: Request, res: Response) => {
@@ -15,15 +16,15 @@ class Route {
         const { loginData = {} } = req.body;
         const authHeader = req.headers["authorization"];
         const token = authHeader && authHeader.split(" ")[1]; // Bearer TOKEN_VALUE
+        if (token) {
+          const tokenUserData = await client
+            .findUser(token, req.secret)
+            .catch(() => {});
 
-        const tokenUserData = await client
-          .findUser(token, req.secret)
-          .catch(() => {});
-
-        if (tokenUserData) {
-          return notFoundError(`You are already logged into the system`, 400);
+          if (tokenUserData) {
+            return notFoundError(`You are already logged into the system`, 400);
+          }
         }
-
         const { userName, password } = loginData;
         if (!userName) {
           return notFoundError(`userName is required`, 400);

src/schema/dashboard.ts

@@ -42,7 +42,7 @@ const dashboardDataSchema: Schema<IDashboardData> = new Schema({
 
 const DashboardDataModel = model<IDashboardData>(
   "DashboardData",
-  dashboardDataSchema,
+  dashboardDataSchema
 );
 
 export default DashboardDataModel;

src/structures/App.ts

@@ -1,46 +1,63 @@
 import express from "express";
-import config from "../config";
+import config, { Config } from "../config";
 import cookieParser from "cookie-parser";
 import mongoose from "mongoose";
 import bodyParser from "body-parser";
 import amqp from "amqplib";
 import jwt from "jsonwebtoken";
 import userDataDb from "../schema/userData";
 import cors from "cors";
-import Logger from "../utils/logger";
+import { LoggerType, logger } from "../utils/logger";
+import { Server } from "http";
 // import * as CircularJSON from "circular-json";
 // import * as dayjs from "dayjs";
 // import { EventEmitter } from "ws";
 // import { v4 as uuidv4 } from "uuid";
 // import { CompressionTypes, Partitioners } from "kafkajs";
 
+interface UserData {
+  _id: string;
+  tokens: { token: string }[];
+  // Add other properties as per your actual structure
+}
+
+type ErrorMiddlewareFunction = (
+  req: express.Request,
+  res: express.Response,
+  next: express.NextFunction
+) => Promise<void>;
+
+interface FindUserFunction {
+  (token: string, secret?: string): Promise<UserData>; // Adjust the return type as per your actual return structure
+}
+
 interface App {
-  new (someParam: any): App;
-  config: any;
-  express: any;
+  config: Config;
   routes: Map<string, any>;
-  logger: any;
-  mongoose: any;
+  logger: LoggerType;
+  mongoose: mongoose.Mongoose;
   fileCache: Map<string, any>;
   linkCache: Map<string, any>;
-  parseURL: any;
-  jwt: any;
-  ipport: any;
-  _errorMiddleware: any;
-  _requirehandlers: any;
-  port: any;
-  links: any;
-  server: any;
-  findUser: any;
-  connect: any;
-  app: any;
+  parseURL: (link: string) => URL;
+  jwt: jwt.JwtPayload;
+  ipport: (link: string, port: number) => string;
+  _errorMiddleware: ErrorMiddlewareFunction;
+  _requirehandlers: () => Promise<void>;
+  port: number;
+  links: string[];
+  server: Server;
+  findUser: FindUserFunction;
+  connect: () => Promise<void>;
+  app: express.Express;
+}
+export interface AppTypes extends App {
+  
 }
-
 class App {
   constructor() {
     this.config = config;
     this.routes = new Map();
-    this.logger = Logger;
+    this.logger = logger;
     this.mongoose = mongoose;
     this.fileCache = new Map();
     this.linkCache = new Map();
@@ -74,12 +91,17 @@ class App {
       req: express.Request,
       res: express.Response,
       next: express.NextFunction
-    ) {
-      return res.status(404).json({ error: true, message: "page not found" });
+    ): Promise<void> {
+      res.status(404).json({ error: true, message: "page not found" });
+      return;
     };
 
     this._requirehandlers = async function () {
-      this.port = this.config.website.port;
+      this.port =
+        parseInt(
+          this.config.website.port ? this.config.website.port : "8080",
+          10
+        ) || 8080;
       this.links = this.config.website.links;
       this.server = this.app.listen(this.port);
       this.app.use(
@@ -204,13 +226,16 @@ class App {
     this.connect = async function () {
       this.logger.log(`[WebSite] Loading !`, "log");
 
-      await this.mongoose.connect(this.config.mongourl, {
-        useNewUrlParser: true,
-        autoIndex: false,
-        connectTimeoutMS: 10000,
-        family: 4,
-        useUnifiedTopology: true,
-      });
+      await this.mongoose.connect(
+        this.config.mongourl ? this.config.mongourl : "",
+        {
+          // useNewUrlParser: true,
+          autoIndex: false,
+          connectTimeoutMS: 10000,
+          family: 4,
+          // useUnifiedTopology: true,
+        }
+      );
 
       await this._requirehandlers();
       this.logger.log(`[WebSite] Website is now Online !`, "ready");

src/utils/filterData.ts

@@ -55,7 +55,7 @@ class FilterData {
 
   private populateDestructuredData(
     destrucuredData: any,
-    findingUserData: UserData,
+    findingUserData: UserData
   ) {
     destrucuredData.profilePicture = findingUserData.profilePicture || "";
     destrucuredData.bio = findingUserData.bio || "";

src/utils/logger.ts

@@ -1,73 +1,87 @@
 import chalk from "chalk";
 import moment from "moment";
 
+type loggerTypes =
+  | "log"
+  | "warn"
+  | "error"
+  | "debug"
+  | "cmd"
+  | "event"
+  | "ready";
+
+interface LoggerType {
+  log(message?: any, optionalParams?: loggerTypes): void;
+}
 export default class Logger {
-  static log(
-    content: string,
-    type:
-      | "log"
-      | "warn"
-      | "error"
-      | "debug"
-      | "cmd"
-      | "event"
-      | "ready" = "log",
-  ) {
+  log(content: string, type: loggerTypes = "log") {
     const date = `${moment().format("DD-MM-YYYY hh:mm:ss")}`;
     switch (type) {
       case "log": {
         return console.log(
           `[${chalk.yellow(date)}]: [${chalk.black.bgBlue(
-            type.toUpperCase(),
-          )}] ${chalk.blue(content)}`,
+            type.toUpperCase()
+          )}] ${chalk.blue(content)}`
         );
       }
       case "warn": {
         return console.log(
           `[${chalk.yellow(date)}]: [${chalk.black.bgYellow(
-            type.toUpperCase(),
-          )}] ${chalk.blue(content)}`,
+            type.toUpperCase()
+          )}] ${chalk.blue(content)}`
         );
       }
       case "error": {
         return console.log(
           `[${chalk.yellow(date)}]: [${chalk.black.bgRed(
-            type.toUpperCase(),
-          )}] ${chalk.blue(content)}`,
+            type.toUpperCase()
+          )}] ${chalk.blue(content)}`
         );
       }
       case "debug": {
         return console.log(
           `[${chalk.yellow(date)}]: [${chalk.black.bgGreen(
-            type.toUpperCase(),
-          )}] ${chalk.blue(content)}`,
+            type.toUpperCase()
+          )}] ${chalk.blue(content)}`
         );
       }
       case "cmd": {
         return console.log(
           `[${chalk.yellow(date)}]: [${chalk.black.bgWhite(
-            type.toUpperCase(),
-          )}] ${chalk.blue(content)}`,
+            type.toUpperCase()
+          )}] ${chalk.blue(content)}`
         );
       }
       case "event": {
         return console.log(
           `[${chalk.yellow(date)}]: [${chalk.black.bgHex("#e1f507")(
-            type.toUpperCase(),
-          )}] ${chalk.blue(content)}`,
+            type.toUpperCase()
+          )}] ${chalk.blue(content)}`
         );
       }
       case "ready": {
         return console.log(
           `[${chalk.yellow(date)}]: [${chalk.black.bgHex("#067032")(
-            type.toUpperCase(),
-          )}] ${chalk.blue(content)}`,
+            type.toUpperCase()
+          )}] ${chalk.blue(content)}`
         );
       }
       default:
         throw new TypeError(
-          "Logger type must be either warn, debug, log, ready, cmd or error.",
+          "Logger type must be either warn, debug, log, ready, cmd or error."
         );
     }
   }
 }
+
+interface CustomLogger {
+  log: (content: string, type?: loggerTypes) => void;
+}
+
+const loggerInstance = new Logger();
+
+const logger: CustomLogger = {
+  log: loggerInstance.log.bind(loggerInstance),
+};
+
+export { logger, LoggerType };

src/websocket/v1/home.ts

@@ -44,12 +44,9 @@ export default {
           socket.removeListener("disconnect", handleClear);
           resolve();
         };
-        setTimeout(
-          () => {
-            handleClear();
-          },
-          1000 * 60 * 2,
-        );
+        setTimeout(() => {
+          handleClear();
+        }, 1000 * 60 * 2);
         socket.on("client-message", handleReceive);
         socket.on("disconnect", handleClear);
       });