Add projects to flowObjects response

Author: czmj

src/domain-services/flow-object/flow-object-service.ts

@@ -7,12 +7,14 @@ import Context from '../Context';
 import { LocationService } from '../location/location-service';
 import { OrganizationService } from '../organization/organization-service';
 import { PlanService } from '../plans/plan-service';
+import { ProjectService } from '../project/project-service';
 import { UsageYearService } from '../usage-year/usage-year-service';
 
 @Service()
 export class FlowObjectService {
   constructor(
     private locationService: LocationService,
+    private projectService: ProjectService,
     private planService: PlanService,
     private organizationService: OrganizationService,
     private usageYearService: UsageYearService
@@ -72,6 +74,15 @@ export class FlowObjectService {
               ),
             ];
           }
+          if (type === 'project') {
+            return [
+              'projects',
+              await this.projectService.findByIds(
+                context.models,
+                flowObjects.map((fo) => fo.objectID)
+              ),
+            ];
+          }
 
           return [];
         }

src/domain-services/flow/graphql/types.ts

@@ -4,6 +4,7 @@ import { BaseTypeWithSoftDelete } from '../../base-types';
 import Location from '../../location/graphql/types';
 import Organization from '../../organization/graphql/types';
 import Plan from '../../plans/graphql/types';
+import Project from '../../project/graphql/types';
 import UsageYear from '../../usage-year/graphql/types';
 
 @ObjectType()
@@ -22,6 +23,9 @@ export class FlowObjectsGroupedByType {
 
   @Field(() => [Plan], { nullable: true })
   plans: Plan[];
+
+  @Field(() => [Project], { nullable: true })
+  projects: Project[];
 }
 
 @ObjectType()

src/domain-services/project/graphql/resolver.ts

@@ -0,0 +1,21 @@
+import { Database } from '@unocha/hpc-api-core/src/db/type';
+import { InstanceDataOfModel } from '@unocha/hpc-api-core/src/db/util/raw-model';
+import { Arg, Ctx, Query, Resolver } from 'type-graphql';
+import { Service } from 'typedi';
+import Context from '../../Context';
+import { ProjectService } from '../project-service';
+import Project from './types';
+
+@Service()
+@Resolver(Project)
+export default class ProjectResolver {
+  constructor(private projectService: ProjectService) {}
+
+  @Query(() => Project)
+  async project(
+    @Arg('id') id: number,
+    @Ctx() context: Context
+  ): Promise<InstanceDataOfModel<Database['project']>> {
+    return await this.projectService.findById(context.models, id);
+  }
+}

src/domain-services/project/graphql/types.ts

@@ -0,0 +1,12 @@
+import { Brand } from '@unocha/hpc-api-core/src/util/types';
+import { Field, ID, ObjectType } from 'type-graphql';
+import { BaseType } from '../../base-types';
+
+@ObjectType()
+export default class Project extends BaseType {
+  @Field(() => ID)
+  id: Brand<number, { readonly s: unique symbol }, 'Project ID'>;
+
+  @Field({ nullable: true })
+  name?: string;
+}

src/domain-services/project/project-service.ts

@@ -0,0 +1,49 @@
+import { ProjectId } from '@unocha/hpc-api-core/src/db/models/project';
+import { Database } from '@unocha/hpc-api-core/src/db/type';
+import { InstanceDataOfModel } from '@unocha/hpc-api-core/src/db/util/raw-model';
+import { createBrandedValue } from '@unocha/hpc-api-core/src/util/types';
+import { Service } from 'typedi';
+
+@Service()
+export class ProjectService {
+  async findById(
+    models: Database,
+    id: number
+  ): Promise<InstanceDataOfModel<Database['project']>> {
+    const project = await models.project.get(createBrandedValue(id));
+
+    if (!project) {
+      throw new Error(`Project with ID ${id} does not exist`);
+    }
+
+    return project;
+  }
+
+  async findByIds(
+    models: Database,
+    ids: number[]
+  ): Promise<{ id: ProjectId; name?: string | null }[]> {
+    const projects = await models.project.find({
+      where: {
+        id: {
+          [models.Op.IN]: ids.map((id) => createBrandedValue(id)),
+        },
+      },
+    });
+
+    const currentProjectVersions = await models.projectVersion.find({
+      where: {
+        projectId: {
+          [models.Op.IN]: projects.map((p) =>
+            createBrandedValue(p.currentPublishedVersionId)
+          ),
+        },
+      },
+    });
+
+    return currentProjectVersions.map((pv) => ({
+      id: pv.projectId,
+      name: pv.name,
+    }));
+  }
+}