@things-factory/resource-base 8.0.0-beta.0 → 8.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/resource-base",
-  "version": "8.0.0-beta.0",
+  "version": "8.0.0-beta.2",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "",
@@ -23,7 +23,7 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^8.0.0-beta.0"
+    "@things-factory/auth-base": "^8.0.0-beta.2"
   },
-  "gitHead": "add6fb8224b2cb19cbea47bed6a5ecb0424c9a28"
+  "gitHead": "f03431a09435511b2595515658f9cb8f78ba4ebb"
 }

package/server/index.ts

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

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

@@ -1,148 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Entity } from './entity'
-import { EntityPatch, NewEntity } from './entity-type'
-
-@Resolver(Entity)
-export class EntityMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Entity, { description: 'To create new Entity' })
-  async createEntity(@Arg('entity') entity: NewEntity, @Ctx() context: ResolverContext): Promise<Entity> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Entity)
-
-    if (entity.master) {
-      entity.master = (await repository.findOne({ where: { id: entity.master } })) as any
-    }
-
-    return await repository.save({
-      ...(entity as any),
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Entity, { description: "To modify Entity' information" })
-  async updateEntity(@Arg('id', type => String) id: string, @Arg('patch', type => EntityPatch) patch: EntityPatch, @Ctx() context: ResolverContext): Promise<Entity> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Entity)
-    const entity = repository.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['master', 'children']
-    })
-
-    if (patch.master) {
-      patch.master = (await repository.findOne({ where: { domain: { id: domain.id }, id: patch.master } })) as any
-    }
-
-    if (patch.children && patch.children.length) {
-      patch.children = (await repository.findBy({ id: In(patch.children) })) as any
-    }
-
-    return await repository.save({
-      ...entity,
-      ...(patch as any),
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Entity], { description: "To modify multiple Entitys' information" })
-  async updateMultipleEntity(@Arg('patches', type => [EntityPatch]) patches: EntityPatch[], @Ctx() context: ResolverContext): Promise<Entity[]> {
-    const { domain, user, 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 entityRepo = tx.getRepository(Entity)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        if (newRecord.master) {
-          newRecord.master = (await tx.getRepository(Entity).findOne({ where: { domain: { id: domain.id }, id: newRecord.master } })) as any
-        }
-
-        if (newRecord.children && newRecord.children.length) {
-          newRecord.children = (await tx.getRepository(Entity).findBy({ id: In(newRecord.children) })) as any
-        }
-
-        const result = await entityRepo.save({
-          ...(newRecord as any),
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const entity = await entityRepo.findOneBy({ id: updateRecord.id })
-
-        if (updateRecord.master) {
-          updateRecord.master = (await tx.getRepository(Entity).findOne({ where: { domain: { id: domain.id }, id: updateRecord.master } })) as any
-        }
-
-        if (updateRecord.children && updateRecord.children.length) {
-          updateRecord.children = (await tx.getRepository(Entity).findBy({ id: In(updateRecord.children) })) as any
-        }
-
-        const result = await entityRepo.save({
-          ...entity,
-          ...(updateRecord as any),
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Entity' })
-  async deleteEntity(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-    const entityRepo = tx.getRepository(Entity)
-
-    const entity: Entity = await entityRepo.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['columns']
-    })
-
-    if (entity.columns.length) throw new Error('cannot delete Entity because columns of entity exists')
-    else await entityRepo.delete(entity.id)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Entities' })
-  async deleteEntities(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-    const entityRepo = tx.getRepository(Entity)
-
-    for (const id of ids) {
-      const entity: Entity = await entityRepo.findOne({
-        where: { domain: { id: domain.id }, id },
-        relations: ['columns']
-      })
-
-      if (entity.columns.length) throw new Error('cannot delete Entity because columns of entity exists')
-      else await entityRepo.delete(entity.id)
-    }
-
-    return true
-  }
-}

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

@@ -1,77 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { EntityColumn } from '../entity-column/entity-column'
-import { Entity } from './entity'
-import { EntityList } from './entity-type'
-
-@Resolver(Entity)
-export class EntityQuery {
-  @Query(returns => Entity, { description: 'To fetch a Entity' })
-  async entity(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Entity> {
-    const { domain } = context.state
-
-    return await getRepository(Entity).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => EntityList, { description: 'To fetch multiple Entities' })
-  async entities(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<EntityList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(Entity),
-      params,
-      domain,
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Entity)
-  async master(@Root() entity: Entity): Promise<Entity> {
-    return await getRepository(Entity).findOneBy({ id: entity.masterId })
-  }
-
-  @FieldResolver(type => [Entity])
-  async children(@Root() entity: Entity): Promise<Entity[]> {
-    return await getRepository(Entity).find({
-      where: {
-        master: { id: entity.id }
-      }
-    })
-  }
-
-  @FieldResolver(type => [EntityColumn])
-  async columns(@Root() entity: Entity): Promise<EntityColumn[]> {
-    return await getRepository(EntityColumn).find({
-      where: {
-        entity: { id: entity.id }
-      },
-      order: {
-        rank: 'ASC'
-      }
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() entity: Entity): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: entity.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() entity: Entity): Promise<User> {
-    return await getRepository(User).findOneBy({ id: entity.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() entity: Entity): Promise<User> {
-    return await getRepository(User).findOneBy({ id: entity.creatorId })
-  }
-}

package/server/service/entity/entity-type.ts

@@ -1,135 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-
-import { Entity } from './entity'
-
-@InputType()
-export class NewEntity {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field()
-  bundle: string
-
-  @Field()
-  tableName: string
-
-  @Field({ nullable: true })
-  searchUrl?: string
-
-  @Field({ nullable: true })
-  multiSaveUrl?: string
-
-  @Field({ nullable: true })
-  idType?: string
-
-  @Field({ nullable: true })
-  idField?: string
-
-  @Field({ nullable: true })
-  titleField?: string
-
-  @Field({ nullable: true })
-  master?: string
-
-  @Field({ nullable: true })
-  association?: string
-
-  @Field({ nullable: true })
-  dataProp?: string
-
-  @Field({ nullable: true })
-  refField?: string
-
-  @Field({ nullable: true })
-  delStrategy?: string
-
-  @Field(type => Int, { nullable: true })
-  fixedColumns?: number
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  extEntity?: boolean
-
-  @Field(type => [String], { nullable: true })
-  columns?: string[]
-}
-
-@InputType()
-export class EntityPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  bundle?: string
-
-  @Field({ nullable: true })
-  tableName?: string
-
-  @Field({ nullable: true })
-  searchUrl?: string
-
-  @Field({ nullable: true })
-  multiSaveUrl?: string
-
-  @Field({ nullable: true })
-  idType?: string
-
-  @Field({ nullable: true })
-  idField?: string
-
-  @Field({ nullable: true })
-  titleField?: string
-
-  @Field({ nullable: true })
-  master?: string
-
-  @Field({ nullable: true })
-  association?: string
-
-  @Field({ nullable: true })
-  dataProp?: string
-
-  @Field({ nullable: true })
-  refField?: string
-
-  @Field({ nullable: true })
-  delStrategy?: string
-
-  @Field(type => Int, { nullable: true })
-  fixedColumns?: number
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  extEntity?: boolean
-
-  @Field(type => [String], { nullable: true })
-  columns?: string[]
-
-  @Field(type => [String], { nullable: true })
-  children: string[]
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class EntityList {
-  @Field(type => [Entity])
-  items: Entity[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/entity/entity.ts

@@ -1,168 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity as ORMEntity,
-  Index,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { EntityColumn } from '../entity-column/entity-column'
-
-@ORMEntity()
-@Index('ix_entity_0', (entity: Entity) => [entity.domain, entity.name], { unique: true })
-@Index('ix_entity_1', (entity: Entity) => [entity.domain])
-@Index('ix_entity_2', (entity: Entity) => [entity.bundle])
-@Index('ix_entity_3', (entity: Entity) => [entity.domain, entity.master])
-@ObjectType({ description: 'Entity for Entity' })
-export class Entity {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((entity: Entity) => entity.domain)
-  domainId?: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column()
-  @Field()
-  bundle: string
-
-  @Column()
-  @Field()
-  tableName: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  searchUrl?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  multiSaveUrl?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  idType?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  idField?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  titleField?: string
-
-  @ManyToOne(type => Entity, master => master.children)
-  @Field(type => Entity, { nullable: true })
-  master?: Entity
-
-  @RelationId((entity: Entity) => entity.master)
-  masterId?: string
-
-  @OneToMany(type => Entity, child => child.master)
-  @Field(type => [Entity], { nullable: true })
-  children?: Entity[]
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  association?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  dataProp?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  refField?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  delStrategy?: string
-
-  @Column('int', {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  fixedColumns?: number
-
-  @Column({
-    nullable: true,
-    default: true
-  })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  extEntity?: boolean
-
-  @OneToMany(type => EntityColumn, entityColumn => entityColumn.entity)
-  @Field(type => [EntityColumn], { nullable: true })
-  columns?: EntityColumn[]
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((entity: Entity) => entity.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((entity: Entity) => entity.updater)
-  updaterId?: string
-}

package/server/service/entity/index.ts

@@ -1,6 +0,0 @@
-import { Entity } from './entity'
-import { EntityQuery } from './entity-query'
-import { EntityMutation } from './entity-mutation'
-
-export const entities = [Entity]
-export const resolvers = [EntityQuery, EntityMutation]

package/server/service/entity-column/entity-column-mutation.ts

@@ -1,130 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Entity } from '../entity/entity'
-import { EntityColumn } from './entity-column'
-import { EntityColumnPatch, NewEntityColumn } from './entity-column-type'
-
-@Resolver(EntityColumn)
-export class EntityColumnMutation {
-  @Directive('@transaction')
-  @Mutation(returns => EntityColumn, { description: 'To create new EntityColumn' })
-  async createEntityColumn(
-    @Arg('entityColumn') entityColumn: NewEntityColumn,
-    @Ctx() context: ResolverContext
-  ): Promise<EntityColumn> {
-    const { domain, user, tx } = context.state
-
-    if (entityColumn.entity) {
-      entityColumn.entity = (await tx.getRepository(Entity).findOne({ where: { id: entityColumn.entity.id } })) as any
-    }
-
-    return await tx.getRepository(EntityColumn).save({
-      ...(entityColumn as any),
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => EntityColumn, { description: 'To modify EntityColumn information' })
-  async updateEntityColumn(
-    @Arg('id') id: string,
-    @Arg('patch') patch: EntityColumnPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<EntityColumn> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(EntityColumn)
-    const entityColumn = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    if (patch.entity) {
-      patch.entity = (await tx.getRepository(Entity).findOneBy({ id: patch.entity.id })) as any
-    }
-
-    return await repository.save({
-      ...entityColumn,
-      ...(patch as any),
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [EntityColumn], { description: "To modify multiple Entitys' information" })
-  async updateMultipleEntityColumn(
-    @Arg('patches', type => [EntityColumnPatch]) patches: EntityColumnPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<EntityColumn[]> {
-    const { domain, user, 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 entityColumnRepo = tx.getRepository(EntityColumn)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        if (newRecord.entity) {
-          newRecord.entity = (await tx.getRepository(Entity).findOneBy({ id: newRecord.entity.id })) as any
-        }
-
-        const result = await entityColumnRepo.save({
-          ...(newRecord as any),
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const entity = await entityColumnRepo.findOneBy({ id: updateRecord.id })
-
-        if (updateRecord.entity) {
-          updateRecord.entity = (await tx.getRepository(Entity).findOneBy({ id: updateRecord.entity.id })) as any
-        }
-
-        const result = await entityColumnRepo.save({
-          ...entity,
-          ...(updateRecord as any),
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete EntityColumn' })
-  async deleteEntityColumn(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(EntityColumn).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple EntityColumns' })
-  async deleteEntityColumns(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(EntityColumn).delete({ domain: { id: domain.id }, id: In(ids) })
-
-    return true
-  }
-}

package/server/service/entity-column/entity-column-query.ts

@@ -1,59 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { Entity } from '../entity/entity'
-import { EntityColumn } from './entity-column'
-import { EntityColumnList } from './entity-column-type'
-
-@Resolver(EntityColumn)
-export class EntityColumnQuery {
-  @Query(returns => EntityColumn, { description: 'To fetch a EntityColumn' })
-  async entityColumn(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<EntityColumn> {
-    const { domain } = context.state
-
-    return await getRepository(EntityColumn).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => EntityColumnList, { description: 'To fetch multiple EntityColumns' })
-  async entityColumns(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<EntityColumnList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(EntityColumn),
-      params,
-      domain,
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Entity)
-  async entity(@Root() entityColumn: EntityColumn): Promise<Entity> {
-    return await getRepository(Entity).findOneBy({ id: entityColumn.entityId })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() entityColumn: EntityColumn): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: entityColumn.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() entityColumn: EntityColumn): Promise<User> {
-    return await getRepository(User).findOneBy({ id: entityColumn.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() entityColumn: EntityColumn): Promise<User> {
-    return await getRepository(User).findOneBy({ id: entityColumn.creatorId })
-  }
-}

package/server/service/entity-column/entity-column-type.ts

@@ -1,228 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-import { ObjectRef } from '@things-factory/shell'
-import { EntityColumn } from './entity-column'
-
-@InputType()
-export class NewEntityColumn {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field()
-  entity: ObjectRef
-
-  @Field({ nullable: true })
-  rank?: number
-
-  @Field({ nullable: true })
-  term?: string
-
-  @Field()
-  colType: string
-
-  @Field({ nullable: true })
-  colSize?: number
-
-  @Field({ nullable: true })
-  nullable?: boolean
-
-  @Field({ nullable: true })
-  refType?: string
-
-  @Field({ nullable: true })
-  refName?: string
-
-  @Field({ nullable: true })
-  refUrl?: string
-
-  @Field({ nullable: true })
-  refParams?: string
-
-  @Field({ nullable: true })
-  refRelated?: string
-
-  @Field(type => Int, { nullable: true })
-  searchRank?: number
-
-  @Field(type => Int, { nullable: true })
-  sortRank?: number
-
-  @Field({ nullable: true })
-  reverseSort?: boolean
-
-  @Field({ nullable: true })
-  virtualField?: boolean
-
-  @Field({ nullable: true })
-  searchName?: string
-
-  @Field({ nullable: true })
-  searchEditor?: string
-
-  @Field({ nullable: true })
-  searchOper?: string
-
-  @Field({ nullable: true })
-  searchInitVal?: string
-
-  @Field(type => Int, { nullable: true })
-  gridRank?: number
-
-  @Field({ nullable: true })
-  gridEditor?: string
-
-  @Field({ nullable: true })
-  gridFormat?: string
-
-  @Field({ nullable: true })
-  gridValidator?: string
-
-  @Field(type => Int, { nullable: true })
-  gridWidth?: number
-
-  @Field({ nullable: true })
-  gridAlign?: string
-
-  @Field(type => Int, { nullable: true })
-  uniqRank?: number
-
-  @Field({ nullable: true })
-  formEditor?: string
-
-  @Field({ nullable: true })
-  formValidator?: string
-
-  @Field({ nullable: true })
-  formFormat?: string
-
-  @Field({ nullable: true })
-  defVal?: string
-
-  @Field({ nullable: true })
-  rangeVal?: string
-
-  @Field({ nullable: true })
-  ignoreOnSav?: boolean
-}
-
-@InputType()
-export class EntityColumnPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  entity?: ObjectRef
-
-  @Field(type => Int, { nullable: true })
-  rank?: number
-
-  @Field({ nullable: true })
-  term?: string
-
-  @Field({ nullable: true })
-  colType?: string
-
-  @Field(type => Int, { nullable: true })
-  colSize?: number
-
-  @Field({ nullable: true })
-  nullable?: boolean
-
-  @Field({ nullable: true })
-  refType?: string
-
-  @Field({ nullable: true })
-  refName?: string
-
-  @Field({ nullable: true })
-  refUrl?: string
-
-  @Field({ nullable: true })
-  refParams?: string
-
-  @Field({ nullable: true })
-  refRelated?: string
-
-  @Field(type => Int, { nullable: true })
-  searchRank?: number
-
-  @Field({ nullable: true })
-  sortRank?: number
-
-  @Field({ nullable: true })
-  reverseSort?: boolean
-
-  @Field({ nullable: true })
-  virtualField?: boolean
-
-  @Field({ nullable: true })
-  searchName?: string
-
-  @Field({ nullable: true })
-  searchEditor?: string
-
-  @Field({ nullable: true })
-  searchOper?: string
-
-  @Field({ nullable: true })
-  searchInitVal?: string
-
-  @Field(type => Int, { nullable: true })
-  gridRank?: number
-
-  @Field({ nullable: true })
-  gridEditor?: string
-
-  @Field({ nullable: true })
-  gridFormat?: string
-
-  @Field({ nullable: true })
-  gridValidator?: string
-
-  @Field(type => Int, { nullable: true })
-  gridWidth?: number
-
-  @Field({ nullable: true })
-  gridAlign?: string
-
-  @Field(type => Int, { nullable: true })
-  uniqRank?: number
-
-  @Field({ nullable: true })
-  formEditor?: string
-
-  @Field({ nullable: true })
-  formValidator?: string
-
-  @Field({ nullable: true })
-  formFormat?: string
-
-  @Field({ nullable: true })
-  defVal?: string
-
-  @Field({ nullable: true })
-  rangeVal?: string
-
-  @Field({ nullable: true })
-  ignoreOnSav?: boolean
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class EntityColumnList {
-  @Field(type => [EntityColumn])
-  items: EntityColumn[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/entity-column/entity-column.ts

@@ -1,266 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity as ORMEntity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { Entity } from '../entity/entity'
-
-@ORMEntity()
-@Index('ix_entity_col_0', (entityColumn: EntityColumn) => [entityColumn.entity, entityColumn.name], {
-  unique: true
-})
-@Index('ix_entity_col_1', (entityColumn: EntityColumn) => [entityColumn.entity, entityColumn.rank])
-@ObjectType({ description: 'Entity for EntityColumn' })
-export class EntityColumn {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((entityColumn: EntityColumn) => entityColumn.domain)
-  domainId?: string
-
-  @ManyToOne(type => Entity, entity => entity.columns)
-  @Field(type => Entity)
-  entity: Entity
-
-  @RelationId((entityColumn: EntityColumn) => entityColumn.entity)
-  entityId?: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column('int', {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  rank?: number
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  term?: string
-
-  @Column()
-  @Field()
-  colType: string
-
-  @Column('int', {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  colSize?: number
-
-  @Column({
-    nullable: true,
-    default: true
-  })
-  @Field({ nullable: true })
-  nullable?: boolean
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  refType?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  refName?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  refUrl?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  refParams?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  refRelated?: string
-
-  @Column('int', {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  searchRank?: number
-
-  @Column('int', {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  sortRank?: number
-
-  @Column({
-    nullable: true,
-    default: false
-  })
-  @Field({ nullable: true })
-  reverseSort?: boolean
-
-  @Column({
-    nullable: true,
-    default: false
-  })
-  @Field({ nullable: true })
-  virtualField?: boolean
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  searchName?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  searchEditor?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  searchOper?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  searchInitVal?: string
-
-  @Column('int', {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  gridRank?: number
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  gridEditor?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  gridFormat?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  gridValidator?: string
-
-  @Column('int', {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  gridWidth?: number
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  gridAlign?: string
-
-  @Column('int', {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  uniqRank?: number
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  formEditor?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  formValidator?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  formFormat?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  defVal?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  rangeVal?: string
-
-  @Column({
-    nullable: true,
-    default: false
-  })
-  @Field({ nullable: true })
-  ignoreOnSav?: boolean
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((entityColumn: EntityColumn) => entityColumn.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((entityColumn: EntityColumn) => entityColumn.updater)
-  updaterId?: string
-}

package/server/service/entity-column/index.ts

@@ -1,6 +0,0 @@
-import { EntityColumn } from './entity-column'
-import { EntityColumnQuery } from './entity-column-query'
-import { EntityColumnMutation } from './entity-column-mutation'
-
-export const entities = [EntityColumn]
-export const resolvers = [EntityColumnQuery, EntityColumnMutation]

package/server/service/entity-metadata/entity-metadata-query.ts

@@ -1,12 +0,0 @@
-import { Arg, Ctx, Query, Resolver } from 'type-graphql'
-import { getConnection } from 'typeorm'
-
-import { EntityMetadata } from './entity-metadata'
-
-@Resolver(EntityMetadata)
-export class EntityMetadataQuery {
-  @Query(returns => EntityMetadata, { description: 'To fetch a EntityMetadata' })
-  async entityMetadata(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<EntityMetadata> {
-    return (await getConnection().getMetadata(name)) as any
-  }
-}

package/server/service/entity-metadata/entity-metadata.ts

@@ -1,81 +0,0 @@
-import { Field, Int, ObjectType } from 'type-graphql'
-
-import { ScalarAny } from '@things-factory/shell'
-
-@ObjectType({ description: 'RelationType of EntityColumn' })
-export class EntityRelationMetadata {
-  @Field({ nullable: true })
-  isOneToMany?: boolean
-
-  @Field({ nullable: true })
-  isOneToOne?: boolean
-
-  @Field({ nullable: true })
-  isManyToOne?: boolean
-
-  @Field({ nullable: true })
-  relationType?: boolean
-
-  @Field(type => [EntityColumnMetadata], { nullable: true })
-  joinColumns?: EntityColumnMetadata[]
-
-  @Field({ nullable: true })
-  joinTableName?: string
-}
-
-@ObjectType({ description: 'EntityColumn of Entity' })
-export class EntityColumnMetadata {
-  @Field()
-  propertyName: string
-
-  @Field(type => ScalarAny)
-  type: any
-
-  @Field(type => Int, { nullable: true })
-  width?: number
-
-  @Field(type => ScalarAny, { nullable: true })
-  target?: string | Function
-
-  @Field(type => [ScalarAny], { nullable: true })
-  enum?: any[]
-
-  @Field({ nullable: true })
-  generatedType?: 'VIRTUAL' | 'STORED'
-
-  @Field({ nullable: true })
-  isArray?: boolean
-
-  @Field()
-  isNullable: boolean
-
-  @Field({ nullable: true })
-  isPrimary: boolean
-
-  @Field({ nullable: true })
-  isReadonly: boolean
-
-  @Field({ nullable: true })
-  isUpdateDate: boolean
-
-  @Field({ nullable: true })
-  isVersion: boolean
-
-  @Field({ nullable: true })
-  length: number
-
-  @Field(type => ScalarAny, { nullable: true })
-  referenceColumn?: any
-
-  @Field(type => EntityRelationMetadata, { nullable: true })
-  relationMetadata?: EntityRelationMetadata
-}
-
-@ObjectType({ description: 'Entity for EntityMetadata' })
-export class EntityMetadata {
-  @Field()
-  name: string
-
-  @Field(type => [EntityColumnMetadata], { nullable: true })
-  columns?: EntityColumnMetadata[]
-}

package/server/service/entity-metadata/index.ts

@@ -1,5 +0,0 @@
-import { EntityMetadata } from './entity-metadata'
-import { EntityMetadataQuery } from './entity-metadata-query'
-
-export const entities = [EntityMetadata]
-export const resolvers = [EntityMetadataQuery]

package/server/service/index.ts

@@ -1,24 +0,0 @@
-import { entities as EntityEntities, resolvers as EntityResolvers } from './entity'
-import { entities as EntityColumnEntities, resolvers as EntityColumnResolvers } from './entity-column'
-import { entities as EntityMetadataEntities, resolvers as EntityMetadataResolvers } from './entity-metadata'
-
-/* EXPORT ENTITY TYPES */
-export * from './entity-metadata/entity-metadata'
-export * from './entity-column/entity-column'
-export * from './entity/entity'
-
-export const entities = [
-  /* ENTITIES */
-  ...EntityMetadataEntities,
-  ...EntityColumnEntities,
-  ...EntityEntities
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...EntityMetadataResolvers,
-    ...EntityColumnResolvers,
-    ...EntityResolvers
-  ]
-}