@things-factory/shell 8.0.0-beta.1 → 8.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/shell",
-  "version": "8.0.0-beta.1",
+  "version": "8.0.0-beta.2",
   "description": "Core module for framework",
   "bin": {
     "things-factory": "bin/things-factory",
@@ -61,11 +61,11 @@
     "@operato/typeorm-history": "^8.0.0-beta",
     "@operato/utils": "^8.0.0-beta",
     "@reduxjs/toolkit": "^2.2.5",
-    "@things-factory/ejs-remote": "^8.0.0-beta.1",
-    "@things-factory/env": "^8.0.0-beta.1",
+    "@things-factory/ejs-remote": "^8.0.0-beta.2",
+    "@things-factory/env": "^8.0.0-beta.2",
     "@things-factory/operato-license-checker": "^4.0.4",
-    "@things-factory/styles": "^8.0.0-beta.1",
-    "@things-factory/utils": "^8.0.0-beta.1",
+    "@things-factory/styles": "^8.0.0-beta.2",
+    "@things-factory/utils": "^8.0.0-beta.2",
     "@webcomponents/scoped-custom-element-registry": "^0.0.9",
     "@webcomponents/webcomponentsjs": "^2.6.0",
     "args": "^5.0.0",
@@ -133,5 +133,5 @@
     "pg": "^8.7.3",
     "sqlite3": "^5.0.8"
   },
-  "gitHead": "36c494e587640c1490318ef7b95adab02606e0c2"
+  "gitHead": "f03431a09435511b2595515658f9cb8f78ba4ebb"
 }

package/server/graphql-local-client.ts

@@ -1,59 +0,0 @@
-/**
- * Apollo Client configuration for a local GraphQL schema.
- * This class provides a static method `init` to initialize the client with a schema and an app context.
- */
-import { ApolloClient, InMemoryCache, NormalizedCacheObject } from '@apollo/client'
-import { SchemaLink } from '@apollo/client/link/schema'
-
-const defaultOptions: any = {
-  watchQuery: {
-    fetchPolicy: 'no-cache',
-    errorPolicy: 'ignore'
-  },
-  query: {
-    fetchPolicy: 'no-cache',
-    errorPolicy: 'all'
-  },
-  mutate: {
-    errorPolicy: 'all'
-  }
-}
-
-/**
- * GraphqlLocalClient is a utility class for initializing an Apollo Client for a local GraphQL schema.
- * It provides a static `init` method for setting up the client with a schema and an app context.
- */
-export class GraphqlLocalClient {
-  /**
-   * Apollo Client instance for local GraphQL schema.
-   * @static
-   * @type {ApolloClient<NormalizedCacheObject>}
-   */
-  static client: ApolloClient<NormalizedCacheObject>
-
-  /**
-   * Initializes the Apollo Client for a local GraphQL schema.
-   * @static
-   * @param {object} schema - The GraphQL schema to use.
-   * @param {object} app - The application context to be passed in as part of the execution context.
-   */
-  static init(schema, app) {
-    const cache = new InMemoryCache({
-      addTypename: false
-    })
-
-    GraphqlLocalClient.client = new ApolloClient({
-      defaultOptions,
-      cache,
-      link: new SchemaLink({
-        schema,
-        context: (obj, args, context, info) => {
-          return {
-            ...obj.getContext(),
-            app
-          }
-        }
-      })
-    })
-  }
-}

package/server/index.ts

@@ -1,13 +0,0 @@
-export * from './migrations'
-export * from './initializers/naming-strategy'
-export * from './initializers/database'
-export * from './utils'
-export * from './pubsub'
-export * from './pubsub-log-transport'
-export * from './middlewares'
-export * from './graphql-local-client'
-export * from './service'
-
-export * from './typeorm/encrypt-transform'
-export * from './typeorm/json5-transform'
-export * from './typeorm/round-transform'

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 domainType should be checked only when signin and checkin.
-     * For purposes such as API calls, the target domainType may be different from the system domainType.
-     * So, we don't check domainType 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'