web,api: Add missing setBookcaseOrder event

Author: bperel

apps/web/src/composables/useDmSocket.ts

@@ -3,10 +3,8 @@ import type { AxiosStorage, SocketClient } from "socket-call-client";
 
 import { type ClientEvents as AppEvents } from "~dm-services/app";
 import { type ClientEvents as AuthEvents } from "~dm-services/auth";
-import {
-  type AuthedClientEvents as UserBookcaseEvents,
-  type ClientEvents as BookcaseEvents,
-} from "~dm-services/bookcase";
+import { type ClientEvents as BookcaseEvents } from "~dm-services/bookcase";
+import { type ClientEvents as BookcasePrivateEvents } from "~dm-services/bookcase/private";
 import {
   type AdminClientEvents as AdminBookstoreEvents,
   type ClientEvents as BookstoreEvents,
@@ -31,7 +29,7 @@ const defaultExport = (options: {
   onConnectError: (
     e: Error,
     namespace: string,
-    eventName?: string,
+    eventName?: string
   ) => Promise<void> | void;
   onConnected?: (namespace: string) => void;
   session: {
@@ -71,18 +69,21 @@ const defaultExport = (options: {
     socket,
     options,
     publicCollection: socket.addNamespace<PublicCollectionEvents>(
-      namespaces.PUBLIC_COLLECTION,
+      namespaces.PUBLIC_COLLECTION
     ),
     app: socket.addNamespace<AppEvents>(namespaces.APP),
 
-    bookcase: socket.addNamespace<BookcaseEvents>(namespaces.BOOKCASE, {
-      session,
-    }),
-    userBookcase: socket.addNamespace<UserBookcaseEvents>(
+    privateBookcase: socket.addNamespace<BookcasePrivateEvents>(
+      namespaces.BOOKCASE_PRIVATE,
+      {
+        session,
+      }
+    ),
+    userBookcase: socket.addNamespace<BookcaseEvents>(
       namespaces.BOOKCASE_USER,
       {
         session,
-      },
+      }
     ),
     stats: socket.addNamespace<StatsEvents>(namespaces.STATS, {
       session,
@@ -98,10 +99,10 @@ const defaultExport = (options: {
       namespaces.EDGECREATOR,
       {
         session,
-      },
+      }
     ),
     presentationText: socket.addNamespace<PresentationTextEvents>(
-      namespaces.PRESENTATION_TEXT,
+      namespaces.PRESENTATION_TEXT
     ),
     edges: socket.addNamespace<EdgesEvents>(namespaces.EDGES, {}),
     coa: socket.addNamespace<CoaEvents>(namespaces.COA, {
@@ -117,7 +118,7 @@ const defaultExport = (options: {
           storage: cacheStorage,
           ttl: 1000, // 1 second only, because we want to always get the latest data but still cache in case of offline
         },
-      },
+      }
     ),
     userGlobalStats: socket.addNamespace<GlobalStatsUserEvents>(
       namespaces.GLOBAL_STATS_USER,
@@ -127,19 +128,19 @@ const defaultExport = (options: {
           storage: cacheStorage,
           ttl: 1000, // 1 second only, because we want to always get the latest data but still cache in case of offline
         },
-      },
+      }
     ),
     events: socket.addNamespace<EventsEvents>(namespaces.EVENTS, {}),
     storySearch: storySearchSocket?.addNamespace<StorySearchEvents>(
       namespaces.STORY_SEARCH,
-      {},
+      {}
     ),
     bookstore: socket.addNamespace<BookstoreEvents>(namespaces.BOOKSTORES),
     adminBookstore: socket.addNamespace<AdminBookstoreEvents>(
       namespaces.BOOKSTORES_ADMIN,
       {
         session,
-      },
+      }
     ),
     collection: socket.addNamespace<CollectionEvents>(namespaces.COLLECTION, {
       session,

apps/web/src/stores/bookcase.ts

@@ -19,8 +19,10 @@ export type BookcaseEdgeWithPopularity = BookcaseEdge & {
 export const bookcase = defineStore("bookcase", () => {
   const route = useRoute();
 
-  const { bookcase: bookcaseEvents, userBookcase: userBookcaseEvents } =
-    inject(socketInjectionKey)!;
+  const {
+    privateBookcase: privateBookcaseEvents,
+    userBookcase: userBookcaseEvents,
+  } = inject(socketInjectionKey)!;
 
   const loadedSprites = ref<{ [key: string]: string }>({}),
     isPrivateBookcase = ref(false),
@@ -46,16 +48,16 @@ export const bookcase = defineStore("bookcase", () => {
               ? 0
               : collection().popularIssuesInCollection?.[issue.issuecode] || 0,
           }))) ||
-        null,
+        null
     ),
     popularIssuesInCollectionWithoutEdge = computed(() =>
       bookcaseWithPopularities.value
         ?.filter(
-          ({ edgeId, popularity }) => !edgeId && popularity && popularity > 0,
+          ({ edgeId, popularity }) => !edgeId && popularity && popularity > 0
         )
         .sort(({ popularity: popularity1 }, { popularity: popularity2 }) =>
-          popularity2 && popularity1 ? popularity2 - popularity1 : 0,
-        ),
+          popularity2 && popularity1 ? popularity2 - popularity1 : 0
+        )
     ),
     addLoadedSprite = ({
       spritePath,
@@ -71,8 +73,8 @@ export const bookcase = defineStore("bookcase", () => {
     },
     loadBookcase = async () => {
       if (!bookcaseContents.value) {
-        const response = await bookcaseEvents.getBookcase(
-          collection().user!.username,
+        const response = await userBookcaseEvents.getBookcase(
+          collection().user!.username
         );
         if ("error" in response) {
           switch (response.error) {
@@ -98,8 +100,8 @@ export const bookcase = defineStore("bookcase", () => {
     },
     loadBookcaseOptions = async () => {
       if (!bookcaseOptions.value) {
-        const response = await bookcaseEvents.getBookcaseOptions(
-          bookcaseUsername.value!,
+        const response = await userBookcaseEvents.getBookcaseOptions(
+          bookcaseUsername.value!
         );
         if ("error" in response) {
           console.error(response.error);
@@ -109,13 +111,14 @@ export const bookcase = defineStore("bookcase", () => {
       }
     },
     updateBookcaseOptions = async () => {
-      await userBookcaseEvents.setBookcaseOptions(bookcaseOptions.value!);
+      await privateBookcaseEvents.setBookcaseOptions(bookcaseOptions.value!);
     },
     loadBookcaseOrder = async () => {
       if (!bookcaseOrder.value) {
-        const response = await bookcaseEvents.getBookcaseOrder(
-          bookcaseUsername.value!,
+        const response = await userBookcaseEvents.getBookcaseOrder(
+          bookcaseUsername.value!
         );
+        debugger;
         if ("error" in response) {
           console.error(response.error);
         } else {
@@ -124,8 +127,7 @@ export const bookcase = defineStore("bookcase", () => {
       }
     },
     updateBookcaseOrder = async () => {
-      // TODO implement
-      // await userBookcaseEvents.setBookcaseOrder(bookcaseOrder.value!);
+      await privateBookcaseEvents.setBookcaseOrder(bookcaseOrder.value!);
     };
 
   return {

packages/api/index.ts

@@ -25,6 +25,7 @@ import { server as globalStats } from "./services/global-stats";
 import { server as globalStatsUser } from "./services/global-stats-user";
 import { server as presentationText } from "./services/presentation-text";
 import { server as publicCollection } from "./services/public-collection";
+import { server as privateBookcase } from "./services/bookcase/private";
 import { server as stats } from "./services/stats";
 import createSocketServer from "./socket";
 
@@ -71,5 +72,6 @@ feedback(io);
 globalStats(io);
 globalStatsUser(io);
 presentationText(io);
+privateBookcase(io);
 publicCollection(io);
 stats(io);

packages/api/services/bookcase/index.ts

@@ -6,9 +6,7 @@ import { prismaClient as prismaCoa } from "~prisma-schemas/schemas/coa/client";
 import { prismaClient as prismaDm } from "~prisma-schemas/schemas/dm/client";
 
 import type { UserServices } from "../../index";
-import { RequiredAuthMiddleware } from "../auth/util";
 import namespaces from "../namespaces";
-import options from "./options";
 
 type BookcaseEdgeRaw = Omit<BookcaseEdge, "sprites"> & {
   spriteName: string;
@@ -56,16 +54,27 @@ const listenEvents = ({ _socket }: UserServices<true>) => ({
           where: { userId },
         })
       ).map(({ publicationcode }) => publicationcode);
-      const userPublicationcodes = (
-        await prismaDm.issue.findMany({
-          select: {
-            publicationcode: true,
-          },
-          distinct: ["publicationcode"],
-          where: { userId },
-          orderBy: [{ publicationcode: "asc" }],
-        })
-      ).map(({ publicationcode }) => publicationcode);
+      const userIssuecodes = await prismaDm.issue.findMany({
+        select: {
+          issuecode: true,
+        },
+        distinct: ["issuecode"],
+        where: { userId },
+        orderBy: { issuecode: "asc" },
+      });
+
+      const augmentedIssuecodes =
+        await prismaCoa.augmentIssueArrayWithInducksData(
+          userIssuecodes.filter(
+            (item): item is { issuecode: string } => !!item.issuecode,
+          ),
+        );
+
+      const userPublicationcodes = [
+        ...new Set(
+          augmentedIssuecodes.map(({ publicationcode }) => publicationcode),
+        ),
+      ];
 
       const missingPublicationCodesInOrder = userPublicationcodes.filter(
         (publicationcode) =>
@@ -170,23 +179,9 @@ const listenEvents = ({ _socket }: UserServices<true>) => ({
 export const { client, server } = useSocketEvents<
   typeof listenEvents,
   Record<string, never>
->(namespaces.BOOKCASE, {
+>(namespaces.BOOKCASE_USER, {
   listenEvents,
   middlewares: [],
 });
 
 export type ClientEvents = (typeof client)["emitEvents"];
-
-const authedListenEvents = (services: UserServices) => ({
-  ...options(services),
-});
-
-export const { client: authedClient, server: authedServer } = useSocketEvents<
-  typeof authedListenEvents,
-  Record<string, never>
->(namespaces.BOOKCASE_USER, {
-  listenEvents: authedListenEvents,
-  middlewares: [RequiredAuthMiddleware],
-});
-
-export type AuthedClientEvents = (typeof authedClient)["emitEvents"];

packages/api/services/bookcase/options/index.ts

@@ -0,0 +1,62 @@
+import { prismaClient as prismaDm } from "~prisma-schemas/schemas/dm/client";
+
+import type { UserServices } from "../../../index";
+import { useSocketEvents } from "socket-call-server";
+import namespaces from "../../namespaces";
+import { RequiredAuthMiddleware } from "../../auth/util";
+
+const listenEvents = ({ _socket }: UserServices) => ({
+  setBookcaseOptions: async ({
+    textures,
+    showAllCopies: showDuplicatesInBookcase,
+  }: {
+    textures: { bookcase: string; bookshelf: string };
+    showAllCopies: boolean;
+  }) => {
+    const [, bookcaseSubTexture1] = textures.bookcase.split("/");
+    const [, bookcaseSubTexture2] = textures.bookshelf.split("/");
+    const user = await prismaDm.user.findUnique({
+      where: {
+        id: _socket.data.user.id,
+      },
+    });
+
+    if (!user) {
+      return "User does not exist";
+    }
+
+    await prismaDm.user.update({
+      data: {
+        ...user,
+        bookcaseSubTexture1,
+        bookcaseSubTexture2,
+        showDuplicatesInBookcase,
+      },
+      where: { id: user.id },
+    });
+    return "OK";
+  },
+  setBookcaseOrder: async (publicationCodes: string[]) => {
+    const userId = _socket.data.user!.id;
+    await prismaDm.bookcasePublicationOrder.deleteMany({
+      where: { userId },
+    });
+    await prismaDm.bookcasePublicationOrder.createMany({
+      data: publicationCodes.map((publicationcode, index) => ({
+        publicationcode,
+        order: index + 1,
+        userId,
+      })),
+    });
+  },
+});
+
+export const { client, server } = useSocketEvents<
+  typeof listenEvents,
+  Record<string, never>
+>(namespaces.BOOKCASE_PRIVATE, {
+  listenEvents,
+  middlewares: [RequiredAuthMiddleware],
+});
+
+export type ClientEvents = (typeof client)["emitEvents"];

packages/api/services/bookcase/private/index.ts

@@ -1,7 +1,7 @@
 export default {
   APP: "/app",
   AUTH: "/auth",
-  BOOKCASE: "/bookcase",
+  BOOKCASE_PRIVATE: "/bookcase",
   BOOKCASE_USER: "/bookcase-user",
   BOOKSTORES: "/bookstores",
   BOOKSTORES_ADMIN: "/bookstores-admin",