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

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
-}

package/server/server-dev.ts

@@ -1,305 +0,0 @@
-// ts-import-sorter: disable
-
-/* following 7 lines should be located in top of the file */
-const OS = require('os')
-process.env.UV_THREADPOOL_SIZE = OS.cpus().length
-
-console.log('UV_THREADPOOL_SIZE', process.env.UV_THREADPOOL_SIZE)
-
-process.env.NODE_ENV = 'development'
-process.setMaxListeners(0)
-
-import { ApolloServer } from '@apollo/server'
-import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer'
-import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default'
-
-import { koaMiddleware } from '@as-integrations/koa'
-import bytesFormat from 'bytes'
-import graphqlUploadKoa from 'graphql-upload/graphqlUploadKoa.js'
-import { useServer } from 'graphql-ws/lib/use/ws'
-import { createServer } from 'http'
-import Koa from 'koa'
-import koaBodyParser from 'koa-bodyparser'
-import compose from 'koa-compose'
-import { historyApiFallback } from 'koa2-connect-history-api-fallback'
-import { WebSocketServer } from 'ws'
-import co from 'co'
-import http from 'http'
-
-import cors from '@koa/cors'
-
-import crypto from 'crypto'
-
-import { config, loader, logger, orderedModuleNames } from '@things-factory/env'
-import { initLicense, checkValidity } from '@things-factory/operato-license-checker'
-
-import { GraphqlLocalClient } from './graphql-local-client'
-import { databaseInitializer } from './initializers/database'
-import {
-  domainPrivateRouter,
-  domainPublicRouter,
-  globalPrivateRouter,
-  globalPublicRouter,
-  graphqlRouter
-} from './routers'
-import { schema } from './schema'
-import { Domain } from './service'
-import { EntityManager } from 'typeorm'
-import { domainMiddleware } from './middlewares'
-const wdm = require('webpack-dev-middleware')
-
-process.on('uncaughtException', error => {
-  logger.error('uncaughtException: ', error)
-
-  //process.exit(1)
-})
-
-const args = require('args')
-
-args.option('port', 'The port on which the app will be running', config.get('port', 3000))
-args.option(
-  'inspect',
-  `The address on which the inspection will be running. Used in development mode only.
-  This option is just to prevent termination for reasons of not recognizing the 'inspect' option.`,
-  config.get('inspect', ':9229')
-)
-args.option('webpack', 'webpack configuration file', config.get('webpack'))
-
-const flags = args.parse(process.argv)
-
-const webpack = require('webpack')
-const webpackConfig = require(flags.webpack || '@things-factory/builder/webpack.config.dev.js')
-
-const compiler = webpack(webpackConfig)
-
-const PORT = (process.env.PORT = flags.port)
-
-const requestBody = config.get('requestBody') || {}
-
-const bodyParserOption = {
-  formLimit: requestBody.formLimit || '10mb',
-  jsonLimit: requestBody.jsonLimit || '10mb',
-  textLimit: requestBody.textLimit || '10mb'
-}
-
-const fileUpload = config.get('fileUpload') || {}
-const fileUploadOption = {
-  maxFileSize: bytesFormat.parse(fileUpload.maxFileSize) || bytesFormat.parse('10mb'),
-  maxFiles: fileUpload.maxFiles || 10
-}
-
-interface ICustomAppState {
-  domain: Domain
-  user: any
-  tx: EntityManager
-}
-
-interface ICustomAppContext {
-  t: any
-  ssoMiddlewares: any[]
-}
-
-initLicense(config.get('licenseKey'))
-
-/* bootstrap */
-const bootstrap = async () => {
-  await databaseInitializer()
-
-  const app = new Koa<ICustomAppState, ICustomAppContext>() as any
-  app.proxy = true
-
-  app.use(
-    cors({
-      origin: function (ctx) {
-        return ctx.request.headers.origin || '*'
-      },
-      exposeHeaders: ['WWW-Authenticate', 'Server-Authorization'],
-      maxAge: 5,
-      credentials: true,
-      /* allowMethods: ['GET', 'POST', 'DELETE'], -- use default */
-      allowHeaders: ['Content-Type', 'Authorization', 'Accept']
-    })
-  )
-
-  app.use(async (ctx, next) => {
-    ctx.set('X-Content-Type-Options', 'nosniff')
-
-    const { directives = {} } = config.get('CSP') || {}
-
-    const nonce = crypto.randomBytes(16).toString('base64')
-    ctx.state.nonce = nonce
-
-    const cspHeader = Object.entries(directives as { [key: string]: string[] })
-      .map(([key, value]) => `${key} ${value.join(' ')}`)
-      .join('; ')
-
-    ctx.set('Content-Security-Policy', cspHeader)
-
-    await next()
-  })
-
-  var subscriptionMiddleware = []
-  process.emit('bootstrap-module-subscription' as any, app, subscriptionMiddleware)
-
-  const builtSchema = await schema()
-
-  const httpServer = createServer(app.callback())
-  const websocketServer = new WebSocketServer({
-    server: httpServer,
-    path: '/graphql'
-  })
-
-  // Save the returned server's info so we can shut down this server later
-  const serverCleanup = useServer(
-    {
-      schema: builtSchema,
-      context: async (ctx, msg, args) => {
-        return ctx['context']
-      },
-      onConnect: async ctx => {
-        var { extra, connectionParams } = ctx
-        var { request } = extra
-
-        if (((connectionParams['headers'] as any) || connectionParams)?.referer) {
-          var url = new URL(((connectionParams['headers'] as any) || connectionParams).referer)
-          var accessToken = url.searchParams.get('access_token')
-          if (accessToken) {
-            connectionParams['headers']['authorization'] = accessToken
-          }
-        }
-
-        request.headers = {
-          ...request.headers,
-          ...(connectionParams['headers'] || (connectionParams as any))
-        }
-
-        var koacontext = await app.createContext(request, new http.ServerResponse(request))
-        koacontext['state'] = {}
-
-        /* in case connect error(like a authentication error) just throw exception */
-        var middlewares = [domainMiddleware, ...subscriptionMiddleware]
-        const fn = co.wrap(compose(middlewares))
-
-        await fn(koacontext)
-
-        return (ctx['context'] = koacontext)
-      },
-      onDisconnect(ctx, code, reason) {
-        console.log('Disconnected!')
-      },
-      onError(ctx, msg, errors) {
-        console.error(msg, errors)
-      }
-    },
-    websocketServer
-  )
-
-  const server = new ApolloServer({
-    schema: builtSchema,
-    formatError: error => {
-      logger.error(error)
-      return error
-    },
-    introspection: true,
-    csrfPrevention: true,
-    plugins: [
-      // Proper shutdown for the HTTP server.
-      ApolloServerPluginDrainHttpServer({ httpServer }),
-      // Proper shutdown for the WebSocket server.
-      {
-        async serverWillStart() {
-          return {
-            async drainServer() {
-              await serverCleanup.dispose()
-            }
-          }
-        }
-      },
-      // TODO make this landing page work
-      ApolloServerPluginLandingPageLocalDefault({
-        footer: false,
-        embed: true,
-        includeCookies: true
-      })
-    ],
-    cache: 'bounded'
-  })
-
-  await server.start()
-
-  GraphqlLocalClient.init(builtSchema, app)
-
-  orderedModuleNames.forEach(name => {
-    const { initMiddlewares } = loader(name)
-    initMiddlewares && initMiddlewares(app)
-  })
-
-  const render = require('@things-factory/ejs-remote')
-  render(app, {
-    root: '/views',
-    host: `http://127.0.0.1:${PORT}`,
-    layout: false,
-    viewExt: 'html',
-    cache: false,
-    debug: false
-  })
-
-  // only for development mode. triggered after webpack compilation is done.
-  compiler.hooks.done.tap({ name: 'server-dev' }, stats => {
-    process.emit('client-rebuilt' as any, app, compiler.outputFileSystem)
-  })
-
-  app.use(koaBodyParser(bodyParserOption))
-
-  /* routers */
-  const ssoMiddlewares = []
-  process.emit('bootstrap-collect-sso-middleware' as any, null, ssoMiddlewares)
-  app.ssoMiddlewares = ssoMiddlewares
-
-  process.emit('bootstrap-module-global-public-route' as any, app, globalPublicRouter)
-  process.emit('bootstrap-module-global-private-route' as any, app, globalPrivateRouter)
-  process.emit('bootstrap-module-domain-public-route' as any, app, domainPublicRouter)
-  process.emit('bootstrap-module-domain-private-route' as any, app, domainPrivateRouter)
-
-  app.use(checkValidity) /* Check the license after most of the context has been built */
-
-  app
-    .use(globalPublicRouter.routes())
-    .use(globalPublicRouter.allowedMethods())
-    .use(globalPrivateRouter.routes())
-    .use(globalPrivateRouter.allowedMethods())
-    .use(domainPublicRouter.routes())
-    .use(domainPublicRouter.allowedMethods())
-    .use(domainPrivateRouter.routes())
-    .use(domainPrivateRouter.allowedMethods())
-
-  /* Graphql Upload's multipart/form-data handling affects the restful file upload feature, so it should be placed after the routers configuration. */
-  app.use(graphqlUploadKoa(fileUploadOption))
-
-  graphqlRouter.post(
-    '/graphql',
-    koaMiddleware(server, {
-      context: async ({ ctx }) => ctx
-    })
-  )
-  app.use(graphqlRouter.routes())
-  app.use(graphqlRouter.allowedMethods())
-
-  /* should follow this order : history-fallback => webpack-middleware */
-  app.use(historyApiFallback({ whiteList: [] }))
-
-  app.use(
-    wdm.koaWrapper(compiler, {
-      publicPath: webpackConfig.output.publicPath
-    })
-  )
-
-  httpServer.listen({ port: PORT }, () => {
-    logger.info(`🚀 Server ready at http://0.0.0.0:${PORT}/graphql`)
-    logger.info(`🚀 Subscriptions ready at ws://0.0.0.0:${PORT}/graphql`)
-
-    process.emit('bootstrap-module-start' as any, { app, config, builtSchema, httpServer } as any)
-  })
-}
-
-bootstrap()