@things-factory/shell 8.0.0 → 9.0.0-beta.5

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

@@ -1,63 +0,0 @@
-import { ObjectType, InputType, Field, Int } from 'type-graphql'
-import { Domain, IPList } from './domain'
-import { ObjectRef, ScalarObject } from '../common-types'
-
-@InputType()
-export class DomainInput {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-}
-
-@InputType()
-export class DomainPatch {
-  @Field({ nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  timezone?: string
-
-  @Field({ nullable: true })
-  systemFlag?: Boolean
-
-  @Field({ nullable: true })
-  subdomain?: string
-
-  @Field({ nullable: true })
-  owner?: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  parent?: ObjectRef
-
-  @Field({ nullable: true })
-  brandName?: string
-
-  @Field({ nullable: true })
-  brandImage?: string
-
-  @Field({ nullable: true })
-  contentImage?: string
-
-  @Field(type => ScalarObject, { nullable: true })
-  attributes?: any
-
-  @Field({ nullable: true })
-  theme?: string
-}
-
-@ObjectType()
-export class DomainList {
-  @Field(type => [Domain], { nullable: true })
-  items: Domain[]
-
-  @Field(type => Int, { nullable: true })
-  total: number
-}

package/server/service/domain/domain.ts

@@ -1,147 +0,0 @@
-import {
-  Column,
-  CreateDateColumn,
-  ManyToOne,
-  OneToMany,
-  RelationId,
-  Entity,
-  Index,
-  UpdateDateColumn,
-  DeleteDateColumn
-} from 'typeorm'
-import { ObjectType, Directive, Field, ID } from 'type-graphql'
-import { config } from '@things-factory/env'
-import { ScalarObject } from '../common-types'
-
-const numericTypes = ['int', 'int2', 'int4', 'int8', 'integer', 'tinyint', 'smallint', 'mediumint', 'bigint']
-const generatedStrategy = ['uuid', 'rowid', 'increment', 'identity']
-const domainPrimaryOption = config.get('domainPrimaryOption')
-const domainPrimaryType = domainPrimaryOption?.type
-const domainPrimaryStrategy = domainPrimaryOption?.strategy
-
-export type IPList = {
-  whitelist?: string[]
-  blacklist?: string[]
-  protectedlist?: string[]
-  privileges?: {
-    category: string
-    privilege: string
-  }[]
-}
-
-@Entity()
-@Index('ix_domain_0', (domain: Domain) => [domain.subdomain, domain.deletedAt], {
-  unique: true,
-  where: '"deleted_at" IS NULL'
-})
-@ObjectType()
-export class Domain {
-  @Field(type => ID)
-  @Column(
-    domainPrimaryOption
-      ? {
-          type: domainPrimaryType,
-          primary: true,
-          transformer: {
-            //from(value: DatabaseType): EntityType
-            from: value => {
-              return value
-            },
-            //to(value: EntityType): DatabaseType
-            to: value => {
-              if (!value) {
-                value = 0
-              }
-              if (numericTypes.indexOf(domainPrimaryType) >= 0) {
-                return parseInt(value)
-              } else {
-                return value
-              }
-            }
-          },
-          generated: generatedStrategy.indexOf(domainPrimaryStrategy) >= 0 ? domainPrimaryStrategy : false
-        }
-      : {
-          type: 'uuid',
-          primary: true,
-          generated: 'uuid'
-        }
-  )
-  readonly id: string
-
-  @Field()
-  @Column({ unique: true })
-  name: string
-
-  @Field({ nullable: true })
-  @Column({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  @Column({ nullable: true })
-  extType: string
-
-  @Field({ nullable: true })
-  @Column({ nullable: true })
-  timezone: string
-
-  @Directive('@deprecated(reason: "Use `parent`")')
-  @Field({ nullable: true })
-  @Column({ default: false })
-  systemFlag: boolean
-
-  @Field({ nullable: true })
-  @Column({ nullable: true })
-  subdomain: string
-
-  @Field({ nullable: true })
-  @ManyToOne(type => Domain, { nullable: true })
-  parent: Domain
-
-  @RelationId((domain: Domain) => domain.parent)
-  parentId?: string
-
-  @OneToMany(type => Domain, domain => domain.parent)
-  @Field(type => Domain, { nullable: true })
-  children: Domain[]
-
-  @Field({ nullable: true })
-  @Column({ nullable: true })
-  brandName: string
-
-  @Field({ nullable: true })
-  @Column({ nullable: true })
-  brandImage: string
-
-  @Field({ nullable: true })
-  @Column({ nullable: true })
-  contentImage: string
-
-  @Field({ nullable: true })
-  @Column({ nullable: true })
-  owner: string
-
-  @Field({ nullable: true })
-  @Column({ nullable: true })
-  theme: string
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, { nullable: true })
-  iplist?: IPList
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, { nullable: true })
-  attributes?: any
-
-  @Field({ nullable: true })
-  @CreateDateColumn()
-  createdAt: Date
-
-  @Field({ nullable: true })
-  @UpdateDateColumn()
-  updatedAt: Date
-
-  @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
-}

package/server/service/domain/index.ts

@@ -1,6 +0,0 @@
-import { Domain } from './domain'
-import { DomainQuery } from './domain-query'
-import { DomainMutation } from './domain-mutation'
-
-export const entities = [Domain]
-export const resolvers = [DomainQuery, DomainMutation]

package/server/service/index.ts

@@ -1,32 +0,0 @@
-import { transactionDirectiveResolver, transactionDirectiveTypeDefs } from './directive-transaction'
-import { entities as DomainEntities, resolvers as DomainResolvers } from './domain'
-import { entities as AttributeEntities, resolvers as AttributeResolvers } from './attribute-set'
-import { resolvers as SubscriptionDataResolvers } from './subscription-data'
-
-export * from './common-types'
-export * from './domain/domain'
-export * from './domain/domain'
-
-/* EXPORT TYPES */
-export * from './domain/domain-types'
-export * from './subscription-data/data-types'
-
-export const entities = [
-  /* Entities */
-  ...AttributeEntities,
-  ...DomainEntities
-]
-export const schema = {
-  typeDefs: {
-    transactionDirectiveTypeDefs
-  },
-  resolverClasses: [
-    /* Resolvers */
-    ...AttributeResolvers,
-    ...DomainResolvers,
-    ...SubscriptionDataResolvers
-  ],
-  directives: {
-    transaction: transactionDirectiveResolver
-  }
-}

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

@@ -1,37 +0,0 @@
-import { filter, pipe } from 'graphql-yoga'
-import { Arg, Resolver, Root, Subscription } from 'type-graphql'
-
-import { pubsub } from '../../pubsub'
-import { Data } from './data-types'
-
-/* 이 Resolver는 @things-factory/integration-base 에서 Overide 된다. (state-register를 사용하기 위해서) */
-@Resolver()
-export class DataResolver {
-  @Subscription({
-    subscribe: ({ args, context, info }) => {
-      const { domain, user } = context.state
-      const { tag } = args
-      const subdomain = domain?.subdomain
-
-      if (!domain || !tag) {
-        throw new Error('domain and tag required')
-      }
-
-      //@ts-ignore
-      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
-        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
-      }
-
-      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 {
-    return payload.data
-  }
-}

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

@@ -1,16 +0,0 @@
-import { Field, ObjectType } from 'type-graphql'
-
-import { ScalarObject } from '../common-types/scalar-object'
-import { Domain } from '../domain/domain'
-
-@ObjectType()
-export class Data {
-  @Field(type => Domain, { nullable: true, description: 'The domain where the data originated' })
-  domain?: Domain
-
-  @Field({ description: 'Tag name attached to data' })
-  tag: string
-
-  @Field(type => ScalarObject, { nullable: true, description: 'Data delivered by subscription' })
-  data?: Object
-}

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

@@ -1,4 +0,0 @@
-import { DataResolver } from './data-resolver'
-
-export const entities = []
-export const resolvers = [DataResolver]

package/server/typeorm/encrypt-transform.ts

@@ -1,70 +0,0 @@
-import { ValueTransformer } from 'typeorm'
-import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'crypto'
-
-import { dataEncryptionKey } from './get-data-encryption-key'
-
-const ALGORITHM = 'aes-256-cbc'
-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
-  }
-
-  const iv = randomBytes(IV_LENGTH)
-  const cipher = createCipheriv(ALGORITHM, dataEncryptionKey, iv)
-  const encrypted = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()])
-
-  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
-  }
-
-  try {
-    const parts = text.split(':')
-    const iv = Buffer.from(parts.shift(), 'hex')
-    const encryptedText = Buffer.from(parts.join(':'), 'hex')
-    const decipher = createDecipheriv(ALGORITHM, dataEncryptionKey, iv)
-
-    return Buffer.concat([decipher.update(encryptedText), decipher.final()]).toString('utf8')
-  } catch (err) {
-    console.error(`decryption for encrypted field failed in encryptTransformer`)
-    return null
-  }
-}

package/server/typeorm/get-data-encryption-key.ts

@@ -1,13 +0,0 @@
-import { config } from '@things-factory/env'
-
-var _DATA_ENCRYPTION_KEY = config.get('dataEncryptionKey')
-
-if (!_DATA_ENCRYPTION_KEY) {
-  if (process.env.NODE_ENV == 'production') {
-    throw new TypeError('dataEncryptionKey not configured.')
-  } else {
-    _DATA_ENCRYPTION_KEY = 'V6g5oHJZb7KcYzIyL6cM95XvIDouon5b'
-  }
-}
-
-export const dataEncryptionKey = _DATA_ENCRYPTION_KEY

package/server/typeorm/json5-transform.ts

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

@@ -1,20 +0,0 @@
-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 * 10000) / 10000 : undefined),
-
-  /**
-   * 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,145 +0,0 @@
-import _ from 'lodash'
-
-/**
- * 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)
-  const values = value instanceof Array ? value : [value]
-
-  switch (operator) {
-    case 'eq':
-      return {
-        clause: `${alias}.${fieldName} = :args${seq}`,
-        parameters: { [`args${seq}`]: value }
-      }
-
-    case 'like':
-      return {
-        clause: `${alias}.${fieldName} LIKE :args${seq}`,
-        parameters: { [`args${seq}`]: `${value}` }
-      }
-
-    case 'search':
-    case 'i_like':
-      return {
-        clause: `LOWER(${alias}.${fieldName}) LIKE :args${seq}`,
-        parameters: { [`args${seq}`]: `${String(value).toLowerCase()}` }
-      }
-
-    case 'nlike':
-      return {
-        clause: `${alias}.${fieldName} NOT LIKE :args${seq}`,
-        value: { [`args${seq}`]: `${value}` }
-      }
-
-    case 'i_nlike':
-      return {
-        clause: `LOWER(${alias}.${fieldName}) NOT LIKE :args${seq}`,
-        value: { [`args${seq}`]: `${String(value).toLowerCase()}` }
-      }
-
-    case 'lt':
-      return {
-        clause: `${alias}.${fieldName} < :args${seq}`,
-        parameters: { [`args${seq}`]: value }
-      }
-
-    case 'gt':
-      return {
-        clause: `${alias}.${fieldName} > :args${seq}`,
-        parameters: { [`args${seq}`]: value }
-      }
-
-    case 'lte':
-      return {
-        clause: `${alias}.${fieldName} <= :args${seq}`,
-        parameters: { [`args${seq}`]: value }
-      }
-
-    case 'gte':
-      return {
-        clause: `${alias}.${fieldName} >= :args${seq}`,
-        parameters: { [`args${seq}`]: value }
-      }
-
-    case 'noteq':
-      return {
-        clause: `${alias}.${fieldName} != :args${seq}`,
-        parameters: { [`args${seq}`]: value }
-      }
-
-    case 'in':
-      return {
-        clause: relation ? `${fieldName}.id IN (:...args${seq})` : `${alias}.${fieldName} IN (:...args${seq})`,
-        parameters: { [`args${seq}`]: values }
-      }
-
-    case 'notin':
-      return {
-        clause: relation ? `${fieldName}.id NOT IN (:...args${seq})` : `${alias}.${fieldName} NOT IN (:...args${seq})`,
-        parameters: { [`args${seq}`]: values }
-      }
-
-    case 'notin_with_null':
-      return {
-        clause: relation
-          ? `(${fieldName}.id IS NULL OR ${fieldName}.id  NOT IN (:...args${seq})`
-          : `${alias}.${fieldName} IS NULL OR ${alias}.${fieldName} NOT IN (:...args${seq}))`,
-        parameters: { [`args${seq}`]: values }
-      }
-
-    case 'is_null':
-      return {
-        clause: `${alias}.${fieldName} IS NULL`
-      }
-    case 'is_not_null':
-      return {
-        clause: `${alias}.${fieldName} IS NOT NULL`
-      }
-    case 'is_false':
-      return {
-        clause: `${alias}.${fieldName} IS FALSE`
-      }
-    case 'is_true':
-      return {
-        clause: `${alias}.${fieldName} IS TRUE`
-      }
-    case 'is_not_false':
-      return {
-        clause: `${alias}.${fieldName} IS NOT FALSE`
-      }
-    case 'is_not_true':
-      return {
-        clause: `${alias}.${fieldName} IS NOT TRUE`
-      }
-    case 'is_present':
-      return {
-        clause: `${alias}.${fieldName} IS PRESENT`
-      }
-    case 'is_blank':
-      return {
-        clause: `${alias}.${fieldName} IS BLANK`
-      }
-    case 'is_empty_num_id':
-      return {
-        clause: `${alias}.${fieldName} IS EMPTY NUMERIC ID`
-      }
-
-    case 'between':
-      return {
-        clause: `${alias}.${fieldName} BETWEEN  :args${seq}_1 AND :args${seq}_2`,
-        parameters: { [`args${seq}_1`]: values[0], [`args${seq}_2`]: values[1] }
-      }
-  }
-}