Refactored loaders to drop deprecated & use latest types

Author: CarsonF

src/components/budget/budget-record.loader.ts

@@ -1,5 +1,5 @@
 import { type ID, NotFoundException, type ObjectView } from '~/common';
-import { LoaderFactory, ObjectViewAwareLoader } from '~/core';
+import { LoaderFactory, ObjectViewAwareLoader } from '~/core/data-loader';
 import { BudgetService } from './budget.service';
 import { BudgetRecord } from './dto';
 

src/components/budget/budget.loader.ts

@@ -1,5 +1,5 @@
 import { type ID, type ObjectView } from '~/common';
-import { LoaderFactory, ObjectViewAwareLoader } from '~/core';
+import { LoaderFactory, ObjectViewAwareLoader } from '~/core/data-loader';
 import { BudgetService } from './budget.service';
 import { Budget } from './dto';
 

src/components/ceremony/ceremony.loader.ts

@@ -1,15 +1,15 @@
 import { type ID } from '~/common';
-import { LoaderFactory, OrderedNestDataLoader } from '~/core';
+import { type DataLoaderStrategy, LoaderFactory } from '~/core/data-loader';
 import { CeremonyService } from './ceremony.service';
 import { Ceremony } from './dto';
 
 @LoaderFactory(() => Ceremony)
-export class CeremonyLoader extends OrderedNestDataLoader<Ceremony> {
-  constructor(private readonly ceremonies: CeremonyService) {
-    super();
-  }
+export class CeremonyLoader
+  implements DataLoaderStrategy<Ceremony, ID<Ceremony>>
+{
+  constructor(private readonly ceremonies: CeremonyService) {}
 
-  async loadMany(ids: readonly ID[]) {
+  async loadMany(ids: ReadonlyArray<ID<Ceremony>>) {
     return await this.ceremonies.readMany(ids);
   }
 }

src/components/comments/comment-thread.loader.ts

@@ -1,19 +1,19 @@
 import { type ID } from '~/common';
-import { LoaderFactory, OrderedNestDataLoader } from '~/core';
+import { type DataLoaderStrategy, LoaderFactory } from '~/core/data-loader';
 import { CommentRepository } from './comment.repository';
 import { CommentService } from './comment.service';
 import { CommentThread } from './dto';
 
 @LoaderFactory(() => CommentThread)
-export class CommentThreadLoader extends OrderedNestDataLoader<CommentThread> {
+export class CommentThreadLoader
+  implements DataLoaderStrategy<CommentThread, ID<CommentThread>>
+{
   constructor(
     private readonly service: CommentService,
     private readonly repo: CommentRepository,
-  ) {
-    super();
-  }
+  ) {}
 
-  async loadMany(ids: readonly ID[]) {
+  async loadMany(ids: ReadonlyArray<ID<CommentThread>>) {
     const threads = await this.repo.threads.readMany(ids);
     return await Promise.all(
       threads.map(async (thread) => {

src/components/comments/comment.loader.ts

@@ -1,16 +1,13 @@
 import { type ID } from '~/common';
-import { OrderedNestDataLoader } from '~/core';
-import { LoaderFactory } from '~/core/resources/loader.registry';
+import { type DataLoaderStrategy, LoaderFactory } from '~/core/data-loader';
 import { CommentService } from './comment.service';
 import { Comment } from './dto';
 
 @LoaderFactory(() => Comment)
-export class CommentLoader extends OrderedNestDataLoader<Comment> {
-  constructor(private readonly comments: CommentService) {
-    super();
-  }
+export class CommentLoader implements DataLoaderStrategy<Comment, ID<Comment>> {
+  constructor(private readonly comments: CommentService) {}
 
-  async loadMany(ids: readonly ID[]) {
+  async loadMany(ids: ReadonlyArray<ID<Comment>>) {
     return await this.comments.readMany(ids);
   }
 }

src/components/engagement/engagement.loader.ts

@@ -1,5 +1,5 @@
 import { type ID, type ObjectView } from '~/common';
-import { LoaderFactory, ObjectViewAwareLoader } from '~/core';
+import { LoaderFactory, ObjectViewAwareLoader } from '~/core/data-loader';
 import {
   type Engagement,
   IEngagement,
@@ -9,7 +9,10 @@ import {
 import { EngagementService } from './engagement.service';
 
 @LoaderFactory(() => [IEngagement, LanguageEngagement, InternshipEngagement])
-export class EngagementLoader extends ObjectViewAwareLoader<Engagement> {
+export class EngagementLoader extends ObjectViewAwareLoader<
+  Engagement,
+  IEngagement
+> {
   constructor(private readonly engagements: EngagementService) {
     super();
   }

src/components/ethno-art/ethno-art.loader.ts

@@ -1,15 +1,15 @@
 import { type ID } from '~/common';
-import { LoaderFactory, OrderedNestDataLoader } from '~/core';
+import { type DataLoaderStrategy, LoaderFactory } from '~/core/data-loader';
 import { EthnoArt } from './dto';
 import { EthnoArtService } from './ethno-art.service';
 
 @LoaderFactory(() => EthnoArt)
-export class EthnoArtLoader extends OrderedNestDataLoader<EthnoArt> {
-  constructor(private readonly ethnoArt: EthnoArtService) {
-    super();
-  }
+export class EthnoArtLoader
+  implements DataLoaderStrategy<EthnoArt, ID<EthnoArt>>
+{
+  constructor(private readonly ethnoArt: EthnoArtService) {}
 
-  async loadMany(ids: readonly ID[]) {
+  async loadMany(ids: ReadonlyArray<ID<EthnoArt>>) {
     return await this.ethnoArt.readMany(ids);
   }
 }

src/components/field-region/field-region.loader.ts

@@ -1,15 +1,15 @@
 import { type ID } from '~/common';
-import { LoaderFactory, OrderedNestDataLoader } from '~/core';
+import { type DataLoaderStrategy, LoaderFactory } from '~/core/data-loader';
 import { FieldRegion } from './dto';
 import { FieldRegionService } from './field-region.service';
 
 @LoaderFactory(() => FieldRegion)
-export class FieldRegionLoader extends OrderedNestDataLoader<FieldRegion> {
-  constructor(private readonly fieldRegions: FieldRegionService) {
-    super();
-  }
+export class FieldRegionLoader
+  implements DataLoaderStrategy<FieldRegion, ID<FieldRegion>>
+{
+  constructor(private readonly fieldRegions: FieldRegionService) {}
 
-  async loadMany(ids: readonly ID[]) {
+  async loadMany(ids: ReadonlyArray<ID<FieldRegion>>) {
     return await this.fieldRegions.readMany(ids);
   }
 }

src/components/field-zone/field-zone.loader.ts

@@ -1,15 +1,15 @@
 import { type ID } from '~/common';
-import { LoaderFactory, OrderedNestDataLoader } from '~/core';
+import { type DataLoaderStrategy, LoaderFactory } from '~/core/data-loader';
 import { FieldZone } from './dto';
 import { FieldZoneService } from './field-zone.service';
 
 @LoaderFactory(() => FieldZone)
-export class FieldZoneLoader extends OrderedNestDataLoader<FieldZone> {
-  constructor(private readonly fieldZones: FieldZoneService) {
-    super();
-  }
+export class FieldZoneLoader
+  implements DataLoaderStrategy<FieldZone, ID<FieldZone>>
+{
+  constructor(private readonly fieldZones: FieldZoneService) {}
 
-  async loadMany(ids: readonly ID[]) {
+  async loadMany(ids: ReadonlyArray<ID<FieldZone>>) {
     return await this.fieldZones.readMany(ids);
   }
 }

src/components/file/file-node.loader.ts

@@ -1,15 +1,15 @@
 import { type ID } from '~/common';
-import { LoaderFactory, OrderedNestDataLoader } from '~/core';
+import { type DataLoaderStrategy, LoaderFactory } from '~/core/data-loader';
 import { Directory, File, type FileNode, FileVersion } from './dto';
 import { FileService } from './file.service';
 
 @LoaderFactory(() => [Directory, File, FileVersion])
-export class FileNodeLoader extends OrderedNestDataLoader<FileNode> {
-  constructor(private readonly files: FileService) {
-    super();
-  }
+export class FileNodeLoader
+  implements DataLoaderStrategy<FileNode, ID<'FileNode'>>
+{
+  constructor(private readonly files: FileService) {}
 
-  async loadMany(ids: ID[]) {
+  async loadMany(ids: ReadonlyArray<ID<'FileNode'>>) {
     return await this.files.getFileNodes(ids);
   }
 }