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

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

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

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

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

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

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

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

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

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

@@ -1,55 +0,0 @@
-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.js'
-import { Domain, IPList } from './domain.js'
-import { DomainList } from './domain-types.js'
-import { ScalarObject } from '../common-types/scalar-object.js'
-import { config } from '@things-factory/env'
-
-@Resolver(Domain)
-export class DomainQuery {
-  @Directive('@privilege(superUserGranted: true)')
-  @Query(returns => [String], { description: 'To fetch domain' })
-  async domainTypes(@Ctx() context: any): Promise<String[]> {
-    return config.get('domainTypes') || ['domain']
-  }
-
-  @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

@@ -1,69 +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
-
-  @Field({ nullable: true })
-  extType?: 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({ nullable: true })
-  extType?: 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,112 +0,0 @@
-import {
-  Column,
-  CreateDateColumn,
-  ManyToOne,
-  OneToMany,
-  RelationId,
-  Entity,
-  Index,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Directive, Field, ID } from 'type-graphql'
-import { ScalarObject } from '../common-types/scalar-object.js'
-
-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 {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  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