Merge pull request #9 from deveshsangwan/migrate-js-to-ts

Migrate js to ts

README.md

@@ -21,8 +21,8 @@ Welcome to the Cricket Score API! This project is designed to provide real-time
 Our aim is to maintain high code coverage to ensure the quality of the project. Here are our current stats:
 
 [![codecov](https://codecov.io/gh/deveshsangwan/cricketScoreApi/graph/badge.svg?token=A3JMLLNTG4)](https://codecov.io/gh/deveshsangwan/cricketScoreApi)
-![Functions](https://img.shields.io/badge/functions-92.98%25-brightgreen.svg?style=flat)
-![Lines](https://img.shields.io/badge/lines-89.33%25-yellow.svg?style=flat)
+![Functions](https://img.shields.io/badge/functions-91.37%25-brightgreen.svg?style=flat)
+![Lines](https://img.shields.io/badge/lines-89.01%25-yellow.svg?style=flat)
 
 ## 🚀 Getting Started
 

app/app.js

@@ -1,7 +1,7 @@
 const express = require('express');
 const bodyParser = require('body-parser');
 const httpContext = require('express-http-context');
-const Mongo = require('./core/mongo');
+const Mongo = require('./dist/core/mongo');
 const { expressjwt, UnauthorizedError } = require('express-jwt');
 require('dotenv').config();
 

app/core/BaseModelInterfaces.ts

@@ -0,0 +1,18 @@
+import { Document } from 'mongoose';
+
+export interface ILiveMatches extends Document {
+    _id: string;
+    matchUrl: string;
+    matchName: string;
+}
+
+export interface IMatchStats extends Document {
+    createdAt: Date;
+    _id: string;
+    team1: object;
+    team2: object;
+    onBatting: object;
+    summary: object;
+    tournamentName: string;
+    matchName: string;
+}

app/core/baseModel.js → app/core/baseModel.ts

@@ -1,13 +1,14 @@
-const Mongoose = require('mongoose');
-const { writeLogInfo, writeLogError } = require('../core/logger');
+import Mongoose, { Model, Schema } from 'mongoose';
+import { ILiveMatches, IMatchStats } from './BaseModelInterfaces';
+import { writeLogInfo, writeLogError } from './Logger';
 
-const MODEL_NAMES = {
-    LIVE_MATCHES: 'liveMatches',
-    MATCH_STATS: 'matchStats'
-};
+enum MODEL_NAMES {
+    LIVE_MATCHES = 'liveMatches',
+    MATCH_STATS = 'matchStats'
+}
 
 // define model
-const liveMatches = new Mongoose.Schema({
+const liveMatches: Schema<ILiveMatches> = new Schema({
     _id: {
         type: String,
         required: true
@@ -22,7 +23,7 @@ const liveMatches = new Mongoose.Schema({
     },
 });
 
-const matchStats = new Mongoose.Schema({
+const matchStats: Schema<IMatchStats> = new Schema({
     createdAt: {
         type: Date,
         default: Date.now
@@ -57,15 +58,15 @@ const matchStats = new Mongoose.Schema({
     },
 });
 
-const LiveMatches = Mongoose.model(MODEL_NAMES.LIVE_MATCHES, liveMatches);
-const MatchStats = Mongoose.model(MODEL_NAMES.MATCH_STATS, matchStats);
+const LiveMatches: Model<ILiveMatches> = Mongoose.model(MODEL_NAMES.LIVE_MATCHES, liveMatches);
+const MatchStats: Model<IMatchStats> = Mongoose.model(MODEL_NAMES.MATCH_STATS, matchStats);
 
 /**
  * Find all matches from a specified model
  * @param {String} modelName - The name of the model to query
  * @returns {Array} - An array of matches
  */
-const findAll = async (modelName) => {
+const findAll = async (modelName: string) => {
     try {
         const response = await Mongoose.model(modelName).find({});
         return response;
@@ -82,7 +83,7 @@ const findAll = async (modelName) => {
  * @param {String} modelName - The name of the model to query
  * @returns {Object} - The match object if found, null otherwise
  */
-const findById = async (matchId, modelName) => {
+const findById = async (matchId: string, modelName: string) => {
     try {
         const response = await Mongoose.model(modelName).find({ _id: matchId });
         return response;
@@ -98,7 +99,7 @@ const findById = async (matchId, modelName) => {
  * @param {String} matchUrl - The URL of the match to find
  * @returns {Object} - The match object if found, null otherwise
  */
-const findIdByMatchUrl = async (matchUrl) => {
+const findIdByMatchUrl = async (matchUrl: string) => {
     try {
         return await Mongoose.model(MODEL_NAMES.LIVE_MATCHES).find({ matchUrl: matchUrl });
     } catch (err) {
@@ -113,11 +114,11 @@ const findIdByMatchUrl = async (matchUrl) => {
  * @param {String} modelName - model name
  * @returns {Object} - response
  */
-const insert = async (data, modelName) => {
+const insert = async (data: object, modelName: string) => {
     try {
         const Model = Mongoose.model(modelName);
         const response = await Model.findOneAndUpdate(
-            { _id: data._id }, // find a document with `_id` same as `data._id`
+            { _id: (data as any)._id }, // find a document with `_id` same as `data._id`
             data, // document to insert when nothing was found
             { upsert: true, new: true, runValidators: true } // options
         );
@@ -136,7 +137,7 @@ const insert = async (data, modelName) => {
  * @param {String} modelName - The name of the model to insert into
  * @returns {Array} - An array of the inserted match objects
  */
-const insertMany = async (matches, modelName) => {
+const insertMany = async (matches: object[], modelName: string) => {
     try {
         const response = await Mongoose.model(modelName).insertMany(matches);
         return response;
@@ -148,7 +149,7 @@ const insertMany = async (matches, modelName) => {
 };
 
 
-module.exports = {
+export {
     findAll,
     findById,
     findIdByMatchUrl,

app/core/configuration.ts

@@ -0,0 +1,12 @@
+import nconf from 'nconf';
+import * as path from 'path';
+
+const nodeEnv: string = process.env.NODE_ENV || 'development';
+const __basedir: string = path.resolve();
+
+nconf.argv().env();
+nconf.file('config', path.join(__basedir, `app/config/config.${nodeEnv}.json`));
+nconf.file('responseMessage', path.join(__basedir, 'app/config/responseMessage.json'));
+nconf.file('partners', path.join(__basedir, 'app/config/partners.json'));
+
+export default nconf;

app/core/logger.ts

@@ -0,0 +1,37 @@
+import config from './configuration';
+import winston from 'winston';
+
+const logger = winston.createLogger({
+    format: winston.format.combine(
+        winston.format.label({ label: config.get('logging:label') as string }),
+        winston.format.errors({ stack: true }),
+        winston.format.timestamp({ format: 'YYYY-MM-DD hh:mm:ss' }),
+        winston.format.printf(({ timestamp, label, level, message, meta, stack }) => {
+            const text = '[' + timestamp + '] ' +
+                label + '.' + level.toUpperCase() + ': ' + (message ??
+                    '') + (meta && Object.keys(meta).length ?
+                        '\n' + JSON.stringify(meta, null, 4) :
+                        '');
+            return stack ? text + '\n' + stack : text;
+        }),
+        winston.format.colorize({ all: true }),
+    ),
+    transports: [
+        new winston.transports.Console({
+            level: config.get('logging:consoleLevel') as string,
+            handleExceptions: true,
+        }),
+    ]
+});
+
+export const writeLogInfo = (arr: unknown[]): void => {
+    logger.info(
+        arr
+    );
+};
+
+export const writeLogError = (arr: unknown[]): void => {
+    logger.error(
+        arr
+    );
+};

app/core/mongo.js → app/core/mongo.ts

@@ -1,18 +1,22 @@
-require('dotenv').config();
-const Mongoose = require('mongoose');
-const { writeLogInfo, writeLogError } = require(__basedir + 'app/core/logger');
+import dotenv from 'dotenv';
+import Mongoose, { Mongoose as MongooseType } from 'mongoose';
+import { writeLogInfo, writeLogError } from './Logger';
+
+dotenv.config();
 
 class Mongo {
+    private connection: MongooseType | undefined;
+
     constructor() {
         this._connect();
     }
 
-    async _connect() {
+    private async _connect(): Promise<MongooseType | undefined> {
         if (this.connection) {
             return this.connection;
         }
 
-        let mongoUrl = process.env.MONGO_URL;
+        const mongoUrl: string = process.env.MONGO_URL || '';
         try {
             this.connection = await Mongoose.connect(mongoUrl);
             writeLogInfo(['Database connection successful']);
@@ -22,4 +26,4 @@ class Mongo {
     }
 }
 
-module.exports = new Mongo();
+export default new Mongo();