onions-node/lib/init_backend.js

onions-node backend

const ssoAuth = require('@razor-node/sso-auth')
const express = require('express')
const {envConfig} = require('@razor-node/core')
const {EkkoSDK} = require('@razor-node/ekko-sdk')
const TrackSDK = require('@razor-node/track-sdk')
const forwardRouter = require('@razor-node/routing-forward')
const bodyParser = require('body-parser')
const cookieParser = require('cookie-parser')
const initLogger = require('./init_logger')
const createProxyRouter = require('./create_proxy_router')
const {createSessionMiddleware, createSessionStore} = require('./create_session_middleware')
const createDistRouter = require('./create_dist_router')
const createCDNRouter = require('./create_cdn_router')
const util = require('./utils')
const { LarkAuth } = require('@razor-node/lark-auth')

const isFunction = (content) => typeof content === 'function'

module.exports = (config, projectRootPath, appInstance) => {
  envConfig.init(config)

  appInstance = appInstance || express();
  appInstance.disable('x-powered-by');
  appInstance.enable('trust proxy');

  if (config.before && isFunction(config.before)) {
    config.before(appInstance, {config})
  }

  // bodyParser
  appInstance.use(
    bodyParser.urlencoded({
      limit: envConfig.getValue('maxBodyLength', '100mb'),
      extended: true
    })
  )
  appInstance.use(
    bodyParser.json({
      limit:  envConfig.getValue('maxBodyLength', '100mb')
    })
  )

  const loggerOptions = {
    logDir: util.resolvePathByExecPath(envConfig.getValue('logPath'), projectRootPath),
    team: envConfig.getValue('team'),
    project: envConfig.getValue('project'),
    env: envConfig.getValue('env'),
  }

  const logger = initLogger(appInstance, loggerOptions)

  appInstance.use(cookieParser())
  const ssoConfig = envConfig.getValue('sso')
  const redisConfig = envConfig.getValue('redisConfig')
  const cdnConfig = envConfig.getValue('cdnConfig')
  let sessionStore
  if (ssoConfig && ssoConfig.useSSO || redisConfig) {
    if (!redisConfig) {
      throw new Error('cannot found key [redisConfig] in config file')
    }
    if (redisConfig) {
      sessionStore = createSessionStore(redisConfig, logger)
    }
    appInstance.use(createSessionMiddleware({
      sameSiteNone: envConfig.getValue('sameSiteNone'),
      sessionSecret: envConfig.getValue('sessionSecret', envConfig.getValue('appInfo.app_secret')),
      cookieSetting: envConfig.getValue('cookieSetting', {}),
      sessionName: envConfig.getValue('sessionId', `${envConfig.getValue('project')}.sid`)
    }, sessionStore, logger))

  }


  /*日志上报接口代理*/
  const ekkoSDK = new EkkoSDK(envConfig.getValue('appInfo.app_id'), envConfig.getValue('env'), {logger})
  appInstance.use(ekkoSDK.createRouter())

  const trackSDK = new TrackSDK(envConfig.getValue('appInfo'), envConfig.getValue('env'), {logger})
  appInstance.use(trackSDK.createRouter())


  if (ssoConfig && ssoConfig.useSSO) {
    ssoAuth.initSSO(appInstance, ssoConfig.ssoEnv || envConfig.getValue('env'), {
      appInfo: envConfig.getValue('appInfo'),
      appId: envConfig.getValue('appInfo.app_id'),
      logger: logger,
      redisStore: sessionStore,
      ...ssoConfig,
    })

    if (config.afterSSO && isFunction(config.afterSSO)) {
      config.afterSSO(appInstance, {logger, config})
    }
  }

  if (cdnConfig && cdnConfig.useCDN !== false) {
    appInstance.use(createCDNRouter(cdnConfig, config, logger))
  }

  if (envConfig.getValue('proxies')) {
    if (config.beforeProxies && isFunction(config.beforeProxies)) {
      config.beforeProxies(appInstance, {logger, config})
    }
    const router = createProxyRouter(envConfig.getValue('proxies'), envConfig._config, logger)
    appInstance.use('/', router)

    if (config.afterProxies && isFunction(config.afterProxies)) {
      config.afterProxies(appInstance, {logger, config})
    }
  }

  const larkConfig = envConfig.getValue('larkConfig')
  if(larkConfig && larkConfig.useJssdk) {
    if (!redisConfig) {
      throw new Error('cannot found key [redisConfig] in config file')
    }
    const larkauth = new LarkAuth(larkConfig.app_id, larkConfig.app_secret, {logger}, redisConfig)
    appInstance.use(larkauth.createRouter())
  }

  appInstance.use(require('./create_env_route')(config, logger))
  // 完整路径跳转
  appInstance.use(forwardRouter(config, logger))

  /*init dist render*/
  if (!envConfig.getValue('inDevServer')) {
    const distRouter = createDistRouter(envConfig.getValue('dist'), projectRootPath)
    appInstance.use(distRouter)

    appInstance.use(['/health', '/status'], (req, res, next) => {
      res.send(`Project ${envConfig.getValue('project')} send OK!`);
    });

    if (config.after && isFunction(config.after)) {
      config.after(appInstance, {
        logger, config
      })
    }

    appInstance.use((req, res, next) => {
      res.send('404 not found!');
    });

    appInstance.use((err, req, res, next) => {
      console.log(err.message)
      logger.error(`uncaught error => ${err.message}`)
      res.json({
        result_code: err.result_code || 'internal_error',
        message: err.message
      });
    });

    process.on('uncaughtException', err => {
      console.error('An uncaught error occurred!')
      console.error(err.message)
      console.error(err.stack)
    })
  } else {
    if (config.after && isFunction(config.after)) {
      config.after(appInstance, {
        logger, config
      })
    }
  }


  logger.info('app init success!!!')

  return appInstance
}