@things-factory/worklist 5.0.11 → 6.0.0-alpha.0

package/server/controllers/activity-thread/terminate.ts

@@ -1,21 +1,22 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
 
 import { ActivityThread, ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
-import { type ContextStatus } from '../common'
 
 export async function terminate(
   { id, output, reason }: { id: string; output?: object; reason?: string },
-  { domain, user, tx, t }: ContextStatus
+  context: any
 ): Promise<ActivityThread> {
+  const { domain, user, tx } = context.state
   var repository = getRepository(ActivityThread)
 
   var activityThread = await repository.findOne({
-    where: { domain, id }
+    where: { domain: { id: domain.id }, id },
+    relations: ['domain', 'activityInstance', 'assignee', 'creator', 'updater']
   })
 
   if (!activityThread) {
     throw new Error(
-      t('error.activity-instance not found', {
+      context.t('error.activity-instance not found', {
         activityThread: id
       })
     )

package/server/controllers/common.ts

@@ -1,22 +1,37 @@
-import { EntityManager } from 'typeorm'
-
 import { Role, User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
 
 import { ActivityInstance, ActivityInstanceStatus } from '../service/activity-instance/activity-instance'
 import { ActivityThread, ActivityThreadStatus } from '../service/activity-thread/activity-thread'
 
-export type ContextStatus = { domain?: Domain; user?: User; tx?: EntityManager; t?: (...args: any[]) => string }
+export async function updateActivityInstanceState(id: string, context: ResolverContext) {
+  const { tx } = context.state
 
-export async function updateActivityInstanceState(id: string, { tx }: ContextStatus) {
   await tx.getRepository(ActivityInstance).save({
-    ...(await tx.getRepository(ActivityInstance).findOne(id)),
-    state: await evalActivityInstanceState(id, { tx })
+    ...(await tx.getRepository(ActivityInstance).findOne({
+      where: { id },
+      relations: [
+        'domain',
+        'activity',
+        'assigneeRole',
+        'supervisoryRole',
+        'updater',
+        'creator',
+        'starter',
+        'terminator'
+      ]
+    })),
+    transaction: 'thread' /* change by transaction of activity thread */,
+    state: await evalActivityInstanceState(id, context)
   })
 }
 
-export async function evalActivityInstanceState(id: string, { tx }: ContextStatus): Promise<ActivityInstanceStatus> {
-  const activityInstance = await tx.getRepository(ActivityInstance).findOne(id, { relations: ['activityThreads'] })
+export async function evalActivityInstanceState(id: string, context: ResolverContext): Promise<ActivityInstanceStatus> {
+  const { tx } = context.state
+
+  const activityInstance = await tx.getRepository(ActivityInstance).findOne({
+    where: { id },
+    relations: ['activityThreads']
+  })
   const { threadsMin, threadsMax, activityThreads, state, dueAt } = activityInstance
 
   const validThreads = activityThreads.filter(thread => thread.isValid())
@@ -42,10 +57,13 @@ export async function evalActivityInstanceState(id: string, { tx }: ContextStatu
 }
 
 export async function createActivityThreadsForUsers(
-  activityInstance,
-  assignees,
-  { domain, user, tx, t }: ContextStatus
-): Promise<[ActivityThread]> {
+  transaction: string,
+  activityInstance: ActivityInstance,
+  assignees: User[],
+  context: ResolverContext
+): Promise<ActivityThread[]> {
+  const { domain, user, tx } = context.state
+
   const threadRepo = tx.getRepository(ActivityThread)
   const now = new Date()
 
@@ -56,23 +74,28 @@ export async function createActivityThreadsForUsers(
         state: ActivityThreadStatus.Assigned,
         activityInstance,
         domain,
+        transaction,
         creator: user,
         updater: user,
         dueAt: activityInstance.dueAt,
         assignedAt: now
-      }
+      } as any
     })
   )
 }
 
 export async function createActivityThreadsForAllRoleUsers(
-  activityInstance,
-  { domain, user, tx, t }: ContextStatus
-): Promise<[ActivityThread]> {
+  transaction: string,
+  activityInstance: ActivityInstance,
+  context: ResolverContext
+): Promise<ActivityThread[]> {
+  const { tx } = context.state
+
   // find how many users are having given role
-  const assigneeRole = (await tx
-    .getRepository(Role)
-    .findOne({ id: activityInstance.assigneeRoleId }, { relations: ['users'] })) as Role
+  const assigneeRole = (await tx.getRepository(Role).findOne({
+    where: { id: activityInstance.assigneeRoleId },
+    relations: ['users']
+  })) as Role
   const assignees = assigneeRole?.users || []
 
   if (assignees.length === 0) {
@@ -80,5 +103,5 @@ export async function createActivityThreadsForAllRoleUsers(
   }
 
   // create activity-thread for all of users having given role
-  return await createActivityThreadsForUsers(activityInstance, assignees, { domain, user, tx, t })
+  return await createActivityThreadsForUsers(transaction, activityInstance, assignees, context)
 }

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

@@ -10,7 +10,7 @@ import { ActivityPatch, NewActivity } from './activity-type'
 export class ActivityMutation {
   @Directive('@transaction')
   @Mutation(returns => Activity, { description: 'To create new Activity' })
-  async createActivity(@Arg('activity') activity: NewActivity, @Ctx() context: any): Promise<Activity> {
+  async createActivity(@Arg('activity') activity: NewActivity, @Ctx() context: ResolverContext): Promise<Activity> {
     const { domain, user, tx } = context.state
 
     const result = await tx.getRepository(Activity).save({
@@ -42,13 +42,15 @@ export class ActivityMutation {
   async updateActivity(
     @Arg('id') id: string,
     @Arg('patch') patch: ActivityPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Activity> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(Activity)
     const activity = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id },
+      /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
+      relations: ['domain', 'issuerRole', 'assigneeRole', 'supervisoryRole', 'creator', 'updater']
     })
 
     const result = await repository.save({
@@ -79,7 +81,7 @@ export class ActivityMutation {
   @Mutation(returns => [Activity], { description: "To modify multiple Activities' information" })
   async updateMultipleActivity(
     @Arg('patches', type => [ActivityPatch]) patches: ActivityPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Activity[]> {
     const { domain, user, tx } = context.state
 
@@ -120,7 +122,11 @@ export class ActivityMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const updateRecord = _updateRecords[i]
-        const activity = await activityRepo.findOne(updateRecord.id)
+        const activity = await activityRepo.findOne({
+          where: { id: updateRecord.id },
+          /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
+          relations: ['domain', 'issuerRole', 'assigneeRole', 'supervisoryRole', 'creator', 'updater']
+        })
 
         const result = await activityRepo.save({
           ...activity,
@@ -152,10 +158,10 @@ export class ActivityMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete Activity' })
-  async deleteActivity(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteActivity(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(Activity).delete({ domain, id })
+    await tx.getRepository(Activity).delete({ domain: { id: domain.id }, id })
     await deleteAttachmentsByRef(null, { refBys: [id] }, context)
 
     return true
@@ -163,11 +169,14 @@ export class ActivityMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple Activities' })
-  async deleteActivities(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteActivities(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(Activity).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 
@@ -180,7 +189,7 @@ export class ActivityMutation {
   @Mutation(returns => Boolean, { description: 'To import multiple Activities' })
   async importActivities(
     @Arg('activities', type => [ActivityPatch]) activities: ActivityPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { domain, tx } = context.state
 

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

@@ -1,9 +1,9 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { Brackets, getRepository } from 'typeorm'
+import { Brackets } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
 import { Activity } from './activity'
 import { ActivityList } from './activity-type'
@@ -11,16 +11,16 @@ import { ActivityList } from './activity-type'
 @Resolver(Activity)
 export class ActivityQuery {
   @Query(returns => Activity!, { nullable: true, description: 'To fetch a Activity' })
-  async activity(@Arg('id') id: string, @Ctx() context: any): Promise<Activity> {
+  async activity(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Activity> {
     const { domain } = context.state
 
     return await getRepository(Activity).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => ActivityList, { description: 'To fetch multiple Activities' })
-  async activities(@Args() params: ListParam, @Ctx() context: any): Promise<ActivityList> {
+  async activities(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -37,7 +37,7 @@ export class ActivityQuery {
   }
 
   @Query(returns => ActivityList, { description: 'To fetch the list of activities I can start' })
-  async startableActivities(@Args() params: ListParam, @Ctx() context: any): Promise<ActivityList> {
+  async startableActivities(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityList> {
     var { domain, user } = context.state
 
     /* 조회한 사용자가 assigner 역할을 가진 activity-instance 리스트만 반환 */
@@ -69,7 +69,7 @@ export class ActivityQuery {
   }
 
   @Query(returns => ActivityList, { description: 'To fetch the list of activities that I can report on' })
-  async supervisableActivities(@Args() params: ListParam, @Ctx() context: any): Promise<ActivityList> {
+  async supervisableActivities(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityList> {
     var { domain, user } = context.state
 
     /* 조회한 사용자가 assigner 역할을 가진 activity-instance 리스트만 반환 */
@@ -100,7 +100,7 @@ export class ActivityQuery {
   async issuerRole(@Root() activity: Activity): Promise<Role> {
     return (
       activity.issuerRole ||
-      (await getRepository(Role).findOne({
+      (await getRepository(Role).findOneBy({
         id: activity.issuerRoleId
       }))
     )
@@ -110,7 +110,7 @@ export class ActivityQuery {
   async assigneeRole(@Root() activity: Activity): Promise<Role> {
     return (
       activity.assigneeRole ||
-      (await getRepository(Role).findOne({
+      (await getRepository(Role).findOneBy({
         id: activity.assigneeRoleId
       }))
     )
@@ -120,7 +120,7 @@ export class ActivityQuery {
   async supervisoryRole(@Root() activity: Activity): Promise<Role> {
     return (
       activity.supervisoryRole ||
-      (await getRepository(Role).findOne({
+      (await getRepository(Role).findOneBy({
         id: activity.supervisoryRoleId
       }))
     )
@@ -130,7 +130,7 @@ export class ActivityQuery {
   async thumbnail(@Root() activity: Activity): Promise<string | undefined> {
     const attachment: Attachment = await getRepository(Attachment).findOne({
       where: {
-        domain: activity.domainId,
+        domain: { id: activity.domainId },
         refType: Activity.name,
         refBy: activity.id
       }
@@ -141,16 +141,16 @@ export class ActivityQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() activity: Activity): Promise<Domain> {
-    return await getRepository(Domain).findOne(activity.domainId)
+    return await getRepository(Domain).findOneBy({ id: activity.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() activity: Activity): Promise<User> {
-    return await getRepository(User).findOne(activity.updaterId)
+    return await getRepository(User).findOneBy({ id: activity.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() activity: Activity): Promise<User> {
-    return await getRepository(User).findOne(activity.creatorId)
+    return await getRepository(User).findOneBy({ id: activity.creatorId })
   }
 }

package/server/service/activity-instance/activity-instance-mutation.ts

@@ -13,18 +13,18 @@ export class ActivityInstanceMutation {
   @Mutation(returns => ActivityInstance, { description: 'To draft standard ActivityInstance' })
   async draftActivityInstance(
     @Arg('activityInstance') activityInstance: NewActivityInstance,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityInstance> {
-    return await draft(activityInstance, context.state)
+    return await draft(activityInstance, context)
   }
 
   @Directive('@transaction')
   @Mutation(returns => ActivityInstance, { description: 'To post standard ActivityInstance' })
   async postActivityInstance(
     @Arg('activityInstance') activityInstance: ActivityInstancePost,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityInstance> {
-    return await post(activityInstance, context.state)
+    return await post(activityInstance, context)
   }
 
   @Directive('@transaction')
@@ -33,29 +33,27 @@ export class ActivityInstanceMutation {
     description:
       'To pick an activity ActivityInstance voluntarily. [cautions] This resolver will return a assigned ActivityThread.'
   })
-  async pickActivityInstance(@Arg('id') id: string, @Ctx() context: any): Promise<ActivityThread> {
-    return await pick(id, context.state)
+  async pickActivityInstance(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ActivityThread> {
+    return await pick(id, context)
   }
 
   @Directive('@transaction')
   @Mutation(returns => ActivityInstance, { description: 'To assign a ActivityInstance' })
   async assignActivityInstance(
     @Arg('id') id: string,
-    @Arg('assigneeRole', { nullable: true }) assigneeRole: string,
-    @Arg('supervisoryRole', { nullable: true }) supervisoryRole: string,
+    @Arg('assignees', type => [String], { nullable: true, description: 'Email of assignee users' }) assignees: string[],
     @Arg('reason', { nullable: true }) reason: string,
     @Arg('dueAt', { nullable: true }) dueAt: Date,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityInstance> {
     return await assign(
       {
         id,
-        assigneeRole,
-        supervisoryRole,
+        assignees,
         reason,
         dueAt
       },
-      context.state
+      context
     )
   }
 
@@ -64,9 +62,9 @@ export class ActivityInstanceMutation {
   async updateActivityInstance(
     @Arg('id') id: string,
     @Arg('patch') patch: ActivityInstancePatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityInstance> {
-    return await adjust(id, patch, context.state)
+    return await adjust(id, patch, context)
   }
 
   @Directive('@transaction')
@@ -76,9 +74,9 @@ export class ActivityInstanceMutation {
     @Arg('assigneeRole', type => ObjectRef, { nullable: true }) assigneeRole: ObjectRef,
     @Arg('dueAt', { nullable: true }) dueAt: Date,
     @Arg('reason', { nullable: true }) reason: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityInstance> {
-    return await delegate({ id, assigneeRole, dueAt, reason }, context.state)
+    return await delegate({ id, assigneeRole, dueAt, reason }, context)
   }
 
   @Directive('@transaction')
@@ -87,9 +85,9 @@ export class ActivityInstanceMutation {
     @Arg('id') id: string,
     @Arg('output', type => ScalarObject, { nullable: true }) output: { [key: string]: any },
     @Arg('reason', { nullable: true }) reason: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityInstance> {
-    return await end({ id, output, reason }, context.state)
+    return await end({ id, output, reason }, context)
   }
 
   @Directive('@transaction')
@@ -97,8 +95,8 @@ export class ActivityInstanceMutation {
   async abortActivityInstance(
     @Arg('id') id: string,
     @Arg('reason', { nullable: true }) reason: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityInstance> {
-    return await abort({ id, reason }, context.state)
+    return await abort({ id, reason }, context)
   }
 }

package/server/service/activity-instance/activity-instance-query.ts

@@ -1,9 +1,8 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
 import { ActivityThread } from '../activity-thread/activity-thread'
 import { Activity } from '../activity/activity'
@@ -13,16 +12,16 @@ import { ActivityInstanceList } from './activity-instance-type'
 @Resolver(ActivityInstance)
 export class ActivityInstanceQuery {
   @Query(returns => ActivityInstance!, { nullable: true, description: 'To fetch a ActivityInstance' })
-  async activityInstance(@Arg('id') id: string, @Ctx() context: any): Promise<ActivityInstance> {
+  async activityInstance(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ActivityInstance> {
     const { domain } = context.state
 
     return await getRepository(ActivityInstance).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => ActivityInstanceList, { description: 'To fetch multiple ActivityInstances' })
-  async activityInstances(@Args() params: ListParam, @Ctx() context: any): Promise<ActivityInstanceList> {
+  async activityInstances(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityInstanceList> {
     const { domain } = context.state
 
     const [items, total] = await getQueryBuilderFromListParams({
@@ -36,7 +35,10 @@ export class ActivityInstanceQuery {
   }
 
   @Query(returns => ActivityInstanceList, { description: 'To get list of activity instance that a user can pick' })
-  async pickableActivityList(@Args() params: ListParam, @Ctx() context: any): Promise<ActivityInstanceList> {
+  async pickableActivityList(
+    @Args() params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ActivityInstanceList> {
     var { domain, user } = context.state
 
     /* 
@@ -74,7 +76,7 @@ export class ActivityInstanceQuery {
   }
 
   @Query(returns => ActivityInstanceList, { description: 'To fetch my own ActivityInstances' })
-  async draftList(@Args() params: ListParam, @Ctx() context: any): Promise<ActivityInstanceList> {
+  async draftList(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityInstanceList> {
     var { domain, user } = context.state
 
     /* 생성자가 자신이면서, 아직 Draft 상태인 activity-instance 리스트만 반환 */
@@ -102,32 +104,36 @@ export class ActivityInstanceQuery {
       return null
     }
 
-    return await getRepository(Activity).findOne(activityId)
+    return await getRepository(Activity).findOneBy({ id: activityId })
   }
 
   @FieldResolver(type => [ActivityThread])
-  async activityThreads(@Root() activityInstance: ActivityInstance, @Ctx() context: any): Promise<ActivityThread[]> {
+  async activityThreads(
+    @Root() activityInstance: ActivityInstance,
+    @Ctx() context: ResolverContext
+  ): Promise<ActivityThread[]> {
     const { user } = context.state
     const { supervisoryRoleId } = activityInstance
 
     if (supervisoryRoleId) {
       /* only user having supervisoryRole can get whole activityThreads */
       const roles = (
-        (await getRepository(User).findOne(user.id, {
+        (await getRepository(User).findOne({
+          where: { id: user.id },
           relations: ['roles']
         })) as User
       ).roles.map(role => role.id)
 
       if (!roles.includes(supervisoryRoleId)) {
-        return await getRepository(ActivityThread).find({
-          activityInstance,
-          assigneeId: user.id
+        return await getRepository(ActivityThread).findBy({
+          activityInstance: { id: activityInstance.id },
+          assignee: { id: user.id }
         })
       }
     }
 
-    return await getRepository(ActivityThread).find({
-      activityInstance
+    return await getRepository(ActivityThread).findBy({
+      activityInstance: { id: activityInstance.id }
     })
   }
 
@@ -135,7 +141,7 @@ export class ActivityInstanceQuery {
   async assigneeRole(@Root() activityInstance: ActivityInstance): Promise<Role> {
     return (
       activityInstance.assigneeRole ||
-      (await getRepository(Role).findOne({
+      (await getRepository(Role).findOneBy({
         id: activityInstance.assigneeRoleId
       }))
     )
@@ -145,7 +151,7 @@ export class ActivityInstanceQuery {
   async supervisoryRole(@Root() activityInstance: ActivityInstance): Promise<Role> {
     return (
       activityInstance.supervisoryRole ||
-      (await getRepository(Role).findOne({
+      (await getRepository(Role).findOneBy({
         id: activityInstance.supervisoryRoleId
       }))
     )
@@ -158,7 +164,7 @@ export class ActivityInstanceQuery {
       activityId &&
       (await getRepository(Attachment).findOne({
         where: {
-          domain: activityInstance.domainId,
+          domain: { id: activityInstance.domainId },
           refBy: activityId
         }
       }))
@@ -168,16 +174,16 @@ export class ActivityInstanceQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() activityInstance: ActivityInstance): Promise<Domain> {
-    return await getRepository(Domain).findOne(activityInstance.domainId)
+    return await getRepository(Domain).findOneBy({ id: activityInstance.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() activityInstance: ActivityInstance): Promise<User> {
-    return await getRepository(User).findOne(activityInstance.updaterId)
+    return await getRepository(User).findOneBy({ id: activityInstance.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() activityInstance: ActivityInstance): Promise<User> {
-    return await getRepository(User).findOne(activityInstance.creatorId)
+    return await getRepository(User).findOneBy({ id: activityInstance.creatorId })
   }
 }

package/server/service/activity-instance/activity-instance-subscription.ts

@@ -1,9 +1,8 @@
 import { withFilter } from 'graphql-subscriptions'
 import { Resolver, Root, Subscription } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { pubsub } from '@things-factory/shell'
+import { getRepository, pubsub } from '@things-factory/shell'
 
 import { ActivityInstance } from './activity-instance'
 

package/server/service/activity-instance/activity-instance-type.ts

@@ -1,6 +1,6 @@
 import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
 
-import { Role, User } from '@things-factory/auth-base'
+import { Role } from '@things-factory/auth-base'
 import { ObjectRef, ScalarDate, ScalarObject } from '@things-factory/shell'
 
 import { ActivityType, ActivityUIType } from '../activity/activity'
@@ -12,7 +12,7 @@ export class NewActivityInstance {
   name: string
 
   @Field({ nullable: true })
-  activityId?: string
+  activityId: string
 
   @Field({ nullable: true })
   description?: string
@@ -110,8 +110,8 @@ export class ActivityInstancePost {
   @Field(type => ObjectRef, { nullable: true })
   assigneeRole?: Role
 
-  @Field(type => [ObjectRef], { nullable: true })
-  assignees?: User[]
+  @Field(type => [String], { nullable: true, description: 'Email of assignee users' })
+  assignees?: string[]
 }
 
 @InputType()
@@ -137,6 +137,12 @@ export class ActivityInstancePatch {
   @Field({ nullable: true })
   state?: ActivityInstanceStatus
 
+  @Field(type => Int, { nullable: true })
+  threadsMin?: number
+
+  @Field(type => Int, { nullable: true })
+  threadsMax?: number
+
   @Field(type => ScalarDate, { nullable: true })
   dueAt?: Date
 

package/server/service/activity-instance/event-subscriber.ts

@@ -9,10 +9,6 @@ import { ActivityInstanceHistory } from './activity-instance-history'
 
 @EventSubscriber()
 export class ActivityInstanceSubscriber implements EntitySubscriberInterface<ActivityInstance> {
-  // constructor(connection: Connection) {
-  //   connection.subscribers.push(this)
-  // }
-
   listenTo() {
     return ActivityInstance
   }
@@ -23,7 +19,6 @@ export class ActivityInstanceSubscriber implements EntitySubscriberInterface<Act
     pubsub.publish('activity-instance', {
       activityInstance
     })
-    console.log('activity-instance created', activityInstance.id)
   }
 
   afterUpdate(event: UpdateEvent<ActivityInstance>): Promise<any> | void {
@@ -32,7 +27,6 @@ export class ActivityInstanceSubscriber implements EntitySubscriberInterface<Act
     pubsub.publish('activity-instance', {
       activityInstance
     })
-    console.log('activity-instance updated', activityInstance.id)
   }
 }