feat: CLI + local linking (#313)

* fix: allow local cmd without exiting process

* fix: improves cli experience

* fix: allow running link with --develop

* test: adds snapshot testing of error logs

* chore: cleanup

* feat(medusa-cli): new command (#320)

* adds: new command

* fix: creates  command for easy project setup

* chore: deps

* chore: deps

* fix: loggin

* fix: logging

* fix: adds cli as dependency in core

* fix: consolidates CLI in medusa

* fix: use project deps medusa bin

* fix: use project deps medusa bin

* fix: use cli path

* fix: new command setup db + env vars

* fix: new command with db seed

* fix: cleanup

packages/medusa/src/bin/medusa.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require(`@medusajs/medusa-cli`)

packages/medusa/src/commands/develop.js

@@ -14,7 +14,8 @@ export default async function({ port, directory }) {
     stdio: ["ignore", process.stdout, process.stderr],
   })
 
-  let child = spawn("medusa", [`start`, ...args], {
+  const cliPath = "./node_modules/@medusajs/medusa/cli.js"
+  let child = spawn(cliPath, [`start`, ...args], {
     cwd: directory,
     env: process.env,
     stdio: ["pipe", process.stdout, process.stderr],
@@ -32,7 +33,7 @@ export default async function({ port, directory }) {
 
     Logger.info("Rebuilt")
 
-    child = spawn("medusa", [`start`, ...args], {
+    child = spawn(cliPath, [`start`, ...args], {
       cwd: directory,
       env: process.env,
       stdio: ["pipe", process.stdout, process.stderr],

packages/medusa/src/commands/start.js

@@ -11,11 +11,12 @@ export default async function({ port, directory }) {
     const app = express()
 
     const { dbConnection } = await loaders({ directory, expressApp: app })
+    const serverActivity = Logger.activity(`Creating server`)
     const server = app.listen(port, err => {
       if (err) {
         return
       }
-      Logger.info(`Server is ready on port: ${port}!`)
+      Logger.success(serverActivity, `Server is ready on port: ${port}`)
     })
 
     return { dbConnection, server }

packages/medusa/src/commands/user.js

@@ -5,15 +5,22 @@ import express from "express"
 
 import loaders from "../loaders"
 
-export default async function({ directory, id, email, password }) {
+export default async function({ directory, id, email, password, keepAlive }) {
   const app = express()
-  const { container } = await loaders({
-    directory,
-    expressApp: app,
-  })
+  try {
+    const { container } = await loaders({
+      directory,
+      expressApp: app,
+    })
 
-  const userService = container.resolve("userService")
-  await userService.create({ id, email }, password)
+    const userService = container.resolve("userService")
+    await userService.create({ id, email }, password)
+  } catch (err) {
+    console.error(err)
+    process.exit(1)
+  }
 
-  process.exit()
+  if (!keepAlive) {
+    process.exit()
+  }
 }

packages/medusa/src/loaders/index.js

@@ -61,33 +61,54 @@ export default async ({ directory: rootDirectory, expressApp }) => {
     logger: asValue(Logger),
   })
 
-  await modelsLoader({ container })
-  Logger.info("Models initialized")
+  const modelsActivity = Logger.activity("Initializing models")
+  await modelsLoader({ container, activityId: modelsActivity })
+  Logger.success(modelsActivity, "Models initialized")
 
-  await registerPluginModels({ rootDirectory, container })
-  Logger.info("Models initialized")
+  const pmActivity = Logger.activity("Initializing plugin models")
+  await registerPluginModels({
+    rootDirectory,
+    container,
+    activityId: pmActivity,
+  })
+  Logger.success(pmActivity, "Plugin models initialized")
 
-  await repositoriesLoader({ container })
-  Logger.info("Repositories initialized")
+  const repoActivity = Logger.activity("Initializing repositories")
+  await repositoriesLoader({ container, activityId: repoActivity })
+  Logger.success(repoActivity, "Repositories initialized")
 
-  const dbConnection = await databaseLoader({ container, configModule })
-  Logger.info("Database initialized")
+  const dbActivity = Logger.activity("Initializing database")
+  const dbConnection = await databaseLoader({
+    container,
+    configModule,
+    activityId: dbActivity,
+  })
+  Logger.success(dbActivity, "Database initialized")
 
   container.register({
     manager: asValue(dbConnection.manager),
   })
 
-  await servicesLoader({ container, configModule })
-  Logger.info("Services initialized")
+  const servicesActivity = Logger.activity("Initializing services")
+  await servicesLoader({
+    container,
+    configModule,
+    activityId: servicesActivity,
+  })
+  Logger.success(servicesActivity, "Services initialized")
 
-  await subscribersLoader({ container })
-  Logger.info("Subscribers initialized")
+  const subActivity = Logger.activity("Initializing subscribers")
+  await subscribersLoader({ container, activityId: subActivity })
+  Logger.success(subActivity, "Subscribers initialized")
 
-  await expressLoader({ app: expressApp, configModule })
-  Logger.info("Express Intialized")
-
-  await passportLoader({ app: expressApp, container })
-  Logger.info("Passport initialized")
+  const expActivity = Logger.activity("Initializing express")
+  await expressLoader({
+    app: expressApp,
+    configModule,
+    activityId: expActivity,
+  })
+  await passportLoader({ app: expressApp, container, activityId: expActivity })
+  Logger.success(expActivity, "Express intialized")
 
   // Add the registered services to the request scope
   expressApp.use((req, res, next) => {
@@ -98,14 +119,27 @@ export default async ({ directory: rootDirectory, expressApp }) => {
     next()
   })
 
-  await pluginsLoader({ container, rootDirectory, app: expressApp })
-  Logger.info("Plugins Intialized")
+  const pluginsActivity = Logger.activity("Initializing plugins")
+  await pluginsLoader({
+    container,
+    rootDirectory,
+    app: expressApp,
+    activityId: pluginsActivity,
+  })
+  Logger.success(pluginsActivity, "Plugins intialized")
 
-  await apiLoader({ container, rootDirectory, app: expressApp })
-  Logger.info("API initialized")
+  const apiActivity = Logger.activity("Initializing API")
+  await apiLoader({
+    container,
+    rootDirectory,
+    app: expressApp,
+    activityId: apiActivity,
+  })
+  Logger.success(apiActivity, "API initialized")
 
-  await defaultsLoader({ container })
-  Logger.info("Defaults initialized")
+  const defaultsActivity = Logger.activity("Initializing defaults")
+  await defaultsLoader({ container, activityId: defaultsActivity })
+  Logger.success(defaultsActivity, "Defaults initialized")
 
   return { container, dbConnection, app: expressApp }
 }

packages/medusa/src/loaders/logger.js

@@ -1,32 +1,2 @@
-import winston from "winston"
-import config from "../config"
-
-const transports = []
-if (process.env.NODE_ENV !== "development") {
-  transports.push(new winston.transports.Console())
-} else {
-  transports.push(
-    new winston.transports.Console({
-      format: winston.format.combine(
-        winston.format.cli(),
-        winston.format.splat()
-      ),
-    })
-  )
-}
-
-const LoggerInstance = winston.createLogger({
-  level: config.logs.level,
-  levels: winston.config.npm.levels,
-  format: winston.format.combine(
-    winston.format.timestamp({
-      format: "YYYY-MM-DD HH:mm:ss",
-    }),
-    winston.format.errors({ stack: true }),
-    winston.format.splat(),
-    winston.format.json()
-  ),
-  transports,
-})
-
-export default LoggerInstance
+import logger from "@medusajs/medusa-cli/dist/reporter"
+export default logger

packages/medusa/src/loaders/plugins.js

@@ -21,7 +21,7 @@ import formatRegistrationName from "../utils/format-registration-name"
 /**
  * Registers all services in the services directory
  */
-export default async ({ rootDirectory, container, app }) => {
+export default async ({ rootDirectory, container, app, activityId }) => {
   const resolved = getResolvedPlugins(rootDirectory)
 
   await Promise.all(
@@ -29,7 +29,7 @@ export default async ({ rootDirectory, container, app }) => {
       registerRepositories(pluginDetails, container)
       await registerServices(pluginDetails, container)
       registerMedusaApi(pluginDetails, container)
-      registerApi(pluginDetails, app, rootDirectory, container)
+      registerApi(pluginDetails, app, rootDirectory, container, activityId)
       registerCoreRouters(pluginDetails, container)
       registerSubscribers(pluginDetails, container)
     })
@@ -159,9 +159,18 @@ function registerCoreRouters(pluginDetails, container) {
 /**
  * Registers the plugin's api routes.
  */
-function registerApi(pluginDetails, app, rootDirectory = "", container) {
+function registerApi(
+  pluginDetails,
+  app,
+  rootDirectory = "",
+  container,
+  activityId
+) {
   const logger = container.resolve("logger")
-  logger.info(`Registering custom endpoints for ${pluginDetails.name}`)
+  logger.progress(
+    activityId,
+    `Registering custom endpoints for ${pluginDetails.name}`
+  )
   try {
     const routes = require(`${pluginDetails.resolve}/api`).default
     if (routes) {
@@ -170,10 +179,10 @@ function registerApi(pluginDetails, app, rootDirectory = "", container) {
     return app
   } catch (err) {
     if (err.message !== `Cannot find module '${pluginDetails.resolve}/api'`) {
-      logger.warn(
-        `An error occured while registering customer endpoints for ${pluginDetails.name}`
+      logger.progress(
+        activityId,
+        `No customer endpoints registered for ${pluginDetails.name}`
       )
-      logger.error(err.stack)
     }
     return app
   }