@things-factory/resource-base 6.0.0-alpha.13 → 6.0.0-alpha.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/resource-base",
-  "version": "6.0.0-alpha.13",
+  "version": "6.0.0-alpha.21",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,7 +24,7 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^6.0.0-alpha.13"
+    "@things-factory/auth-base": "^6.0.0-alpha.21"
   },
-  "gitHead": "ee18af4bbf6b44e2f1d76258ad6922a535a9f0d8"
+  "gitHead": "484fbcb93bff65e7ffe0104b79eb7360ac9a8134"
 }

package/server/constants/del-strategy-type.ts

@@ -0,0 +1,6 @@
+export const DEL_STRATEGY = {
+  DELETE: 'delete',
+  DESTROY: 'destroy',
+  NULLIFY: 'nullify',
+  RESTRICT_WITH_ERROR: 'restrict with error'
+}

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

@@ -1,5 +1,7 @@
+import { DEL_STRATEGY } from '../../constants/del-strategy-type'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { In } from 'typeorm'
+import { EntityColumn } from '../entity-column/entity-column'
 
 import { Entity } from './entity'
 import { EntityPatch, NewEntity } from './entity-type'
@@ -28,7 +30,7 @@ export class EntityMutation {
   @Directive('@transaction')
   @Mutation(returns => Entity, { description: "To modify Entity' information" })
   async updateEntity(
-    @Arg('name', type => String) name: string,
+    @Arg('id', type => String) id: string,
     @Arg('patch', type => EntityPatch) patch: EntityPatch,
     @Ctx() context: ResolverContext
   ): Promise<Entity> {
@@ -36,7 +38,7 @@ export class EntityMutation {
 
     const repository = tx.getRepository(Entity)
     const entity = repository.findOne({
-      where: { domain: { id: domain.id }, name },
+      where: { domain: { id: domain.id }, id },
       relations: ['master', 'children']
     })
 
@@ -55,12 +57,104 @@ export class EntityMutation {
     })
   }
 
+  @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('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+  async deleteEntity(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
+    const entityRepo = tx.getRepository(Entity)
 
-    await tx.getRepository(Entity).delete({ domain, name })
+    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

@@ -10,11 +10,11 @@ import { EntityList } from './entity-type'
 @Resolver(Entity)
 export class EntityQuery {
   @Query(returns => Entity, { description: 'To fetch a Entity' })
-  async entity(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<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 }, name }
+      where: { domain: { id: domain.id }, id }
     })
   }
 

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

@@ -120,6 +120,9 @@ export class EntityPatch {
 
   @Field(type => [String], { nullable: true })
   children: string[]
+
+  @Field({ nullable: true })
+  cuFlag?: string
 }
 
 @ObjectType()

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

@@ -1,4 +1,5 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
 
 import { Entity } from '../entity/entity'
 import { EntityColumn } from './entity-column'
@@ -15,7 +16,7 @@ export class EntityColumnMutation {
     const { domain, user, tx } = context.state
 
     if (entityColumn.entity) {
-      entityColumn.entity = (await tx.getRepository(Entity).findOne({ where: { id: entityColumn.entity } })) as any
+      entityColumn.entity = (await tx.getRepository(Entity).findOne({ where: { id: entityColumn.entity.id } })) as any
     }
 
     return await tx.getRepository(EntityColumn).save({
@@ -29,7 +30,7 @@ export class EntityColumnMutation {
   @Directive('@transaction')
   @Mutation(returns => EntityColumn, { description: 'To modify EntityColumn information' })
   async updateEntityColumn(
-    @Arg('name') name: string,
+    @Arg('id') id: string,
     @Arg('patch') patch: EntityColumnPatch,
     @Ctx() context: ResolverContext
   ): Promise<EntityColumn> {
@@ -37,11 +38,11 @@ export class EntityColumnMutation {
 
     const repository = tx.getRepository(EntityColumn)
     const entityColumn = await repository.findOne({
-      where: { domain: { id: domain.id }, name }
+      where: { domain: { id: domain.id }, id }
     })
 
     if (patch.entity) {
-      patch.entity = (await tx.getRepository(Entity).findOneBy({ id: patch.entity })) as any
+      patch.entity = (await tx.getRepository(Entity).findOneBy({ id: patch.entity.id })) as any
     }
 
     return await repository.save({
@@ -51,12 +52,79 @@ export class EntityColumnMutation {
     })
   }
 
+  @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('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+  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, name })
+    await tx.getRepository(EntityColumn).delete({ domain: { id: domain.id }, id: In(ids) })
+
     return true
   }
 }

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

@@ -10,11 +10,11 @@ import { EntityColumnList } from './entity-column-type'
 @Resolver(EntityColumn)
 export class EntityColumnQuery {
   @Query(returns => EntityColumn, { description: 'To fetch a EntityColumn' })
-  async entityColumn(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<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 }, name }
+      where: { domain: { id: domain.id }, id }
     })
   }
 

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

@@ -1,5 +1,5 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+import { ObjectRef } from '@things-factory/shell'
 import { EntityColumn } from './entity-column'
 
 @InputType()
@@ -11,7 +11,7 @@ export class NewEntityColumn {
   description?: string
 
   @Field()
-  entity: string
+  entity: ObjectRef
 
   @Field({ nullable: true })
   rank?: number
@@ -109,6 +109,9 @@ export class NewEntityColumn {
 
 @InputType()
 export class EntityColumnPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
   @Field({ nullable: true })
   name?: string
 
@@ -116,7 +119,7 @@ export class EntityColumnPatch {
   description?: string
 
   @Field({ nullable: true })
-  entity?: string
+  entity?: ObjectRef
 
   @Field(type => Int, { nullable: true })
   rank?: number
@@ -210,6 +213,9 @@ export class EntityColumnPatch {
 
   @Field({ nullable: true })
   ignoreOnSav?: boolean
+
+  @Field({ nullable: true })
+  cuFlag?: string
 }
 
 @ObjectType()