refactor: Change routing constructors to work with Components.js

src/storage/routing/ConvertingRouterRule.ts

@@ -24,9 +24,9 @@ export class ConvertingRouterRule extends RouterRule {
   private readonly typedStores: ConvertingStoreEntry[];
   private readonly defaultStore: ResourceStore;
 
-  public constructor(typedStores: ConvertingStoreEntry[], defaultStore: ResourceStore) {
+  public constructor(typedStore: ConvertingStoreEntry, defaultStore: ResourceStore) {
     super();
-    this.typedStores = typedStores;
+    this.typedStores = [ typedStore ];
     this.defaultStore = defaultStore;
   }
 

src/storage/routing/RegexRouterRule.ts

@@ -20,7 +20,8 @@ export class RegexRouterRule extends RouterRule {
   /**
    * The keys of the `storeMap` will be converted into actual RegExp objects that will be used for testing.
    */
-  public constructor(base: string, storeMap: Record<string, ResourceStore>) {
+  // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
+  public constructor(base: string, storeMap: { [ regex: string ]: ResourceStore }) {
     super();
     this.base = trimTrailingSlashes(base);
     this.regexes = new Map(Object.keys(storeMap).map((regex): [ RegExp, ResourceStore ] =>

test/unit/storage/routing/ConvertingRouterRule.test.ts

@@ -9,32 +9,23 @@ import { NotFoundHttpError } from '../../../../src/util/errors/NotFoundHttpError
 
 describe('A ConvertingRouterRule', (): void => {
   let store1: ResourceStore;
-  let store2: ResourceStore;
   let defaultStore: ResourceStore;
   let checker1: PreferenceSupport;
-  let checker2: PreferenceSupport;
   let rule: ConvertingRouterRule;
   let representation: Representation;
   let metadata: RepresentationMetadata;
 
   beforeEach(async(): Promise<void> => {
     store1 = { name: 'turtleStore' } as any;
-    store2 = { name: 'textStore' } as any;
     defaultStore = { name: 'defaultStore' } as any;
 
     checker1 = {
       async supports(input: { representation: Representation }): Promise<boolean> {
         return input.representation.metadata.contentType === 'text/turtle';
       },
     } as any;
-    checker2 = {
-      async supports(input: { representation: Representation }): Promise<boolean> {
-        return input.representation.metadata.contentType === 'application/ld+json';
-      },
-    } as any;
 
-    rule = new ConvertingRouterRule([{ store: store1, supportChecker: checker1 },
-      { store: store2, supportChecker: checker2 }], defaultStore);
+    rule = new ConvertingRouterRule({ store: store1, supportChecker: checker1 }, defaultStore);
 
     metadata = new RepresentationMetadata();
     representation = { binary: true, data: 'data!' as any, metadata };
@@ -43,9 +34,6 @@ describe('A ConvertingRouterRule', (): void => {
   it('returns the corresponding store if it supports the input.', async(): Promise<void> => {
     metadata.contentType = 'text/turtle';
     await expect(rule.handle({ identifier: { path: 'identifier' }, representation })).resolves.toBe(store1);
-
-    metadata.contentType = 'application/ld+json';
-    await expect(rule.handle({ identifier: { path: 'identifier' }, representation })).resolves.toBe(store2);
   });
 
   it('returns the defaultStore if the converter does not support the input.', async(): Promise<void> => {
@@ -54,21 +42,15 @@ describe('A ConvertingRouterRule', (): void => {
 
   it('checks if the stores contain the identifier if there is no data.', async(): Promise<void> => {
     const data: Readable = { destroy: jest.fn() } as any;
-    store1.getRepresentation = (): any => {
-      throw new NotFoundHttpError();
-    };
-    store2.getRepresentation = async(): Promise<Representation> => ({ data } as any);
-    await expect(rule.handle({ identifier: { path: 'identifier' }})).resolves.toBe(store2);
+    store1.getRepresentation = async(): Promise<Representation> => ({ data } as any);
+    await expect(rule.handle({ identifier: { path: 'identifier' }})).resolves.toBe(store1);
     expect(data.destroy).toHaveBeenCalledTimes(1);
   });
 
   it('returns the defaultStore if no other store has the resource.', async(): Promise<void> => {
     store1.getRepresentation = (): any => {
       throw new NotFoundHttpError();
     };
-    store2.getRepresentation = (): any => {
-      throw new NotFoundHttpError();
-    };
     await expect(rule.handle({ identifier: { path: 'identifier' }})).resolves.toBe(defaultStore);
   });