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

package/server/service/common-types/object-ref.ts

@@ -0,0 +1,13 @@
+import { InputType, Field, ID } from 'type-graphql'
+
+@InputType()
+export class ObjectRef {
+  @Field(() => ID, { description: 'Field id' })
+  id: string
+
+  @Field({ nullable: true, description: 'Field name' })
+  name?: string
+
+  @Field({ nullable: true, description: 'Field description' })
+  description?: string
+}

package/server/service/common-types/scalar-any.ts

@@ -0,0 +1,44 @@
+import { GraphQLScalarType, Kind } from 'graphql'
+
+function parseObject(ast) {
+  const value = Object.create(null)
+  ast.fields.forEach(field => {
+    value[field.name.value] = parseAst(field.value)
+  })
+  return value
+}
+
+function parseAst(ast) {
+  switch (ast.kind) {
+    case Kind.INT:
+      return parseInt(ast.value)
+    case Kind.FLOAT:
+      return parseFloat(ast.value)
+    case Kind.BOOLEAN:
+      return ast.value
+    case Kind.STRING:
+      return ast.value
+    case Kind.LIST:
+      return ast.values.map(parseAst)
+    case Kind.OBJECT:
+      return parseObject(ast)
+    default:
+      return null
+  }
+}
+
+export const ScalarAny = new GraphQLScalarType({
+  name: 'Any',
+  description: 'Any Scalar type (String, Boolean, Int, Float, Object, List)',
+  serialize(value) {
+    // Implement your own behavior here by setting the 'result' variable
+    return value
+  },
+  parseValue(value) {
+    // Implement your own behavior here by setting the 'result' variable
+    return value
+  },
+  parseLiteral(ast) {
+    return parseAst(ast)
+  }
+})

package/server/service/common-types/scalar-date.ts

@@ -0,0 +1,22 @@
+import { GraphQLScalarType, Kind } from 'graphql'
+
+export const ScalarDate = new GraphQLScalarType({
+  name: 'Date',
+  description: 'Date custom scalar type',
+  parseValue(value) {
+    return new Date(value as string | number) // value from the client
+  },
+  serialize(value) {
+    /**
+     * Note: Allow value to be date only like "2021-01-31" to be serialize before passing data to clientside for TypeGraphql.
+     * Usage: When database column datatype is "date" and data do not contain any time component.
+     */
+    return new Date(value as any).getTime() // value sent to the client
+  },
+  parseLiteral(ast) {
+    if (ast.kind === Kind.INT) {
+      return new Date(+ast.value) // ast value is always in string format
+    }
+    return null
+  }
+})

package/server/service/common-types/scalar-object.ts

@@ -0,0 +1,15 @@
+const { GraphQLScalarType } = require('graphql')
+
+export const ScalarObject = new GraphQLScalarType({
+  name: 'Object',
+  description: 'Can be anything',
+  parseValue(value) {
+    return value
+  },
+  serialize(value) {
+    return value
+  },
+  parseLiteral(ast) {
+    return ast
+  }
+})

package/server/service/directive-transaction/index.ts

@@ -0,0 +1 @@
+export * from './transaction'

package/server/service/directive-transaction/transaction.ts

@@ -0,0 +1,40 @@
+import { defaultFieldResolver, GraphQLSchema } from 'graphql'
+import gql from 'graphql-tag'
+
+import { getDirective, MapperKind, mapSchema } from '@graphql-tools/utils'
+
+import { getDataSource } from '../../initializers/database'
+
+const DIRECTIVE = 'transaction'
+
+export const transactionDirectiveTypeDefs = gql`
+    directive @${DIRECTIVE} on FIELD_DEFINITION
+  `
+export const transactionDirectiveResolver = (schema: GraphQLSchema) =>
+  mapSchema(schema, {
+    [MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName) => {
+      const transactionDirective = getDirective(schema, fieldConfig, DIRECTIVE)?.[0]
+      if (transactionDirective) {
+        const { resolve = defaultFieldResolver } = fieldConfig
+
+        fieldConfig.resolve = async function (source, args, context, info) {
+          return await getDataSource('tx').transaction(async tx => {
+            /* local-graphql-client로부터 invoke인 경우에는 context.req, context.res 가 없으므로, 빈 오브젝트로 대체해준다. */
+            let wrap = context.app.createContext(context.req || {}, context.res || {})
+
+            wrap.state = {
+              ...context.state,
+              tx
+            }
+            wrap.t = context.t
+
+            let result = await resolve.call(this, source, args, wrap, info)
+
+            return result
+          })
+        }
+
+        return fieldConfig
+      }
+    }
+  })

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

@@ -0,0 +1,120 @@
+import { Arg, Args, Ctx, Directive, Mutation, Query, Resolver, Root } from 'type-graphql'
+import { In, Repository } from 'typeorm'
+
+import { slugger } from '@things-factory/utils'
+
+import { getRepository } from '../../initializers/database'
+
+import { Domain, IPList } from './domain'
+import { DomainPatch } from './domain-types'
+import { ScalarObject } from '../common-types'
+
+@Resolver(Domain)
+export class DomainMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Domain, { description: 'To create domain (Only superuser is granted this privilege.)' })
+  async createDomain(@Arg('domainInput') domainInput: DomainPatch) {
+    const { name, description } = domainInput
+    const domainRepo: Repository<Domain> = getRepository(Domain)
+    const subdomain: string = slugger(name)
+
+    const domain: Domain = await domainRepo.findOneBy({ subdomain })
+    if (domain) {
+      throw new Error('domain is duplicated')
+    }
+
+    return await domainRepo.save({ name, description, subdomain })
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Domain, { description: 'To delete domain (Only superuser is granted this privilege.)' })
+  async deleteDomain(@Arg('name') name: string) {
+    return await getRepository(Domain).delete({ name })
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Boolean, {
+    description: 'To delete multiple domains (Only superuser is granted this privilege.)'
+  })
+  async deleteDomains(@Arg('names', () => [String]) names: string[]) {
+    const domains: Domain[] = await getRepository(Domain).find({ where: { name: In(names) } })
+    const domainIds: string[] = domains.map(domain => domain.id)
+
+    await getRepository(Domain).delete({ id: In(domainIds) })
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Domain, {
+    description: 'To update domain (Only superuser is granted this privilege.)'
+  })
+  async updateDomain(@Arg('name') name: string, @Arg('patch', () => DomainPatch) patch: DomainPatch) {
+    const repository = getRepository(Domain)
+    const domain: Domain = await repository.findOneBy({ name })
+
+    if (patch.parent && patch.parent.id == domain.id) {
+      delete patch.parent
+    }
+
+    return await repository.save({
+      ...domain,
+      ...patch
+    } as any)
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Boolean, {
+    description: 'To update multiple domains (Only superuser is granted this privilege.)'
+  })
+  async updateDomains(@Arg('patches', () => [DomainPatch]) patches: DomainPatch[]): Promise<boolean> {
+    const domainRepo: Repository<Domain> = getRepository(Domain)
+
+    const patchIds = patches.filter((patch: any) => patch.id)
+
+    if (patchIds.length > 0) {
+      patchIds.forEach(async updateRecord => {
+        const domain: Domain = await domainRepo.findOne({ where: { id: updateRecord.id } })
+
+        if (updateRecord.name) {
+          updateRecord.subdomain = slugger(updateRecord.name)
+        }
+
+        if (updateRecord.parent && updateRecord.parent.id == domain.id) {
+          delete updateRecord.parent
+        }
+
+        await domainRepo.save({
+          ...domain,
+          ...updateRecord
+        } as any)
+      })
+    }
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive(
+    '@privilege(category: "security", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)'
+  )
+  @Mutation(returns => ScalarObject, { nullable: true, description: 'To update secure IP list for domain' })
+  async updateSecureIPList(
+    @Arg('iplist', type => ScalarObject) iplist: IPList,
+    @Ctx() context: any
+  ): Promise<IPList | null> {
+    const { domain } = context.state
+    const repository = getRepository(Domain)
+    // const domain: Domain = await repository.findOneBy({ id })
+
+    const { iplist: result } = await repository.save({
+      ...domain,
+      iplist
+    } as any)
+
+    return result
+  }
+}

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

@@ -0,0 +1,48 @@
+import { Arg, Args, Ctx, Directive, Mutation, Query, Resolver, FieldResolver, Root } from 'type-graphql'
+import { In, Repository } from 'typeorm'
+
+import { getRepository } from '../../initializers/database'
+import { getQueryBuilderFromListParams } from '../../utils/get-query-builder-from-list-params'
+
+import { ListParam } from '../common-types/list-param'
+import { Domain, IPList } from './domain'
+import { DomainList } from './domain-types'
+import { ScalarObject } from '../common-types'
+
+@Resolver(Domain)
+export class DomainQuery {
+  @Directive('@privilege(superUserGranted: true)')
+  @Query(returns => Domain, { description: 'To fetch domain' })
+  async domain(@Arg('id') id: string, @Ctx() context: any): Promise<Domain> {
+    const repository = getRepository(Domain)
+
+    return await repository.findOneBy({ id })
+  }
+
+  @Directive('@privilege(superUserGranted: true)')
+  @Query(returns => DomainList, { description: 'To fetch all domains (Only superuser is granted this privilege.)' })
+  async domains(@Args(type => ListParam) params: ListParam, @Ctx() context: any): Promise<DomainList> {
+    const queryBuilder = await getQueryBuilderFromListParams({
+      repository: getRepository(Domain),
+      alias: 'ContactPoint',
+      params,
+      searchables: ['name', 'description', 'subdomain']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "security", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
+  @Query(returns => ScalarObject, { nullable: true, description: 'To fetch domain' })
+  async secureIPList(@Ctx() context: any): Promise<IPList | null> {
+    const { domain } = context.state
+    return domain.iplist
+  }
+
+  @FieldResolver(type => Domain)
+  async parent(@Root() domain: Domain): Promise<Domain> {
+    return domain.parentId && (await getRepository(Domain).findOneBy({ id: domain.parentId }))
+  }
+}

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

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

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

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

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

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

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

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

package/server/typeorm/encrypt-transform.ts

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