fix: Use classes instead of factory functions for stores

src/dependencies.ts

@@ -1,10 +1,10 @@
 import { createIocContainer } from "@aklinker1/zero-ioc";
 
-import { createChromeWebStore } from "./services/chrome-web-store";
-import { createEdgeAddonStore } from "./services/edge-addon-store";
+import { ChromeWebStore } from "./services/chrome-web-store";
+import { EdgeAddonStore } from "./services/edge-addon-store";
 import { createEdgeApi } from "./services/edge-api";
 import { ExtensionStoreProvider } from "./services/extension-store-provider";
-import { createFirefoxAddonStore } from "./services/firefox-addon-store";
+import { FirefoxAddonStore } from "./services/firefox-addon-store";
 import { createFirefoxApi } from "./services/firefox-api";
 import { createInMemoryCache } from "./services/in-memory-cache";
 import { createRedisCache } from "./services/redis-cache";
@@ -26,9 +26,9 @@ export type Dependencies = typeof container.registrations;
 
 export const requestScope = container
   .scope<{}>()
-  .register("chromeWebStore", createChromeWebStore)
-  .register("firefoxAddonStore", createFirefoxAddonStore)
-  .register("edgeAddonStore", createEdgeAddonStore)
+  .register("chromeWebStore", ChromeWebStore)
+  .register("firefoxAddonStore", FirefoxAddonStore)
+  .register("edgeAddonStore", EdgeAddonStore)
   .register("stores", ExtensionStoreProvider);
 
 export type RequestDependencies = ReturnType<typeof requestScope>["registrations"];

src/services/chrome-web-store.ts

@@ -2,12 +2,8 @@ import type { Cache } from "./cache";
 import { crawlExtension } from "./chrome-crawler";
 import { ExtensionStore } from "./extension-store";
 
-export type ChromeWebStore = ExtensionStore<Gql.ChromeExtension>;
-
-export function createChromeWebStore({ cache }: { cache: Cache }): ChromeWebStore {
-  return new ExtensionStore({
-    fetch: (id) => crawlExtension(String(id), "en"),
-    cacheKeyPrefix: "chrome-extension-v2-",
-    cache,
-  });
+export class ChromeWebStore extends ExtensionStore<Gql.ChromeExtension> {
+  constructor(deps: { cache: Cache }) {
+    super(deps.cache, "chrome-extension-v2-", (id) => crawlExtension(String(id), "en"));
+  }
 }

src/services/edge-addon-store.ts

@@ -2,18 +2,8 @@ import type { Cache } from "./cache";
 import type { EdgeApi } from "./edge-api";
 import { ExtensionStore } from "./extension-store";
 
-export type EdgeAddonStore = ExtensionStore<Gql.EdgeAddon>;
-
-export function createEdgeAddonStore({
-  cache,
-  edgeApi,
-}: {
-  cache: Cache;
-  edgeApi: EdgeApi;
-}): EdgeAddonStore {
-  return new ExtensionStore({
-    fetch: (id) => edgeApi.getAddon(String(id)),
-    cacheKeyPrefix: "edge-addon-v2-",
-    cache,
-  });
+export class EdgeAddonStore extends ExtensionStore<Gql.EdgeAddon> {
+  constructor(deps: { cache: Cache; edgeApi: EdgeApi }) {
+    super(deps.cache, "edge-addon-v2-", (id) => deps.edgeApi.getAddon(String(id)));
+  }
 }

src/services/extension-store.ts

@@ -8,18 +8,14 @@ export class ExtensionStore<TGqlExtension extends Gql.Extension> {
   private dataloader: DataLoader<ExtensionId, TGqlExtension>;
 
   constructor(
-    readonly options: {
-      cacheKeyPrefix: string;
-      fetch: (id: ExtensionId) => Promise<TGqlExtension | undefined>;
-      cache: Cache;
-    },
+    readonly cache: Cache,
+    readonly cacheKeyPrefix: string,
+    readonly fetch: (id: ExtensionId) => Promise<TGqlExtension | undefined>,
   ) {
     this.dataloader = new DataLoader<ExtensionId, TGqlExtension>(
       async (ids): Promise<Array<TGqlExtension | Error>> => {
         const results = await Promise.allSettled(
-          ids.map(async (id) =>
-            options.cache.with(options.cacheKeyPrefix + id, () => options.fetch(id)),
-          ),
+          ids.map(async (id) => cache.with(cacheKeyPrefix + id, () => fetch(id))),
         );
         return results.map((res) => (res.status === "fulfilled" ? res.value : res.reason));
       },

src/services/firefox-addon-store.ts

@@ -2,18 +2,8 @@ import type { Cache } from "./cache";
 import { ExtensionStore } from "./extension-store";
 import type { FirefoxApi } from "./firefox-api";
 
-export type FirefoxAddonStore = ExtensionStore<Gql.FirefoxAddon>;
-
-export function createFirefoxAddonStore({
-  cache,
-  firefoxApi,
-}: {
-  cache: Cache;
-  firefoxApi: FirefoxApi;
-}): FirefoxAddonStore {
-  return new ExtensionStore({
-    fetch: (id) => firefoxApi.getAddon(String(id)),
-    cacheKeyPrefix: "firefox-addon-v2-",
-    cache,
-  });
+export class FirefoxAddonStore extends ExtensionStore<Gql.FirefoxAddon> {
+  constructor(deps: { cache: Cache; firefoxApi: FirefoxApi }) {
+    super(deps.cache, "firefox-addon-v2-", (id) => deps.firefoxApi.getAddon(String(id)));
+  }
 }