Expose Tools.usages

Author: CarsonF

src/components/tools/tool-usage/tool-usage-by-tool.loader.ts

@@ -0,0 +1,32 @@
+import { type ID } from '~/common';
+import {
+  type DataLoaderStrategy,
+  LoaderFactory,
+  type LoaderOptionsOf,
+} from '~/core/data-loader';
+import { type Tool } from '../tool/dto';
+import { type ToolUsage } from './dto';
+import { ToolUsageService } from './tool-usage.service';
+
+export interface UsagesByTool {
+  tool: Tool;
+  usages: readonly ToolUsage[];
+}
+
+@LoaderFactory()
+export class ToolUsageByToolLoader
+  implements DataLoaderStrategy<UsagesByTool, Tool, ID>
+{
+  constructor(private readonly usages: ToolUsageService) {}
+
+  getOptions() {
+    return {
+      propertyKey: ({ tool }) => tool,
+      cacheKeyFn: (tool) => tool.id,
+    } satisfies LoaderOptionsOf<ToolUsageByToolLoader>;
+  }
+
+  async loadMany(tools: readonly Tool[]): Promise<readonly UsagesByTool[]> {
+    return await this.usages.readManyForTools(tools);
+  }
+}

src/components/tools/tool-usage/tool-usage.gel.repository.ts

@@ -38,4 +38,18 @@ export class ToolUsageRepository
       }));
     },
   );
+
+  async listForTools(tools: readonly ID[]) {
+    return await this.db.run(this.listForToolsQuery, { tools });
+  }
+  private readonly listForToolsQuery = e.params(
+    { tools: e.array(e.uuid) },
+    ($) => {
+      const tools = e.cast(e.Tool, e.array_unpack($.tools));
+      return e.select(tools, (tool) => ({
+        tool: e.select(tool, (c) => ({ id: c.id })),
+        usages: e.select(tool.usages, this.hydrate),
+      }));
+    },
+  );
 }

src/components/tools/tool-usage/tool-usage.module.ts

@@ -3,19 +3,23 @@ import { splitDb } from '~/core/database';
 import { ToolCoreModule } from '../tool/tool.module';
 import { ResourceToolsResolver } from './resource-tools.resolver';
 import { ToolUsageByContainerLoader } from './tool-usage-by-container.loader';
+import { ToolUsageByToolLoader } from './tool-usage-by-tool.loader';
 import { ToolUsageRepository as GelRepository } from './tool-usage.gel.repository';
 import { ToolUsageLoader } from './tool-usage.loader';
 import { ToolUsageRepository as Neo4jRepository } from './tool-usage.neo4j.repository';
 import { ToolUsageResolver } from './tool-usage.resolver';
 import { ToolUsageService } from './tool-usage.service';
+import { ToolUsagesResolver } from './tool-usages.resolver';
 
 @Module({
   imports: [ToolCoreModule],
   providers: [
     ToolUsageResolver,
     ResourceToolsResolver,
+    ToolUsagesResolver,
     ToolUsageLoader,
     ToolUsageByContainerLoader,
+    ToolUsageByToolLoader,
     ToolUsageService,
     splitDb(Neo4jRepository, GelRepository),
   ],

src/components/tools/tool-usage/tool-usage.neo4j.repository.ts

@@ -69,6 +69,29 @@ export class ToolUsageRepository extends DtoRepository(ToolUsage) {
     return result;
   }
 
+  async listForTools(tools: readonly ID[]) {
+    const result = await this.db
+      .query()
+      .unwind([...tools], 'toolId')
+      .match(node('tool', 'Tool', { id: variable('toolId') }))
+      .subQuery('tool', (sub) =>
+        sub
+          .match([
+            node('node', 'ToolUsage'),
+            relation('out', '', 'tool', ACTIVE),
+            node('tool'),
+          ])
+          .subQuery('node', this.hydrate())
+          .return(collect('dto').as('usages')),
+      )
+      .return<{
+        tool: { id: ID };
+        usages: ReadonlyArray<UnsecuredDto<ToolUsage>>;
+      }>(['tool { .id }', 'usages'])
+      .run();
+    return result;
+  }
+
   async create(input: CreateToolUsage) {
     const initialProps = {
       startDate: input.startDate,

src/components/tools/tool-usage/tool-usage.service.ts

@@ -15,6 +15,7 @@ import { Privileges } from '../../authorization';
 import { Tool } from '../tool/dto';
 import { type CreateToolUsage, ToolUsage, type UpdateToolUsage } from './dto';
 import { type UsagesByContainer } from './tool-usage-by-container.loader';
+import { type UsagesByTool } from './tool-usage-by-tool.loader';
 import { ToolUsageRepository } from './tool-usage.neo4j.repository';
 
 type TypedResource = Resource & { __typename: string };
@@ -62,6 +63,23 @@ export class ToolUsageService {
     });
   }
 
+  async readManyForTools(tools: readonly Tool[]) {
+    const toolsById = mapKeys.fromList(tools, (t) => t.id).asMap;
+    const rows = await this.repo.listForTools(tools.map((t) => t.id));
+    return await Promise.all(
+      rows.map(async (row): Promise<UsagesByTool> => {
+        const tool = toolsById.get(row.tool.id)!;
+        const usages = await Promise.all(
+          row.usages.map(async (dto) => {
+            const container = await this.loadContainer(dto.container);
+            return this.secure(dto, container) ?? [];
+          }),
+        );
+        return { tool, usages: usages.flat() };
+      }),
+    );
+  }
+
   private secure(
     dto: UnsecuredDto<ToolUsage>,
     container: Resource,

src/components/tools/tool-usage/tool-usages.resolver.ts

@@ -0,0 +1,20 @@
+import { Parent, ResolveField, Resolver } from '@nestjs/graphql';
+import { Loader, type LoaderOf } from '@seedcompany/data-loader';
+import { Tool } from '../tool/dto';
+import { ToolUsage } from './dto';
+import { ToolUsageByToolLoader } from './tool-usage-by-tool.loader';
+
+@Resolver(() => Tool)
+export class ToolUsagesResolver {
+  @ResolveField(() => [ToolUsage], {
+    description: 'The usages of this tool',
+  })
+  async usages(
+    @Parent() tool: Tool,
+    @Loader(() => ToolUsageByToolLoader)
+    loader: LoaderOf<ToolUsageByToolLoader>,
+  ): Promise<readonly ToolUsage[]> {
+    const { usages } = await loader.load(tool);
+    return usages;
+  }
+}