@things-factory/shell 8.0.38 → 9.0.0-9.0.0-beta.59.0

package/server/initializers/database.ts

@@ -1,96 +0,0 @@
-import { createConnection, DataSource, EntityManager, EntityTarget, Repository } from 'typeorm'
-
-import { appRootPath, config, logger } from '@things-factory/env'
-
-const path = require('path')
-
-var ormconfig
-try {
-  ormconfig = require(path.resolve(appRootPath, 'ormconfig'))
-} catch (e) {
-  ormconfig = require('@things-factory/shell/ormconfig')
-}
-
-const dataSources: { [name: string]: DataSource } = {}
-
-/**
- * Returns the specified DataSource by name.
- * @param {string} name - The name of the DataSource.
- * @returns {DataSource} - The DataSource with the specified name.
- */
-export function getDataSource(name?: string): DataSource {
-  return dataSources[name || 'default']
-}
-
-/**
- * Adds a new DataSource with the specified name.
- * @param {string} name - The name of the DataSource to add.
- * @param {DataSource} dataSource - The DataSource to add.
- */
-export function addDataSource(name: string, dataSource: DataSource) {
-  dataSources[name] = dataSource
-}
-
-/**
- * Removes a DataSource with the specified name.
- * @param {string} name - The name of the DataSource to remove.
- */
-export function removeDataSource(name: string) {
-  delete dataSources[name]
-}
-
-/**
- * Returns an array of all registered DataSource names.
- * @returns {string[]} - An array of DataSource names.
- */
-export function getDataSourceNames() {
-  return Object.keys(dataSources)
-}
-
-/**
- * Returns a repository for the specified entity.
- * @param {EntityTarget<X>} target - The target entity for which to get the repository.
- * @returns {Repository<X>} - The repository for the specified entity.
- */
-export function getRepository<X>(target: EntityTarget<X>, tx?: EntityManager): Repository<X> {
-  return tx ? tx.getRepository<X>(target) : getDataSource('default').getRepository<X>(target)
-}
-
-/**
- * Initializes the database connections and data sources.
- */
-export const databaseInitializer = async () => {
-  try {
-    const readConnectionConfig = config.get('ormconfig')
-
-    const dataSource = await createConnection({
-      ...ormconfig,
-      ...readConnectionConfig
-    })
-
-    addDataSource('default', dataSource)
-
-    logger.info('Default DataSource established')
-
-    if (readConnectionConfig.type == 'sqlite' && readConnectionConfig.synchronize == false) {
-      await dataSource.query('PRAGMA foreign_keys=OFF')
-      await dataSource.synchronize()
-      await dataSource.query('PRAGMA foreign_keys=ON')
-    }
-
-    if (config.get('ormconfig4Tx')) {
-      const dataSource4Tx = new DataSource({
-        ...ormconfig,
-        ...config.get('ormconfig4Tx')
-      })
-      await dataSource4Tx.initialize()
-      addDataSource('tx', dataSource4Tx)
-
-      logger.info('Transaction DataSource established')
-    } else {
-      addDataSource('tx', dataSource)
-    }
-  } catch (e) {
-    logger.error(e)
-  }
-}

package/server/initializers/naming-strategy.ts

@@ -1,14 +0,0 @@
-import { NamingStrategyInterface } from 'typeorm'
-import { DefaultNamingStrategy } from 'typeorm'
-import pluralize from 'pluralize'
-import _ from 'lodash'
-
-export class NamingStrategy extends DefaultNamingStrategy implements NamingStrategyInterface {
-  tableName(targetName: string, userSpecifiedName: string): string {
-    return userSpecifiedName || pluralize(_.snakeCase(targetName))
-  }
-
-  columnName(propertyName: string, customName: string, embeddedPrefixes: string[]): string {
-    return _.snakeCase(embeddedPrefixes.concat(customName || propertyName).join('_'))
-  }
-}

package/server/middlewares/domain-middleware.ts

@@ -1,60 +0,0 @@
-import requestIp from 'request-ip'
-import { getDomainFromURL } from '../utils'
-
-export async function domainMiddleware(context: any, next: any) {
-  var { domain } = context.state
-  if (!domain) {
-    /*
-     * The domainTypes should be checked only when signin and checkin.
-     * For purposes such as API calls, the target domainTypes may be different from the system domainTypes.
-     * So, we don't check domainTypes here.
-     */
-    domain = await getDomainFromURL(context)
-  }
-
-  if (domain) {
-    const ip = requestIp.getClientIp(context.req)
-    const { whitelist = [], blacklist = [], protectedlist = [], privileges = [] } = domain.iplist || {}
-
-    if (Array.isArray(whitelist) && whitelist.length > 0) {
-      /* whitelist 우선 */
-      const whitelisted =
-        Array.isArray(whitelist) &&
-        whitelist.some(item => {
-          return new RegExp(item).test(ip)
-        })
-
-      if (!whitelisted) {
-        context.status = 403
-        return
-      }
-    } else {
-      const blacklisted =
-        Array.isArray(blacklist) &&
-        blacklist.some(item => {
-          return new RegExp(item).test(ip)
-        })
-
-      if (blacklisted) {
-        context.status = 403
-        return
-      }
-    }
-
-    if (Array.isArray(protectedlist) && protectedlist.length > 0) {
-      const safe = protectedlist.some(item => {
-        return new RegExp(item).test(ip)
-      })
-
-      context.state.unsafeIP = !safe
-
-      if (!safe) {
-        context.state.prohibitedPrivileges = privileges
-      }
-    }
-  }
-
-  context.state.domain = domain
-
-  return next()
-}

package/server/middlewares/index.ts

@@ -1,43 +0,0 @@
-import { config, logger } from '@things-factory/env'
-
-import { domainMiddleware } from './domain-middleware'
-
-export function initMiddlewares(app) {
-  app.subdomainOffset = config.get('subdomainOffset', 2)
-
-  app.on('error', (err, context) => {
-    logger.error(err)
-  })
-
-  /*
-   * Catching downstream errors
-   * - recommend to use context.throw, context.assert
-   */
-  app.use(async (context, next) => {
-    try {
-      await next()
-    } catch (err) {
-      context.status = err?.status || 500
-      context.body = err?.message
-
-      // emitting error to app.on('error', ...)
-      context.app.emit('error', err, context)
-    }
-  })
-
-  /*
-   * post:graphql 에 대해서는 domain을 확인한다.
-   * graphql app을 router에 적용하지 못하기 때문임.
-   */
-  app.use(async (context, next) => {
-    const { method, path } = context
-
-    if (method == 'POST' && path.startsWith('/graphql')) {
-      return await domainMiddleware(context, next)
-    }
-
-    await next()
-  })
-}
-
-export * from './domain-middleware'

package/server/migrations/1000000000000-SeedDomain.ts

@@ -1,37 +0,0 @@
-import { MigrationInterface, QueryRunner } from 'typeorm'
-
-import { getRepository } from '../initializers/database'
-import { Domain } from '../service/domain/domain'
-
-const SEED_DOMAINS = [
-  {
-    name: 'SYSTEM',
-    subdomain: 'system',
-    systemFlag: true
-  }
-]
-
-export class SeedDomain1000000000000 implements MigrationInterface {
-  public async up(queryRunner: QueryRunner): Promise<any> {
-    const repository = getRepository(Domain)
-
-    return await Promise.all(
-      SEED_DOMAINS.map(async domain => {
-        await repository.save({
-          ...domain
-        })
-      })
-    )
-  }
-
-  public async down(queryRunner: QueryRunner): Promise<any> {
-    const repository = getRepository(Domain)
-
-    return await Promise.all(
-      SEED_DOMAINS.reverse().map(async domain => {
-        let recode = await repository.findOneBy({ subdomain: domain.subdomain })
-        await repository.remove(recode)
-      })
-    )
-  }
-}

package/server/migrations/index.ts

@@ -1,9 +0,0 @@
-const glob = require('glob')
-const path = require('path')
-
-export var migrations = []
-
-glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
-  if (file.indexOf('index.js') !== -1) return
-  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
-})

package/server/pubsub-log-transport.ts

@@ -1,59 +0,0 @@
-import camelCase from 'lodash/camelCase'
-import Transport from 'winston-transport'
-import { pubsub } from './pubsub'
-
-/**
- * PubSubLogTransport is a custom Winston transport that publishes log messages to a GraphQL Pub/Sub topic.
- */
-export class PubSubLogTransport extends Transport {
-  /**
-   * The source object providing the log messages.
-   * @type {object}
-   */
-  source: object
-
-  /**
-   * The Pub/Sub topic to which log messages will be published.
-   * @type {string}
-   */
-  topic: string
-
-  /**
-   * The name of the field resolver for log messages.
-   * @type {string}
-   */
-  resolver: string /* field resolver name */
-
-  /**
-   * Creates an instance of PubSubLogTransport.
-   * @param {object} opts - Options for configuring the transport.
-   * @param {string} opts.topic - The Pub/Sub topic to which log messages will be published.
-   * @param {object} opts.source - The source object providing the log messages.
-   * @param {string} opts.resolver - The name of the field resolver for log messages (default: derived from the topic).
-   */
-  constructor(opts) {
-    super(opts)
-
-    this.topic = opts.topic
-    this.source = opts.source
-    this.resolver = opts.resolver || camelCase(this.topic)
-  }
-
-  /**
-   * Publishes a log message to the configured Pub/Sub topic.
-   * @param {object} info - The log message information.
-   * @param {Function} callback - The callback function to be called after publishing the message.
-   */
-  log(info, callback) {
-    setImmediate(() => {
-      pubsub.publish(this.topic, {
-        [this.resolver]: {
-          source: this.source,
-          ...info
-        }
-      })
-    })
-
-    callback()
-  }
-}

package/server/pubsub.ts

@@ -1,84 +0,0 @@
-/**
- * @module pubsub
- * @description
- * This module provides a Pub/Sub (Publish/Subscribe) mechanism for handling messages and events.
- * Developers can use various middleware options such as Redis, Redis Cluster
- * to implement Pub/Sub functionality.
- */
-
-import { createPubSub } from 'graphql-yoga'
-import { createRedisEventTarget } from '@graphql-yoga/redis-event-target'
-import Redis from 'ioredis'
-
-import { config, logger } from '@things-factory/env'
-import { PubSub } from 'type-graphql'
-
-const { middleware, host, port, nodes, options } = config.get('pubsub', {})
-
-let pubsub: PubSub
-
-switch (middleware) {
-  case 'redis':
-    const redisOption = {
-      host,
-      port,
-      retryStrategy: times => {
-        // reconnect after
-        return Math.min(times * 50, 2000)
-      },
-      ...options
-    }
-    //@ts-ignore
-    pubsub = createPubSub({
-      eventTarget: createRedisEventTarget({
-        publishClient: new Redis(redisOption),
-        subscribeClient: new Redis(redisOption)
-      })
-    })
-    break
-  case 'redisCluster':
-    const cluster = new Redis.Cluster(nodes, options)
-    //@ts-ignore
-    pubsub = createPubSub({
-      eventTarget: createRedisEventTarget({
-        publishClient: cluster,
-        subscribeClient: cluster
-      })
-    })
-    break
-  default:
-    pubsub = createPubSub()
-    break
-}
-
-// kafka pubsub keeps connection and app port with 'ctrl+c' termination.
-const exitHandler = async evt => {
-  //@ts-ignore
-  if (pubsub.close) {
-    try {
-      //@ts-ignore
-      await pubsub.close()
-    } catch (err) {
-      logger.error(err)
-    }
-  }
-}
-
-/*
- * exit events hint from https://stackoverflow.com/a/14032965/14539284
- */
-
-//do something when app is closing
-process.on('exit', exitHandler.bind(null, { name: 'exit', exit: true }))
-
-//catches ctrl+c event
-process.on('SIGINT', exitHandler.bind(null, { name: 'SIGINT', exit: true }))
-
-// catches "kill pid" (for example: nodemon restart)
-process.on('SIGUSR1', exitHandler.bind(null, { name: 'SIGUSR1', exit: true }))
-process.on('SIGUSR2', exitHandler.bind(null, { name: 'SIGUSR2', exit: true }))
-
-//catches uncaught exceptions
-// process.on('uncaughtException', exitHandler.bind(null, { name: 'uncaughtException', exit: true }))
-
-export { pubsub }

package/server/routers/domain-router.ts

@@ -1,13 +0,0 @@
-import Router from 'koa-router'
-
-import { domainMiddleware } from '../middlewares/domain-middleware'
-
-export const domainPublicRouter = new Router()
-domainPublicRouter.use(async (context, next) => {
-  await next()
-}, domainMiddleware)
-
-export const domainPrivateRouter = new Router()
-domainPrivateRouter.use(async (context, next) => {
-  await next()
-}, domainMiddleware)

package/server/routers/global-router.ts

@@ -1,76 +0,0 @@
-import Router from 'koa-router'
-import requestIp from 'request-ip'
-
-import { getLicenseInfo } from '@things-factory/operato-license-checker'
-import { domainMiddleware } from '../middlewares/domain-middleware'
-
-var crawler = require('npm-license-crawler')
-
-export const globalPublicRouter = new Router()
-export const globalPrivateRouter = new Router()
-
-/* even though global private router, catch domain for information */
-globalPrivateRouter.use(domainMiddleware)
-
-if (process.env.NODE_ENV != 'production') {
-  globalPublicRouter.get('/graphql', async (context, next) => {
-    const initialEndpoint = context.request.href
-
-    await context.render('graphql', { initialEndpoint })
-  })
-}
-
-globalPublicRouter.get('/dependencies', async (context, next) => {
-  const { dependencyGraph } = require('@things-factory/env')
-
-  await context.render('dependencies-view-graphviz', { model: dependencyGraph })
-})
-
-globalPublicRouter.get('/license-info', (context, next) => {
-  context.type = 'application/json'
-  context.body = getLicenseInfo()
-})
-
-globalPublicRouter.get('/opensource-licenses', (context, next) => {
-  return new Promise(function (resolve, reject) {
-    var options = {
-      start: ['.'],
-      exclude: [],
-      noColor: true,
-      production: true,
-      unknown: false
-    }
-
-    crawler.dumpLicenses(options, function (error, res) {
-      if (error) {
-        console.error('get:/opensource-licenses', error)
-        reject(error)
-      } else {
-        context.type = 'application/json'
-        context.body = res
-        resolve(res)
-      }
-    })
-  })
-})
-
-globalPublicRouter.get('/request-info', context => {
-  context.body = `
-    Client info. from "requestIp": ${requestIp.getClientIp(context.req)}
-
-    Client info. from "context.ip": ${context.ip}
-    Client info. from "context.protocol": ${context.protocol}
-    Client info. from "context.host": ${context.host}
-
-    Client info. from "x-forwarded-for": ${context.headers['x-forwarded-for']}
-    Client info. from "x-forwarded-proto": ${context.headers['x-forwarded-proto']}
-    Client info. from "x-forwarded-host": ${context.headers['x-forwarded-host']}
-    Client info. from "x-forwarded-port": ${context.headers['x-forwarded-port']}
-  `
-})
-
-/* Paths starting with /public are assumed to use the koa-view renderer. */
-globalPublicRouter.get('/public/(.[^.]*)', async (context, next) => {
-  const { path } = context
-  await context.render(path.substr(1))
-})

package/server/routers/graphql-router.ts

@@ -1,3 +0,0 @@
-import Router from 'koa-router'
-
-export const graphqlRouter = new Router()

package/server/routers/index.ts

@@ -1,3 +0,0 @@
-export * from './global-router'
-export * from './domain-router'
-export * from './graphql-router'

package/server/schema.ts

@@ -1,163 +0,0 @@
-import { GraphQLSchema } from 'graphql'
-import { GraphQLUpload } from 'graphql-upload/GraphQLUpload.js'
-import { buildSchema } from 'type-graphql'
-import { typeDefs as scalarTypeDefs, resolvers as scalarResolvers } from 'graphql-scalars'
-
-import { mergeSchemas } from '@graphql-tools/schema'
-import { loader, orderedModuleNames } from '@things-factory/env'
-import { deepMerge } from '@things-factory/utils'
-import { pubsub } from './pubsub'
-
-const path = require('path')
-
-/**
- * Generates and returns a GraphQL schema by merging schemas and resolvers from various modules.
- * @returns {GraphQLSchema} The merged GraphQL schema.
- */
-export async function schema() {
-  const schemas = orderedModuleNames
-    .map(dep => loader(dep).schema)
-    .filter(schema => schema)
-    .reduce(
-      (sum, schema) => {
-        const { typeDefs, resolvers, resolverClasses, directives } = sum
-        let { typeDefs: sTypeDefs = {}, resolvers: sResolvers = {}, resolverClasses: sResolverClasses = [], directives: sDirectives = {} } = schema
-
-        return {
-          typeDefs: deepMerge(typeDefs, sTypeDefs),
-          resolvers: deepMerge(resolvers, sResolvers),
-          resolverClasses: [...resolverClasses, ...(sResolverClasses || [])],
-          directives: deepMerge(directives, sDirectives)
-        }
-      },
-      {
-        typeDefs: {},
-        resolvers: {},
-        resolverClasses: [],
-        directives: {}
-      }
-    )
-
-  /* for typeDefs */
-  var typeDefs = schemas.typeDefs
-  var { queries = [], mutations = [], subscriptions = [], directives = [], types = [] } = typeDefs
-
-  queries = [...queries, ...(typeDefs.Query || [])]
-  mutations = [...mutations, ...(typeDefs.Mutation || [])]
-  subscriptions = [...subscriptions, ...(typeDefs.Subscription || [])]
-  directives = [...directives, ...(typeDefs.Directive || [])]
-
-  delete typeDefs.Query
-  delete typeDefs.Mutation
-  delete typeDefs.Subscription
-  delete typeDefs.Directive
-
-  delete typeDefs.queries
-  delete typeDefs.mutations
-  delete typeDefs.subscriptions
-  delete typeDefs.directives
-  delete typeDefs.types
-
-  const defs = {
-    query: queries.length > 0 ? ['type Query {', ...queries, '}'].join('\n') : 'type Query {  _ : Boolean  }',
-    mutation: mutations.length > 0 ? ['type Mutation {', ...mutations, '}'].join('\n') : 'type Mutation {  _ : Boolean  }',
-    subscription: subscriptions.length > 0 ? ['type Subscription {', ...subscriptions, '}'].join('\n') : 'type Subscription {  _ : Boolean  }'
-  }
-
-  typeDefs = [
-    ...scalarTypeDefs,
-    `
-    scalar Upload
-  `,
-    defs.query,
-    defs.mutation,
-    defs.subscription,
-    ...directives,
-    ...types,
-    ...Object.values(typeDefs)
-  ].filter(type => !!type)
-
-  /* for resolvers */
-  var { resolvers } = schemas
-  var { queries = [], mutations = [], subscriptions = [], directives = [] } = resolvers
-
-  var queryResolvers =
-    queries.length > 0 &&
-    queries.reduce((sum, query) => {
-      return {
-        ...sum,
-        ...query
-      }
-    }, {})
-
-  var mutationResolvers =
-    mutations.length > 0 &&
-    mutations.reduce((sum, mutation) => {
-      return {
-        ...sum,
-        ...mutation
-      }
-    }, {})
-
-  var subscriptionResolvers =
-    subscriptions.length > 0 &&
-    subscriptions.reduce((sum, subscription) => {
-      return {
-        ...sum,
-        ...subscription
-      }
-    }, {})
-
-  var directiveResolvers = directives.reduce((sum, directive) => {
-    return {
-      ...sum,
-      ...directive
-    }
-  }, {})
-
-  delete resolvers.queries
-  delete resolvers.mutations
-  delete resolvers.subscriptions
-  delete resolvers.directives
-
-  var Query = resolvers.Query || {}
-  var Mutation = resolvers.Mutation || {}
-  var Subscription = resolvers.Subscription || {}
-  var Directive = resolvers.Directive || {}
-
-  delete resolvers.Query
-  delete resolvers.Mutation
-  delete resolvers.Subscription
-  delete resolvers.Directive
-
-  resolvers = {
-    Upload: GraphQLUpload as any,
-    Query: deepMerge(Query, queryResolvers),
-    Mutation: deepMerge(Mutation, mutationResolvers),
-    Subscription: deepMerge(Subscription, subscriptionResolvers),
-    ...scalarResolvers,
-    ...resolvers
-  }
-
-  var merged = mergeSchemas({
-    schemas: [
-      await buildSchema({
-        pubSub: pubsub,
-        resolvers: schemas.resolverClasses,
-        // automatically create `schema.gql` file with schema definition
-        // in project's working directory
-        // or create the file with schema in selected path
-        emitSchemaFile: process.env.NODE_ENV == 'development'
-        // emitSchemaFile: path.resolve(__dirname, 'snapshots/schema', 'schema.gql')
-      })
-    ],
-    typeDefs,
-    resolvers
-  })
-
-  Object.values(schemas.directives).map((directive: (schema: GraphQLSchema) => {}) => {
-    merged = directive(merged) as any
-  })
-
-  return merged
-}