@things-factory/shell 4.0.0-y.0 → 4.0.5

package/server/server.ts

@@ -1,25 +1,24 @@
 process.env.NODE_ENV = 'production'
 process.setMaxListeners(0)
 
-import Koa from 'koa'
-import ip from 'koa-ip'
-import cors from '@koa/cors'
-import koaStatic from 'koa-static'
-import koaBodyParser from 'koa-bodyparser'
-import { historyApiFallback } from 'koa2-connect-history-api-fallback'
+import { ConnectionContext, SubscriptionServer } from 'subscriptions-transport-ws'
+import { config, loader, logger, orderedModuleNames } from '@things-factory/env'
+import { domainPrivateRouter, domainPublicRouter, globalPrivateRouter, globalPublicRouter } from './routers'
+import { execute, subscribe } from 'graphql'
 
 import { ApolloServer } from 'apollo-server-koa'
-import { graphqlUploadKoa } from 'graphql-upload'
-
+import { GraphqlLocalClient } from './graphql-local-client'
+import Koa from 'koa'
 import co from 'co'
 import compose from 'koa-compose'
-
-import { config, logger, orderedModuleNames, loader } from '@things-factory/env'
-
+import cors from '@koa/cors'
+import { createServer } from 'http'
 import { databaseInitializer } from './initializers/database'
-import { globalPublicRouter, globalPrivateRouter, domainPublicRouter, domainPrivateRouter } from './routers'
-import { GraphqlLocalClient } from './graphql-local-client'
-
+import { graphqlUploadKoa } from 'graphql-upload'
+import { historyApiFallback } from 'koa2-connect-history-api-fallback'
+import ip from 'koa-ip'
+import koaBodyParser from 'koa-bodyparser'
+import koaStatic from 'koa-static'
 import { schema } from './schema'
 
 const args = require('args')
@@ -77,12 +76,15 @@ const bootstrap = async () => {
 
   const builtSchema = await schema()
 
-  const server = new ApolloServer({
-    schema: builtSchema,
-    uploads: false,
-    subscriptions: {
-      path: '/subscriptions',
-      onConnect: async (connectionParams, webSocket, context) => {
+  const httpServer = createServer(app.callback())
+
+  const subscriptionServer = SubscriptionServer.create(
+    {
+      schema: builtSchema,
+      // These are imported from `graphql`.
+      execute,
+      subscribe,
+      async onConnect(connectionParams: Object, webSocket: WebSocket, context: ConnectionContext) {
         var { request } = context
 
         var url = new URL((connectionParams['headers'] || connectionParams).referer)
@@ -106,6 +108,14 @@ const bootstrap = async () => {
         return koacontext
       }
     },
+    {
+      server: httpServer,
+      path: '/subscriptions'
+    }
+  )
+
+  const server = new ApolloServer({
+    schema: builtSchema,
     formatError: error => {
       logger.error(error)
       return error
@@ -115,20 +125,28 @@ const bootstrap = async () => {
       return response
     },
     introspection: true,
-    playground: {
-      settings: {
-        'request.credentials': 'include'
-      }
-    },
     context: async ({ connection, ctx }) => {
       if (connection) {
         return connection.context
       } else {
         return ctx
       }
-    }
+    },
+    plugins: [
+      {
+        async serverWillStart() {
+          return {
+            async drainServer() {
+              subscriptionServer.close()
+            }
+          }
+        }
+      }
+    ]
   })
 
+  await server.start()
+
   GraphqlLocalClient.init(builtSchema, app)
 
   orderedModuleNames.forEach(name => {
@@ -136,7 +154,7 @@ const bootstrap = async () => {
     initMiddlewares && initMiddlewares(app)
   })
 
-  const render = require('koa-ejs-remote')
+  const render = require('@things-factory/ejs-remote')
   render(app, {
     root: '/views',
     host: `http://127.0.0.1:${PORT}`,
@@ -180,14 +198,12 @@ const bootstrap = async () => {
     })
   )
 
-  const httpServer = app.listen({ port: PORT }, () => {
+  httpServer.listen({ port: PORT }, () => {
     logger.info(`🚀 Server ready at http://0.0.0.0:${PORT}${server.graphqlPath}`)
-    logger.info(`🚀 Subscriptions ready at ws://0.0.0.0:${PORT}${server.subscriptionsPath}`)
+    logger.info(`🚀 Subscriptions ready at ws://0.0.0.0:${PORT}${'/subscriptions'}`)
 
     process.emit('bootstrap-module-start' as any, { app, config, builtSchema, httpServer } as any)
   })
-
-  server.installSubscriptionHandlers(httpServer)
 }
 
 bootstrap()

package/server/service/domain/domain-resolver.ts

@@ -1,19 +1,21 @@
-import { Resolver, Query, Mutation, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Arg, Args, Ctx, Directive, Mutation, Query, Resolver } from 'type-graphql'
 import { getRepository, In, Repository } from 'typeorm'
-import { ListParam } from '../common-types/list-param'
+
 import { slugger } from '@things-factory/utils'
-import { Domain } from './domain'
-import { DomainPatch, DomainList } from './domain-types'
+
 import { buildQuery } from '../../utils/list-query-builder'
+import { ListParam } from '../common-types/list-param'
+import { Domain } from './domain'
+import { DomainList, DomainPatch } from './domain-types'
 
 @Resolver(Domain)
 export class DomainResolver {
   @Directive('@privilege(category: "system", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
   @Query(returns => Domain, { description: 'To fetch domain' })
-  async domain(@Arg('name') name: string): Promise<Domain> {
+  async domain(@Arg('id') id: string): Promise<Domain> {
     const repository = getRepository(Domain)
 
-    return await repository.findOne({ name })
+    return await repository.findOne({ id })
   }
 
   @Directive('@privilege(category: "system", privilege: "query", superUserGranted: true)')

package/server/service/index.ts

@@ -1,11 +1,18 @@
+import { transactionDirectiveResolver, transactionDirectiveTypeDefs } from './directive-transaction'
+import {
+  entities as DataEntities,
+  entities as DomainEntities,
+  resolvers as DataResolvers,
+  resolvers as DomainResolvers
+} from './domain'
+import { resolvers as SubscriptionDataResolvers } from './subscription-data'
+
 export * from './common-types'
 export * from './domain/domain'
-export * from './domain/domain-types'
 
-import { entities as DataEntities, resolvers as DataResolvers } from './domain'
-import { entities as DomainEntities, resolvers as DomainResolvers } from './domain'
-import { resolvers as SubscriptionDataResolvers } from './subscription-data'
-import { transactionDirectiveTypeDefs, transactionDirectiveResolver } from './directive-transaction'
+/* EXPORT TYPES */
+export * from './domain/domain-types'
+export * from './subscription-data/data-types'
 
 export const entities = [
   /* Entities */

package/server/utils/condition-builder.ts

@@ -15,68 +15,66 @@ export const buildCondition = function (
   switch (operator) {
     case 'eq':
       return {
-        clause: `"${alias}"."${fieldName}" = :args${seq}`,
+        clause: `${alias}.${fieldName} = :args${seq}`,
         parameters: { [`args${seq}`]: value }
       }
 
     case 'like':
       return {
-        clause: `"${alias}"."${fieldName}" LIKE :args${seq}`,
+        clause: `${alias}.${fieldName} LIKE :args${seq}`,
         parameters: { [`args${seq}`]: `${value}` }
       }
 
     case 'i_like':
       return {
-        clause: `LOWER("${alias}"."${fieldName}") LIKE :args${seq}`,
+        clause: `LOWER(${alias}.${fieldName}) LIKE :args${seq}`,
         parameters: { [`args${seq}`]: `${String(value).toLowerCase()}` }
       }
 
     case 'nlike':
       return {
-        clause: `"${alias}"."${fieldName}" NOT LIKE :args${seq}`,
+        clause: `${alias}.${fieldName} NOT LIKE :args${seq}`,
         value: { [`args${seq}`]: `${value}` }
       }
 
     case 'i_nlike':
       return {
-        clause: `LOWER("${alias}"."${fieldName}") NOT LIKE :args${seq}`,
+        clause: `LOWER(${alias}.${fieldName}) NOT LIKE :args${seq}`,
         value: { [`args${seq}`]: `${String(value).toLowerCase()}` }
       }
 
     case 'lt':
       return {
-        clause: `"${alias}"."${fieldName}" < :args${seq}`,
+        clause: `${alias}.${fieldName} < :args${seq}`,
         parameters: { [`args${seq}`]: value }
       }
 
     case 'gt':
       return {
-        clause: `"${alias}"."${fieldName}" > :args${seq}`,
+        clause: `${alias}.${fieldName} > :args${seq}`,
         parameters: { [`args${seq}`]: value }
       }
 
     case 'lte':
       return {
-        clause: `"${alias}"."${fieldName}" <= :args${seq}`,
+        clause: `${alias}.${fieldName} <= :args${seq}`,
         parameters: { [`args${seq}`]: value }
       }
 
     case 'gte':
       return {
-        clause: `"${alias}"."${fieldName}" >= :args${seq}`,
+        clause: `${alias}.${fieldName} >= :args${seq}`,
         parameters: { [`args${seq}`]: value }
       }
 
     case 'noteq':
       return {
-        clause: `"${alias}"."${fieldName}" != :args${seq}`,
+        clause: `${alias}.${fieldName} != :args${seq}`,
         parameters: { [`args${seq}`]: value }
       }
 
     case 'in':
-      const clause = relation
-        ? `"${fieldName}"."id" IN (:...args${seq})`
-        : `"${alias}"."${fieldName}" IN (:...args${seq})`
+      const clause = relation ? `${fieldName}.id IN (:...args${seq})` : `${alias}.${fieldName} IN (:...args${seq})`
       value = value?.length ? value : [value]
       return {
         clause,
@@ -85,57 +83,57 @@ export const buildCondition = function (
     case 'notin':
       value = value?.length ? value : [value]
       return {
-        clause: `"${alias}"."${fieldName}" NOT IN (:...args${seq})`,
+        clause: `${alias}.${fieldName} NOT IN (:...args${seq})`,
         parameters: { [`args${seq}`]: value }
       }
 
     case 'notin_with_null':
       value = value?.length ? value : [value]
       return {
-        clause: `("${alias}"."${fieldName}" IS NULL OR "${alias}"."${fieldName}" NOT IN (:...args${seq}))`,
+        clause: `(${alias}.${fieldName} IS NULL OR ${alias}.${fieldName} NOT IN (:...args${seq}))`,
         parameters: { [`args${seq}`]: value }
       }
 
     case 'is_null':
       return {
-        clause: `"${alias}"."${fieldName}" IS NULL`
+        clause: `${alias}.${fieldName} IS NULL`
       }
     case 'is_not_null':
       return {
-        clause: `"${alias}"."${fieldName}" IS NOT NULL`
+        clause: `${alias}.${fieldName} IS NOT NULL`
       }
     case 'is_false':
       return {
-        clause: `"${alias}"."${fieldName}" IS FALSE`
+        clause: `${alias}.${fieldName} IS FALSE`
       }
     case 'is_true':
       return {
-        clause: `"${alias}"."${fieldName}" IS TRUE`
+        clause: `${alias}.${fieldName} IS TRUE`
       }
     case 'is_not_false':
       return {
-        clause: `"${alias}"."${fieldName}" IS NOT FALSE`
+        clause: `${alias}.${fieldName} IS NOT FALSE`
       }
     case 'is_not_true':
       return {
-        clause: `"${alias}"."${fieldName}" IS NOT TRUE`
+        clause: `${alias}.${fieldName} IS NOT TRUE`
       }
     case 'is_present':
       return {
-        clause: `"${alias}"."${fieldName}" IS PRESENT`
+        clause: `${alias}.${fieldName} IS PRESENT`
       }
     case 'is_blank':
       return {
-        clause: `"${alias}"."${fieldName}" IS BLANK`
+        clause: `${alias}.${fieldName} IS BLANK`
       }
     case 'is_empty_num_id':
       return {
-        clause: `"${alias}"."${fieldName}" IS EMPTY NUMERIC ID`
+        clause: `${alias}.${fieldName} IS EMPTY NUMERIC ID`
       }
 
     case 'between':
       return {
-        clause: `"${alias}"."${fieldName}" BETWEEN  :args${seq}_1 AND :args${seq}_2`,
+        clause: `${alias}.${fieldName} BETWEEN  :args${seq}_1 AND :args${seq}_2`,
         parameters: { [`args${seq}_1`]: value[0], [`args${seq}_2`]: value[1] }
       }
   }

package/server/utils/list-query-builder.ts

@@ -23,7 +23,7 @@ export const buildQuery = function (queryBuilder: any, params: any, context: any
   }
 
   if (domainRef) {
-    queryBuilder.andWhere(`"${queryBuilder.alias}"."domain_id" = :domainId`, { domainId })
+    queryBuilder.andWhere(`${queryBuilder.alias}.domain = :domainId`, { domainId })
   }
 
   if (pagination && pagination.page > 0 && pagination.limit > 0) {