updating deps; various updates

Author: samuel27m

jest.config.js

@@ -8,9 +8,7 @@ module.exports = {
   collectCoverage: true,
   coverageReporters: ['lcov', 'text', 'html'],
   collectCoverageFrom: [
-      '<rootDir>/src/**/*.{ts,js}',
-      '!<rootDir>/src/index.{ts,js}',
-      '!<rootDir>/src/database/**',
+      '<rootDir>/src/**/*.{ts,js}'
   ],
   coverageThreshold: {
     global: {
@@ -21,5 +19,13 @@ module.exports = {
     },
   },
   testMatch: ["<rootDir>/tests/**/*.spec.ts", "<rootDir>/tests/**/*.test.ts"],
+  transform: {
+    '^.+\\.ts?$': [
+      'ts-jest',
+      {
+        tsconfig: 'tsconfig.json', // Specify your TypeScript config file
+      },
+    ],
+  },
   clearMocks: true
 };

package-lock.json

@@ -14,37 +14,37 @@
    "author": "Samuel Caçador",
    "license": "MIT",
    "dependencies": {
-      "apollo-server": "^3.6.3",
-      "apollo-server-express": "^3.6.3",
+      "@apollo/server": "^4.11.2",
       "class-validator": "^0.14.1",
       "dotenv": "^16.0.0",
       "express": "^4.17.3",
       "graphql": "^16.9.0",
       "graphql-playground-middleware-express": "^1.7.23",
+      "graphql-scalars": "^1.23.0",
       "mysql2": "^3.11.4",
       "reflect-metadata": "^0.1.13",
       "sqlite3": "^5.0.11",
       "type-graphql": "^2.0.0-rc.2",
       "typeorm": "^0.3.20"
    },
    "devDependencies": {
-      "@types/express": "^4.17.13",
-      "@types/jest": "^28.1.6",
-      "@types/node": "^16.11.10",
-      "@typescript-eslint/eslint-plugin": "^5.12.0",
-      "@typescript-eslint/parser": "^5.12.0",
-      "eslint": "^7.32.0",
-      "eslint-config-prettier": "^8.3.0",
-      "eslint-config-standard": "^16.0.3",
-      "eslint-plugin-import": "^2.25.4",
+      "@types/express": "^5.0.0",
+      "@types/jest": "^29.5.14",
+      "@types/node": "^22.9.3",
+      "@typescript-eslint/eslint-plugin": "^8.15.0",
+      "@typescript-eslint/parser": "^8.15.0",
+      "eslint": "^8.57.1",
+      "eslint-config-prettier": "^9.1.0",
+      "eslint-config-standard": "^17.1.0",
+      "eslint-plugin-import": "^2.31.0",
       "eslint-plugin-node": "^11.1.0",
-      "eslint-plugin-prettier": "^4.0.0",
-      "eslint-plugin-promise": "^5.2.0",
-      "jest": "^28.1.3",
-      "prettier": "2.5.1",
-      "ts-jest": "^28.0.7",
-      "ts-node": "10.7.0",
+      "eslint-plugin-prettier": "^5.2.1",
+      "eslint-plugin-promise": "^6.6.0",
+      "jest": "^29.7.0",
+      "prettier": "3.3.3",
+      "ts-jest": "^29.2.5",
+      "ts-node": "10.9.2",
       "ts-node-dev": "^2.0.0",
-      "typescript": "4.5.2"
+      "typescript": "5.7.2"
    }
 }

package.json

@@ -1,7 +1,13 @@
-import { Request, Response } from 'express';
+import { NextFunction, Request, Response } from 'express';
 
-const IndexController = (request: Request, response: Response): Response => {
-    return response.json(['ok']);
+const IndexController = (request: Request, response: Response, next: NextFunction) => {
+    try {
+        response.json({
+            status: 200,
+            message: 'Hello, world! ' + Date.now(),
+        });
+    } catch (error) {
+        next(error);
+    }
 };
-
 export { IndexController };

src/controllers/IndexController.ts

@@ -1,25 +1,31 @@
 import 'reflect-metadata';
 import 'dotenv/config';
 import express from 'express';
+import bodyParser from 'body-parser';
+import { expressMiddleware } from '@apollo/server/express4';
 import router from './router';
-import { createApolloServer } from './services/ApolloServices/ApolloServerService';
 import { initialiseDataSource } from './database';
+import { createApolloServer } from './services/ApolloServices/ApolloServerService';
 
 const app = express();
 
-createApolloServer()
-    .then(async (apolloServer: { start: () => void; getMiddleware: () => any }) => {
-        await apolloServer.start();
-        await initialiseDataSource();
+const startServer = async () => {
+    await initialiseDataSource();
+
+    const apolloServer = await createApolloServer();
+    await apolloServer.start();
 
-        app.use(express.json());
-        app.use(apolloServer.getMiddleware());
-        app.use(router);
+    app.use('/graphql', bodyParser.json(), expressMiddleware(apolloServer));
+    app.use(express.json());
+    app.use(router);
 
-        app.listen(process.env.PORT || 3333, () => {
-            console.log(`🚀 App started on port ${process.env.PORT || 3333} - Hello ${process.env.HELLO}`);
-        });
-    })
-    .catch(err => {
-        console.log(err);
+    app.listen(process.env.PORT || 3333, () => {
+        console.log(`🚀 App started on port ${process.env.PORT || 3333} - Hello ${process.env.HELLO}`);
     });
+};
+
+startServer().catch(err => {
+    console.error('Server failed to start', err);
+});
+
+export { startServer };

src/index.ts

@@ -1,15 +1,18 @@
-import { ApolloServer } from 'apollo-server-express';
+import { ApolloServer } from '@apollo/server';
 import { buildSchema } from 'type-graphql';
 import { RecipeResolver } from '../../graphql/resolvers/RecipeResolver';
 
-async function createApolloServer(): Promise<ApolloServer> {
-    const schema = await buildSchema({
+async function getSchema() {
+    return buildSchema({
         resolvers: [RecipeResolver],
         validate: true,
     });
+}
+
+async function createApolloServer(): Promise<ApolloServer> {
     return new ApolloServer({
-        schema: schema,
+        schema: await getSchema(),
     });
 }
 
-export { createApolloServer };
+export { getSchema, createApolloServer };

src/services/ApolloServices/ApolloServerService.ts

@@ -0,0 +1,52 @@
+import { AppDataSource, initialiseDataSource, destroyDataSource } from '../../src/database';
+
+describe('DataSource Utility', () => {
+    const originalConsoleError = console.error;
+
+    beforeEach(async () => {
+        console.error = jest.fn();
+
+        if (!AppDataSource.isInitialized) {
+            await initialiseDataSource();
+        }
+    });
+
+    afterEach(async () => {
+        console.error = originalConsoleError;
+
+        if (AppDataSource.isInitialized) {
+            await destroyDataSource();
+        }
+    });
+
+    it('should initialize the data source successfully', async () => {
+        expect(AppDataSource.isInitialized).toBe(true);
+    });
+
+    it('should destroy the data source successfully', async () => {
+        await destroyDataSource();
+        expect(AppDataSource.isInitialized).toBe(false);
+    });
+
+    it('should throw an error if initialize is called twice without destroying', async () => {
+        await expect(AppDataSource.initialize()).rejects.toThrow();
+    });
+
+    it('should allow reinitialization after destruction', async () => {
+        await destroyDataSource();
+        expect(AppDataSource.isInitialized).toBe(false);
+
+        await initialiseDataSource();
+        expect(AppDataSource.isInitialized).toBe(true);
+    });
+
+    it('should log an error if initialization fails', async () => {
+        jest.spyOn(AppDataSource, 'initialize').mockImplementationOnce(() => {
+            throw new Error('Mock Initialization Error');
+        });
+
+        await initialiseDataSource();
+
+        expect(console.error).toHaveBeenCalledWith('Error during Data Source initialization', expect.any(Error));
+    });
+});

tests/database/index.spec.ts

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
-import { createApolloServer } from '../../src/services/ApolloServices/ApolloServerService';
 import { AppDataSource, initialiseDataSource, destroyDataSource } from '../../src/database';
 import { Recipe } from '../../src/entities/Recipe';
+import { testGraphQLQuery } from '../utils';
 
 jest.mock('../../src/database');
 
@@ -16,7 +16,6 @@ describe('RecipeResolver', () => {
 
     it('adds a recipe', async () => {
         const title = 'another one';
-        const apolloServer = await createApolloServer();
         const query = `mutation {
           addRecipe(data: {title: "${title}"}) {
             id,
@@ -25,15 +24,13 @@ describe('RecipeResolver', () => {
           }
         }`;
 
-        const result = await apolloServer.executeOperation({
-            query,
-        });
+        const result = await testGraphQLQuery<{ addRecipe: Recipe }>(query);
 
         const addedRecipe = result.data?.addRecipe;
 
         expect(addedRecipe).not.toBeNull();
-        expect(addedRecipe.title).toEqual(title);
-        expect(addedRecipe.description).toBeNull();
+        expect(addedRecipe?.title).toEqual(title);
+        expect(addedRecipe?.description).toBeNull();
     });
 
     it('gets recipes', async () => {
@@ -45,7 +42,6 @@ describe('RecipeResolver', () => {
         const repository = AppDataSource.getRepository(Recipe);
         await repository.save(recipe);
 
-        const apolloServer = await createApolloServer();
         const query = `{
           recipes {
             id
@@ -54,9 +50,7 @@ describe('RecipeResolver', () => {
           }
         }`;
 
-        const result = await apolloServer.executeOperation({
-            query,
-        });
+        const result = await testGraphQLQuery<{ recipes: Recipe[] }>(query);
 
         expect(result.data?.recipes).toHaveLength(1);
     });

tests/graphql/RecipeResolver.spec.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { ApolloServer } from 'apollo-server-express';
+import { ApolloServer } from '@apollo/server';
 import { createApolloServer } from '../../../src/services/ApolloServices/ApolloServerService';
 
 describe('ApolloServiceService', () => {

tests/services/ApolloServices/ApolloServerService.spec.ts

@@ -0,0 +1,14 @@
+import { ExecutionResult, graphql } from 'graphql';
+import { getSchema } from '../src/services/ApolloServices/ApolloServerService';
+
+async function testGraphQLQuery<T>(query: string, variables?: Record<string, any>) {
+    const schema = await getSchema();
+
+    return graphql({
+        schema,
+        source: query,
+        variableValues: variables,
+    }) as unknown as Promise<ExecutionResult<T>>;
+}
+
+export { testGraphQLQuery };