@things-factory/resource-base 8.0.5 → 9.0.0-beta.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/resource-base",
-  "version": "8.0.5",
+  "version": "9.0.0-beta.12",
   "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.5"
+    "@things-factory/auth-base": "^9.0.0-beta.12"
   },
-  "gitHead": "9ab6fca18eeb58b9d2f3411661508a39d0ab6aee"
+  "gitHead": "5e9ade1c2d4b4c96b89396e36c3afa1caaf18ef0"
 }

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