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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/resource-base",
-  "version": "6.0.0-alpha.13",
+  "version": "6.0.0-alpha.20",
   "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.20"
   },
-  "gitHead": "ee18af4bbf6b44e2f1d76258ad6922a535a9f0d8"
+  "gitHead": "6e50e3cefe9c4158500f3cb2bf14300684c05623"
 }

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,13 +57,124 @@ 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
+    await deleteEntity(id, domain, tx)
+
+    return true
+  }
 
-    await tx.getRepository(Entity).delete({ domain, name })
+  @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
+
+    for (let i = 0; i < ids.length; i++) {
+      await deleteEntity(ids[i], domain, tx)
+    }
 
     return true
   }
 }
+
+async function deleteEntityAndEntityColumns(id, domain, tx) {
+  const entity: Entity = tx.getRepository(Entity).findOne({ domain: { id: domain.id }, id })
+  const columns: EntityColumn[] = tx
+    .getRepository(EntityColumn)
+    .find({ where: { entity: { id: entity.id }, domain: { id: domain.id } }, relations: ['entity'] })
+
+  if (columns && columns.length) await tx.getRepository(EntityColumn).delete(columns)
+  await tx.getRepository(Entity).delete(entity)
+}
+
+async function deleteEntity(id, domain, tx) {
+  const entity: Entity = await tx.getRepository(Entity).findOne({
+    where: {
+      domain: { id: domain.id },
+      id
+    },
+    relations: ['children']
+  })
+
+  if ((entity.children && entity.children.length) || entity.delStrategy === DEL_STRATEGY.NULLIFY) {
+    if (entity.delStrategy === DEL_STRATEGY.DELETE || entity.delStrategy === DEL_STRATEGY.DESTROY) {
+      const children = entity.children
+      for (let i = 0; i < children.length; i++) {
+        await deleteEntityAndEntityColumns(children[i].id, domain, tx)
+      }
+      await deleteEntityAndEntityColumns(entity.id, domain, tx)
+    } else if (entity.delStrategy === DEL_STRATEGY.RESTRICT_WITH_ERROR) {
+      throw new Error('entity cannot delete')
+    }
+  } else {
+    await deleteEntityAndEntityColumns(entity.id, domain, tx)
+  }
+}

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'
@@ -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,7 +38,7 @@ 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) {
@@ -51,12 +52,76 @@ 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 })) 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 })) 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 deleteEntities(@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,4 +1,4 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
 
 import { EntityColumn } from './entity-column'
 
@@ -109,6 +109,9 @@ export class NewEntityColumn {
 
 @InputType()
 export class EntityColumnPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
   @Field({ nullable: true })
   name?: string
 
@@ -210,6 +213,9 @@ export class EntityColumnPatch {
 
   @Field({ nullable: true })
   ignoreOnSav?: boolean
+
+  @Field({ nullable: true })
+  cuFlag?: string
 }
 
 @ObjectType()