rhythia-api 84.0.0 → 85.0.0

package/.prettierrc.json

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": false
+}

package/api/editProfile.ts

@@ -1,74 +1,74 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { Database } from "../types/database";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    data: z.object({
-      avatar_url: z.string().optional(),
-      about_me: z.string().optional(),
-      username: z.string().optional(),
-    }),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-  }),
-};
-
-export async function POST(res: Response): Promise<NextResponse> {
-  return protectedApi({
-    response: res,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler(
-  data: (typeof Schema)["input"]["_type"]
-): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  const user = (await supabase.auth.getUser(data.session)).data.user!;
-  let userData: Database["public"]["Tables"]["profiles"]["Update"];
-
-  // Find user's entry
-  {
-    let { data: queryUserData, error } = await supabase
-      .from("profiles")
-      .select("*")
-      .eq("uid", user.id);
-
-    if (!queryUserData?.length) {
-      return NextResponse.json(
-        {
-          error: "User cannot be retrieved from session",
-        },
-        { status: 404 }
-      );
-    }
-    userData = queryUserData[0];
-  }
-
-  const upsertPayload: Database["public"]["Tables"]["profiles"]["Update"] = {
-    id: userData.id,
-    ...data.data,
-  };
-
-  const upsertResult = await supabase
-    .from("profiles")
-    .upsert(upsertPayload)
-    .select();
-
-  if (upsertResult.status == 409) {
-    return NextResponse.json(
-      {
-        error: "Can't update, username might be used by someone else!",
-      },
-      { status: 404 }
-    );
-  }
-
-  return NextResponse.json({});
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { Database } from "../types/database";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    data: z.object({
+      avatar_url: z.string().optional(),
+      about_me: z.string().optional(),
+      username: z.string().optional(),
+    }),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(
+  data: (typeof Schema)["input"]["_type"]
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  const user = (await supabase.auth.getUser(data.session)).data.user!;
+  let userData: Database["public"]["Tables"]["profiles"]["Update"];
+
+  // Find user's entry
+  {
+    let { data: queryUserData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .eq("uid", user.id);
+
+    if (!queryUserData?.length) {
+      return NextResponse.json(
+        {
+          error: "User cannot be retrieved from session",
+        },
+        { status: 404 }
+      );
+    }
+    userData = queryUserData[0];
+  }
+
+  const upsertPayload: Database["public"]["Tables"]["profiles"]["Update"] = {
+    id: userData.id,
+    ...data.data,
+  };
+
+  const upsertResult = await supabase
+    .from("profiles")
+    .upsert(upsertPayload)
+    .select();
+
+  if (upsertResult.status == 409) {
+    return NextResponse.json(
+      {
+        error: "Can't update, username might be used by someone else!",
+      },
+      { status: 404 }
+    );
+  }
+
+  return NextResponse.json({});
+}

package/api/getLeaderboard.ts

@@ -1,68 +1,68 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    page: z.number().optional(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    total: z.number().optional(),
-    leaderboard: z
-      .array(
-        z.object({
-          flag: z.string().nullable(),
-          id: z.number(),
-          username: z.string().nullable(),
-          play_count: z.number().nullable(),
-          skill_points: z.number().nullable(),
-          total_score: z.number().nullable(),
-        })
-      )
-      .optional(),
-  }),
-};
-
-export async function POST(res: Response): Promise<NextResponse> {
-  return protectedApi({
-    response: res,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler(
-  data: (typeof Schema)["input"]["_type"]
-): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  const range = [0, 100];
-  if (data.page) {
-    range[0] = 100 * data.page;
-    range[1] = range[0] + 100;
-  }
-
-  const countQuery = await supabase
-    .from("profiles")
-    .select("*", { count: "exact", head: true });
-
-  let { data: queryData, error } = await supabase
-    .from("profiles")
-    .select("*")
-    .order("skill_points", { ascending: false })
-    .range(range[0], range[1]);
-
-  return NextResponse.json({
-    total: countQuery.count || 0,
-    leaderboard: queryData?.map((user) => ({
-      flag: user.flag,
-      id: user.id,
-      play_count: user.play_count,
-      skill_points: user.skill_points,
-      total_score: user.total_score,
-      username: user.username,
-    })),
-  });
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    page: z.number().optional(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    total: z.number().optional(),
+    leaderboard: z
+      .array(
+        z.object({
+          flag: z.string().nullable(),
+          id: z.number(),
+          username: z.string().nullable(),
+          play_count: z.number().nullable(),
+          skill_points: z.number().nullable(),
+          total_score: z.number().nullable(),
+        })
+      )
+      .optional(),
+  }),
+};
+
+export async function POST(res: Response): Promise<NextResponse> {
+  return protectedApi({
+    response: res,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(
+  data: (typeof Schema)["input"]["_type"]
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  const range = [0, 100];
+  if (data.page) {
+    range[0] = 100 * data.page;
+    range[1] = range[0] + 100;
+  }
+
+  const countQuery = await supabase
+    .from("profiles")
+    .select("*", { count: "exact", head: true });
+
+  let { data: queryData, error } = await supabase
+    .from("profiles")
+    .select("*")
+    .order("skill_points", { ascending: false })
+    .range(range[0], range[1]);
+
+  return NextResponse.json({
+    total: countQuery.count || 0,
+    leaderboard: queryData?.map((user) => ({
+      flag: user.flag,
+      id: user.id,
+      play_count: user.play_count,
+      skill_points: user.skill_points,
+      total_score: user.total_score,
+      username: user.username,
+    })),
+  });
+}

package/api/getProfile.ts

@@ -1,115 +1,115 @@
-import { geolocation } from "@vercel/edge";
-import { NextResponse } from "next/server";
-import z from "zod";
-import { Database } from "../types/database";
-import { protectedApi, validUser } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    id: z.number().optional(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    user: z
-      .object({
-        about_me: z.string().nullable(),
-        avatar_url: z.string().nullable(),
-        badges: z.any().nullable(),
-        created_at: z.number().nullable(),
-        flag: z.string().nullable(),
-        id: z.number(),
-        uid: z.string().nullable(),
-        username: z.string().nullable(),
-        verified: z.boolean().nullable(),
-        play_count: z.number().nullable(),
-        skill_points: z.number().nullable(),
-        squares_hit: z.number().nullable(),
-        total_score: z.number().nullable(),
-        position: z.number().nullable(),
-      })
-      .optional(),
-  }),
-};
-
-export async function POST(res: Response): Promise<NextResponse> {
-  return protectedApi({
-    response: res,
-    schema: Schema,
-    authorization: validUser,
-    activity: handler,
-  });
-}
-
-export async function handler(
-  data: (typeof Schema)["input"]["_type"],
-  req: Request
-): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  let profiles: Database["public"]["Tables"]["profiles"]["Row"][] = [];
-
-  // Fetch by id
-  if (data.id !== undefined) {
-    let { data: queryData, error } = await supabase
-      .from("profiles")
-      .select("*")
-      .eq("id", data.id);
-
-    console.log(profiles, error);
-
-    if (!queryData?.length) {
-      return NextResponse.json(
-        {
-          error: "User not found",
-        },
-        { status: 404 }
-      );
-    }
-
-    profiles = queryData;
-  } else {
-    // Fetch by session id
-    const user = (await supabase.auth.getUser(data.session)).data.user!;
-
-    let { data: queryData, error } = await supabase
-      .from("profiles")
-      .select("*")
-      .eq("uid", user.id);
-
-    console.log(profiles, error);
-    if (!queryData?.length) {
-      const geo = geolocation(req);
-      const data = await supabase
-        .from("profiles")
-        .upsert({
-          uid: user.id,
-          about_me: "",
-          avatar_url: user.user_metadata.avatar_url,
-          badges: ["Early Bird"],
-          username: user.user_metadata.full_name,
-          flag: (geo.country || "US").toUpperCase(),
-          created_at: Date.now(),
-        })
-        .select();
-
-      profiles = data.data!;
-    } else {
-      profiles = queryData;
-    }
-  }
-
-  const user = profiles[0];
-
-  // Query to count how many players have more skill points than the specific player
-  const { count: playersWithMorePoints, error: rankError } = await supabase
-    .from("profiles")
-    .select("*", { count: "exact", head: true })
-    .gt("skill_points", user.skill_points);
-
-  return NextResponse.json({
-    user: {
-      ...user,
-      position: (playersWithMorePoints || 0) + 1,
-    },
-  });
-}
+import { geolocation } from "@vercel/edge";
+import { NextResponse } from "next/server";
+import z from "zod";
+import { Database } from "../types/database";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    id: z.number().optional(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    user: z
+      .object({
+        about_me: z.string().nullable(),
+        avatar_url: z.string().nullable(),
+        badges: z.any().nullable(),
+        created_at: z.number().nullable(),
+        flag: z.string().nullable(),
+        id: z.number(),
+        uid: z.string().nullable(),
+        username: z.string().nullable(),
+        verified: z.boolean().nullable(),
+        play_count: z.number().nullable(),
+        skill_points: z.number().nullable(),
+        squares_hit: z.number().nullable(),
+        total_score: z.number().nullable(),
+        position: z.number().nullable(),
+      })
+      .optional(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: validUser,
+    activity: handler,
+  });
+}
+
+export async function handler(
+  data: (typeof Schema)["input"]["_type"],
+  req: Request
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  let profiles: Database["public"]["Tables"]["profiles"]["Row"][] = [];
+
+  // Fetch by id
+  if (data.id !== undefined) {
+    let { data: queryData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .eq("id", data.id);
+
+    console.log(profiles, error);
+
+    if (!queryData?.length) {
+      return NextResponse.json(
+        {
+          error: "User not found",
+        },
+        { status: 404 }
+      );
+    }
+
+    profiles = queryData;
+  } else {
+    // Fetch by session id
+    const user = (await supabase.auth.getUser(data.session)).data.user!;
+
+    let { data: queryData, error } = await supabase
+      .from("profiles")
+      .select("*")
+      .eq("uid", user.id);
+
+    console.log(profiles, error);
+    if (!queryData?.length) {
+      const geo = geolocation(req);
+      const data = await supabase
+        .from("profiles")
+        .upsert({
+          uid: user.id,
+          about_me: "",
+          avatar_url: user.user_metadata.avatar_url,
+          badges: ["Early Bird"],
+          username: user.user_metadata.full_name,
+          flag: (geo.country || "US").toUpperCase(),
+          created_at: Date.now(),
+        })
+        .select();
+
+      profiles = data.data!;
+    } else {
+      profiles = queryData;
+    }
+  }
+
+  const user = profiles[0];
+
+  // Query to count how many players have more skill points than the specific player
+  const { count: playersWithMorePoints, error: rankError } = await supabase
+    .from("profiles")
+    .select("*", { count: "exact", head: true })
+    .gt("skill_points", user.skill_points);
+
+  return NextResponse.json({
+    user: {
+      ...user,
+      position: (playersWithMorePoints || 0) + 1,
+    },
+  });
+}

package/api/searchUsers.ts

@@ -1,46 +1,44 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-export const Schema = {
-  input: z.strictObject({
-    text: z.string(),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-    results: z
-      .array(
-        z.object({
-          id: z.number(),
-          username: z.string().nullable(),
-        })
-      )
-      .optional(),
-  }),
-};
-
-export async function POST(res: Response): Promise<NextResponse> {
-  return protectedApi({
-    response: res,
-    schema: Schema,
-    authorization: () => {},
-    activity: handler,
-  });
-}
-
-export async function handler(
-  data: (typeof Schema)["input"]["_type"]
-): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
-  const { data: searchData, error } = await supabase
-    .from("profiles")
-    .select()
-    .ilike("username", `%${data.text}%`)
-    .limit(10);
-  return NextResponse.json({
-    results: (searchData || []).map((data) => ({
-      id: data.id,
-      username: data.username,
-    })),
-  });
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    text: z.string(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    results: z
+      .array(
+        z.object({
+          id: z.number(),
+          username: z.string().nullable(),
+        })
+      )
+      .optional(),
+  }),
+};
+
+export async function POST(request: Request) {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(data: (typeof Schema)["input"]["_type"]) {
+  const { data: searchData, error } = await supabase
+    .from("profiles")
+    .select()
+    .ilike("username", `%${data.text}%`)
+    .limit(10);
+  return NextResponse.json({
+    results: (searchData || []).map((data) => ({
+      id: data.id,
+      username: data.username,
+    })),
+  });
+}

package/api/submitScore.ts

@@ -1,95 +1,106 @@
-import { NextResponse } from "next/server";
-import z from "zod";
-import { protectedApi } from "../utils/requestUtils";
-import { supabase } from "../utils/supabase";
-
-export const Schema = {
-  input: z.strictObject({
-    session: z.string(),
-    data: z.strictObject({
-      token: z.string(),
-      relayHwid: z.string(),
-      songId: z.string(),
-      noteResults: z.record(z.boolean()),
-      triggers: z.array(z.array(z.number())),
-      mapHash: z.string(),
-      mapTitle: z.string(),
-      mapDifficulty: z.number(),
-      mapNoteCount: z.number(),
-      mapLength: z.number(),
-    }),
-  }),
-  output: z.object({
-    error: z.string().optional(),
-  }),
-};
-
-export async function POST(res: Response): Promise<NextResponse> {
-  return protectedApi({
-    response: res,
-    schema: Schema,
-    authorization: () => {},
-    activity: handler,
-  });
-}
-
-export async function handler({
-  data,
-  session,
-}: (typeof Schema)["input"]["_type"]): Promise<
-  NextResponse<(typeof Schema)["output"]["_type"]>
-> {
-  const user = (await supabase.auth.getUser(session)).data.user!;
-
-  let { data: userData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id);
-
-  if (!userData?.length)
-    return NextResponse.json(
-      {
-        error: "User doesn't exist",
-      },
-      { status: 500 }
-    );
-
-  let { data: beatmaps, error } = await supabase
-    .from("beatmaps")
-    .select("*")
-    .eq("beatmapHash", data.mapHash);
-
-  let newPlaycount = 1;
-
-  if (beatmaps?.length) {
-    newPlaycount = (beatmaps[0].playcount || 1) + 1;
-  }
-
-  const upsertData = await supabase
-    .from("beatmaps")
-    .upsert({
-      beatmapHash: data.mapHash,
-      title: data.mapTitle,
-      playcount: newPlaycount,
-      difficulty: data.mapDifficulty,
-      noteCount: data.mapNoteCount,
-      length: data.mapLength,
-    })
-    .select();
-
-  const insertData = await supabase
-    .from("scores")
-    .upsert({
-      beatmapHash: data.mapHash,
-      noteResults: data.noteResults,
-      replayHwid: data.relayHwid,
-      songId: data.songId,
-      triggers: data.triggers,
-      userId: userData[0].id,
-      passed: data.mapNoteCount == Object.keys(data.noteResults).length,
-      misses: Object.values(data.noteResults).filter((e) => !e).length,
-    })
-    .select();
-
-  return NextResponse.json({});
-}
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+    data: z.strictObject({
+      token: z.string(),
+      relayHwid: z.string(),
+      songId: z.string(),
+      noteResults: z.record(z.boolean()),
+      triggers: z.array(z.array(z.number())),
+      mapHash: z.string(),
+      mapTitle: z.string(),
+      mapDifficulty: z.number(),
+      mapNoteCount: z.number(),
+      mapLength: z.number(),
+    }),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler({
+  data,
+  session,
+}: (typeof Schema)["input"]["_type"]): Promise<
+  NextResponse<(typeof Schema)["output"]["_type"]>
+> {
+  const user = (await supabase.auth.getUser(session)).data.user!;
+
+  let { data: userData, error: userError } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id);
+
+  if (!userData?.length)
+    return NextResponse.json(
+      {
+        error: "User doesn't exist",
+      },
+      { status: 500 }
+    );
+
+  let { data: beatmaps, error } = await supabase
+    .from("beatmaps")
+    .select("*")
+    .eq("beatmapHash", data.mapHash);
+
+  let newPlaycount = 1;
+
+  if (beatmaps?.length) {
+    newPlaycount = (beatmaps[0].playcount || 1) + 1;
+  }
+
+  const upsertData = await supabase
+    .from("beatmaps")
+    .upsert({
+      beatmapHash: data.mapHash,
+      title: data.mapTitle,
+      playcount: newPlaycount,
+      difficulty: data.mapDifficulty,
+      noteCount: data.mapNoteCount,
+      length: data.mapLength,
+    })
+    .select();
+
+  const insertData = await supabase
+    .from("scores")
+    .upsert({
+      beatmapHash: data.mapHash,
+      noteResults: data.noteResults,
+      replayHwid: data.relayHwid,
+      songId: data.songId,
+      triggers: data.triggers,
+      userId: userData[0].id,
+      passed: data.mapNoteCount == Object.keys(data.noteResults).length,
+      misses: Object.values(data.noteResults).filter((e) => !e).length,
+    })
+    .select();
+
+  const insertUserData = await supabase
+    .from("profiles")
+    .upsert({
+      id: userData[0].id,
+      play_count: (userData[0].play_count || 0) + 1,
+      squares_hit:
+        (userData[0].squares_hit || 0) +
+        Object.values(data.noteResults).filter((e) => e).length,
+    })
+    .select();
+
+  return NextResponse.json({});
+}

package/handleApi.ts

@@ -1,19 +1,19 @@
-import { z } from "zod";
-let env = "development";
-export function setEnvironment(
-  stage: "development" | "testing" | "production"
-) {
-  env = stage;
-}
-export function handleApi<
-  T extends { url: string; input: z.ZodObject<any>; output: z.ZodObject<any> }
->(apiSchema: T) {
-  return async (input: T["input"]["_type"]): Promise<T["output"]["_type"]> => {
-    const response = await fetch(`https://${env}.rhythia.com${apiSchema.url}`, {
-      method: "POST",
-      body: JSON.stringify(input),
-    });
-    const output = await response.json();
-    return output;
-  };
-}
+import { z } from "zod";
+let env = "development";
+export function setEnvironment(
+  stage: "development" | "testing" | "production"
+) {
+  env = stage;
+}
+export function handleApi<
+  T extends { url: string; input: z.ZodObject<any>; output: z.ZodObject<any> }
+>(apiSchema: T) {
+  return async (input: T["input"]["_type"]): Promise<T["output"]["_type"]> => {
+    const response = await fetch(`https://${env}.rhythia.com${apiSchema.url}`, {
+      method: "POST",
+      body: JSON.stringify(input),
+    });
+    const output = await response.json();
+    return output;
+  };
+}

package/index.html

@@ -1,3 +1,3 @@
-<html>
-    <div>Rhythia API</div>
+<html>
+    <div>Rhythia API</div>
 </html>

package/index.ts

@@ -5,16 +5,16 @@ import { Schema as EditProfile } from "./api/editProfile"
 export { Schema as SchemaEditProfile } from "./api/editProfile"
 export const editProfile = handleApi({url:"/api/editProfile",...EditProfile})
 
-// ./api/getLeaderboard.ts API
-import { Schema as GetLeaderboard } from "./api/getLeaderboard"
-export { Schema as SchemaGetLeaderboard } from "./api/getLeaderboard"
-export const getLeaderboard = handleApi({url:"/api/getLeaderboard",...GetLeaderboard})
-
 // ./api/getProfile.ts API
 import { Schema as GetProfile } from "./api/getProfile"
 export { Schema as SchemaGetProfile } from "./api/getProfile"
 export const getProfile = handleApi({url:"/api/getProfile",...GetProfile})
 
+// ./api/getLeaderboard.ts API
+import { Schema as GetLeaderboard } from "./api/getLeaderboard"
+export { Schema as SchemaGetLeaderboard } from "./api/getLeaderboard"
+export const getLeaderboard = handleApi({url:"/api/getLeaderboard",...GetLeaderboard})
+
 // ./api/searchUsers.ts API
 import { Schema as SearchUsers } from "./api/searchUsers"
 export { Schema as SchemaSearchUsers } from "./api/searchUsers"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "84.0.0",
+  "version": "85.0.0",
   "main": "index.ts",
   "scripts": {
     "update": "bun ./scripts/update.ts",

package/scripts/ci-deploy.ts

@@ -1,76 +1,76 @@
-import fs from "fs";
-import * as git from "isomorphic-git";
-import http from "isomorphic-git/http/node";
-import path from "path";
-
-// Set up the repository URL
-const repoUrl = `https://${process.env.GIT_KEY}@github.com/cunev/rhythia-api.git`;
-
-const sourceBranch = process.env.SOURCE_BRANCH!;
-const targetBranch = process.env.TARGET_BRANCH!;
-
-async function cloneBranch() {
-  const dir = path.join("/tmp", "repo");
-
-  try {
-    // Ensure the directory is clean before cloning
-    if (fs.existsSync(dir)) {
-      fs.rmdirSync(dir, { recursive: true });
-      console.log(`Deleted existing directory: ${dir}`);
-    }
-
-    // Clone the repository into a temporary directory
-    await git.clone({
-      fs,
-      http,
-      dir,
-      url: repoUrl,
-      ref: sourceBranch,
-      singleBranch: true,
-      depth: 1,
-    });
-    console.log(`Cloned ${sourceBranch} branch from remote repository.`);
-
-    // Check out the source branch
-    await git.checkout({ fs, dir, ref: sourceBranch });
-    console.log(`Checked out to branch: ${sourceBranch}`);
-
-    // Pull the latest changes from the source branch
-    await git.pull({
-      fs,
-      http,
-      dir,
-      ref: sourceBranch,
-      singleBranch: true,
-      author: {
-        name: process.env.GIT_USER,
-        email: "you@example.com", // Replace with the actual email
-      },
-    });
-    console.log(`Pulled latest changes from branch: ${sourceBranch}`);
-
-    // Create and checkout the target branch from the source branch
-    await git.branch({ fs, dir, ref: targetBranch });
-    await git.checkout({ fs, dir, ref: targetBranch });
-    console.log(`Created and checked out to branch: ${targetBranch}`);
-
-    // Push the new branch to the remote repository
-    await git.push({
-      fs,
-      http,
-      dir,
-      remote: "origin",
-      ref: targetBranch,
-      force: true,
-      onAuth: () => ({
-        username: process.env.GIT_KEY, // GitHub token or password
-        password: "",
-      }),
-    });
-    console.log(`Pushed new branch to remote: ${targetBranch}`);
-  } catch (error) {
-    console.error("Error performing Git operations:", error.message);
-  }
-}
-
-cloneBranch();
+import fs from "fs";
+import * as git from "isomorphic-git";
+import http from "isomorphic-git/http/node";
+import path from "path";
+
+// Set up the repository URL
+const repoUrl = `https://${process.env.GIT_KEY}@github.com/cunev/rhythia-api.git`;
+
+const sourceBranch = process.env.SOURCE_BRANCH!;
+const targetBranch = process.env.TARGET_BRANCH!;
+
+async function cloneBranch() {
+  const dir = path.join("/tmp", "repo");
+
+  try {
+    // Ensure the directory is clean before cloning
+    if (fs.existsSync(dir)) {
+      fs.rmdirSync(dir, { recursive: true });
+      console.log(`Deleted existing directory: ${dir}`);
+    }
+
+    // Clone the repository into a temporary directory
+    await git.clone({
+      fs,
+      http,
+      dir,
+      url: repoUrl,
+      ref: sourceBranch,
+      singleBranch: true,
+      depth: 1,
+    });
+    console.log(`Cloned ${sourceBranch} branch from remote repository.`);
+
+    // Check out the source branch
+    await git.checkout({ fs, dir, ref: sourceBranch });
+    console.log(`Checked out to branch: ${sourceBranch}`);
+
+    // Pull the latest changes from the source branch
+    await git.pull({
+      fs,
+      http,
+      dir,
+      ref: sourceBranch,
+      singleBranch: true,
+      author: {
+        name: process.env.GIT_USER,
+        email: "you@example.com", // Replace with the actual email
+      },
+    });
+    console.log(`Pulled latest changes from branch: ${sourceBranch}`);
+
+    // Create and checkout the target branch from the source branch
+    await git.branch({ fs, dir, ref: targetBranch });
+    await git.checkout({ fs, dir, ref: targetBranch });
+    console.log(`Created and checked out to branch: ${targetBranch}`);
+
+    // Push the new branch to the remote repository
+    await git.push({
+      fs,
+      http,
+      dir,
+      remote: "origin",
+      ref: targetBranch,
+      force: true,
+      onAuth: () => ({
+        username: process.env.GIT_KEY, // GitHub token or password
+        password: "",
+      }),
+    });
+    console.log(`Pushed new branch to remote: ${targetBranch}`);
+  } catch (error) {
+    console.error("Error performing Git operations:", error.message);
+  }
+}
+
+cloneBranch();

package/scripts/update.ts

@@ -1,49 +1,49 @@
-import { $ } from "bun";
-import { readdirSync, readFileSync, writeFileSync } from "fs";
-import { lowerFirst, upperFirst } from "lodash";
-import path from "path";
-const packageJson = JSON.parse(readFileSync("./package.json", "utf-8"));
-
-const versions = packageJson.version.split(".");
-versions[0] = Number(versions[0]) + 1;
-
-packageJson.version = versions.join(".");
-
-writeFileSync("./package.json", JSON.stringify(packageJson, null, 2));
-
-const apis = readdirSync("./api");
-
-const exports: string[] = [];
-exports.push(`import { handleApi } from "./handleApi"`);
-
-for (const api of apis) {
-  if (
-    !readFileSync(path.join("./api", api), "utf-8").includes(
-      "export const Schema"
-    )
-  ) {
-    continue;
-  }
-  exports.push(`\n// ./api/${api} API`);
-
-  const apiName = path.parse(api).name;
-  exports.push(
-    `import { Schema as ${upperFirst(apiName)} } from "./api/${apiName}"`
-  );
-  exports.push(
-    `export { Schema as Schema${upperFirst(apiName)} } from "./api/${apiName}"`
-  );
-
-  exports.push(
-    `export const ${lowerFirst(
-      apiName
-    )} = handleApi({url:"/api/${apiName}",...${upperFirst(apiName)}})`
-  );
-}
-exports.push(`export { handleApi } from "./handleApi"`);
-
-writeFileSync("./index.ts", exports.join("\n"));
-
-// const conf = readFileSync("./.cred", "utf-8");
-// await $`npm logout`.nothrow();
-await $`yarn publish`;
+import { $ } from "bun";
+import { readdirSync, readFileSync, writeFileSync } from "fs";
+import { lowerFirst, upperFirst } from "lodash";
+import path from "path";
+const packageJson = JSON.parse(readFileSync("./package.json", "utf-8"));
+
+const versions = packageJson.version.split(".");
+versions[0] = Number(versions[0]) + 1;
+
+packageJson.version = versions.join(".");
+
+writeFileSync("./package.json", JSON.stringify(packageJson, null, 2));
+
+const apis = readdirSync("./api");
+
+const exports: string[] = [];
+exports.push(`import { handleApi } from "./handleApi"`);
+
+for (const api of apis) {
+  if (
+    !readFileSync(path.join("./api", api), "utf-8").includes(
+      "export const Schema"
+    )
+  ) {
+    continue;
+  }
+  exports.push(`\n// ./api/${api} API`);
+
+  const apiName = path.parse(api).name;
+  exports.push(
+    `import { Schema as ${upperFirst(apiName)} } from "./api/${apiName}"`
+  );
+  exports.push(
+    `export { Schema as Schema${upperFirst(apiName)} } from "./api/${apiName}"`
+  );
+
+  exports.push(
+    `export const ${lowerFirst(
+      apiName
+    )} = handleApi({url:"/api/${apiName}",...${upperFirst(apiName)}})`
+  );
+}
+exports.push(`export { handleApi } from "./handleApi"`);
+
+writeFileSync("./index.ts", exports.join("\n"));
+
+// const conf = readFileSync("./.cred", "utf-8");
+// await $`npm logout`.nothrow();
+await $`yarn publish`;

package/utils/requestUtils.ts

@@ -1,51 +1,55 @@
-import { NextResponse } from "next/server";
-import { supabase } from "./supabase";
-
-export async function protectedApi({
-  response,
-  schema,
-  authorization,
-  activity,
-}: {
-  response: Response;
-  schema: { input: Zod.ZodObject<any>; output: Zod.ZodObject<any> };
-  authorization: Function;
-  activity: Function;
-}) {
-  let data;
-
-  try {
-    const toParse = await response.json();
-    data = schema.input.parse(toParse);
-  } catch (error) {
-    return NextResponse.json({ error: error.toString() }, { status: 400 });
-  }
-
-  const authorizationReponse = await authorization(data);
-  if (authorizationReponse) {
-    return authorizationReponse;
-  }
-
-  return await activity(data, response);
-}
-
-export async function validUser(data) {
-  if (!data.session) {
-    return NextResponse.json(
-      {
-        error: "Session is missing",
-      },
-      { status: 501 }
-    );
-  }
-
-  const user = await supabase.auth.getUser(data.session);
-  if (user.error || !user.data.user) {
-    return NextResponse.json(
-      {
-        error: "Invalid user session",
-      },
-      { status: 400 }
-    );
-  }
-}
+import { NextResponse } from "next/server";
+import { supabase } from "./supabase";
+import { ZodObject } from "zod";
+
+interface Props<
+  K = (...args: any[]) => Promise<NextResponse<any>>,
+  T = ZodObject<any>
+> {
+  request: Request;
+  schema: { input: T; output: T };
+  authorization?: Function;
+  activity: K;
+}
+
+export async function protectedApi({
+  request,
+  schema,
+  authorization,
+  activity,
+}: Props) {
+  try {
+    const toParse = await request.json();
+    const data = schema.input.parse(toParse);
+    if (authorization) {
+      const authorizationResponse = await authorization(data);
+      if (authorizationResponse) {
+        return authorizationResponse;
+      }
+    }
+    return await activity(data, request);
+  } catch (error) {
+    return NextResponse.json({ error: error.toString() }, { status: 400 });
+  }
+}
+
+export async function validUser(data) {
+  if (!data.session) {
+    return NextResponse.json(
+      {
+        error: "Session is missing",
+      },
+      { status: 501 }
+    );
+  }
+
+  const user = await supabase.auth.getUser(data.session);
+  if (user.error || !user.data.user) {
+    return NextResponse.json(
+      {
+        error: "Invalid user session",
+      },
+      { status: 400 }
+    );
+  }
+}

package/utils/supabase.ts

@@ -1,13 +1,13 @@
-import { createClient } from "@supabase/supabase-js";
-import { Database } from "../types/database";
-
-export const supabase = createClient<Database>(
-  `https://pfkajngbllcbdzoylrvp.supabase.co`,
-  process.env.ADMIN_KEY || "key",
-  {
-    auth: {
-      autoRefreshToken: false,
-      persistSession: false,
-    },
-  }
-);
+import { createClient } from "@supabase/supabase-js";
+import { Database } from "../types/database";
+
+export const supabase = createClient<Database>(
+  `https://pfkajngbllcbdzoylrvp.supabase.co`,
+  process.env.ADMIN_KEY || "key",
+  {
+    auth: {
+      autoRefreshToken: false,
+      persistSession: false,
+    },
+  }
+);

package/vercel.json

@@ -1,13 +1,13 @@
-{
-  "headers": [
-    {
-      "source": "/api/(.*)",
-      "headers": [
-        { "key": "Access-Control-Allow-Credentials", "value": "true" },
-        { "key": "Access-Control-Allow-Origin", "value": "*" },
-        { "key": "Access-Control-Allow-Methods", "value": "GET,OPTIONS,PATCH,DELETE,POST,PUT" },
-        { "key": "Access-Control-Allow-Headers", "value": "X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version" }
-      ]
-    }
-  ]
+{
+  "headers": [
+    {
+      "source": "/api/(.*)",
+      "headers": [
+        { "key": "Access-Control-Allow-Credentials", "value": "true" },
+        { "key": "Access-Control-Allow-Origin", "value": "*" },
+        { "key": "Access-Control-Allow-Methods", "value": "GET,OPTIONS,PATCH,DELETE,POST,PUT" },
+        { "key": "Access-Control-Allow-Headers", "value": "X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version" }
+      ]
+    }
+  ]
 }