@things-factory/worklist 6.0.21 → 6.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worklist",
-  "version": "6.0.21",
+  "version": "6.0.25",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,11 +27,11 @@
   "dependencies": {
     "@operato/graphql": "^1.0.0",
     "@operato/grist-editor": "^1.0.0",
-    "@things-factory/attachment-base": "^6.0.21",
-    "@things-factory/auth-base": "^6.0.21",
-    "@things-factory/board-service": "^6.0.21",
-    "@things-factory/organization": "^6.0.21",
-    "@things-factory/shell": "^6.0.21"
+    "@things-factory/attachment-base": "^6.0.25",
+    "@things-factory/auth-base": "^6.0.25",
+    "@things-factory/board-service": "^6.0.25",
+    "@things-factory/organization": "^6.0.25",
+    "@things-factory/shell": "^6.0.25"
   },
-  "gitHead": "074a4f460d08fed4bc7e9882aa57f4c120cf0f11"
+  "gitHead": "8a987a42de944dc915b8cfddb047eb7bc0d4ba41"
 }

package/server/controllers/activity-installation-controller.ts

@@ -0,0 +1,17 @@
+import { InstallableActivity } from '../service/installable-activity/installable-activity'
+
+export class ActivityInstallations {
+  static templates: { [name: string]: InstallableActivity } = {}
+
+  static installActivityTemplate(template: InstallableActivity) {
+    ActivityInstallations.templates[template.name] = template
+  }
+
+  static get(name: string): InstallableActivity {
+    return ActivityInstallations.templates[name]
+  }
+
+  static list(): InstallableActivity[] {
+    return Object.values(ActivityInstallations.templates)
+  }
+}

package/server/controllers/activity-instance/bid.ts

@@ -0,0 +1,52 @@
+import { In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+
+import { ActivityInstance, ActivityInstanceStatus } from '../../service/activity-instance/activity-instance'
+import { ActivityInstancePost } from '../../service/activity-instance/activity-instance-type'
+import { createActivityThreadsForAllRoleUsers, createActivityThreadsForUsers } from '../common'
+
+export async function bid(activityInstance: ActivityInstancePost, context: ResolverContext): Promise<ActivityInstance> {
+  const { domain, user, tx } = context.state
+  const { id, assignees } = activityInstance
+
+  var origin = id
+    ? await tx.getRepository(ActivityInstance).findOne({
+        where: { domain: { id: domain.id }, id },
+        relations: [
+          'domain',
+          'activity',
+          'assigneeRole',
+          'supervisoryRole',
+          'updater',
+          'creator',
+          'starter',
+          'terminator'
+        ]
+      })
+    : null
+
+  const bid = await tx.getRepository(ActivityInstance).save({
+    ...origin,
+    ...activityInstance,
+    transaction: 'bid',
+    state: ActivityInstanceStatus.Posted,
+    domain,
+    creator: user,
+    updater: user
+  })
+
+  const assignedUsers = await tx.getRepository(User).findBy({
+    email: In(assignees || [])
+  })
+
+  if (bid.threadsMin === 0 && bid.assigneeRoleId) {
+    await createActivityThreadsForAllRoleUsers('post', bid, context)
+  }
+
+  if (assignedUsers.length > 0) {
+    await createActivityThreadsForUsers('post', bid, assignedUsers, context)
+  }
+
+  return await tx.getRepository(ActivityInstance).findOneBy({ id: bid.id })
+}

package/server/controllers/activity-instance/post.ts

@@ -1,10 +1,10 @@
-import { In } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-
 import { ActivityInstance, ActivityInstanceStatus } from '../../service/activity-instance/activity-instance'
 import { ActivityInstancePost } from '../../service/activity-instance/activity-instance-type'
-import { createActivityThreadsForAllRoleUsers, createActivityThreadsForUsers } from '../common'
+import {
+  createActivityThreadsForAllRoleUsers,
+  createActivityThreadsForUsers,
+  getSystemUserFromAssigneeItem
+} from '../common'
 
 export async function post(
   activityInstance: ActivityInstancePost,
@@ -39,11 +39,11 @@ export async function post(
     updater: user
   })
 
-  const assignedUsers = await tx.getRepository(User).findBy({
-    email: In(assignees || [])
-  })
+  const assignedUsers = await Promise.all(assignees.map(assignee => getSystemUserFromAssigneeItem(assignee, context)))
+
+  assignees.map(async assignee => await getSystemUserFromAssigneeItem(assignee, context))
 
-  if (posted.threadsMin === 0 && posted.assigneeRoleId) {
+  if (assignedUsers.length == 0 && posted.threadsMin === 0 && posted.assigneeRoleId) {
     await createActivityThreadsForAllRoleUsers('post', posted, context)
   }
 

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

@@ -2,7 +2,7 @@ import { ActivityThread, ActivityThreadStatus } from '../../service/activity-thr
 import { ActivityApproval, ActivityApprovalJudgment } from '../../service/activity-approval/activity-approval'
 import { getSystemUserFromApprovalLineItem, updateActivityInstanceState } from '../common'
 import { User } from '@things-factory/auth-base'
-import { Department, Employee, ApprovalLineItem, ApprovalLineItemType } from '@things-factory/organization'
+import { Department, Employee, ApprovalLineItem, OrgMemberTargetType } from '@things-factory/organization'
 
 export async function submit(
   { id, output, reason }: { id: string; output?: object; reason?: string },

package/server/controllers/call-webhook.ts

@@ -0,0 +1,40 @@
+import { EntityManager } from 'typeorm'
+import { Application } from '@things-factory/auth-base'
+import { Domain, getRepository } from '@things-factory/shell'
+
+export async function callWebhook(domain: Domain, tag: string, data: any, tx?: EntityManager) {
+  /* 
+    TODO webhook callback의 다양한 subscription 조건을 지원한다. 
+    - activity의 client에 해당하는 application
+    - activityInstance의 starter에 해당하는 application
+    - 모든 이벤트를 받고자하는 application
+    - 특정 activity들의 이벤트를 받고자하는 application
+  */
+
+  const applications = await (tx ? tx.getRepository(Application) : getRepository(Application)).findBy({
+    domain: { id: domain.id }
+  })
+  const options = {
+    method: 'post',
+    headers: {
+      'x-things-factory-domain': domain.name,
+      'Content-Type': 'application/json'
+    },
+    body: {
+      tag,
+      data
+    } as any
+  }
+
+  try {
+    applications
+      .filter(app => app.webhook)
+      .every(app => {
+        const webhook = app.webhook
+
+        fetch(webhook, options)
+      })
+  } catch (err) {
+    console.error(err)
+  }
+}

package/server/controllers/common.ts

@@ -1,8 +1,8 @@
 import { Role, User } from '@things-factory/auth-base'
 
-import { ActivityInstance, ActivityInstanceStatus } from '../service/activity-instance/activity-instance'
+import { ActivityInstance, ActivityInstanceStatus, AssigneeItem } from '../service/activity-instance/activity-instance'
 import { ActivityThread, ActivityThreadStatus } from '../service/activity-thread/activity-thread'
-import { Department, Employee, ApprovalLineItem, ApprovalLineItemType } from '@things-factory/organization'
+import { Department, Employee, ApprovalLineItem, OrgMemberTargetType } from '@things-factory/organization'
 
 export async function updateActivityInstanceState(id: string, context: ResolverContext) {
   const { tx } = context.state
@@ -120,20 +120,56 @@ export async function getSystemUserFromApprovalLineItem(
   const { type, value, approver } = approvalLineItem
   const { id: approverId, name, description, controlNo } = approver
 
-  if (type == ApprovalLineItemType.Employee) {
+  if (type == OrgMemberTargetType.Employee) {
     const employee = await tx.getRepository(Employee).findOne({ where: { id: approverId }, relations: ['user'] })
 
     if (!employee || !employee.user) {
       return
     }
     return employee.user
-  } else if (type == ApprovalLineItemType.Department) {
+  } else if (type == OrgMemberTargetType.Department) {
     const department = await tx.getRepository(Department).findOne({ where: { id: approverId }, relations: ['manager'] })
 
     if (!department || !department.manager) {
       return
     }
     return await tx.getRepository(User).findOneBy({ id: department.manager.userId })
-  } else if (type == ApprovalLineItemType.Role) {
+  } else if (type == OrgMemberTargetType.Role) {
+  } else if (type == OrgMemberTargetType.Myself) {
+    return user
+  } else if (type == OrgMemberTargetType.MyDepartment) {
+    // return user
+  } else if (type == OrgMemberTargetType.MySupervisor) {
+    // return user
+  }
+}
+
+export async function getSystemUserFromAssigneeItem(assigneeItem: AssigneeItem, context: any): Promise<User> {
+  const { domain, user, tx } = context.state
+
+  const { type, value, assignee } = assigneeItem
+  const { id: assigneeId, name, description, controlNo } = assignee
+
+  if (type == OrgMemberTargetType.Employee) {
+    const employee = await tx.getRepository(Employee).findOne({ where: { id: assigneeId }, relations: ['user'] })
+
+    if (!employee || !employee.user) {
+      return
+    }
+    return employee.user
+  } else if (type == OrgMemberTargetType.Department) {
+    const department = await tx.getRepository(Department).findOne({ where: { id: assigneeId }, relations: ['manager'] })
+
+    if (!department || !department.manager) {
+      return
+    }
+    return await tx.getRepository(User).findOneBy({ id: department.manager.userId })
+  } else if (type == OrgMemberTargetType.Role) {
+  } else if (type == OrgMemberTargetType.Myself) {
+    return user
+  } else if (type == OrgMemberTargetType.MyDepartment) {
+    // return user
+  } else if (type == OrgMemberTargetType.MySupervisor) {
+    // return user
   }
 }

package/server/controllers/index.ts

@@ -0,0 +1 @@
+export * from './activity-installation-controller'

package/server/index.ts

@@ -1,5 +1,5 @@
 import './routes'
 
-export * from './migrations'
+export * from './controllers'
 export * from './middlewares'
 export * from './service'

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

@@ -29,8 +29,8 @@ registerEnumType(ActivityModelItemType, {
 
 @ObjectType({ description: 'Entity for ActivityModelItem' })
 export class ActivityModelItem {
-  @Field()
-  name: string
+  @Field({ nullable: true })
+  name?: string
 
   @Field({ nullable: true })
   description?: string
@@ -60,7 +60,7 @@ export class ActivityModelItem {
   unit?: string
 
   @Field(type => [Int], { nullable: true })
-  quantifier: number[]
+  quantifier?: number[]
 
   @Field(type => ScalarObject, { nullable: true })
   spec?: { [key: string]: any }

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

@@ -5,7 +5,7 @@ import { Attachment } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
 import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
-import { Activity } from './activity'
+import { Activity, ActivityStatus } from './activity'
 import { ActivityList } from './activity-type'
 
 @Resolver(Activity)
@@ -64,6 +64,7 @@ export class ActivityQuery {
       searchables: ['name', 'description']
     })
       .andWhere(`activity.startable = :startable`, { startable: true })
+      .andWhere(`activity.state = :state`, { state: ActivityStatus.Released })
       .andWhere(
         roles.length > 0
           ? new Brackets(qb => {

package/server/service/activity/activity.ts

@@ -173,6 +173,13 @@ export class Activity {
   @Field({ nullable: true })
   updatedAt?: Date
 
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'User assigned to the client application' })
+  client?: User
+
+  @RelationId((activity: Activity) => activity.creator)
+  clientId?: string
+
   @ManyToOne(type => User, { nullable: true })
   @Field(type => User, { nullable: true })
   creator?: User

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

@@ -1,8 +1,9 @@
 import { EventSubscriber, EntitySubscriberInterface, InsertEvent, UpdateEvent } from 'typeorm'
 
-import { pubsub } from '@things-factory/shell'
+import { Domain, pubsub } from '@things-factory/shell'
 
 import { ActivityApproval } from './activity-approval'
+import { callWebhook } from '../../controllers/call-webhook'
 
 @EventSubscriber()
 export class ActivityApprovalSubscriber implements EntitySubscriberInterface<ActivityApproval> {
@@ -10,19 +11,35 @@ export class ActivityApprovalSubscriber implements EntitySubscriberInterface<Act
     return ActivityApproval
   }
 
-  afterInsert(event: InsertEvent<ActivityApproval>): Promise<any> | void {
-    const activityApproval = event.entity
+  async afterInsert(event: InsertEvent<ActivityApproval>): Promise<any | void> {
+    const { manager: tx, entity } = event
+    const activityApproval = await tx.getRepository(ActivityApproval).findOne({
+      where: { id: entity.id },
+      relations: ['domain', 'activityThread']
+    })
 
     pubsub.publish('activity-approval', {
       activityApproval
     })
+
+    try {
+      callWebhook(activityApproval.domain, 'activity-approval-created', activityApproval, tx)
+    } catch (err) {}
   }
 
-  afterUpdate(event: UpdateEvent<ActivityApproval>): Promise<any> | void {
-    const activityApproval = event.entity
+  async afterUpdate(event: UpdateEvent<ActivityApproval>): Promise<any | void> {
+    const { manager: tx, entity } = event
+    const activityApproval = await tx.getRepository(ActivityApproval).findOne({
+      where: { id: entity.id },
+      relations: ['domain', 'activityThread']
+    })
 
     pubsub.publish('activity-approval', {
       activityApproval
     })
+
+    try {
+      callWebhook(activityApproval.domain, 'activity-approval-updated', activityApproval, tx)
+    } catch (err) {}
   }
 }

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

@@ -6,7 +6,7 @@ import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from
 
 import { ActivityThread } from '../activity-thread/activity-thread'
 import { Activity } from '../activity/activity'
-import { ActivityInstance, ActivityInstanceStatus } from './activity-instance'
+import { ActivityInstance, ActivityInstanceStatus, AssigneeItem } from './activity-instance'
 import { ActivityInstanceList } from './activity-instance-type'
 
 @Resolver(ActivityInstance)
@@ -150,6 +150,49 @@ export class ActivityInstanceQuery {
     )
   }
 
+  @FieldResolver(type => [AssigneeItem])
+  async assignees(
+    @Root() activityInstance: ActivityInstance,
+    @Ctx() context: ResolverContext
+  ): Promise<AssigneeItem[]> {
+    const { domain, user } = context.state
+    const { assignees } = activityInstance
+
+    if (!assignees || !(assignees instanceof Array)) {
+      return null
+    }
+
+    var assigneeItemList = []
+
+    for (let item of assignees) {
+      var { type, value: id } = item
+      var assignee
+
+      switch (type) {
+        case 'Employee':
+          assignee = await getRepository('Employee').findOneBy({ domain: { id: domain.id }, id })
+          break
+        case 'Department':
+          assignee = await getRepository('Department').findOneBy({ domain: { id: domain.id }, id })
+          break
+        case 'Role':
+          assignee = await getRepository('Role').findOneBy({ domain: { id: domain.id }, id })
+          break
+        case 'Myself':
+          assignee = user
+          break
+        case 'MyDepartment':
+        case 'MySupervisor':
+          break
+        default:
+      }
+
+      assignee && assigneeItemList.push({ type, value: id, assignee })
+    }
+
+    return assigneeItemList
+  }
+
   @FieldResolver(type => Role)
   async supervisoryRole(@Root() activityInstance: ActivityInstance): Promise<Role> {
     return (

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

@@ -5,8 +5,7 @@ import { ObjectRef, ScalarDate, ScalarObject } from '@things-factory/shell'
 import { ApprovalLineItem } from '@things-factory/organization'
 
 import { ActivityType, ActivityUIType } from '../activity/activity'
-import { ActivityInstance, ActivityInstanceStatus } from './activity-instance'
-
+import { AssigneeItem, ActivityInstance, ActivityInstanceStatus } from './activity-instance'
 @InputType()
 export class NewActivityInstance {
   @Field()
@@ -57,6 +56,9 @@ export class NewActivityInstance {
   @Field(type => ObjectRef, { nullable: true })
   assigneeRole?: Role
 
+  @Field(type => ScalarObject, { nullable: true })
+  assignees?: AssigneeItem[]
+
   @Field(type => ScalarObject, { nullable: true })
   approvalLine?: ApprovalLineItem[]
 }
@@ -114,8 +116,8 @@ export class ActivityInstancePost {
   @Field(type => ObjectRef, { nullable: true })
   assigneeRole?: Role
 
-  @Field(type => [String], { nullable: true, description: 'Email of assignee users' })
-  assignees?: string[]
+  @Field(type => ScalarObject, { nullable: true })
+  assignees?: AssigneeItem[]
 
   @Field(type => ScalarObject, { nullable: true })
   approvalLine?: ApprovalLineItem[]
@@ -126,6 +128,9 @@ export class ActivityInstanceSave {
   @Field(type => ScalarObject, { nullable: true })
   output?: { [key: string]: any }
 
+  @Field(type => ScalarObject, { nullable: true })
+  assignees?: AssigneeItem[]
+
   @Field(type => ScalarObject, { nullable: true })
   approvalLine?: ApprovalLineItem[]
 }
@@ -159,6 +164,9 @@ export class ActivityInstancePatch {
   @Field(type => ScalarObject, { nullable: true })
   input?: { [key: string]: any }
 
+  @Field(type => ScalarObject, { nullable: true })
+  assignees?: AssigneeItem[]
+
   @Field(type => ScalarObject, { nullable: true })
   approvalLine?: ApprovalLineItem[]
 

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

@@ -14,7 +14,7 @@ import {
 
 import { Role, User } from '@things-factory/auth-base'
 import { Domain, ScalarObject } from '@things-factory/shell'
-import { ApprovalLineItem } from '@things-factory/organization'
+import { OrgMemberTargetType, OrgMemberTarget, ApprovalLineItem } from '@things-factory/organization'
 
 import { ActivityThread } from '../activity-thread/activity-thread'
 import { Activity, ActivityType, ActivityUIType } from '../activity/activity'
@@ -35,6 +35,18 @@ registerEnumType(ActivityInstanceStatus, {
   description: 'state enumeration of a activityInstance'
 })
 
+@ObjectType()
+export class AssigneeItem {
+  @Field(type => OrgMemberTargetType, { nullable: true })
+  type?: OrgMemberTargetType
+
+  @Field({ nullable: true })
+  value?: string
+
+  @Field(type => OrgMemberTarget, { nullable: true })
+  assignee?: OrgMemberTarget
+}
+
 @Entity()
 @Index(
   'ix_activity_instance_0',
@@ -152,6 +164,10 @@ export class ActivityInstance {
   @Field({ nullable: true })
   transaction?: string
 
+  @Column('simple-json', { nullable: true })
+  @Field(type => [AssigneeItem], { nullable: true })
+  assignees?: AssigneeItem[]
+
   @Column('simple-json', { nullable: true })
   @Field(type => [ApprovalLineItem], { nullable: true })
   approvalLine?: ApprovalLineItem[]

package/server/service/index.ts

@@ -4,6 +4,7 @@ export * from './activity-thread/activity-thread'
 export * from './activity-template/activity-template'
 export * from './activity-instance/activity-instance'
 export * from './activity/activity'
+export * from './installable-activity/installable-activity'
 export * from './activity-summary/activity-summary'
 
 /* IMPORT ENTITIES AND RESOLVERS */
@@ -28,6 +29,10 @@ import {
   resolvers as ActivityThreadResolvers,
   subscribers as ActivityThreadSubscribers
 } from './activity-thread'
+import {
+  entities as InstallableActivityEntities,
+  resolvers as InstallableActivityResolvers
+} from './installable-activity'
 import { entities as ActivitySummaryEntities, resolvers as ActivitySummaryResolvers } from './activity-summary'
 
 export const entities = [
@@ -37,6 +42,7 @@ export const entities = [
   ...ActivityInstanceEntities,
   ...ActivityTemplateEntities,
   ...ActivityThreadEntities,
+  ...InstallableActivityEntities,
   ...ActivitySummaryEntities
 ]
 
@@ -56,6 +62,7 @@ export const schema = {
     ...ActivityInstanceResolvers,
     ...ActivityTemplateResolvers,
     ...ActivityThreadResolvers,
+    ...InstallableActivityResolvers,
     ...ActivitySummaryResolvers
   ]
 }

package/server/service/installable-activity/index.ts

@@ -0,0 +1,7 @@
+import { InstallableActivity } from './installable-activity'
+import { InstallableActivityQuery } from './installable-activity-query'
+import { InstallableActivityMutation } from './installable-activity-mutation'
+
+export const entities = [InstallableActivity]
+export const resolvers = [InstallableActivityQuery, InstallableActivityMutation]
+export const subscribers = []

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

@@ -0,0 +1,61 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+
+import { ActivityInstallations } from '../../controllers/activity-installation-controller'
+import { Activity, ActivityStatus } from '../activity/activity'
+import { InstallableActivity } from './installable-activity'
+
+@Resolver(InstallableActivity)
+export class InstallableActivityMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Activity, { description: 'To activate installable activity to Activity on given domain' })
+  async activateInstallableActivity(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Activity> {
+    const { domain, user, tx } = context.state
+    const installableActivity = ActivityInstallations.get(name)
+    const repository = tx.getRepository(Activity)
+
+    const activity = await repository.findOneBy({
+      domain: { id: domain.id },
+      name
+    })
+
+    if (!activity) {
+      return await repository.save({
+        ...(installableActivity as any),
+        state: ActivityStatus.Released,
+        domain,
+        creator: user,
+        updater: user
+      })
+    } else {
+      return await repository.save({
+        ...activity,
+        ...(installableActivity as any),
+        state: ActivityStatus.Released,
+        domain,
+        updater: user
+      })
+    }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Activity, { description: 'To deactivate installable activity to Activity on given domain' })
+  async deactivateInstallableActivity(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Activity> {
+    const { domain, user, tx } = context.state
+    const repository = tx.getRepository(Activity)
+
+    const activity = await repository.findOneBy({
+      domain: { id: domain.id },
+      name
+    })
+
+    if (!activity) {
+      return
+    }
+
+    return await repository.save({
+      ...activity,
+      state: ActivityStatus.Deprecated,
+      updater: user
+    })
+  }
+}

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

@@ -0,0 +1,36 @@
+import { Arg, Args, Ctx, Query, Resolver, FieldResolver, Root } from 'type-graphql'
+import { Domain, getRepository, ListParam } from '@things-factory/shell'
+
+import { ActivityInstallations } from '../../controllers/activity-installation-controller'
+import { Activity } from '../activity/activity'
+import { InstallableActivity } from './installable-activity'
+import { InstallableActivityList } from './installable-activity-type'
+
+@Resolver(InstallableActivity)
+export class InstallableActivityQuery {
+  @Query(returns => InstallableActivity!, { nullable: true, description: 'To fetch a InstallableActivity' })
+  async installableActivity(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<InstallableActivity> {
+    return await ActivityInstallations.get(name)
+  }
+
+  @Query(returns => InstallableActivityList, { description: 'To fetch multiple InstallableActivitys' })
+  async installableActivities(
+    @Args() params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<InstallableActivityList> {
+    const { domain } = context.state
+
+    const items = ActivityInstallations.list()
+
+    for (var item of items) {
+      item.activity = await getRepository(Activity).findOneBy({
+        domain: { id: domain.id },
+        name: item.name
+      })
+    }
+
+    const total = items.length
+
+    return { items, total }
+  }
+}

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

@@ -0,0 +1,12 @@
+import { Field, Int, ObjectType } from 'type-graphql'
+
+import { InstallableActivity } from './installable-activity'
+
+@ObjectType()
+export class InstallableActivityList {
+  @Field(type => [InstallableActivity])
+  items: InstallableActivity[]
+
+  @Field(type => Int)
+  total: number
+}