chore: Start cleaning up medusa-core-utils (#7450)

**What**
- remove medusa-core-utils
- dispatch the utils where they belongs
- update usage

**NOTE**
I have been wondering if the graceful class should go into the utils package or medusa package, I ve put it in the medusa package as it seems to be the best place I can see for now and is tight to the server as well. Also, I wanted to avoid the utils package to depends on http and net dependencies, happy to change that if you feel like it

packages/medusa/src/utils/__tests__/graceful-shutdown-server.ts

@@ -0,0 +1,186 @@
+import { GracefulShutdownServer } from "../graceful-shutdown-server"
+
+describe("GracefulShutdownServer", () => {
+  beforeEach(() => {
+    jest.clearAllTimers()
+    jest.clearAllMocks()
+  })
+  afterEach(() => {})
+
+  it('should add "isShuttingDown" property to the existing server', () => {
+    const server = GracefulShutdownServer.create({ on: jest.fn() } as any)
+    expect(server).toHaveProperty("isShuttingDown")
+    expect(server.isShuttingDown).toEqual(false)
+  })
+
+  it("should listen for client connections and store reference to them", async () => {
+    const onEventMock = jest.fn()
+
+    GracefulShutdownServer.create({ on: onEventMock } as any)
+
+    expect(onEventMock).toBeCalledTimes(3)
+
+    expect(onEventMock.mock.calls[2][0]).toEqual("request")
+
+    const connectEvent: (socket) => any = onEventMock.mock.calls[0][1]
+
+    const onSocketClose = jest.fn()
+    const socket = { on: onSocketClose }
+    connectEvent(socket)
+    expect(socket).toEqual(
+      expect.objectContaining({
+        _idle: true,
+        _connectionId: 1,
+      })
+    )
+
+    const socket2 = { on: onSocketClose }
+    connectEvent(socket2)
+    expect(socket2).toEqual(
+      expect.objectContaining({
+        _idle: true,
+        _connectionId: 2,
+      })
+    )
+
+    const requestMock = onEventMock.mock.calls[2][1]
+    expect(typeof requestMock).toEqual("function")
+
+    const socket3 = { on: onSocketClose }
+    const req = { socket: socket3, on: jest.fn() }
+    const res = { on: jest.fn() }
+    connectEvent(socket3)
+    requestMock(req, res)
+
+    const finishRequestMock = res.on.mock.calls[0][1]
+
+    expect(socket3).toEqual(
+      expect.objectContaining({
+        _idle: false,
+        _connectionId: 3,
+      })
+    )
+    finishRequestMock()
+    expect(socket3).toEqual(
+      expect.objectContaining({
+        _idle: true,
+        _connectionId: 3,
+      })
+    )
+
+    expect(onSocketClose).toBeCalledTimes(3)
+    expect(onSocketClose.mock.calls[0][0]).toEqual("close")
+  })
+
+  it("waits requests to complete before shutting the server down", (done: Function) => {
+    jest.useFakeTimers()
+
+    const onEventMock = jest.fn()
+    const setIntervalSpy = jest.spyOn(global, "setInterval")
+    const setTimeoutSpy = jest.spyOn(global, "setTimeout")
+    const clearIntervalSpy = jest.spyOn(global, "clearInterval")
+
+    const waitTime = 200
+    let closeServerCallback: Function
+    const server = GracefulShutdownServer.create(
+      {
+        close: (callback) => {
+          closeServerCallback = callback
+        },
+        on: onEventMock,
+      } as any,
+      waitTime
+    )
+
+    const requestMock = onEventMock.mock.calls[2][1]
+    const connectEvent: (socket) => any = onEventMock.mock.calls[0][1]
+
+    expect(typeof requestMock).toEqual("function")
+
+    const socket = { on: jest.fn(), destroy: jest.fn() }
+    const req = { socket, on: jest.fn() }
+    const res = { on: jest.fn() }
+    connectEvent(socket)
+
+    requestMock(req, res)
+
+    const finishRequestMock = res.on.mock.calls[0][1]
+
+    server.shutdown().then(() => {
+      done()
+    })
+
+    expect(setTimeoutSpy).toBeCalledTimes(0)
+    expect(setIntervalSpy).toBeCalledTimes(1)
+    expect(setIntervalSpy.mock.calls[0][1]).toEqual(waitTime)
+    expect(clearIntervalSpy).toBeCalledTimes(0)
+    expect(socket.destroy).toBeCalledTimes(0)
+
+    jest.advanceTimersByTime(200)
+
+    expect(socket.destroy).toBeCalledTimes(0)
+
+    finishRequestMock()
+
+    expect(socket.destroy).toBeCalledTimes(0)
+
+    jest.advanceTimersByTime(waitTime)
+
+    expect(socket.destroy).toBeCalledTimes(1)
+
+    closeServerCallback!()
+  })
+
+  it("should force close all connections after the timeout is reached", (done: Function) => {
+    jest.useFakeTimers()
+
+    const onEventMock = jest.fn()
+    const setIntervalSpy = jest.spyOn(global, "setInterval")
+    const setTimeoutSpy = jest.spyOn(global, "setTimeout")
+    const clearIntervalSpy = jest.spyOn(global, "clearInterval")
+
+    const waitTime = 300
+    let closeServerCallback: Function
+    const server = GracefulShutdownServer.create(
+      {
+        close: (callback) => {
+          closeServerCallback = callback
+        },
+        on: onEventMock,
+      } as any,
+      waitTime
+    )
+
+    const requestMock = onEventMock.mock.calls[2][1]
+    const connectEvent: (socket) => any = onEventMock.mock.calls[0][1]
+
+    expect(typeof requestMock).toEqual("function")
+
+    const socket = { on: jest.fn(), destroy: jest.fn() }
+    const req = { socket, on: jest.fn() }
+    const res = { on: jest.fn() }
+    connectEvent(socket)
+
+    requestMock(req, res) // pending request
+
+    const forceTimeout = 600
+    server.shutdown(forceTimeout).then(() => {
+      done()
+    })
+
+    expect(setTimeoutSpy).toBeCalledTimes(1)
+    expect(setTimeoutSpy.mock.calls[0][1]).toEqual(forceTimeout)
+    expect(setIntervalSpy).toBeCalledTimes(1)
+    expect(setIntervalSpy.mock.calls[0][1]).toEqual(waitTime)
+    expect(clearIntervalSpy).toBeCalledTimes(0)
+    expect(socket.destroy).toBeCalledTimes(0)
+
+    jest.advanceTimersByTime(waitTime)
+    expect(socket.destroy).toBeCalledTimes(0)
+
+    jest.advanceTimersByTime(forceTimeout)
+    expect(socket.destroy).toBeCalledTimes(1)
+
+    closeServerCallback!()
+  })
+})

packages/medusa/src/utils/exception-formatter.ts

@@ -1,4 +1,4 @@
-import { MedusaError } from "medusa-core-utils"
+import { MedusaError } from "@medusajs/utils"
 
 export enum PostgresError {
   DUPLICATE_ERROR = "23505",

packages/medusa/src/utils/get-query-config.ts

@@ -4,7 +4,7 @@ import {
   stringToSelectRelationObject,
 } from "@medusajs/utils"
 import { pick } from "lodash"
-import { MedusaError, isDefined } from "medusa-core-utils"
+import { MedusaError, isDefined } from "@medusajs/utils"
 import { RequestQueryFields } from "@medusajs/types"
 import { FindConfig, QueryConfig } from "../types/common"
 

packages/medusa/src/utils/graceful-shutdown-server.ts

@@ -0,0 +1,96 @@
+import { Server } from "http"
+import { Socket } from "net"
+import Timeout = NodeJS.Timeout
+
+interface SocketState extends Socket {
+  _idle: boolean
+  _connectionId: number
+}
+
+export abstract class GracefulShutdownServer {
+  public isShuttingDown: boolean
+  public abstract shutdown(timeout?: number): Promise<void>
+  public static create<T extends Server>(
+    originalServer: T,
+    waitingResponseTime: number = 200
+  ): T & GracefulShutdownServer {
+    let connectionId = 0
+    let shutdownPromise: Promise<void>
+
+    const allSockets: { [id: number]: SocketState } = {}
+
+    const server = originalServer as T & GracefulShutdownServer
+    server.isShuttingDown = false
+    server.shutdown = async (timeout: number = 0): Promise<void> => {
+      if (server.isShuttingDown) {
+        return shutdownPromise
+      }
+
+      server.isShuttingDown = true
+
+      shutdownPromise = new Promise((ok, nok) => {
+        let forceQuit = false
+        let cleanInterval: Timeout
+
+        try {
+          // stop accepting new incoming connections
+          server.close(() => {
+            clearInterval(cleanInterval)
+            ok()
+          })
+
+          if (+timeout > 0) {
+            setTimeout(() => {
+              forceQuit = true
+            }, timeout).unref()
+          }
+
+          cleanInterval = setInterval(() => {
+            if (!Object.keys(allSockets).length) {
+              clearInterval(cleanInterval)
+            }
+
+            for (const key of Object.keys(allSockets)) {
+              const socketId = +key
+              if (forceQuit || allSockets[socketId]._idle) {
+                allSockets[socketId].destroy()
+                delete allSockets[socketId]
+              }
+            }
+          }, waitingResponseTime)
+        } catch (error) {
+          clearInterval(cleanInterval!)
+          return nok(error)
+        }
+      })
+
+      return shutdownPromise
+    }
+
+    const onConnect = (originalSocket) => {
+      connectionId++
+      const socket = originalSocket as SocketState
+      socket._idle = true
+      socket._connectionId = connectionId
+      allSockets[connectionId] = socket
+
+      socket.on("close", () => {
+        delete allSockets[socket._connectionId]
+      })
+    }
+
+    server.on("connection", onConnect)
+    server.on("secureConnection", onConnect)
+
+    server.on("request", (req, res) => {
+      const customSocket = req.socket as SocketState
+      customSocket._idle = false
+
+      res.on("finish", () => {
+        customSocket._idle = true
+      })
+    })
+
+    return server
+  }
+}

packages/medusa/src/utils/index.ts

@@ -3,3 +3,4 @@ export * from "./exception-formatter"
 export * from "./middlewares"
 export * from "./omit-deep"
 export * from "./remove-undefined-properties"
+export * from "./graceful-shutdown-server"

packages/medusa/src/utils/middlewares/error-handler.ts

@@ -1,6 +1,6 @@
 import { NextFunction, Request, Response } from "express"
 
-import { MedusaError } from "medusa-core-utils"
+import { MedusaError } from "@medusajs/utils"
 import { Logger } from "../../types/global"
 import { formatException } from "../../utils"
 

packages/medusa/src/utils/remove-undefined-properties.ts

@@ -1,4 +1,4 @@
-import { isDefined } from "medusa-core-utils"
+import { isDefined } from "@medusajs/utils"
 
 export function removeUndefinedProperties<T extends object>(inputObj: T): T {
   const removeProperties = (obj: T) => {