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

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
-}

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 }))
-  }
-}