Apply lint

Author: bperel

apps/dumili/api/services/indexation/index.ts

@@ -237,14 +237,13 @@ const createAiStorySuggestions = async (
           if ("error" in results) {
             console.error(results.error);
           } else {
-            let aiResultId =
-              (
-                await prisma.image.findUnique({
-                  where: {
-                    id: firstPageOfEntry.image.id,
-                  },
-                })
-              )?.[`${field}Id`];
+            let aiResultId = (
+              await prisma.image.findUnique({
+                where: {
+                  id: firstPageOfEntry.image.id,
+                },
+              })
+            )?.[`${field}Id`];
 
             if (aiResultId) {
               if (field === "aiOcrResult") {

packages/api/http.ts

@@ -1,5 +1,6 @@
 import { createServer } from "http";
 import { parse } from "url";
+
 import { prismaClient as prismaCoa } from "~prisma-schemas/schemas/coa/client";
 
 import { getUpdateFileUrl } from "./services/app";
@@ -51,17 +52,17 @@ export default () =>
                           issuenumber,
                         },
                       });
-                      const publishers = (
-                        await prismaCoa.inducks_publishingjob.findMany({
-                          select: {
-                            issuecode: true,
-                            publisherid: true,
-                          },
-                          where: {
-                            issuecode: issue.issuecode,
-                          },
-                        })
-                      ).groupBy("issuecode", "publisherid[]");
+                    const publishers = (
+                      await prismaCoa.inducks_publishingjob.findMany({
+                        select: {
+                          issuecode: true,
+                          publisherid: true,
+                        },
+                        where: {
+                          issuecode: issue.issuecode,
+                        },
+                      })
+                    ).groupBy("issuecode", "publisherid[]");
                     const entriesList = await prismaCoa.inducks_entry.findMany({
                       select: {
                         entrycode: true,
@@ -105,10 +106,14 @@ export default () =>
                           },
                         },
                       })
-                    ).groupBy("storyversioncode", "[]", ({ personcode, plotwritartink }) => ({
-                      personcode,
-                      plotwritartink,
-                    }));
+                    ).groupBy(
+                      "storyversioncode",
+                      "[]",
+                      ({ personcode, plotwritartink }) => ({
+                        personcode,
+                        plotwritartink,
+                      }),
+                    );
 
                     const storyversionAppearances = (
                       await prismaCoa.inducks_appearance.findMany({

packages/api/services/events/index.ts

@@ -20,20 +20,20 @@ import type {
 } from "~dm-types/events/EdgeCreationEvent";
 import type { MedalEvent } from "~dm-types/events/MedalEvent";
 import type { SignupEvent } from "~dm-types/events/SignupEvent";
+import MEDAL_LEVELS from "~dm-types/MedalLevels";
 import { prismaClient as prismaDm } from "~prisma-schemas/schemas/dm/client";
 
 import namespaces from "../namespaces";
-import MEDAL_LEVELS from "~dm-types/MedalLevels";
 
 const listenEvents = () => ({
   getEvents: () =>
     Promise.all([
-        retrieveSignups(),
-        retrieveCollectionUpdates(),
-        retrieveCollectionSubscriptionAdditions(),
-        retrieveBookstoreCreations(),
-        retrieveEdgeCreations(),
-        retrieveNewMedals(),
+      retrieveSignups(),
+      retrieveCollectionUpdates(),
+      retrieveCollectionSubscriptionAdditions(),
+      retrieveBookstoreCreations(),
+      retrieveEdgeCreations(),
+      retrieveNewMedals(),
     ]).then((data) => data.flat()),
 });
 
@@ -161,36 +161,36 @@ const retrieveNewMedals = async () =>
   (
     (
       await prismaDm.userContribution.findMany({
-      select: {
-        totalPoints: true,
-        newPoints: true,
-        userId: true,
-        contribution: true,
-        date: true,
-      },
-      where: {
-        date: {
-          gt: dayjs().subtract(1, "month").toDate(),
+        select: {
+          totalPoints: true,
+          newPoints: true,
+          userId: true,
+          contribution: true,
+          date: true,
+        },
+        where: {
+          date: {
+            gt: dayjs().subtract(1, "month").toDate(),
+          },
         },
-      },
       })
-      )
+    )
       .map(({ contribution, newPoints, totalPoints, userId, date }) => ({
-            contribution: Object.keys(MEDALS_L10N_FR).find(
+        contribution: Object.keys(MEDALS_L10N_FR).find(
           (medalType) => MEDALS_L10N_FR[medalType] === contribution,
-            ),
-            userId,
-            timestamp: dayjs(date).subtract(2, "hour").unix(),
-            type: "medal",
+        ),
+        userId,
+        timestamp: dayjs(date).subtract(2, "hour").unix(),
+        type: "medal",
         level:
           Object.entries(
-              Object.entries(MEDAL_LEVELS).find(
+            Object.entries(MEDAL_LEVELS).find(
               ([medalType]) => contribution === MEDALS_L10N_FR[medalType],
             )![1],
-            ).find(
+          ).find(
             ([, points]) =>
               totalPoints >= points && totalPoints - newPoints < points,
-            )?.[0] || null,
+          )?.[0] || null,
       }))
-        .filter(({ level }) => level !== null) as AbstractEventRaw[]
-    ).map(mapUsers<MedalEvent>);
+      .filter(({ level }) => level !== null) as AbstractEventRaw[]
+  ).map(mapUsers<MedalEvent>);

packages/types/MedalLevels.ts

@@ -2,4 +2,4 @@ export default {
   edge_photographer: { 1: 50, 2: 150, 3: 600 },
   edge_designer: { 1: 20, 2: 70, 3: 150 },
   duckhunter: { 1: 1, 2: 3, 3: 8 },
-} as { [contribution: string]: { [level: number]: number } };
+} as { [contribution: string]: { [level: number]: number } };

util/group-by/index.ts

@@ -30,7 +30,7 @@ type GroupByValueType<
 type GroupByResultType<
   T,
   V extends null | "[]" | NestedKeyOf<T> | `${NestedKeyOf<T>}[]`,
-  R
+  R,
 > = [R] extends [never]
   ? GroupByValueType<T, V>
   : V extends null