whattheduck: Reduce amount of calls to retrieve coa counts

bperel · bperel · commit 391e185357d5 · 2024-10-02T23:17:44.000+02:00
diff --git a/apps/web/src/pages/stats/possessions.vue b/apps/web/src/pages/stats/possessions.vue
@@ -46,7 +46,7 @@ let chartData = $ref<ChartData<"bar", number[]> | null>(null),
   unitTypeCurrent = $ref<string>("number"),
   options = $ref<ChartOptions<"bar">>({});
 
-const { loadCollection, fetchIssueCountsByPublicationcode } = collection();
+const { loadCollection } = collection();
 const {
   totalPerPublicationUniqueIssuecodesSorted,
   coaIssueCountsByPublicationcode,
@@ -107,7 +107,6 @@ watch(
     await fetchPublicationNames(
       newValue.map(([publicationcode]) => publicationcode),
     );
-    await fetchIssueCountsByPublicationcode();
     hasCoaData = true;
   },
   { immediate: true },
diff --git a/apps/web/src/stores/collection.ts b/apps/web/src/stores/collection.ts
@@ -47,9 +47,9 @@ export const collection = defineStore("collection", () => {
 
   const { bookcaseWithPopularities } = storeToRefs(bookcase());
 
-  const issues = shallowRef<EventReturnType<
-    CollectionServices["getIssues"]
-  > | null>(null);
+  const issues = shallowRef<
+    EventReturnType<CollectionServices["getIssues"]>["issues"] | null
+  >(null);
 
   const collectionUtils = useCollection(
       issues as ShallowRef<(issue & { issuecode: string })[]>,
@@ -75,12 +75,16 @@ export const collection = defineStore("collection", () => {
     isLoadingPurchases = ref(false),
     isLoadingSuggestions = ref(false),
     isLoadingSubscriptions = ref(false),
-    coaIssueCountsPerCountrycode = shallowRef<EventReturnType<
-      CollectionServices["getCoaCountByCountrycode"]
-    > | null>(null),
-    coaIssueCountsByPublicationcode = shallowRef<EventReturnType<
-      CollectionServices["getCoaCountByPublicationcode"]
-    > | null>(null),
+    coaIssueCountsPerCountrycode = shallowRef<
+      | EventReturnType<CollectionServices["getIssues"]>["countByCountrycode"]
+      | null
+    >(null),
+    coaIssueCountsByPublicationcode = shallowRef<
+      | EventReturnType<
+          CollectionServices["getIssues"]
+        >["countByPublicationcode"]
+      | null
+    >(null),
     user = shallowRef<
       EventReturnType<CollectionServices["getUser"]> | undefined | null
     >(undefined),
@@ -162,16 +166,6 @@ export const collection = defineStore("collection", () => {
       await collectionServices.deletePurchase(id);
       await loadPurchases(true);
     },
-    fetchIssueCountsByCountrycode = async (force = false) => {
-      if (!coaIssueCountsByPublicationcode.value || force)
-        coaIssueCountsPerCountrycode.value =
-          await collectionServices.getCoaCountByCountrycode();
-    },
-    fetchIssueCountsByPublicationcode = async (force = false) => {
-      if (!coaIssueCountsByPublicationcode.value || force)
-        coaIssueCountsByPublicationcode.value =
-          await collectionServices.getCoaCountByPublicationcode();
-    },
     fetchPublicationNames = () => collectionServices.getPublicationTitles(),
     loadPreviousVisit = async () => {
       const result = await collectionServices.getLastVisit();
@@ -184,7 +178,11 @@ export const collection = defineStore("collection", () => {
     loadCollection = async (afterUpdate = false) => {
       if (afterUpdate || (!isLoadingCollection.value && !issues.value)) {
         isLoadingCollection.value = true;
-        issues.value = await collectionServices.getIssues();
+        ({
+          issues: issues.value,
+          countByCountrycode: coaIssueCountsPerCountrycode.value,
+          countByPublicationcode: coaIssueCountsByPublicationcode.value,
+        } = await collectionServices.getIssues());
         Object.assign(
           coa().issuecodeDetails,
           issues.value.map(({ issuecode, publicationcode, issuenumber }) => ({
@@ -376,8 +374,6 @@ export const collection = defineStore("collection", () => {
     publicationUrlRoot,
     createPurchase,
     deletePurchase,
-    fetchIssueCountsByCountrycode,
-    fetchIssueCountsByPublicationcode,
     fetchPublicationNames,
     hasRole,
     hasSuggestions,
diff --git a/apps/whattheduck/src/stores/wtdcollection.ts b/apps/whattheduck/src/stores/wtdcollection.ts
@@ -16,8 +16,6 @@ export const wtdcollection = defineStore('wtdcollection', () => {
   const {
     createPurchase,
     findInCollection,
-    fetchIssueCountsByCountrycode,
-    fetchIssueCountsByPublicationcode,
     fetchPublicationNames,
     isLoadingSuggestions,
     loadCollection,
@@ -71,9 +69,6 @@ export const wtdcollection = defineStore('wtdcollection', () => {
       await usersStore.fetchStats([webCollectionStore.user?.id || 0], force);
       // TODO retrieve user notification countries
 
-      await fetchIssueCountsByCountrycode(force);
-      await fetchIssueCountsByPublicationcode(force);
-
       (async () => {
         await loadSuggestions({ countryCode: 'ALL', sinceLastVisit: false });
         await statsStore.loadRatings();
@@ -96,7 +91,6 @@ export const wtdcollection = defineStore('wtdcollection', () => {
     coaIssueCountsPerCountrycode,
     createPurchase,
     fetchCollection,
-    fetchIssueCountsByPublicationcode,
     findInCollection,
     getCollectionIssues,
     highestQuotedIssue,
diff --git a/apps/whattheduck/src/views/CoverSearchResults.vue b/apps/whattheduck/src/views/CoverSearchResults.vue
@@ -34,10 +34,10 @@
                   numberOfUsers: issuePopularities[cover.issuecode]!.popularity,
                 })
               }}</ion-col></ion-row
-            ><ion-row style="font-size: 0.8rem; width: 100%" v-if="getEstimationWithAverage(cover.issuecode)"
+            ><ion-row style="font-size: 0.8rem; width: 100%" v-if="issueQuotations[cover.issuecode]"
               ><ion-col size="2"><ion-icon :ios="pricetagOutline" :md="pricetagSharp"></ion-icon></ion-col
               ><ion-col class="ion-text-left"
-                ><IssueQuotation :issue="getEstimationWithAverage(cover.issuecode)" /></ion-col></ion-row
+                ><IssueQuotation :issue="{ ...cover, ...issueQuotations[cover.issuecode] }" /></ion-col></ion-row
           ></ion-row>
         </div>
         <ion-note>
@@ -77,14 +77,8 @@ import type CoverIdServices from '~dm-services/cover-id/types';
 
 const { t } = useI18n();
 const hasCoaData = ref(false);
-const { issuecodeDetails, publicationNames, issuePopularities } = storeToRefs(webStores.coa());
-const {
-  fetchPublicationNames,
-  fetchIssuecodeDetails,
-  fetchIssuePopularities,
-  fetchIssueQuotations,
-  getEstimationWithAverage,
-} = webStores.coa();
+const { issuecodeDetails, publicationNames, issuePopularities, issueQuotations } = storeToRefs(webStores.coa());
+const { fetchPublicationNames, fetchIssuecodeDetails, fetchIssuePopularities, fetchIssueQuotations } = webStores.coa();
 const { currentNavigationItem } = storeToRefs(app());
 
 const { IssueQuotation } = webComponents;
diff --git a/packages/api/services/collection/issues/index.ts b/packages/api/services/collection/issues/index.ts
@@ -7,10 +7,10 @@ import { augmentIssueArrayWithInducksData } from "~/services/coa";
 import { getPublicationTitles } from "~/services/coa/publications";
 import type { InducksIssueQuotationSimple } from "~dm-types/InducksIssueQuotationSimple";
 import type { TransactionResults } from "~dm-types/TransactionResults";
-import { prismaClient as prismaCoa } from "~prisma-schemas/schemas/coa/client";
 import type { issue, user } from "~prisma-schemas/schemas/dm";
 import { issue_condition } from "~prisma-schemas/schemas/dm";
 import { prismaClient as prismaDm } from "~prisma-schemas/schemas/dm/client";
+import { prismaClient as prismaCoa } from "~prisma-schemas/schemas/coa/client";
 
 import type Events from "../types";
 import {
@@ -19,23 +19,65 @@ import {
   handleIsOnSale,
 } from "./util";
 
-export const getCollectionCountrycodes = (userId: number) =>
-  getCollectionPublicationcodes(userId).then((data) => [
-    ...new Set(data.map((publicationcode) => publicationcode.split("/")[0])),
-  ]);
-
-export const getCollectionPublicationcodes = (userId: number) =>
-  prismaDm.issue
-    .findMany({
-      distinct: ["publicationcode"],
-      select: {
-        publicationcode: true,
+const getCoaCountByPublicationcode = (collectionPublicationcodes: string[]) =>
+  prismaCoa.inducks_issue
+    .groupBy({
+      _count: {
+        issuenumber: true,
       },
       where: {
-        userId,
+        publicationcode: {
+          in: collectionPublicationcodes,
+        },
+      },
+      by: ["publicationcode"],
+    })
+    .then((data) =>
+      Object.fromEntries(
+        data.map(({ publicationcode, _count }) => [
+          publicationcode!,
+          _count.issuenumber,
+        ]),
+      ),
+    );
+
+const getCoaCountByCountrycode = (collectionCountrycodes: string[]) =>
+  prismaCoa.inducks_issue
+    .groupBy({
+      _count: {
+        issuenumber: true,
+      },
+      where: {
+        OR: collectionCountrycodes.map((countrycode) => ({
+          publicationcode: {
+            startsWith: `${countrycode}/`,
+          },
+        })),
       },
+      by: ["publicationcode"],
     })
-    .then((data) => [...data.map(({ publicationcode }) => publicationcode!)]);
+    .then((data) =>
+      data.reduce<Record<string, number>>(
+        (acc, { publicationcode, _count }) => {
+          const countrycode = publicationcode!.split("/")[0];
+          acc[countrycode] = _count.issuenumber + (acc[countrycode] || 0);
+          return acc;
+        },
+        {},
+      ),
+    );
+
+export const getCollectionCountrycodes = (issues: issue[]) => [
+  ...new Set(
+    getCollectionPublicationcodes(issues).map(
+      (publicationcode) => publicationcode.split("/")[0],
+    ),
+  ),
+];
+
+export const getCollectionPublicationcodes = (issues: issue[]) => [
+  ...new Set(issues.map(({ publicationcode }) => publicationcode!)),
+];
 
 export default (socket: Socket<Events>) => {
   socket.on("getPublicationTitles", async (callback) =>
@@ -65,6 +107,28 @@ export default (socket: Socket<Events>) => {
           issues as (issue & { issuecode: string })[],
         ),
       )
+      .then(async (issues) => {
+        const collectionPublicationcodes = [
+          ...new Set(issues.map(({ publicationcode }) => publicationcode!)),
+        ];
+        const collectionCountrycodes = [
+          ...new Set(
+            collectionPublicationcodes.map(
+              (publicationcode) => publicationcode.split("/")[0],
+            ),
+          ),
+        ];
+
+        return {
+          issues,
+          countByCountrycode: await getCoaCountByCountrycode(
+            collectionCountrycodes,
+          ),
+          countByPublicationcode: await getCoaCountByPublicationcode(
+            collectionPublicationcodes,
+          ),
+        };
+      })
       .then(callback);
   });
 
@@ -161,55 +225,6 @@ export default (socket: Socket<Events>) => {
     callback(output);
   });
 
-  socket.on("getCoaCountByCountrycode", async (callback) =>
-    prismaCoa.inducks_issue
-      .groupBy({
-        _count: {
-          issuenumber: true,
-        },
-        where: {
-          OR: (await getCollectionCountrycodes(socket.data.user!.id)).map(
-            (countrycode) => ({
-              publicationcode: {
-                startsWith: `${countrycode}/`,
-              },
-            }),
-          ),
-        },
-        by: ["publicationcode"],
-      })
-      .then((data) =>
-        data.reduce<Record<string, number>>((acc, { publicationcode, _count }) => {
-          const countrycode = publicationcode!.split("/")[0];
-          acc[countrycode] = (_count.issuenumber + (acc[countrycode] || 0));
-          return acc
-        }, {})
-      )
-      .then(callback),
-  );
-
-  socket.on("getCoaCountByPublicationcode", async (callback) =>
-    prismaCoa.inducks_issue
-      .groupBy({
-        _count: {
-          issuenumber: true,
-        },
-        where: {
-          publicationcode: {
-            in: await getCollectionPublicationcodes(socket.data.user!.id),
-          },
-        },
-        by: ["publicationcode"],
-      })
-      .then((data) => {
-        callback(
-          Object.fromEntries(
-            data.map(({ publicationcode, _count }) => [publicationcode!, _count.issuenumber])
-          )
-        );
-      }),
-  );
-
   socket.on("getCollectionQuotations", async (callback) => {
     callback({
       quotations: (
diff --git a/packages/api/services/collection/types.ts b/packages/api/services/collection/types.ts
@@ -46,7 +46,7 @@ export default abstract class {
   ) => void;
 
   abstract getIssues: (
-    callback: (data: AugmentedIssue<issue & { issuecode: string }>[]) => void,
+    callback: (data: {countByCountrycode: Record<string, number>, countByPublicationcode: Record<string, number>, issues: AugmentedIssue<issue & { issuecode: string }>[]}) => void,
   ) => void;
   abstract addOrChangeIssues: (
     data: CollectionUpdateMultipleIssues,
@@ -61,14 +61,6 @@ export default abstract class {
     callback: (value: Record<string, string>) => void,
   ) => void;
 
-  abstract getCoaCountByPublicationcode: (
-    callback: (value: Record<string, number>) => void,
-  ) => void;
-
-  abstract getCoaCountByCountrycode: (
-    callback: (value: Record<string, number>) => void,
-  ) => void;
-
   abstract createRequests: (
     issueIds: number[],
     callback: (
