@things-factory/operato-hub 4.3.107 → 4.3.108

package/server/routers/api/restful-apis/v1/middlewares/business-middleware.ts

@@ -0,0 +1,68 @@
+import { getRepository } from 'typeorm'
+
+import { Application } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Domain, getDomainFromURL } from '@things-factory/shell'
+import { Partner } from '@things-factory/auth-base'
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { isValidUUID } from '../utils/validate-util'
+
+const debug = require('debug')('things-factory:operato-hub:business-middleware')
+
+export async function businessMiddleware(context, next) {
+  const { user } = context.state
+
+  debug('user', user?.email)
+
+  try {
+    if (user) {
+      const domain: Domain = await getDomainFromURL(context)
+      const application: Application = await getRepository(Application).findOne({ where: { id: user.reference } })
+
+      if (
+        context?.query?.bizplaceId ||
+        context?.request?.body?.bizplaceId ||
+        context?.request?.body?.data?.bizplaceId
+      ) {
+        let bizplaceId =
+          context?.query?.bizplaceId || context?.request?.body?.bizplaceId || context?.request?.body?.data?.bizplaceId
+        if (!isValidUUID(bizplaceId)) throw new ApiError('E01', 'bizplaceId')
+
+        const bizplace: Bizplace = await getRepository(Bizplace).findOne({
+          where: { id: bizplaceId },
+          relations: ['domain', 'company', 'company.domain']
+        })
+        if (!bizplace || (bizplace.company.domain.id !== domain.id && domain.extType == 'company')) {
+          throw new ApiError('E01', 'bizplace')
+        }
+        if (domain.extType == 'warehouse') {
+          const partner: Partner = await getRepository(Partner).findOne({
+            where: { partnerDomain: bizplace.domain, domain }
+          })
+          if (!partner) {
+            throw new ApiError('E01', 'bizplace')
+          }
+        }
+        context.state.business = bizplace.company
+      }
+      // storeId validation
+      else if (context?.query?.storeId || context?.request?.body?.storeId || context?.request?.body?.data?.storeId) {
+        let storeId =
+          context?.query?.storeId || context?.request?.body?.storeId || context?.request?.body?.data?.storeId
+        const store: MarketplaceStore = await getRepository(MarketplaceStore).findOne({
+          where: { name: storeId, domain }
+        })
+
+        if (!store) {
+          throw new ApiError('E01', 'storeId')
+        }
+      }
+      context.state.application = application
+    }
+    await next()
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+}

package/server/routers/api/restful-apis/v1/middlewares/index.ts

@@ -0,0 +1,26 @@
+import { businessMiddleware } from './business-middleware'
+
+const debug = require('debug')('things-factory:operato-hub:index')
+
+export function initMiddlewares(app) {
+  /*
+   * post:graphql 에 대해서는 businessMiddleware를 적용한다.
+   * graphql app을 router에 적용하지 못하기 때문임.
+   */
+  app.use(async (context, next) => {
+    const { method, path } = context
+
+    if (method == 'POST' && path.startsWith('/graphql')) {
+      debug(method, path)
+      return await businessMiddleware(context, next)
+    }
+
+    await next()
+  })
+}
+
+export * from './business-middleware'
+export * from './logging-middleware'
+export * from './store-middleware'
+export * from './warehouse-middleware'
+export * from './validation-middleware'

package/server/routers/api/restful-apis/v1/middlewares/logging-middleware.ts

@@ -0,0 +1,24 @@
+import { createPayloadLog, PayloadType } from '@things-factory/integration-base'
+
+// inserts payload log after successful endpoint request
+export async function loggingMiddleware(context, next) {
+  // wait for endpoint logic to complete
+  await next()
+
+  // name of requester's domain
+  const name = context.state.domain.name
+
+  // endpoint that was queried
+  const endpoint = context.req._parsedUrl.pathname
+
+  // request body and query
+  const request = {
+    query: context.query,
+    requestBody: context.request.body
+  }
+
+  // response
+  const response = context.body
+
+  await createPayloadLog(name, endpoint, request, response, context, PayloadType.INGESTION)
+}

package/server/routers/api/restful-apis/v1/middlewares/store-middleware.ts

@@ -0,0 +1,34 @@
+import { getRepository } from 'typeorm'
+
+import { ApiError } from '../utils/error-util'
+
+import { MarketplaceStore as MarketplaceStoreEntity } from '@things-factory/integration-marketplace'
+
+const debug = require('debug')('things-factory:operato-hub:store-middleware')
+
+export async function storeMiddleware(context, next) {
+  const { storeId } = context.method == 'GET' ? context.query : context.request.body.data
+  const { business } = context.state
+
+  let marketplaceStore: MarketplaceStoreEntity
+
+  debug('company and store', business, storeId)
+
+  if (!business) throw new ApiError('E04', 'Company')
+
+  if (storeId) {
+    marketplaceStore = await getRepository(MarketplaceStoreEntity).findOne({
+      where: { domain: business.domain, name: storeId, status: 'ACTIVE' },
+      relations: ['domain']
+    })
+    debug('marketplace-store', storeId, marketplaceStore?.domain?.subdomain)
+
+    if (!marketplaceStore) throw new ApiError('E04', 'Operato Marketplace Store')
+  } else {
+    throw new ApiError('E04', 'storeId')
+  }
+
+  context.state.marketplaceStore = marketplaceStore
+
+  await next()
+}

package/server/routers/api/restful-apis/v1/middlewares/validation-middleware.ts

@@ -0,0 +1,116 @@
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+
+const debug = require('debug')('things-factory:operato-hub:validation-middleware')
+
+import { params, reqParams, requireLimitOffsetValidation, requireFromToDateValidation } from '../utils/params'
+import { validateFromToDate, validateLimitOffset } from '../utils/validate-util'
+
+let req
+
+export async function validationMiddleware(context, next) {
+  let path = context.req._parsedUrl.pathname
+  let endpoint = path.substring(path.lastIndexOf('/') + 1)
+  let q = context?.request?.query
+  req = reqParams[endpoint]
+
+  // validate data key
+  try {
+    if (context.method == 'POST' && !context?.request?.body?.data) {
+      throw new ApiError('E03', 'data')
+    }
+
+    validateExpected(endpoint, context)
+    validateRequired(endpoint, context)
+
+    if (requireLimitOffsetValidation.includes(endpoint)) {
+      let { limit, offset } = validateLimitOffset(q?.limit, q?.offset)
+      context.request.query.limit = limit
+      context.request.query.offset = offset
+    }
+    if (requireFromToDateValidation.includes(endpoint)) {
+      let { fromDate, toDate } = validateFromToDate(q?.fromDate, q?.toDate)
+      context.request.query.fromDate = fromDate
+      context.request.query.toDate = toDate
+    }
+
+    await next()
+  } catch (e) {
+    if (e instanceof ApiError) ApiErrorHandler(context, e)
+    else throwInternalServerError(context, e)
+  }
+}
+
+function validateExpected(endpoint, context) {
+  let data = context.method == 'POST' ? context.request.body.data : context.request.query
+  let expected = params[endpoint]
+  let result = context.method == 'POST' ? Object.keys(flatten(data)) : Object.keys(data)
+  for (let r of result) {
+    if (!expected.includes(r)) throw new ApiError('E02', r.toString())
+  }
+}
+
+function validateRequired(endpoint, context) {
+  let data
+  if (context.method == 'GET') {
+    data = context.request.query
+    let required = reqParams[endpoint]
+    let result = Object.keys(data)
+    if (required) {
+      for (let r of required) {
+        if (!result.includes(r)) throw new ApiError('E03', r.toString())
+      }
+      for (let r of result) {
+        if (data[r] == null || data[r] === "") throw new ApiError('E01', r.toString())
+      }
+    }
+  } else {
+    data = context.request.body.data
+    if (data instanceof Array) {
+      for (let d of data) {
+        validateReq(d)
+      }
+    } else {
+      validateReq(data)
+    }
+  }
+}
+
+function flatten(obj, path = '') {
+  if (!(obj instanceof Object)) return { [path.replace(/\.$/g, '')]: obj }
+
+  return Object.keys(obj).reduce((output, key) => {
+    return obj instanceof Array
+      ? { ...output, ...flatten(obj[key], path) }
+      : { ...output, ...flatten(obj[key], path + key + '.') }
+  }, {})
+}
+
+function validateReq(obj, path = []) {
+  let keys = Object.keys(obj)
+  let reqTemp = req
+  let pathTemp = path.slice()
+  while (pathTemp.length > 0) {
+    reqTemp = reqTemp.find(e => e.name == pathTemp[0]).data
+    pathTemp.shift()
+  }
+  for (let rule of reqTemp) {
+    if (rule.type == 'field') {
+      if (rule.required && !keys.includes(rule.name)) {
+        throw new ApiError('E03', rule.name)
+      }
+    } else {
+      if (!obj.hasOwnProperty(rule.name) && rule.required) {
+        throw new ApiError('E03', rule.name)
+      }
+      if (obj[rule.name]) {
+        let arr = rule.type == 'array' ? obj[rule.name] : [obj[rule.name]]
+        for (let arrObj of arr) {
+          validateReq(arrObj, [...path, rule.name])
+        }
+      }
+    }
+    if (rule.required && (obj[rule.name] == null || obj[rule.name] == undefined || obj[rule.name] === "")) {
+      throw new ApiError('E01', `${rule.name}: null`)
+    }
+  }
+}

package/server/routers/api/restful-apis/v1/middlewares/warehouse-middleware.ts

@@ -0,0 +1,31 @@
+import { getRepository } from 'typeorm'
+import { Bizplace } from '@things-factory/biz-base'
+import { ApiError } from '../utils/error-util'
+
+const debug = require('debug')('things-factory:operato-hub:warehouse-middleware')
+
+export async function warehouseMiddleware(context, next) {
+  const { warehouseId } = context.query
+  const { business } = context.state
+
+  let warehouse: Bizplace
+
+  debug('company and warehouse', business, warehouseId)
+
+  if (!business) throw new ApiError('E04', 'Company')
+
+  if (warehouseId) {
+    warehouse = await getRepository(Bizplace).findOne(warehouseId, {
+      relations: ['company', 'domain']
+    })
+    debug('warehouse', warehouseId, warehouse?.domain?.subdomain)
+
+    if (!warehouse) throw new ApiError('E04', 'Warehouse')
+  } else {
+    throw new ApiError('E04', 'Warehouse')
+  }
+
+  context.state.warehouse = warehouse
+
+  await next()
+}

package/server/routers/api/restful-apis/v1/utils/error-util.ts

@@ -0,0 +1,70 @@
+// custom error class used when throwing errors for API V1
+export class ApiError extends Error {
+  responseCode: string
+  status: number
+  message: string
+  details: string
+  constructor(responseCode: string, message: string, ...params) {
+    super(...params)
+    this.responseCode = responseCode
+    this.name = 'ApiError'
+    switch (responseCode) {
+      case 'E01':
+        this.status = 400
+        this.message = 'Invalid parameter values'
+        this.details = message
+        break
+      case 'E02':
+        this.status = 400
+        this.message = 'Unexpected parameters'
+        this.details = message
+        break
+      case 'E03':
+        this.status = 400
+        this.message = 'Missing parameters'
+        this.details = message
+        break
+      case 'E04':
+        this.status = 404
+        this.message = 'Resource not found'
+        this.details = message
+        break
+      case 'E05':
+        this.status = 409
+        this.message = 'Duplicate entry'
+        this.details = message
+        break
+      case 'E06':
+        this.status = 500
+        this.message = 'Internal server error'
+        this.details = message
+        break
+    }
+  }
+}
+
+// used in catch block to give an error response
+export function ApiErrorHandler(context, e) {
+  context.type = 'application/json'
+  context.status = e.status
+  context.body = {
+    error: {
+      responseCode: e.responseCode,
+      message: e.message,
+      details: e.details
+    }
+  }
+}
+
+// used in catch block for all errors that are not ApiError
+export function throwInternalServerError(context, e) {
+  context.type = 'application/json'
+  context.status = 500
+  context.body = {
+    error: {
+      responseCode: 'E06',
+      message: 'Internal Server Error',
+      details: e.message
+    }
+  }
+}