@things-factory/shell 8.0.0-beta.9 → 8.0.0

package/dist-server/typeorm/json5-transform.js

@@ -10,7 +10,7 @@ exports.json5Transformer = {
      * @returns {string} - The stringified JSON5 representation of the entityValue.
      */
     to(entityValue) {
-        return entityValue === null || entityValue === undefined ? null : json5_1.default.stringify(entityValue);
+        return json5_1.default.stringify(entityValue);
     },
     /**
      * Converts a JSON5 string from the database back into its original type when retrieving it.
@@ -19,7 +19,7 @@ exports.json5Transformer = {
      */
     from(databaseValue) {
         try {
-            return databaseValue === null ? null : json5_1.default.parse(databaseValue);
+            return json5_1.default.parse(databaseValue);
         }
         finally {
             return databaseValue;

package/dist-server/typeorm/json5-transform.js.map

@@ -1 +1 @@
-{"version":3,"file":"json5-transform.js","sourceRoot":"","sources":["../../server/typeorm/json5-transform.ts"],"names":[],"mappings":";;;;AACA,0DAAyB;AAEZ,QAAA,gBAAgB,GAAqB;IAChD;;;;OAIG;IACH,EAAE,CAAC,WAAgB;QACjB,OAAO,WAAW,KAAK,IAAI,IAAI,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,eAAK,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA;IAChG,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAC,aAAqB;QACxB,IAAI,CAAC;YACH,OAAO,aAAa,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,eAAK,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;QACnE,CAAC;gBAAS,CAAC;YACT,OAAO,aAAa,CAAA;QACtB,CAAC;IACH,CAAC;CACF,CAAA","sourcesContent":["import { ValueTransformer } from 'typeorm'\nimport json5 from 'json5'\n\nexport const json5Transformer: ValueTransformer = {\n  /**\n   * Converts the entity's value to a JSON5 string before storing it in the database.\n   * @param {any} entityValue - The unencrypted entity field value.\n   * @returns {string} - The stringified JSON5 representation of the entityValue.\n   */\n  to(entityValue: any) {\n    return entityValue === null || entityValue === undefined ? null : json5.stringify(entityValue)\n  },\n\n  /**\n   * Converts a JSON5 string from the database back into its original type when retrieving it.\n   * @param {string} databaseValue - The JSON5 string stored in the database.\n   * @returns {any} - The original type of the entityValue, parsed from the JSON5 string.\n   */\n  from(databaseValue: string) {\n    try {\n      return databaseValue === null ? null : json5.parse(databaseValue)\n    } finally {\n      return databaseValue\n    }\n  }\n}\n"]}
+{"version":3,"file":"json5-transform.js","sourceRoot":"","sources":["../../server/typeorm/json5-transform.ts"],"names":[],"mappings":";;;;AACA,0DAAyB;AAEZ,QAAA,gBAAgB,GAAqB;IAChD;;;;OAIG;IACH,EAAE,CAAC,WAAgB;QACjB,OAAO,eAAK,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA;IACrC,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAC,aAAqB;QACxB,IAAI,CAAC;YACH,OAAO,eAAK,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;QACnC,CAAC;gBAAS,CAAC;YACT,OAAO,aAAa,CAAA;QACtB,CAAC;IACH,CAAC;CACF,CAAA","sourcesContent":["import { ValueTransformer } from 'typeorm'\nimport json5 from 'json5'\n\nexport const json5Transformer: ValueTransformer = {\n  /**\n   * Converts the entity's value to a JSON5 string before storing it in the database.\n   * @param {any} entityValue - The unencrypted entity field value.\n   * @returns {string} - The stringified JSON5 representation of the entityValue.\n   */\n  to(entityValue: any) {\n    return json5.stringify(entityValue)\n  },\n\n  /**\n   * Converts a JSON5 string from the database back into its original type when retrieving it.\n   * @param {string} databaseValue - The JSON5 string stored in the database.\n   * @returns {any} - The original type of the entityValue, parsed from the JSON5 string.\n   */\n  from(databaseValue: string) {\n    try {\n      return json5.parse(databaseValue)\n    } finally {\n      return databaseValue\n    }\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/shell",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.0",
   "description": "Core module for framework",
   "bin": {
     "things-factory": "bin/things-factory",
@@ -43,7 +43,7 @@
     "@graphql-tools/schema": "^8.5.0",
     "@graphql-tools/utils": "^10.1.2",
     "@graphql-yoga/redis-event-target": "^3.0.1",
-    "@hatiolab/things-scene": "^8.0.0-beta",
+    "@hatiolab/things-scene": "^3.2.0",
     "@koa/cors": "^5.0.0",
     "@material-design-icons/font": "^0.14.9",
     "@material/mwc-button": "^0.27.0",
@@ -53,19 +53,19 @@
     "@material/mwc-textfield": "^0.27.0",
     "@material/web": "^2.0.0",
     "@open-wc/scoped-elements": "^2.1.3",
-    "@operato/board": "^8.0.0-beta",
-    "@operato/graphql": "^8.0.0-beta",
-    "@operato/help": "^8.0.0-beta",
-    "@operato/layout": "^8.0.0-beta",
-    "@operato/shell": "^8.0.0-beta",
-    "@operato/typeorm-history": "^8.0.0-beta",
-    "@operato/utils": "^8.0.0-beta",
+    "@operato/board": "^8.0.0",
+    "@operato/graphql": "^8.0.0",
+    "@operato/help": "^8.0.0",
+    "@operato/layout": "^8.0.0",
+    "@operato/shell": "^8.0.0",
+    "@operato/typeorm-history": "^8.0.0",
+    "@operato/utils": "^8.0.0",
     "@reduxjs/toolkit": "^2.2.5",
-    "@things-factory/ejs-remote": "^8.0.0-beta.4",
-    "@things-factory/env": "^8.0.0-beta.4",
+    "@things-factory/ejs-remote": "^8.0.0",
+    "@things-factory/env": "^8.0.0",
     "@things-factory/operato-license-checker": "^4.0.4",
-    "@things-factory/styles": "^8.0.0-beta.4",
-    "@things-factory/utils": "^8.0.0-beta.4",
+    "@things-factory/styles": "^8.0.0",
+    "@things-factory/utils": "^8.0.0",
     "@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": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/graphql-local-client.ts

@@ -0,0 +1,59 @@
+/**
+ * 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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,84 @@
+/**
+ * @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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,76 @@
+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

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

package/server/routers/index.ts

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