@things-factory/integration-base 8.0.5 → 9.0.0-beta.12

package/server/routers/scenario-schedule-callback-router.ts

@@ -1,69 +0,0 @@
-import Router from 'koa-router'
-
-import { getRepository } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ScheduleRegisterRequest } from '@things-factory/scheduler-client'
-
-import { Scenario } from '../service/scenario/scenario'
-import { ScenarioEngine } from '../engine/scenario-engine'
-
-export const scenarioScheduleCallbackRouter = new Router()
-
-/* When a callback occurs from the scheduler when a scheduled scenario is on schedule. */
-scenarioScheduleCallbackRouter.post('/callback-schedule-for-scenario', async (context, next) => {
-  const { client, task } = context.request.body as ScheduleRegisterRequest
-  const { userId } = task?.data
-
-  // application: Application,
-  // group: `${domain.id}`,
-  // type: 'scenario',
-  // key: scenario.id,
-  // operation: 'start'
-
-  const { domain } = context.state
-
-  if (!domain) {
-    throw new Error('cannot identify the current domain.')
-  }
-
-  if (!client || typeof client !== 'object') {
-    throw new Error('client property should be a part of callback body.')
-  }
-
-  const { group: domainId, key: scenarioId, operation, type } = client
-
-  if (!domainId || !scenarioId) {
-    throw new Error(`group(${domainId}) and key(${scenarioId}) properties should not be empty`)
-  }
-
-  if (domainId != domain.id) {
-    throw new Error('client property(group) is not matched with the current domain.')
-  }
-
-  if (type != 'scenario') {
-    throw new Error('client property(type) is not matched with the required value.')
-  }
-
-  if (operation != 'start') {
-    throw new Error('client property(operation) is not matched with the required value.')
-  }
-
-  const scenario = await getRepository(Scenario).findOne({
-    where: { domain: { id: domainId }, id: scenarioId },
-    relations: ['domain', 'steps', 'creator']
-  })
-
-  if (!scenario) {
-    throw new Error(`Scenario having given scenarioId(${domain?.subdomain}:${scenarioId}) not found`)
-  }
-
-  const user = (userId && (await getRepository(User).findOne({ where: { id: userId } }))) || scenario.creator
-
-  ScenarioEngine.load(scenario.name, scenario, {
-    domain,
-    user
-    /* variables: schedule 등록시 variables 는 설정할 방법이 없음. */
-  })
-
-  context.status = 200
-})

package/server/routers/scenario-view-router.ts

@@ -1,46 +0,0 @@
-import Router from 'koa-router'
-
-import { getRepository } from '@things-factory/shell'
-
-import { Scenario } from '../service/scenario/scenario'
-import { Step } from '../service/step/step-type'
-
-export const scenarioViewRouter = new Router()
-
-scenarioViewRouter.get('/scenario-view/:name', async (context, next) => {
-  const { domain } = context.state
-  const { name } = context.params
-
-  const scenario = await getRepository(Scenario).findOne({
-    where: {
-      domain: { id: domain.id },
-      name
-    },
-    relations: ['steps']
-  })
-
-  const steps: Step[] = scenario.steps
-  const nodes = {}
-  const edges = []
-
-  steps.forEach(({ id, name }) => {
-    nodes[id] = {
-      id,
-      name
-    }
-  })
-
-  for (let i = 0; i < steps.length - 1; i++) {
-    edges.push({
-      source: steps[i].id,
-      target: steps[i + 1].id
-    })
-  }
-
-  await context.render('scenario-view', {
-    model: {
-      nodes,
-      edges
-    }
-  })
-})

package/server/routes.ts

@@ -1,30 +0,0 @@
-import { config } from '@things-factory/env'
-
-import { scenarioViewRouter } from './routers/scenario-view-router'
-import { scenarioScheduleCallbackRouter } from './routers/scenario-schedule-callback-router'
-
-const isPathBaseDomain = !config.get('subdomain') && !config.get('useVirtualHostBasedDomain')
-
-process.on('bootstrap-module-domain-public-route' as any, (app, domainPrivateRouter) => {
-  if (isPathBaseDomain) {
-    domainPrivateRouter.use(
-      '/domain/:domain',
-      scenarioScheduleCallbackRouter.routes(),
-      scenarioScheduleCallbackRouter.allowedMethods()
-    )
-  } else {
-    domainPrivateRouter.use(
-      '',
-      scenarioScheduleCallbackRouter.routes(),
-      scenarioScheduleCallbackRouter.allowedMethods()
-    )
-  }
-})
-
-process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
-  if (isPathBaseDomain) {
-    domainPrivateRouter.use('/domain/:domain', scenarioViewRouter.routes(), scenarioViewRouter.allowedMethods())
-  } else {
-    domainPrivateRouter.use('', scenarioViewRouter.routes(), scenarioViewRouter.allowedMethods())
-  }
-})

package/server/service/analysis/analysis-query.ts

@@ -1,13 +0,0 @@
-import { Resolver, Query, Ctx } from 'type-graphql'
-import { ScalarObject } from '@things-factory/shell'
-import { analyzeIntegration } from '../../engine/analyzer/analyze-integration'
-
-@Resolver()
-export class IntegrationAnalysisQuery {
-  @Query(returns => ScalarObject, { description: 'To fetch integration Analyses' })
-  async integrationAnalysis(@Ctx() context: ResolverContext): Promise<any> {
-    const { domain } = context.state
-
-    return await analyzeIntegration(domain)
-  }
-}

package/server/service/analysis/index.ts

@@ -1,3 +0,0 @@
-import { IntegrationAnalysisQuery } from './analysis-query'
-
-export const resolvers = [IntegrationAnalysisQuery]

package/server/service/connection/connection-mutation.ts

@@ -1,190 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { getRepository } from '@things-factory/shell'
-
-import { ConnectionManager } from '../../engine/connection-manager'
-import { Connection, ConnectionPatch, ConnectionStatus, NewConnection } from './connection-type'
-
-@Resolver(Connection)
-export class ConnectionMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Connection, { description: 'To create new connection' })
-  async createConnection(@Arg('connection') connection: NewConnection, @Ctx() context: ResolverContext): Promise<Connection> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(Connection).save({
-      ...connection,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Connection, { description: 'To modify connection information' })
-  async updateConnection(@Arg('name') name: string, @Arg('patch') patch: ConnectionPatch, @Ctx() context: ResolverContext): Promise<Connection> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Connection)
-    const connection = await repository.findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-
-    return await repository.save({
-      ...connection,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Connection], { description: "To modify multiple connections' information" })
-  async updateMultipleConnection(@Arg('patches', type => [ConnectionPatch]) patches: ConnectionPatch[], @Ctx() context: ResolverContext): Promise<Connection[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const connectionRepo = tx.getRepository(Connection)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await connectionRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const connection = await connectionRepo.findOneBy({ id: newRecord.id })
-
-        const result = await connectionRepo.save({
-          ...connection,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete connection' })
-  async deleteConnection(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Connection).delete({ domain: { id: domain.id }, name })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple connections' })
-  async deleteConnections(@Arg('names', type => [String]) names: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Connection).delete({
-      domain: { id: domain.id },
-      name: In(names)
-    })
-
-    return true
-  }
-
-  @Mutation(returns => Connection, { description: 'To connect a connection' })
-  async connectConnection(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Connection> {
-    const { domain } = context.state
-    var repository = getRepository(Connection)
-    var connection = await repository.findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: ['domain', 'edge']
-    })
-
-    await connection.connect()
-    await repository.save(connection)
-
-    return {
-      ...connection,
-      state: ConnectionManager.getConnectionInstance(connection) ? ConnectionStatus.CONNECTED : ConnectionStatus.DISCONNECTED
-    } as Connection
-  }
-
-  @Mutation(returns => Connection, { description: 'To disconnect a connection' })
-  async disconnectConnection(@Arg('name') name: string, @Ctx() context: ResolverContext) {
-    const { domain } = context.state
-
-    var repository = getRepository(Connection)
-    var connection = await repository.findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: ['domain', 'edge']
-    })
-
-    await connection.disconnect()
-    await repository.save(connection)
-
-    return {
-      ...connection,
-      state: ConnectionManager.getConnectionInstance(connection) ? ConnectionStatus.CONNECTED : ConnectionStatus.DISCONNECTED
-    }
-  }
-
-  @Directive('@transaction')
-  // @Directive('@privilege(category: "connection", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To import multiple connections' })
-  async importConnections(@Arg('connections', type => [ConnectionPatch]) connections: Connection[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx, domain, user } = context.state
-
-    const repository = tx.getRepository(Connection)
-
-    await Promise.all(
-      connections.map(async (connection: Connection) => {
-        const { id, name } = connection
-
-        if (id) {
-          const sameId = await repository.findOneBy({ id })
-
-          if (sameId) {
-            if (sameId.domainId != domain.id) {
-              throw `Connection with id '${id}:${name}' is already taken by another domain`
-            }
-
-            const sameName = await repository.findOneBy({ domain: { id: domain.id }, name })
-            if (sameName && sameName.id != id) {
-              throw `Connection with name '${name}' is already taken by another connection`
-            }
-
-            await repository.save({
-              ...sameId,
-              ...connection,
-              domain,
-              updater: user
-            })
-
-            return
-          }
-        }
-
-        await repository.save({
-          ...connection,
-          domain,
-          updater: user,
-          creator: user
-        })
-      })
-    )
-
-    return true
-  }
-}

package/server/service/connection/connection-query.ts

@@ -1,87 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { Appliance, User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { ConnectionManager } from '../../engine/connection-manager'
-import { Connection, ConnectionList, ConnectionState, ConnectionStatus } from './connection-type'
-
-@Resolver(Connection)
-export class ConnectionQuery {
-  @Query(returns => Connection, { description: 'To fetch a connection' })
-  async connection(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Connection> {
-    const { domain } = context.state
-
-    var connection = await getRepository(Connection).findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: ['domain']
-    })
-
-    return {
-      ...connection,
-      state: ConnectionManager.getConnectionInstance(connection)
-        ? ConnectionStatus.CONNECTED
-        : ConnectionStatus.DISCONNECTED
-    } as Connection
-  }
-
-  @Query(returns => ConnectionList, { description: 'To fetch multiple connections' })
-  async connections(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<ConnectionList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(Connection),
-      params,
-      domain,
-      alias: 'connection',
-      searchables: ['name', 'description', 'type', 'endpoint']
-    })
-
-    const [items, total] = await queryBuilder.leftJoinAndSelect('connection.domain', 'domain').getManyAndCount()
-
-    items.forEach(connection => {
-      connection['state'] = ConnectionManager.getConnectionInstance(connection)
-        ? ConnectionStatus.CONNECTED
-        : ConnectionStatus.DISCONNECTED
-    })
-
-    return { items, total }
-  }
-
-  @Query(returns => ConnectionState, { description: 'To fetch the state of a connection' })
-  fetchConnectionState(@Arg('name') name: string, @Ctx() context: ResolverContext): ConnectionState {
-    const { domain } = context.state
-
-    const connection = ConnectionManager.getConnectionInstanceEntityByName(domain, name)
-
-    return {
-      ...connection,
-      state: connection ? ConnectionStatus.CONNECTED : ConnectionStatus.DISCONNECTED
-    }
-  }
-
-  @FieldResolver(type => Domain)
-  async edge(@Root() connection: Connection) {
-    return connection.edgeId && (await getRepository(Appliance).findOneBy({ id: connection.edgeId }))
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() connection: Connection) {
-    return (
-      connection.domain || (connection.domainId && (await getRepository(Domain).findOneBy({ id: connection.domainId })))
-    )
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() connection: Connection): Promise<User> {
-    return connection.updaterId && (await getRepository(User).findOneBy({ id: connection.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() connection: Connection): Promise<User> {
-    return connection.creatorId && (await getRepository(User).findOneBy({ id: connection.creatorId }))
-  }
-}

package/server/service/connection/connection-subscription.ts

@@ -1,104 +0,0 @@
-import { filter, pipe } from 'graphql-yoga'
-import { Arg, Resolver, Root, Subscription } from 'type-graphql'
-
-import { getRepository, Log, pubsub } from '@things-factory/shell'
-
-import { ConnectionManager } from '../../engine/connection-manager'
-import { Connection, ConnectionState, ConnectionStatus } from './connection-type'
-
-const debug = require('debug')('things-factory:integration:connection-subscription')
-
-@Resolver(Connection)
-export class ConnectionSubscription {
-  @Subscription({
-    subscribe: ({ args, context, info }) => {
-      const { domain, user } = context.state
-      const { name } = args
-      const subdomain = domain?.subdomain
-
-      debug('subscribe', subdomain)
-      if (!domain) {
-        throw new Error('domain required.')
-      }
-
-      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
-        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
-      }
-
-      process.nextTick(async () => {
-        var where = { domain: { id: domain.id } }
-        if (name) {
-          where['name'] = name
-        }
-
-        var connections = await getRepository(Connection).find({
-          where,
-          relations: ['domain', 'edge']
-        })
-
-        connections.forEach(connection => {
-          pubsub.publish('connection-state', {
-            connectionState: {
-              ...connection,
-              state: ConnectionManager.getConnectionInstance(connection) ? ConnectionStatus.CONNECTED : ConnectionStatus.DISCONNECTED,
-              timestamp: new Date()
-            }
-          })
-        })
-      })
-
-      return pipe(
-        pubsub.subscribe('connection-state'),
-        filter(async (payload: { connectionState: ConnectionState }) => {
-          const { domain: pdomain, name: pname } = payload.connectionState
-
-          return (!name || name === pname) && subdomain === pdomain?.subdomain
-        })
-      )
-    }
-  })
-  connectionState(@Root() payload: { connectionState: ConnectionState }, @Arg('name', { nullable: true }) name: string): ConnectionState {
-    return payload.connectionState
-  }
-
-  @Subscription({
-    subscribe: ({ args, context, info }) => {
-      const { domain, user } = context.state
-      const { level } = args
-
-      const subdomain = domain?.subdomain
-
-      debug('subscribe', subdomain)
-
-      if (!domain) {
-        throw new Error('domain required')
-      }
-
-      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
-        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
-      }
-
-      return pipe(
-        pubsub.subscribe('connection-log'),
-        filter(async (payload: { log: Log }) => {
-          // TODO support domain filtering
-          const { /* source, */ level: plevel } = payload.log
-          // const { domain: pdomain } = source
-
-          // if (subdomain !== pdomain?.subdomain) {
-          //   return false
-          // }
-
-          if (level && level !== plevel) {
-            return false
-          }
-
-          return true
-        })
-      )
-    }
-  })
-  connectionLog(@Root() payload: { log: Log }, @Arg('level', { nullable: true }) level: string): Log {
-    return payload.log
-  }
-}