@things-factory/shell 7.0.0-alpha.0 → 7.0.0-alpha.18

package/server/initializers/database.ts

@@ -13,26 +13,52 @@ try {
 
 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>): Repository<X> {
   return getDataSource('default').getRepository<X>(target)
 }
 
+/**
+ * Initializes the database connections and data sources.
+ */
 export const databaseInitializer = async () => {
   try {
     const readConnectionConfig = config.get('ormconfig')

package/server/pubsub-log-transport.ts

@@ -2,11 +2,35 @@ 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)
 
@@ -15,6 +39,11 @@ export class PubSubLogTransport extends Transport {
     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, {

package/server/pubsub.ts

@@ -1,17 +1,27 @@
+/**
+ * @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 MQTT, Redis, Redis Cluster, or Kafka
+ * to implement Pub/Sub functionality.
+ */
+
 import { MQTTPubSub } from 'graphql-mqtt-subscriptions'
 import { RedisPubSub } from 'graphql-redis-subscriptions'
-import { PubSub } from 'graphql-subscriptions'
+import { createPubSub } from 'graphql-yoga'
 import Redis from 'ioredis'
 import { connect } from 'mqtt'
 
 import { config, logger } from '@things-factory/env'
+import { PubSub } from 'type-graphql'
 
 const { middleware, host, port, nodes, topic, options } = config.get('pubsub', {})
 
-let pubsub: any
+let pubsub: PubSub
 
 switch (middleware) {
   case 'mqtt':
+    //@ts-ignore
     pubsub = new MQTTPubSub({
       client: connect('mqtt://' + host, {
         reconnectPeriod: 1000,
@@ -29,6 +39,7 @@ switch (middleware) {
       },
       ...options
     }
+    //@ts-ignore
     pubsub = new RedisPubSub({
       publisher: new Redis(redisOption),
       subscriber: new Redis(redisOption)
@@ -36,6 +47,7 @@ switch (middleware) {
     break
   case 'redisCluster':
     const cluster = new Redis.Cluster(nodes, options)
+    //@ts-ignore
     pubsub = new RedisPubSub({
       publisher: cluster,
       subscriber: cluster
@@ -59,14 +71,16 @@ switch (middleware) {
     }
     break
   default:
-    pubsub = new PubSub()
+    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)

package/server/schema.ts

@@ -6,9 +6,14 @@ import { typeDefs as scalarTypeDefs, resolvers as scalarResolvers } from 'graphq
 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)
@@ -16,12 +21,7 @@ export async function schema() {
     .reduce(
       (sum, schema) => {
         const { typeDefs, resolvers, resolverClasses, directives } = sum
-        let {
-          typeDefs: sTypeDefs = {},
-          resolvers: sResolvers = {},
-          resolverClasses: sResolverClasses = [],
-          directives: sDirectives = {}
-        } = schema
+        let { typeDefs: sTypeDefs = {}, resolvers: sResolvers = {}, resolverClasses: sResolverClasses = [], directives: sDirectives = {} } = schema
 
         return {
           typeDefs: deepMerge(typeDefs, sTypeDefs),
@@ -60,12 +60,8 @@ export async function schema() {
 
   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  }'
+    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 = [
@@ -146,6 +142,7 @@ export async function schema() {
   var merged = mergeSchemas({
     schemas: [
       await buildSchema({
+        pubSub: pubsub,
         resolvers: schemas.resolverClasses,
         // automatically create `schema.gql` file with schema definition
         // in project's working directory

package/server/server-dev.ts

@@ -1,6 +1,11 @@
 // ts-import-sorter: disable
 
-/* following 2 lines should be located in top of the file */
+/* 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)
 
@@ -29,13 +34,7 @@ import { initLicense, checkValidity } from '@things-factory/operato-license-chec
 
 import { GraphqlLocalClient } from './graphql-local-client'
 import { databaseInitializer } from './initializers/database'
-import {
-  domainPrivateRouter,
-  domainPublicRouter,
-  globalPrivateRouter,
-  globalPublicRouter,
-  graphqlRouter
-} from './routers'
+import { domainPrivateRouter, domainPublicRouter, globalPrivateRouter, globalPublicRouter, graphqlRouter } from './routers'
 import { schema } from './schema'
 import { Domain } from './service'
 import { EntityManager } from 'typeorm'

package/server/server.ts

@@ -1,6 +1,11 @@
 // ts-import-sorter: disable
 
-/* following 2 lines should be located in top of the file */
+/* 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)
 
@@ -28,13 +33,7 @@ import { initLicense, checkValidity } from '@things-factory/operato-license-chec
 
 import { GraphqlLocalClient } from './graphql-local-client'
 import { databaseInitializer } from './initializers/database'
-import {
-  domainPrivateRouter,
-  domainPublicRouter,
-  globalPrivateRouter,
-  globalPublicRouter,
-  graphqlRouter
-} from './routers'
+import { domainPrivateRouter, domainPublicRouter, globalPrivateRouter, globalPublicRouter, graphqlRouter } from './routers'
 import { schema } from './schema'
 import { domainMiddleware } from './middlewares'
 

package/server/service/subscription-data/data-resolver.ts

@@ -1,4 +1,4 @@
-import { withFilter } from 'graphql-subscriptions'
+import { filter, pipe } from 'graphql-yoga'
 import { Arg, Resolver, Root, Subscription } from 'type-graphql'
 
 import { pubsub } from '../../pubsub'
@@ -7,7 +7,7 @@ import { Data } from './data-types'
 @Resolver()
 export class DataResolver {
   @Subscription({
-    subscribe: (_, args, context, info) => {
+    subscribe: ({ args, context, info }) => {
       const { domain, user } = context.state
       const { tag } = args
       const subdomain = domain?.subdomain
@@ -21,22 +21,13 @@ export class DataResolver {
         throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
       }
 
-      return withFilter(
-        () => pubsub.asyncIterator('data'),
-        (payload, variables, context, info) => {
-          const { domain: pdomain, tag } = payload.data
-
-          if (tag !== variables.tag) {
-            return false
-          }
-
-          if (subdomain !== pdomain?.subdomain) {
-            return false
-          }
-
-          return true
-        }
-      )(_, args, context, info)
+      return pipe(
+        pubsub.subscribe('data'),
+        filter((payload: { data: Data }) => {
+          const { domain: pdomain, tag: ptag, data } = payload.data
+          return tag === ptag && subdomain === pdomain?.subdomain
+        })
+      )
     }
   })
   data(@Root() payload: { data: Data }, @Arg('tag') tag: string): Data {

package/server/typeorm/encrypt-transform.ts

@@ -8,11 +8,32 @@ const KEY_LENGTH = 32
 const SALT_LENGTH = 16
 const IV_LENGTH = 16
 
+/**
+ * ValueTransformer object for encrypting and decrypting database entity field values.
+ * Used in TypeORM entities to encrypt field values before storing them in the database
+ * and decrypt values when retrieving them from the database.
+ */
 export const encryptTransformer: ValueTransformer = {
+  /**
+   * Encrypts the entity field value before storing it in the database.
+   * @param {string} entityValue - Unencrypted entity field value
+   * @returns {string} - Encrypted string
+   */
   to: (entityValue: string) => encrypt(entityValue), // DB에 저장하기 전에 암호화
+
+  /**
+   * Decrypts the encrypted database value when retrieving it from the database.
+   * @param {string} databaseValue - Encrypted database field value
+   * @returns {string} - Decrypted string
+   */
   from: (databaseValue: string) => decrypt(databaseValue) // DB에서 값을 가져올 때 복호화
 }
 
+/**
+ * Encrypts the given text using the AES-256-CBC algorithm.
+ * @param {string} text - Text to encrypt
+ * @returns {string} - Encrypted string
+ */
 function encrypt(text: string): string {
   if (!text) {
     return null
@@ -25,6 +46,11 @@ function encrypt(text: string): string {
   return `${iv.toString('hex')}:${encrypted.toString('hex')}`
 }
 
+/**
+ * Decrypts the given encrypted text.
+ * @param {string} text - Encrypted text to decrypt
+ * @returns {string} - Decrypted string
+ */
 function decrypt(text: string): string {
   if (!text) {
     return null

package/server/typeorm/json5-transform.ts

@@ -0,0 +1,26 @@
+import { ValueTransformer } from 'typeorm'
+import json5 from 'json5'
+
+export const json5Transformer: ValueTransformer = {
+  /**
+   * Converts the entity's value to a JSON5 string before storing it in the database.
+   * @param {any} entityValue - The unencrypted entity field value.
+   * @returns {string} - The stringified JSON5 representation of the entityValue.
+   */
+  to(entityValue: any) {
+    return json5.stringify(entityValue)
+  },
+
+  /**
+   * Converts a JSON5 string from the database back into its original type when retrieving it.
+   * @param {string} databaseValue - The JSON5 string stored in the database.
+   * @returns {any} - The original type of the entityValue, parsed from the JSON5 string.
+   */
+  from(databaseValue: string) {
+    try {
+      return json5.parse(databaseValue)
+    } finally {
+      return databaseValue
+    }
+  }
+}

package/server/typeorm/round-transform.ts

@@ -0,0 +1,20 @@
+import { ValueTransformer } from 'typeorm'
+
+/**
+ * ValueTransformer object for rounding floating point values.
+ */
+export const roundTransformer: ValueTransformer = {
+  /**
+   * Rounds the entity field value before storing it in the database.
+   * @param {number | null} value - Floating point value to round or null
+   * @returns {number | null} - Rounded number or null
+   */
+  to: (value: number | null) => (value !== null && !isNaN(value) ? Math.round(value * 100) / 100 : null),
+
+  /**
+   * Returns the entity field value as it is without any transformation when reading from the database.
+   * @param {number} value - Number value read from the database
+   * @returns {number} - The number value as is
+   */
+  from: (value: number) => value
+}

package/server/utils/condition-builder.ts

@@ -1,13 +1,17 @@
 import _ from 'lodash'
 
-export const buildCondition = function (
-  alias: string,
-  fieldName: string,
-  operator: string,
-  value: any,
-  relation: boolean | string,
-  seq: number
-) {
+/**
+ * Generates and returns a condition clause based on the provided parameters.
+ *
+ * @param alias {string} Alias or table name of the entity.
+ * @param fieldName {string} Field or column name.
+ * @param operator {string} Comparison operator.
+ * @param value {any} Value or an array of values to compare.
+ * @param relation {boolean | string} Indicates if it's a related field or the name of the relation (optional).
+ * @param seq {number} Integer representing the order of condition generation (internal use).
+ * @returns {Object} An object containing the generated condition clause and parameters.
+ */
+export const buildCondition = function (alias: string, fieldName: string, operator: string, value: any, relation: boolean | string, seq: number) {
   seq++
 
   fieldName = _.snakeCase(fieldName)

package/server/utils/get-domain.ts

@@ -11,6 +11,13 @@ const protocol: string = config.get('protocol')
 const fixed = config.get('subdomain')
 const subdomainOffset = config.getNumber('subdomainOffset', 2)
 
+/**
+ * Creates a URL based on the given context and path.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @param path {string} The path to be added to the created URL (optional).
+ * @returns {URL} The generated URL object.
+ */
 export function getUrlFromContext(context, path = '') {
   const { method, href, host, header } = context
   const { referer } = header || {}
@@ -44,12 +51,24 @@ export function getUrlFromContext(context, path = '') {
   return url
 }
 
+/**
+ * Extracts subdomains from the Host header.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {string[]} An array of extracted subdomains.
+ */
 function getSubdomainsFromHost(context: any) {
   const { request } = context
   var subdomains = request.headers.host.split('.').reverse()
   return subdomains.slice(subdomainOffset)
 }
 
+/**
+ * Extracts a subdomain from the path.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {string} The extracted subdomain.
+ */
 function getSubdomainFromPath(context: any) {
   var { path } = context
 
@@ -68,16 +87,34 @@ function getSubdomainFromPath(context: any) {
   }
 }
 
+/**
+ * Extracts a subdomain based on virtual host.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {string} The extracted subdomain.
+ */
 function getSubdomainFromVhost(context: any) {
   const subdomain = (context.subdomains || getSubdomainsFromHost(context)).slice(-1)[0]
 
   return subdomain
 }
 
+/**
+ * Extracts a subdomain from the URL context.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {string} The extracted subdomain.
+ */
 function getSubdomainFromURL(context) {
   return fixed || (useVirtualHostBasedDomain ? getSubdomainFromVhost(context) : getSubdomainFromPath(context))
 }
 
+/**
+ * Asynchronously searches for a domain object based on the URL context.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {Promise<Domain>} A promise that resolves to the domain object.
+ */
 export async function getDomainFromURL(context: any): Promise<Domain> {
   const { header } = context
 
@@ -88,16 +125,36 @@ export async function getDomainFromURL(context: any): Promise<Domain> {
   }
 }
 
+/**
+ * Extracts the cookie domain from the hostname.
+ *
+ * @param hostname {string} The hostname.
+ * @returns {string} The extracted cookie domain.
+ */
 export function getCookieDomainFromHostname(hostname) {
   if (useVirtualHostBasedDomain) {
     return hostname.split('.').slice(-subdomainOffset).join('.')
   }
 }
 
+/**
+ * Generates a context path based on the subdomain.
+ *
+ * @param subdomain {string} The subdomain.
+ * @returns {string} The generated context path.
+ */
 export function getContextPath(subdomain) {
   return fixed || useVirtualHostBasedDomain ? '' : '/domain/' + subdomain
 }
 
+/**
+ * Generates a redirection path considering the subdomain.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @param subdomain {string} The subdomain.
+ * @param redirectTo {string} The path to redirect to (optional).
+ * @returns {string} The generated redirection path.
+ */
 export function getRedirectSubdomainPath(context, subdomain, redirectTo = '/') {
   if (fixed) {
     return redirectTo || '/'
@@ -127,6 +184,13 @@ export function getRedirectSubdomainPath(context, subdomain, redirectTo = '/') {
   return parsed.toString()
 }
 
+/**
+ * Finds a subdomain from the given path.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @param path {string} The path to search in.
+ * @returns {string} The found subdomain.
+ */
 export function findSubdomainFromPath(context, path) {
   if (fixed) {
     return fixed
@@ -143,6 +207,12 @@ export function findSubdomainFromPath(context, path) {
   return match && match[1]
 }
 
+/**
+ * Generates a site root path based on the current environment.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {string} The generated site root path.
+ */
 export function getSiteRootPath(context) {
   if (useVirtualHostBasedDomain) {
     var { protocol, host } = context

package/server/utils/get-query-builder-from-list-params.ts

@@ -5,9 +5,19 @@ import { Filter, ListParam, InheritedValueType } from '../service/common-types/l
 import { Domain } from '../service/domain/domain'
 
 /**
+ * Function to create a TypeORM SelectQueryBuilder for database queries.
  *
- * @param options
- * @returns
+ * @param options - An object containing options for querying and building.
+ * @param options.repository - TypeORM repository used for database operations.
+ * @param options.params - ListParam object for data retrieval and manipulation.
+ * @param [options.domain] - Optional domain object for applying domain-related filters.
+ * @param [options.alias] - Alias to be used in SQL queries (optional).
+ * @param [options.searchables] - List of searchable columns (optional).
+ * @param [options.filtersMap] - Mapping of filter names to their corresponding columns or relation columns (optional).
+ * @param [options.filtersMap.name] - Filter name.
+ * @param [options.filtersMap.columnName] - Name of the column where the filter is applied.
+ * @param [options.filtersMap.relationColumn] - If the filter is applied to a related column, the name of that relation column (optional).
+ * @returns {SelectQueryBuilder<Type>} - The generated SelectQueryBuilder object.
  */
 export function getQueryBuilderFromListParams<Type>(options: {
   repository: Repository<Type>
@@ -29,10 +39,7 @@ export function getQueryBuilderFromListParams<Type>(options: {
         return false
       }
       if (filter.operator.toLowerCase().includes('like') && (!searchables || !searchables.includes(filter.name))) {
-        console.warn(
-          '"searchables" setting is required for like searches with a heavy database query load',
-          filter.name
-        )
+        console.warn('"searchables" setting is required for like searches with a heavy database query load', filter.name)
         return false
       }
       return true
@@ -44,10 +51,7 @@ export function getQueryBuilderFromListParams<Type>(options: {
             return false
           }
           if (!searchables.includes(filter.name)) {
-            console.warn(
-              '"searchables" setting is required for like searches with a heavy database query load',
-              filter.name
-            )
+            console.warn('"searchables" setting is required for like searches with a heavy database query load', filter.name)
             return false
           }
           return true
@@ -107,6 +111,16 @@ export function getQueryBuilderFromListParams<Type>(options: {
   return selectQueryBuilder
 }
 
+/**
+ * Add a condition to a TypeORM SelectQueryBuilder based on the provided filter and mapping options.
+ *
+ * @param {EntityMetadata} metadata - The EntityMetadata for the TypeORM entity.
+ * @param {SelectQueryBuilder<Type>} selectQueryBuilder - The SelectQueryBuilder to add the condition to.
+ * @param {WhereExpressionBuilder} whereExpressionBuilder - The WhereExpressionBuilder to build the condition.
+ * @param {Filter} filter - The filter object containing the filter conditions.
+ * @param {Object} filtersMap - A mapping of filter names to column names and relation column names.
+ * @param {boolean} andCondition - Flag indicating whether to use "AND" or "OR" for combining conditions.
+ */
 function addCondition<T>(
   metadata: EntityMetadata,
   selectQueryBuilder: SelectQueryBuilder<T>,
@@ -172,9 +186,7 @@ function addCondition<T>(
       if (relationIdMeta) {
         columnMeta = relationIdMeta.relation.joinColumns[0]
       } else {
-        columnName
-          ? console.warn(`columnName "${columnName}" in filtersMap for "${name}" is not a column`)
-          : console.warn(`name "${name}" is not a column`)
+        columnName ? console.warn(`columnName "${columnName}" in filtersMap for "${name}" is not a column`) : console.warn(`name "${name}" is not a column`)
       }
     } else {
       var relation = columnMeta.relationMetadata
@@ -322,8 +334,6 @@ function addCondition<T>(
       whereExpressionBuilder.orWhere(clause, parameters)
     }
   } else {
-    andCondition
-      ? whereExpressionBuilder.andWhere(clause, parameters)
-      : whereExpressionBuilder.orWhere(clause, parameters)
+    andCondition ? whereExpressionBuilder.andWhere(clause, parameters) : whereExpressionBuilder.orWhere(clause, parameters)
   }
 }