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

package/server/server.ts

@@ -1,296 +0,0 @@
-// ts-import-sorter: disable
-
-/* following 5 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 = 'production'
-process.setMaxListeners(0)
-
-import { ApolloServer } from '@apollo/server'
-import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer'
-import { ApolloServerPluginLandingPageProductionDefault } 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 koaStatic from 'koa-static'
-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 { domainMiddleware } from './middlewares'
-
-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))
-
-const flags = args.parse(process.argv)
-
-const path = require('path')
-
-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
-}
-
-initLicense(config.get('licenseKey'))
-
-/* bootstrap */
-const bootstrap = async () => {
-  await databaseInitializer()
-
-  const app = new Koa() 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
-      ApolloServerPluginLandingPageProductionDefault({
-        graphRef: 'my-graph-id@my-graph-variant',
-        footer: false
-      })
-    ],
-    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: true,
-    debug: false
-  })
-
-  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 => koaStatic */
-  app.use(historyApiFallback({ whiteList: [] }))
-
-  app.use(
-    koaStatic(path.join(process.cwd(), 'dist-app'), {
-      index: 'index.html'
-    })
-  )
-
-  // Set keep-alive timeout from configuration or fallback to default (65000ms).
-  // The keepAliveTimeout determines how long the server will keep an idle connection
-  // alive before closing it.
-  const keepAliveTimeout = config.get('keepAliveTimeout', 65000)
-
-  // Apply the configured keep-alive timeout to the server. If no configuration is
-  // provided, default to 65000ms (65 seconds). In the context of an external load balancer,
-  // this timeout is critical for maintaining persistent connections between the load
-  // balancer and the server. Setting a sufficiently long keepAliveTimeout minimizes
-  // the need to constantly re-establish TCP connections, improving efficiency and
-  // reducing connection overhead.
-  httpServer.keepAliveTimeout = keepAliveTimeout || 65000
-
-  // Set headersTimeout to be 1000ms (1 second) longer than keepAliveTimeout.
-  // This ensures the server has sufficient time to receive headers from the client
-  // before closing the connection, preventing premature disconnections. In the context
-  // of a load balancer, this ensures that if the load balancer is sending headers
-  // slowly (due to network delays or other factors), the connection isn't closed
-  // before the headers are fully transmitted.
-  httpServer.headersTimeout = keepAliveTimeout + 1000
-
-  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()

package/server/service/attribute-set/attribute-set-item-type.ts

@@ -1,65 +0,0 @@
-import { Field, InputType, Int, ObjectType, registerEnumType } from 'type-graphql'
-import { ScalarObject } from '../common-types'
-
-export enum AttributeSetItemType {
-  number = 'number',
-  text = 'text',
-  boolean = 'boolean',
-  select = 'select',
-  date = 'date',
-  datetime = 'datetime',
-  file = 'file'
-}
-
-registerEnumType(AttributeSetItemType, {
-  name: 'AttributeSetItemType',
-  description: 'type enumeration of a attribute-set-item'
-})
-
-@ObjectType({ description: 'Entity for AttributeSetItem' })
-export class AttributeSetItem {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  tag?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  hidden?: boolean
-
-  @Field({ nullable: true })
-  type?: AttributeSetItemType
-
-  @Field(type => ScalarObject, { nullable: true })
-  options?: { [option: string]: any }
-}
-
-@InputType()
-export class AttributeSetItemPatch {
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  tag?: string
-
-  @Field(type => AttributeSetItemType, { nullable: true })
-  type?: AttributeSetItemType
-
-  @Field(type => ScalarObject, { nullable: true })
-  options?: { [option: string]: any }
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  hidden?: boolean
-}

package/server/service/attribute-set/attribute-set-mutation.ts

@@ -1,125 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { AttributeSet } from './attribute-set'
-import { NewAttributeSet, AttributeSetPatch } from './attribute-set-type'
-
-@Resolver(AttributeSet)
-export class AttributeSetMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(superUserGranted: true)')
-  @Mutation(returns => AttributeSet, { description: 'To create new AttributeSet' })
-  async createAttributeSet(@Arg('attribute') attribute: NewAttributeSet, @Ctx() context: any): Promise<AttributeSet> {
-    const { tx } = context.state
-
-    return await tx.getRepository(AttributeSet).save({
-      ...attribute
-    })
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(superUserGranted: true)')
-  @Mutation(returns => AttributeSet, { description: 'To modify AttributeSet information' })
-  async updateAttributeSet(
-    @Arg('id') id: string,
-    @Arg('patch') patch: AttributeSetPatch,
-    @Ctx() context: any
-  ): Promise<AttributeSet> {
-    const { tx } = context.state
-
-    const repository = tx.getRepository(AttributeSet)
-    const attribute = await repository.findOne({
-      where: { id }
-    })
-
-    return await repository.save({
-      ...attribute,
-      ...patch
-    })
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(superUserGranted: true)')
-  @Mutation(returns => [AttributeSet], { description: "To modify multiple AttributeSets' information" })
-  async updateMultipleAttributeSet(
-    @Arg('patches', type => [AttributeSetPatch]) patches: AttributeSetPatch[],
-    @Ctx() context: any
-  ): Promise<AttributeSet[]> {
-    const { tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const attributeRepo = tx.getRepository(AttributeSet)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await attributeRepo.save({
-          ...newRecord
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const attribute = await attributeRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await attributeRepo.save({
-          ...attribute,
-          ...updateRecord
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete AttributeSet' })
-  async deleteAttributeSet(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
-    const { tx } = context.state
-
-    await tx.getRepository(AttributeSet).delete({ id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete multiple AttributeSets' })
-  async deleteAttributeSets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
-    const { tx } = context.state
-
-    await tx.getRepository(AttributeSet).delete({
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To import multiple AttributeSets' })
-  async importAttributeSets(
-    @Arg('attributes', type => [AttributeSetPatch]) attributes: AttributeSetPatch[],
-    @Ctx() context: any
-  ): Promise<boolean> {
-    const { tx } = context.state
-
-    await Promise.all(
-      attributes.map(async (attribute: AttributeSetPatch) => {
-        await tx.getRepository(AttributeSet).save(attribute)
-      })
-    )
-
-    return true
-  }
-}

package/server/service/attribute-set/attribute-set-query.ts

@@ -1,36 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { AttributeSet } from './attribute-set'
-import { AttributeSetList } from './attribute-set-type'
-import { ListParam } from '../common-types'
-import { getRepository } from '../../initializers/database'
-import { getQueryBuilderFromListParams } from '../../utils'
-
-@Resolver(AttributeSet)
-export class AttributeSetQuery {
-  @Query(returns => AttributeSet!, { nullable: true, description: 'To fetch a AttributeSet' })
-  async attributeSet(@Arg('id') id: string, @Ctx() context: any): Promise<AttributeSet> {
-    return await getRepository(AttributeSet).findOne({
-      where: { id }
-    })
-  }
-
-  @Query(returns => AttributeSet!, { nullable: true, description: 'To fetch a AttributeSet by Entity name' })
-  async attributeSetByEntity(@Arg('entity') entity: string, @Ctx() context: any): Promise<AttributeSet> {
-    return await getRepository(AttributeSet).findOne({
-      where: { entity }
-    })
-  }
-
-  @Query(returns => AttributeSetList, { description: 'To fetch multiple AttributeSets' })
-  async attributeSets(@Args(type => ListParam) params: ListParam, @Ctx() context: any): Promise<AttributeSetList> {
-    const queryBuilder = getQueryBuilderFromListParams({
-      params,
-      repository: await getRepository(AttributeSet),
-      searchables: ['entity', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-}

package/server/service/attribute-set/attribute-set-type.ts

@@ -1,46 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-
-import { AttributeSet } from './attribute-set'
-import { AttributeSetItemPatch } from './attribute-set-item-type'
-
-@InputType()
-export class NewAttributeSet {
-  @Field()
-  entity: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => [AttributeSetItemPatch], { nullable: true })
-  items?: AttributeSetItemPatch[]
-
-  @Field({ nullable: true })
-  active?: boolean
-}
-
-@InputType()
-export class AttributeSetPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  entity?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => [AttributeSetItemPatch], { nullable: true })
-  items?: AttributeSetItemPatch[]
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class AttributeSetList {
-  @Field(type => [AttributeSet])
-  items: AttributeSet[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/attribute-set/attribute-set.ts

@@ -1,35 +0,0 @@
-import { CreateDateColumn, UpdateDateColumn, Entity, Index, Column, PrimaryGeneratedColumn } from 'typeorm'
-import { ObjectType, Field, ID } from 'type-graphql'
-
-import { AttributeSetItem } from './attribute-set-item-type'
-
-@Entity()
-@Index('ix_attribute_set_0', (attributeSet: AttributeSet) => [attributeSet.entity], {
-  unique: true
-})
-@ObjectType({ description: 'Entity for AttributeSet' })
-export class AttributeSet {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @Column({ nullable: true, default: '' })
-  @Field({ nullable: true })
-  entity: string = ''
-
-  @Column({ nullable: true, default: '' })
-  @Field({ nullable: true })
-  description: string = ''
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [AttributeSetItem], { nullable: true })
-  items: AttributeSetItem[]
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-}

package/server/service/attribute-set/index.ts

@@ -1,6 +0,0 @@
-import { AttributeSet } from './attribute-set'
-import { AttributeSetQuery } from './attribute-set-query'
-import { AttributeSetMutation } from './attribute-set-mutation'
-
-export const entities = [AttributeSet]
-export const resolvers = [AttributeSetQuery, AttributeSetMutation]

package/server/service/common-types/index.ts

@@ -1,6 +0,0 @@
-export * from './list-param'
-export * from './scalar-any'
-export * from './scalar-date'
-export * from './scalar-object'
-export * from './object-ref'
-export * from './log'

package/server/service/common-types/list-param.ts

@@ -1,61 +0,0 @@
-import { ArgsType, Field, InputType, Int, registerEnumType } from 'type-graphql'
-
-import { ScalarAny } from './scalar-any'
-
-export enum InheritedValueType {
-  None = 'None',
-  Only = 'Only',
-  Include = 'Include'
-}
-
-registerEnumType(InheritedValueType, {
-  name: 'InheritedValueType'
-})
-
-@InputType()
-export class Sorting {
-  @Field({ description: 'Field name to sort by' })
-  name: string
-
-  @Field({ nullable: true, description: 'Set to true if descending sort. Default is "false"' })
-  desc?: boolean
-}
-
-@InputType()
-export class Pagination {
-  @Field(type => Int, { nullable: true })
-  page?: number
-
-  @Field(type => Int, { nullable: true })
-  limit?: number
-}
-
-@InputType()
-export class Filter {
-  @Field()
-  name: string
-
-  @Field()
-  operator: string
-
-  @Field(type => ScalarAny, { nullable: true })
-  value?: any
-
-  @Field({ nullable: true })
-  relation?: boolean
-}
-
-@ArgsType()
-export class ListParam {
-  @Field(type => [Filter], { nullable: true })
-  filters?: Filter[]
-
-  @Field(type => Pagination, { nullable: true })
-  pagination?: Pagination
-
-  @Field(type => [Sorting], { nullable: true })
-  sortings?: Sorting[]
-
-  @Field(type => InheritedValueType, { nullable: true })
-  inherited?: InheritedValueType
-}

package/server/service/common-types/log.ts

@@ -1,17 +0,0 @@
-import { ObjectType, Field } from 'type-graphql'
-import { ScalarObject } from './scalar-object'
-
-@ObjectType()
-export class Log {
-  @Field(() => ScalarObject, { description: 'the source of the log' })
-  source: object
-
-  @Field({ description: 'log level (error, warning, info, ..)' })
-  level: string
-
-  @Field({ description: 'log body message' })
-  message: string
-
-  @Field({ description: 'timestamp the log occurred' })
-  timestamp: string
-}