Update packages

src/server/addTournament.ts

@@ -8,7 +8,7 @@ import { TimeControl } from "@/types";
 import { errorLog } from "@/utils/logger";
 
 import { TournamentModel } from "./models/tournamentModel";
-import { action } from "./safeAction";
+import { actionClient } from "./safeAction";
 
 const tcMap: Record<TimeControl, TournamentModel["time_control"]> = {
   [TimeControl.Classic]: "Cadence Lente",
@@ -17,61 +17,68 @@ const tcMap: Record<TimeControl, TournamentModel["time_control"]> = {
   [TimeControl.Other]: "Other",
 };
 
-export const addTournament = action(addTournamentSchema, async (input) => {
-  try {
-    await dbConnect();
+export const addTournament = actionClient
+  .schema(addTournamentSchema)
+  .action(async (input) => {
+    try {
+      await dbConnect();
 
-    const { name, email, message, tournament } = input;
+      const { name, email, message, tournament } = input.parsedInput;
 
-    const tournamentData: Omit<TournamentModel, "_id" | "tournament_id"> = {
-      ...tournament,
-      date: format(tournament.date, "dd/MM/yyyy"),
-      start_date: format(tournament.date, "dd/MM/yyyy"),
-      end_date: format(tournament.date, "dd/MM/yyyy"),
-      time_control: tcMap[tournament.time_control],
-      coordinates: tournament.coordinates as [number, number],
-      entry_method: "manual",
-      pending: true,
-      status: "scheduled",
-    };
+      const tournamentData: Omit<TournamentModel, "_id" | "tournament_id"> = {
+        ...tournament,
+        date: format(tournament.date, "dd/MM/yyyy"),
+        start_date: format(tournament.date, "dd/MM/yyyy"),
+        end_date: format(tournament.date, "dd/MM/yyyy"),
+        time_control: tcMap[tournament.time_control],
+        coordinates: tournament.coordinates as [number, number],
+        entry_method: "manual",
+        pending: true,
+        status: "scheduled",
+      };
 
-    const result = await collections.tournaments!.insertOne(tournamentData);
+      const result = await collections.tournaments!.insertOne(tournamentData);
 
-    if (result.insertedId) {
-      const { tournament, country, date, time_control } = tournamentData;
+      if (result.insertedId) {
+        const { tournament, country, date, time_control } = tournamentData;
 
-      if (typeof process.env.DISCORD_WEBHOOK_ADD_TOURNAMENT_URL === "string") {
-        await fetch(process.env.DISCORD_WEBHOOK_ADD_TOURNAMENT_URL as string, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({
-            embeds: [
-              {
-                title: "Tournament Submitted",
-                fields: [
-                  { name: "Tournament", value: tournament },
-                  { name: "Country", value: country },
-                  { name: "Date", value: date },
-                  {
-                    name: "Time Control",
-                    value: time_control,
-                  },
-                  { name: "Sender", value: name },
-                  { name: "Sender Email", value: email },
-                  { name: "Message", value: message ?? "" },
-                ],
+        if (
+          typeof process.env.DISCORD_WEBHOOK_ADD_TOURNAMENT_URL === "string"
+        ) {
+          await fetch(
+            process.env.DISCORD_WEBHOOK_ADD_TOURNAMENT_URL as string,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
               },
-            ],
-          }),
-        });
-      }
+              body: JSON.stringify({
+                embeds: [
+                  {
+                    title: "Tournament Submitted",
+                    fields: [
+                      { name: "Tournament", value: tournament },
+                      { name: "Country", value: country },
+                      { name: "Date", value: date },
+                      {
+                        name: "Time Control",
+                        value: time_control,
+                      },
+                      { name: "Sender", value: name },
+                      { name: "Sender Email", value: email },
+                      { name: "Message", value: message ?? "" },
+                    ],
+                  },
+                ],
+              }),
+            },
+          );
+        }
 
-      return true;
+        return true;
+      }
+    } catch (error) {
+      errorLog(error);
+      throw error;
     }
-  } catch (error) {
-    errorLog(error);
-    throw error;
-  }
-});
+  });

src/server/contactUs.ts

@@ -5,32 +5,34 @@ import { z } from "zod";
 import { contactUsSchema } from "@/schemas";
 import { errorLog } from "@/utils/logger";
 
-import { action } from "./safeAction";
+import { actionClient } from "./safeAction";
 
-export const contactUs = action(contactUsSchema, async (input) => {
-  try {
-    const { email, subject, message } = input;
-    await fetch(process.env.DISCORD_WEBHOOK_CONTACT_URL as string, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        embeds: [
-          {
-            title: "Contact",
-            fields: [
-              { name: "Email", value: email },
-              { name: "Subject", value: subject },
-              { name: "Message", value: message },
-            ],
-          },
-        ],
-      }),
-    });
-    return true;
-  } catch (error) {
-    errorLog(error);
-    throw error;
-  }
-});
+export const contactUs = actionClient
+  .schema(contactUsSchema)
+  .action(async (input) => {
+    try {
+      const { email, subject, message } = input.parsedInput;
+      await fetch(process.env.DISCORD_WEBHOOK_CONTACT_URL as string, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          embeds: [
+            {
+              title: "Contact",
+              fields: [
+                { name: "Email", value: email },
+                { name: "Subject", value: subject },
+                { name: "Message", value: message },
+              ],
+            },
+          ],
+        }),
+      });
+      return true;
+    } catch (error) {
+      errorLog(error);
+      throw error;
+    }
+  });

src/server/createZone.ts

@@ -8,31 +8,33 @@ import { collections, dbConnect } from "@/server/mongodb";
 import { errorLog } from "@/utils/logger";
 
 import { ZoneModel } from "./models/zoneModel";
-import { action } from "./safeAction";
+import { actionClient } from "./safeAction";
 
-export const createZone = action(zoneSchema, async (input) => {
-  try {
-    await dbConnect();
+export const createZone = actionClient
+  .schema(zoneSchema)
+  .action(async (input) => {
+    try {
+      await dbConnect();
 
-    const user = await auth();
-    if (!user?.user) {
-      throw new Error("You must be logged in to create a zone");
+      const user = await auth();
+      if (!user?.user) {
+        throw new Error("You must be logged in to create a zone");
+      }
+
+      const zoneData: ZoneModel = {
+        ...input.parsedInput,
+        userId: new ObjectId(user.user!.id!),
+      };
+
+      const result = await collections.zones!.insertOne(zoneData);
+
+      if (!result.acknowledged) {
+        throw new Error("ERR_ZONE_INSERT_FAILED");
+      }
+
+      return true;
+    } catch (error) {
+      errorLog(error);
+      throw error;
     }
-
-    const zoneData: ZoneModel = {
-      ...input,
-      userId: new ObjectId(user.user!.id!),
-    };
-
-    const result = await collections.zones!.insertOne(zoneData);
-
-    if (!result.acknowledged) {
-      throw new Error("ERR_ZONE_INSERT_FAILED");
-    }
-
-    return true;
-  } catch (error) {
-    errorLog(error);
-    throw error;
-  }
-});
+  });

src/server/deleteAccount.ts

@@ -7,9 +7,9 @@ import { adapter, auth } from "@/auth";
 import { collections, dbConnect } from "@/server/mongodb";
 import { errorLog } from "@/utils/logger";
 
-import { action } from "./safeAction";
+import { actionClient } from "./safeAction";
 
-export const deleteAccount = action(z.void(), async () => {
+export const deleteAccount = actionClient.action(async () => {
   try {
     await dbConnect();
 

src/server/deleteZone.ts

@@ -7,33 +7,37 @@ import { auth } from "@/auth";
 import { collections, dbConnect } from "@/server/mongodb";
 import { errorLog } from "@/utils/logger";
 
-import { action } from "./safeAction";
+import { actionClient } from "./safeAction";
 
 const deleteZoneSchema = z.object({
   id: z.string(),
 });
 
-export const deleteZone = action(deleteZoneSchema, async ({ id }) => {
-  try {
-    await dbConnect();
+export const deleteZone = actionClient
+  .schema(deleteZoneSchema)
+  .action(async (input) => {
+    const { id } = input.parsedInput;
 
-    const user = await auth();
-    if (!user?.user) {
-      throw new Error("You must be logged in to create a zone");
+    try {
+      await dbConnect();
+
+      const user = await auth();
+      if (!user?.user) {
+        throw new Error("You must be logged in to create a zone");
+      }
+
+      const result = await collections.zones!.deleteOne({
+        _id: new ObjectId(id),
+        userId: new ObjectId(user.user!.id!),
+      });
+
+      if (!result || result.deletedCount !== 1) {
+        throw new Error("ERR_ZONE_DELETE_FAILED");
+      }
+
+      return true;
+    } catch (error) {
+      errorLog(error);
+      throw error;
     }
-
-    const result = await collections.zones!.deleteOne({
-      _id: new ObjectId(id),
-      userId: new ObjectId(user.user!.id!),
-    });
-
-    if (!result || result.deletedCount !== 1) {
-      throw new Error("ERR_ZONE_DELETE_FAILED");
-    }
-
-    return true;
-  } catch (error) {
-    errorLog(error);
-    throw error;
-  }
-});
+  });

src/server/editZone.ts

@@ -10,43 +10,46 @@ import { collections, dbConnect } from "@/server/mongodb";
 import { errorLog } from "@/utils/logger";
 
 import { ZoneModel } from "./models/zoneModel";
-import { action } from "./safeAction";
+import { actionClient } from "./safeAction";
 
 const editZoneSchema = z.object({
   id: z.string(),
   zone: zoneSchema,
 });
 
-export const editZone = action(editZoneSchema, async ({ id, zone }) => {
-  try {
-    await dbConnect();
+export const editZone = actionClient
+  .schema(editZoneSchema)
+  .action(async (input) => {
+    const { id, zone } = input.parsedInput;
+    try {
+      await dbConnect();
 
-    const user = await auth();
-    if (!user?.user) {
-      throw new Error("You must be logged in to create a zone");
+      const user = await auth();
+      if (!user?.user) {
+        throw new Error("You must be logged in to create a zone");
+      }
+
+      const zoneData: ZoneModel = {
+        ...zone,
+        userId: new ObjectId(user.user!.id!),
+      };
+
+      const result = await collections.zones!.findOneAndUpdate(
+        { _id: new ObjectId(id), userId: new ObjectId(user.user!.id!) },
+        { $set: { _id: new ObjectId(id), ...zoneData } },
+      );
+
+      if (!result) {
+        throw new Error("ERR_ZONE_UPDATE_FAILED");
+      }
+
+      return {
+        ...omit(result, ["_id"]),
+        id: result._id.toString(),
+        userId: result.userId.toString(),
+      };
+    } catch (error) {
+      errorLog(error);
+      throw error;
     }
-
-    const zoneData: ZoneModel = {
-      ...zone,
-      userId: new ObjectId(user.user!.id!),
-    };
-
-    const result = await collections.zones!.findOneAndUpdate(
-      { _id: new ObjectId(id), userId: new ObjectId(user.user!.id!) },
-      { $set: { _id: new ObjectId(id), ...zoneData } },
-    );
-
-    if (!result) {
-      throw new Error("ERR_ZONE_UPDATE_FAILED");
-    }
-
-    return {
-      ...omit(result, ["_id"]),
-      id: result._id.toString(),
-      userId: result.userId.toString(),
-    };
-  } catch (error) {
-    errorLog(error);
-    throw error;
-  }
-});
+  });

src/server/fetchTournamentResults.ts

@@ -5,7 +5,7 @@ import { z } from "zod";
 import { fetchTournamentResultsSchema } from "@/schemas";
 import { errorLog } from "@/utils/logger";
 
-import { action } from "./safeAction";
+import { actionClient } from "./safeAction";
 
 const dbSchema = z.array(
   z.object({
@@ -106,9 +106,10 @@ const reportFetchError = async (url: string, error: any) => {
   }
 };
 
-export const fetchTournamentResults = action(
-  fetchTournamentResultsSchema,
-  async (input) => {
+export const fetchTournamentResults = actionClient
+  .schema(fetchTournamentResultsSchema)
+  .action(async (input) => {
+    const { id } = input.parsedInput;
     try {
       const headers = new Headers();
       const apiKey = process.env.RESULTS_API_KEY;
@@ -118,7 +119,7 @@ export const fetchTournamentResults = action(
       }
 
       const rawResults = await fetch(
-        `${process.env.RESULTS_SCRAPER_URL}${input.id}`,
+        `${process.env.RESULTS_SCRAPER_URL}${id}`,
         {
           headers: headers,
         },
@@ -155,9 +156,8 @@ export const fetchTournamentResults = action(
         })),
       );
     } catch (error) {
-      reportFetchError(input.id, error);
+      reportFetchError(id, error);
       errorLog(JSON.stringify(error, null, 2));
       throw error;
     }
-  },
-);
+  });

src/server/getTournamentDetails.ts

@@ -6,38 +6,41 @@ import { collections, dbConnect } from "@/server/mongodb";
 import { TimeControl, tcMap } from "@/types";
 import { errorLog } from "@/utils/logger";
 
-import { action } from "./safeAction";
+import { actionClient } from "./safeAction";
 
 const inputSchema = z.object({
   ffeId: z.string(),
 });
 
-export const getTournamentDetails = action(inputSchema, async (input) => {
-  try {
-    await dbConnect();
-    const t = await collections.tournaments!.findOne({
-      tournament_id: input.ffeId,
-    });
+export const getTournamentDetails = actionClient
+  .schema(inputSchema)
+  .action(async (input) => {
+    const { ffeId } = input.parsedInput;
+    try {
+      await dbConnect();
+      const t = await collections.tournaments!.findOne({
+        tournament_id: ffeId,
+      });
 
-    if (t === null) {
-      return null;
+      if (t === null) {
+        return null;
+      }
+
+      const timeControl = tcMap[t.time_control] ?? TimeControl.Other;
+
+      return {
+        id: t._id.toString(),
+        ffeId: t.tournament_id!,
+        tournament: t.tournament,
+        town: t.town,
+        department: t.department,
+        date: t.date,
+        url: t.url,
+        timeControl,
+        status: t.status,
+      };
+    } catch (error) {
+      errorLog(JSON.stringify(error, null, 2));
+      throw error;
     }
-
-    const timeControl = tcMap[t.time_control] ?? TimeControl.Other;
-
-    return {
-      id: t._id.toString(),
-      ffeId: t.tournament_id!,
-      tournament: t.tournament,
-      town: t.town,
-      department: t.department,
-      date: t.date,
-      url: t.url,
-      timeControl,
-      status: t.status,
-    };
-  } catch (error) {
-    errorLog(JSON.stringify(error, null, 2));
-    throw error;
-  }
-});
+  });

src/server/myZones.ts

@@ -3,20 +3,19 @@
 import { FeatureCollection } from "geojson";
 import { omit } from "lodash";
 import { ObjectId } from "mongodb";
-import { z } from "zod";
 
 import { auth } from "@/auth";
 import { collections, dbConnect } from "@/server/mongodb";
 
 import { ZoneModel } from "./models/zoneModel";
-import { action } from "./safeAction";
+import { actionClient } from "./safeAction";
 
 export type Zone = Omit<ZoneModel, "userId" | "features"> & {
   id: string;
   features: FeatureCollection;
 };
 
-export const myZones = action(z.void(), async () => {
+export const myZones = actionClient.action(async () => {
   await dbConnect();
 
   const user = await auth();

src/server/searchTournaments.ts

@@ -8,7 +8,7 @@ import { TimeControl, Tournament, tcMap } from "@/types";
 import { errorLog } from "@/utils/logger";
 import { removeDiacritics } from "@/utils/string";
 
-import { action } from "./safeAction";
+import { actionClient } from "./safeAction";
 
 const inputSchema = z.object({
   searchValue: z.string(),
@@ -28,66 +28,69 @@ export type SearchedTournament = Pick<
   | "url"
 >;
 
-export const searchTournaments = action(inputSchema, async (input) => {
-  try {
-    await dbConnect();
+export const searchTournaments = actionClient
+  .schema(inputSchema)
+  .action(async (input) => {
+    const { searchValue, limit } = input.parsedInput;
+    try {
+      await dbConnect();
 
-    const searchTerms = input.searchValue
-      .split(" ")
-      .map((s) => removeDiacritics(s.trim()))
-      .filter((s) => s !== "")
-      .map((s) => ({ tournament_index: { $regex: s, $options: "i" } }));
+      const searchTerms = searchValue
+        .split(" ")
+        .map((s) => removeDiacritics(s.trim()))
+        .filter((s) => s !== "")
+        .map((s) => ({ tournament_index: { $regex: s, $options: "i" } }));
 
-    const data = await collections
-      .tournaments!.aggregate([
-        {
-          $addFields: {
-            dateParts: {
-              $dateFromString: {
-                dateString: "$start_date",
-                format: "%d/%m/%Y",
+      const data = await collections
+        .tournaments!.aggregate([
+          {
+            $addFields: {
+              dateParts: {
+                $dateFromString: {
+                  dateString: "$start_date",
+                  format: "%d/%m/%Y",
+                },
               },
             },
           },
-        },
-        {
-          $match: {
-            $and: [
-              { federation: { $eq: "FFE" } },
-              { dateParts: { $lte: endOfDay(new Date()) } },
-              ...searchTerms,
-            ],
+          {
+            $match: {
+              $and: [
+                { federation: { $eq: "FFE" } },
+                { dateParts: { $lte: endOfDay(new Date()) } },
+                ...searchTerms,
+              ],
+            },
           },
-        },
-        {
-          $sort: {
-            dateParts: -1,
+          {
+            $sort: {
+              dateParts: -1,
+            },
           },
-        },
-        { $limit: input.limit ?? 20 },
-        {
-          $unset: "dateParts",
-        },
-      ])
-      .toArray();
+          { $limit: limit ?? 20 },
+          {
+            $unset: "dateParts",
+          },
+        ])
+        .toArray();
 
-    return data.map<SearchedTournament>((t) => {
-      const timeControl = tcMap[t.time_control] ?? TimeControl.Other;
+      return data.map<SearchedTournament>((t) => {
+        const timeControl = tcMap[t.time_control] ?? TimeControl.Other;
 
-      return {
-        id: t._id.toString(),
-        ffeId: t.tournament_id,
-        tournament: t.tournament,
-        town: t.town,
-        department: t.department,
-        date: t.start_date,
-        url: t.url,
-        timeControl,
-        status: t.status,
-      };
-    });
-  } catch (error) {
-    errorLog(JSON.stringify(error, null, 2));
-    throw error;
-  }
-});
+        return {
+          id: t._id.toString(),
+          ffeId: t.tournament_id,
+          tournament: t.tournament,
+          town: t.town,
+          department: t.department,
+          date: t.start_date,
+          url: t.url,
+          timeControl,
+          status: t.status,
+        };
+      });
+    } catch (error) {
+      errorLog(JSON.stringify(error, null, 2));
+      throw error;
+    }
+  });