chore(framework): Continue to move loaders to framework (#8258)

**What**
More move and cleanup

FIXES FRMW-2603
FIXES FRMW-2608
FIXES FRMW-2610
FIXES FRMW-2611

Co-authored-by: Oli Juhl <59018053+olivermrbl@users.noreply.github.com>

packages/medusa/src/loaders/express.ts

@@ -1,85 +0,0 @@
-import { ConfigModule } from "@medusajs/types"
-import createStore from "connect-redis"
-import cookieParser from "cookie-parser"
-import express, { Express } from "express"
-import session from "express-session"
-import Redis from "ioredis"
-import morgan from "morgan"
-import path from "path"
-
-type Options = {
-  app: Express
-  configModule: ConfigModule
-  rootDirectory: string
-}
-
-export default async ({
-  app,
-  configModule,
-  rootDirectory,
-}: Options): Promise<{
-  app: Express
-  shutdown: () => Promise<void>
-}> => {
-  let sameSite: string | boolean = false
-  let secure = false
-  if (
-    process.env.NODE_ENV === "production" ||
-    process.env.NODE_ENV === "staging"
-  ) {
-    secure = true
-    sameSite = "none"
-  }
-
-  const { http, sessionOptions } = configModule.projectConfig
-  const sessionOpts = {
-    name: sessionOptions?.name ?? "connect.sid",
-    resave: sessionOptions?.resave ?? true,
-    rolling: sessionOptions?.rolling ?? false,
-    saveUninitialized: sessionOptions?.saveUninitialized ?? true,
-    proxy: true,
-    secret: sessionOptions?.secret ?? http?.cookieSecret,
-    cookie: {
-      sameSite,
-      secure,
-      maxAge: sessionOptions?.ttl ?? 10 * 60 * 60 * 1000,
-    },
-    store: null,
-  }
-
-  let redisClient
-
-  if (configModule?.projectConfig?.redisUrl) {
-    const RedisStore = createStore(session)
-    redisClient = new Redis(
-      configModule.projectConfig.redisUrl,
-      configModule.projectConfig.redisOptions ?? {}
-    )
-    sessionOpts.store = new RedisStore({
-      client: redisClient,
-      prefix: `${configModule?.projectConfig?.redisPrefix ?? ""}sess:`,
-    })
-  }
-
-  app.set("trust proxy", 1)
-  app.use(
-    morgan("combined", {
-      skip: () => process.env.NODE_ENV === "test",
-    })
-  )
-  app.use(cookieParser())
-  app.use(session(sessionOpts))
-
-  // Currently we don't allow configuration of static files, but this can be revisited as needed.
-  app.use("/static", express.static(path.join(rootDirectory, "static")))
-
-  app.get("/health", (req, res) => {
-    res.status(200).send("OK")
-  })
-
-  const shutdown = async () => {
-    redisClient?.disconnect()
-  }
-
-  return { app, shutdown }
-}

packages/medusa/src/loaders/helpers/register-jobs.ts

@@ -1,10 +1,10 @@
 import {
-  StepResponse,
   createStep,
   createWorkflow,
+  StepResponse,
 } from "@medusajs/workflows-sdk"
 import { glob } from "glob"
-import logger from "../logger"
+import { logger } from "@medusajs/framework"
 import { ContainerRegistrationKeys, MedusaError } from "@medusajs/utils"
 
 export const registerJobs = async (plugins) => {

packages/medusa/src/loaders/helpers/routing/index.ts

@@ -6,7 +6,7 @@ import { readdir } from "fs/promises"
 import { extname, join, sep } from "path"
 import { MedusaRequest, MedusaResponse } from "../../../types/routing"
 import { authenticate, errorHandler } from "../../../utils/middlewares"
-import logger from "../../logger"
+import { logger } from "@medusajs/framework"
 import {
   AsyncRouteHandler,
   GlobalMiddlewareDescriptor,

packages/medusa/src/loaders/helpers/subscribers/index.ts

@@ -9,7 +9,7 @@ import { readdir } from "fs/promises"
 import { extname, join, sep } from "path"
 
 import { SubscriberArgs, SubscriberConfig } from "../../../types/subscribers"
-import logger from "../../logger"
+import { logger } from "@medusajs/framework"
 
 type SubscriberHandler<T> = (args: SubscriberArgs<T>) => Promise<void>
 

packages/medusa/src/loaders/index.ts

@@ -1,10 +1,6 @@
 import { createDefaultsWorkflow } from "@medusajs/core-flows"
 import { ConfigModule, MedusaContainer, PluginDetails } from "@medusajs/types"
-import {
-  ContainerRegistrationKeys,
-  createMedusaContainer,
-  promiseAll,
-} from "@medusajs/utils"
+import { ContainerRegistrationKeys, promiseAll } from "@medusajs/utils"
 import { asValue } from "awilix"
 import { Express, NextFunction, Request, Response } from "express"
 import path from "path"
@@ -12,8 +8,13 @@ import requestIp from "request-ip"
 import { v4 } from "uuid"
 import adminLoader from "./admin"
 import apiLoader from "./api"
-import { configLoader, logger } from "@medusajs/framework"
-import expressLoader from "./express"
+import {
+  configLoader,
+  container,
+  expressLoader,
+  logger,
+  pgConnectionLoader,
+} from "@medusajs/framework"
 import featureFlagsLoader from "./feature-flags"
 import { registerJobs } from "./helpers/register-jobs"
 import { registerWorkflows } from "./helpers/register-workflows"
@@ -21,7 +22,6 @@ import { getResolvedPlugins } from "./helpers/resolve-plugins"
 import { resolvePluginsLinks } from "./helpers/resolve-plugins-links"
 import { SubscriberLoader } from "./helpers/subscribers"
 import loadMedusaApp from "./medusa-app"
-import registerPgConnection from "./pg-connection"
 
 type Options = {
   directory: string
@@ -93,9 +93,8 @@ async function loadEntrypoints(
 
   const { shutdown } = await expressLoader({
     app: expressApp,
-    configModule,
-    rootDirectory,
   })
+
   expressApp.use((req: Request, res: Response, next: NextFunction) => {
     req.scope = container.createScope() as MedusaContainer
     req.requestId = (req.headers["x-request-id"] as string) ?? v4()
@@ -121,8 +120,7 @@ async function loadEntrypoints(
   return shutdown
 }
 
-export async function initializeContainer(rootDirectory: string) {
-  const container = createMedusaContainer()
+export function initializeContainer(rootDirectory: string): MedusaContainer {
   const configModule = configLoader(rootDirectory, "medusa-config.js")
   const featureFlagRouter = featureFlagsLoader(configModule, logger)
 
@@ -133,7 +131,7 @@ export async function initializeContainer(rootDirectory: string) {
     [ContainerRegistrationKeys.REMOTE_QUERY]: asValue(null),
   })
 
-  await registerPgConnection({ container, configModule })
+  pgConnectionLoader()
   return container
 }
 
@@ -145,7 +143,7 @@ export default async ({
   app: Express
   shutdown: () => Promise<void>
 }> => {
-  const container = await initializeContainer(rootDirectory)
+  const container = initializeContainer(rootDirectory)
   const configModule = container.resolve(
     ContainerRegistrationKeys.CONFIG_MODULE
   )

packages/medusa/src/loaders/logger.ts

@@ -1,3 +0,0 @@
-import logger from "@medusajs/medusa-cli/dist/reporter"
-
-export default logger

packages/medusa/src/loaders/pg-connection.ts

@@ -1,41 +0,0 @@
-import { ConfigModule } from "@medusajs/framework"
-import { ContainerRegistrationKeys, ModulesSdkUtils } from "@medusajs/utils"
-import { asValue, AwilixContainer } from "awilix"
-
-type Options = {
-  container: AwilixContainer
-  configModule: ConfigModule
-}
-
-export default async ({ container, configModule }: Options): Promise<any> => {
-  if (container.hasRegistration(ContainerRegistrationKeys.PG_CONNECTION)) {
-    return container.resolve(ContainerRegistrationKeys.PG_CONNECTION)
-  }
-
-  // Share a knex connection to be consumed by the shared modules
-  const connectionString = configModule.projectConfig.databaseUrl
-  const driverOptions: any =
-    configModule.projectConfig.databaseDriverOptions || {}
-  const schema = configModule.projectConfig.databaseSchema || "public"
-  const idleTimeoutMillis = driverOptions.pool?.idleTimeoutMillis ?? undefined // prevent null to be passed
-  const poolMax = driverOptions.pool?.max
-
-  delete driverOptions.pool
-
-  const pgConnection = ModulesSdkUtils.createPgConnection({
-    clientUrl: connectionString,
-    schema,
-    driverOptions,
-    pool: {
-      max: poolMax,
-      idleTimeoutMillis,
-    },
-  })
-
-  container.register(
-    ContainerRegistrationKeys.PG_CONNECTION,
-    asValue(pgConnection)
-  )
-
-  return pgConnection
-}

packages/medusa/src/loaders/redis.ts

@@ -1,63 +0,0 @@
-import { asValue } from "awilix"
-import Redis from "ioredis"
-import FakeRedis from "ioredis-mock"
-import { EOL } from "os"
-import { Logger, MedusaContainer } from "../types/global"
-import { ConfigModule } from "@medusajs/types"
-
-type Options = {
-  container: MedusaContainer
-  configModule: ConfigModule
-  logger: Logger
-}
-
-// TODO: Will be removed when the strict dependency on Redis in the core is removed
-async function redisLoader({
-  container,
-  configModule,
-  logger,
-}: Options): Promise<{ shutdown: () => Promise<void> }> {
-  let client!: Redis | FakeRedis
-
-  if (configModule.projectConfig.redisUrl) {
-    client = new Redis(configModule.projectConfig.redisUrl, {
-      // Lazy connect to properly handle connection errors
-      lazyConnect: true,
-      ...(configModule.projectConfig.redisOptions ?? {}),
-    })
-
-    try {
-      await client.connect()
-      logger?.info(`Connection to Redis established`)
-    } catch (err) {
-      logger?.error(`An error occurred while connecting to Redis:${EOL} ${err}`)
-    }
-
-    container.register({
-      redisClient: asValue(client),
-    })
-  } else {
-    if (process.env.NODE_ENV === "production") {
-      logger.warn(
-        `No Redis url was provided - using Medusa in production without a proper Redis instance is not recommended`
-      )
-    }
-
-    logger.info("Using fake Redis")
-
-    // Economical way of dealing with redis clients
-    client = new FakeRedis()
-
-    container.register({
-      redisClient: asValue(client),
-    })
-  }
-
-  return {
-    shutdown: async () => {
-      client.disconnect()
-    },
-  }
-}
-
-export default redisLoader