fix: fix outdated dependencies

Author: Datlyfe

backend/.env.example

@@ -1,8 +1,3 @@
-DB_HOST=localhost
-DB_PORT=5432
-DB_USERNAME=jira_user
-DB_PASSWORD=jira_password
-DB_DATABASE=jira_db
-DB_TEST_DATABASE=jira_test_db
+DATABASE_URL=postgres://user:password@localhost:5432/jira_clone_gql?sslmode=disable
 JWT_SECRET=secret123
-SENTRY_DSN=<your sentry dsn>
+SENTRY_DSN=https://sentry.io/...

backend/package.json

@@ -12,33 +12,35 @@
     "build": "tsc"
   },
   "dependencies": {
-    "@sentry/integrations": "^5.15.5",
-    "@sentry/node": "5.15.5",
-    "apollo-server-express": "^2.14.2",
-    "apollo-server-plugin-base": "^0.7.1",
+    "@apollo/server": "^4.3.0",
+    "@sentry/integrations": "7.28.1",
+    "@sentry/node": "7.28.1",
+    "body-parser": "^1.20.1",
     "cors": "^2.8.5",
-    "dotenv": "^8.2.0",
-    "express": "^4.17.1",
-    "graphql-middleware-sentry": "^3.2.1",
-    "jsonwebtoken": "^8.5.1",
-    "module-alias": "^2.2.2",
-    "node-cron": "^2.0.3",
-    "pg": "^7.18.1",
-    "reflect-metadata": "^0.1.13",
-    "striptags": "^3.1.1",
-    "ts-node-dev": "^1.0.0-pre.44",
-    "type-graphql": "^0.17.6",
-    "typeorm": "^0.2.22"
+    "dotenv": "16.0.3",
+    "express": "^4.18.2",
+    "graphql": "^16.6.0",
+    "graphql-middleware-sentry": "3.2.1",
+    "jsonwebtoken": "9.0.0",
+    "module-alias": "2.2.2",
+    "node-cron": "3.0.2",
+    "pg": "8.8.0",
+    "reflect-metadata": "0.1.13",
+    "striptags": "3.2.0",
+    "ts-node-dev": "2.0.0",
+    "type-graphql": "2.0.0-beta.1",
+    "typeorm": "0.3.11"
   },
   "devDependencies": {
-    "@types/cors": "^2.8.6",
-    "@types/express": "^4.17.3",
-    "@types/graphql": "^14.5.0",
-    "@types/jsonwebtoken": "^8.3.7",
-    "@types/module-alias": "^2.0.0",
-    "@types/node": "^13.7.4",
-    "@types/node-cron": "^2.0.3",
-    "cross-env": "^7.0.1",
-    "typescript": "^3.7.5"
+    "@types/cors": "2.8.13",
+    "@types/express": "4.17.15",
+    "@types/graphql": "14.5.0",
+    "@types/jsonwebtoken": "9.0.0",
+    "@types/module-alias": "2.0.1",
+    "@types/node": "18.11.17",
+    "@types/node-cron": "3.0.6",
+    "class-validator": "^0.14.0",
+    "cross-env": "7.0.3",
+    "typescript": "4.9.4"
   }
-}
+}

backend/src/database/createConnection.ts

@@ -1,32 +1,30 @@
-import { createConnection, Connection, ConnectionOptions } from "typeorm";
+import { DataSource, DataSourceOptions } from "typeorm";
 
-import * as models from "@/models";
+import * as entities from "@/models";
 
-const commonConfig: ConnectionOptions = {
+const commonOptions: DataSourceOptions = {
   type: "postgres",
-  entities: Object.values(models),
+  entities: Object.values(entities),
   synchronize: true,
 };
 
-const connectionOptions: ConnectionOptions =
+const AppDataSourceOptions: DataSourceOptions =
   process.env.NODE_ENV === "production"
     ? {
         url: process.env.DATABASE_URL,
-        ...commonConfig,
+        ...commonOptions,
         extra: {
           max: 5,
         },
       }
     : {
-        host: process.env.DB_HOST,
-        port: Number(process.env.DB_PORT),
-        username: process.env.DB_USERNAME,
-        password: process.env.DB_PASSWORD,
-        database: process.env.DB_DATABASE,
-        ...commonConfig,
+        url: process.env.DATABASE_URL,
+        ...commonOptions,
       };
 
-const createDatabaseConnection = (): Promise<Connection> =>
-  createConnection(connectionOptions);
+const createDatabaseConnection = (): Promise<DataSource> => {
+  const AppDataSource = new DataSource(AppDataSourceOptions);
+  return AppDataSource.initialize();
+};
 
 export default createDatabaseConnection;

backend/src/gql/index.ts

@@ -9,5 +9,5 @@ export const RESOLVERS = [
   UserResolver,
   CommentResolver,
   IssueResolver,
-  ProjectResolver
-];
+  ProjectResolver,
+] as const;

backend/src/gql/issues.ts

@@ -5,14 +5,14 @@ import {
   Int,
   Mutation,
   UseMiddleware,
-  Ctx
+  Ctx,
 } from "type-graphql";
 import { Issue } from "@/models";
 import {
   findEntityOrThrow,
   createEntity,
   updateEntity,
-  deleteEntity
+  deleteEntity,
 } from "@/utils/typeorm";
 import { IsAuth } from "@/middlewares/isAuth";
 import { ErrorInterceptor } from "@/middlewares/errorInterceptor";
@@ -21,9 +21,9 @@ import { GQLContext } from "../types/context";
 
 const calculateListPosition = async ({
   projectId,
-  status
+  status,
 }: Partial<Issue>): Promise<number> => {
-  const issues = await Issue.find({ projectId, status });
+  const issues = await Issue.find({ where: { projectId, status } });
 
   const listPositions = issues.map(({ listPosition }) => listPosition);
 
@@ -64,7 +64,7 @@ class IssueResolver {
     @Arg("issueId", () => Int) issueId: number
   ): Promise<Issue> {
     const issue = await findEntityOrThrow(Issue, issueId, {
-      relations: ["users", "comments", "comments.user"]
+      relations: ["users", "comments", "comments.user"],
     });
 
     return issue;
@@ -78,7 +78,7 @@ class IssueResolver {
     const listPosition = await calculateListPosition(issueInput);
     const issue = await createEntity(Issue, {
       ...issueInput,
-      listPosition
+      listPosition,
     });
     return issue;
   }

backend/src/gql/plugins/sentry.ts

@@ -1,33 +1,44 @@
-import * as Sentry from "@sentry/node";
-import { ApolloServerPlugin } from "apollo-server-plugin-base";
-import { GQLContext } from "@/types/context";
-export const apolloServerSentryPlugin:ApolloServerPlugin = {
-  requestDidStart() {
+import { captureException, withScope } from "@sentry/node";
+import type { ApolloServerPlugin } from "@apollo/server";
+
+export const apolloServerSentryPlugin: ApolloServerPlugin = {
+  async requestDidStart() {
     return {
-      didEncounterErrors(rc) {
-        Sentry.withScope((scope) => {
-          scope.addEventProcessor((event) =>
-            Sentry.Handlers.parseRequest(event, (rc.context as GQLContext).req)
-          );
+      async didEncounterErrors(ctx) {
+        if (!ctx.operation) {
+          for (const err of ctx.errors) {
+            withScope((scope) => {
+              scope.setExtra("query", ctx.request.query);
+              captureException(err);
+            });
+          }
+          return;
+        }
 
-          scope.setTags({
-            graphql: rc.operation?.operation || "parse_err",
-            graphqlName:
-              (rc.operationName as any) || (rc.request.operationName as any),
-          });
+        for (const err of ctx.errors) {
+          withScope((scope) => {
+            scope.setTag("kind", ctx.operation?.operation ?? "unknown");
+
+            scope.setExtra("query", ctx.request.query);
+            scope.setExtra("variables", ctx.request.variables);
 
-          rc.errors.forEach((error) => {
-            if (error.path || error.name !== "GraphQLError") {
-              scope.setExtras({
-                path: error.path,
+            if (err.path) {
+              scope.setLevel("debug");
+              scope.addBreadcrumb({
+                category: "query-path",
+                message: err.path.join(" > "),
               });
-              Sentry.captureException(error);
-            } else {
-              scope.setExtras({});
-              Sentry.captureMessage(`GraphQLWrongQuery: ${error.message}`);
             }
+
+            const transactionId =
+              ctx.request?.http?.headers.get("x-transaction-id");
+            if (transactionId) {
+              scope.setTransactionName(transactionId);
+            }
+
+            captureException(err);
           });
-        });
+        }
       },
     };
   },

backend/src/index.ts

@@ -1,27 +1,34 @@
 require("module-alias").addAlias("@", __dirname);
 import "dotenv/config";
 import "reflect-metadata";
-import * as Sentry from "@sentry/node";
+import http from "http";
+import { init as SentryInit, Handlers as SentryHandlers } from "@sentry/node";
 import { RewriteFrames } from "@sentry/integrations";
 import Express from "express";
 import cors from "cors";
-import { ApolloServer } from "apollo-server-express";
+import { json } from "body-parser";
+import { ApolloServer } from "@apollo/server";
+import { expressMiddleware } from "@apollo/server/express4";
+import { ApolloServerPluginDrainHttpServer } from "@apollo/server/plugin/drainHttpServer";
 import { buildSchema } from "type-graphql";
-import { GraphQLSchema } from "graphql";
 import createDatabaseConnection from "@/database/createConnection";
 import { RESOLVERS } from "@/gql";
 import { apolloServerSentryPlugin } from "@/gql/plugins/sentry";
 
-Sentry.init({
-  environment: process.env.APP_ENV,
-  release: 'jira-clone-api',
-  dsn: process.env.SENTRY_DSN,
-  integrations: [
-    new RewriteFrames({
-      root: process.cwd(),
-    }) as any,
-  ],
-});
+const PORT = process.env.PORT || 5001;
+
+if (process.env.NODE_ENV === "production") {
+  SentryInit({
+    environment: process.env.APP_ENV,
+    release: "jira-clone-api",
+    dsn: process.env.SENTRY_DSN,
+    integrations: [
+      new RewriteFrames({
+        root: process.cwd(),
+      }),
+    ],
+  });
+}
 
 const establishDatabaseConnection = async (): Promise<void> => {
   try {
@@ -36,31 +43,40 @@ const initExpressGraphql = async () => {
     resolvers: RESOLVERS,
   }).catch((err) => console.log(err));
 
-  const apolloServer = new ApolloServer({
-    schema: schema as GraphQLSchema,
-    context: ({ req, res }: any) => ({ req, res }),
-    playground: true,
+  if (!schema) {
+    throw new Error("Could not build graphql schema");
+  }
+
+  const app = Express();
+  const httpServer = http.createServer(app);
+
+  const gqlServer = new ApolloServer({
+    schema,
+    plugins: [
+      ApolloServerPluginDrainHttpServer({ httpServer }),
+      apolloServerSentryPlugin,
+    ],
     introspection: true,
-    plugins: [apolloServerSentryPlugin as any],
   });
 
-  const app = Express();
+  await gqlServer.start();
 
-  app.use(Sentry.Handlers.requestHandler());
+  app.use(SentryHandlers.requestHandler());
 
-  app.use(cors());
-  app.use(Express.urlencoded({ extended: true }));
+  app.use(
+    "/graphql",
+    cors(),
+    json(),
+    expressMiddleware(gqlServer),
+    SentryHandlers.errorHandler()
+  );
 
   app.get("/", (_, res) => {
     res.json({ server: "jira-clone-api" });
   });
 
-  apolloServer.applyMiddleware({ app });
-  app.use(Sentry.Handlers.errorHandler());
-  app.listen(process.env.PORT || 5000, () => {
-    console.log(
-      `server started on http://localhost:5000${apolloServer.graphqlPath}`
-    );
+  httpServer.listen({ port: PORT }, () => {
+    console.log(`🚀 Server ready at http://localhost:${PORT}/graphql`);
   });
 };
 

backend/src/utils/typeorm.ts

@@ -15,15 +15,15 @@ const entities: { [key: string]: EntityConstructor } = {
   Comment,
   Issue,
   Project,
-  User
+  User,
 };
 
 export const findEntityOrThrow = async <T extends EntityConstructor>(
   Constructor: T,
   id: number | string,
   options?: FindOneOptions
 ): Promise<InstanceType<T>> => {
-  const instance = await Constructor.findOne(id, options);
+  const instance = await Constructor.findOne({ where: { id }, ...options });
   if (!instance) {
     throw new EntityNotFoundError(Constructor.name);
   }