rhythia-api 92.0.0 → 93.0.0

package/api/getUserScores.ts

@@ -0,0 +1,84 @@
+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({
+    id: z.number(),
+  }),
+  output: z.object({
+    error: z.string().optional(),
+    lastDay: z
+      .array(
+        z.object({
+          awarded_sp: z.number().nullable(),
+          beatmapHash: z.string().nullable(),
+          created_at: z.string(),
+          id: z.number(),
+          misses: z.number().nullable(),
+          passed: z.boolean().nullable(),
+          rank: z.string().nullable(),
+          songId: z.string().nullable(),
+          userId: z.number().nullable(),
+        })
+      )
+      .optional(),
+    top: z.array(z.object({})).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 { data: scores1, error: errorlast } = await supabase
+    .from("scores")
+    .select("*")
+    .eq("userId", data.id)
+    .order("created_at", { ascending: false })
+    .limit(10);
+
+  let { data: scores2, error: errorsp } = await supabase
+    .from("scores")
+    .select("*")
+    .eq("userId", data.id)
+    .order("awarded_sp", { ascending: false })
+    .limit(10);
+
+  return NextResponse.json({
+    lastDay: scores1?.map((s) => ({
+      created_at: s.created_at,
+      id: s.id,
+      passed: s.passed,
+      userId: s.userId,
+      awarded_sp: s.awarded_sp,
+      beatmapHash: s.beatmapHash,
+      misses: s.misses,
+      rank: s.rank,
+      songId: s.songId,
+    })),
+    top: scores2?.map((s) => ({
+      created_at: s.created_at,
+      id: s.id,
+      passed: s.passed,
+      userId: s.userId,
+      awarded_sp: s.awarded_sp,
+      beatmapHash: s.beatmapHash,
+      misses: s.misses,
+      rank: s.rank,
+      songId: s.songId,
+    })),
+  });
+}

package/api/searchUsers.ts

@@ -1,41 +1,41 @@
-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("id,username")
-    .ilike("username", `%${data.text}%`)
-    .limit(10);
-  return NextResponse.json({
-    results: searchData || [],
-  });
-}
+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("id,username")
+    .ilike("username", `%${data.text}%`)
+    .limit(10);
+  return NextResponse.json({
+    results: searchData || [],
+  });
+}

package/api/submitScore.ts

@@ -1,106 +1,108 @@
-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(),
-    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: validUser,
-    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)
-    .single();
-
-  if (!userData)
-    return NextResponse.json(
-      {
-        error: "User doesn't exist",
-      },
-      { status: 500 }
-    );
-
-  console.log(userData);
-  let { data: beatmaps, error } = await supabase
-    .from("beatmaps")
-    .select("playcount")
-    .eq("beatmapHash", data.mapHash)
-    .single();
-
-  let newPlaycount = 1;
-
-  if (beatmaps) {
-    newPlaycount = (beatmaps.playcount || 1) + 1;
-  }
-
-  console.log(newPlaycount);
-  const p1 = await supabase.from("beatmaps").upsert({
-    beatmapHash: data.mapHash,
-    title: data.mapTitle,
-    playcount: newPlaycount,
-    difficulty: data.mapDifficulty,
-    noteCount: data.mapNoteCount,
-    length: data.mapLength,
-  });
-
-  console.log("p1");
-  const p2 = await supabase.from("scores").upsert({
-    beatmapHash: data.mapHash,
-    noteResults: data.noteResults,
-    replayHwid: data.relayHwid,
-    songId: data.songId,
-    triggers: data.triggers,
-    userId: userData.id,
-    passed: data.mapNoteCount == Object.keys(data.noteResults).length,
-    misses: Object.values(data.noteResults).filter((e) => !e).length,
-  });
-  console.log("p2");
-
-  const p3 = await supabase.from("profiles").upsert({
-    id: userData.id,
-    play_count: (userData.play_count || 0) + 1,
-    squares_hit:
-      (userData.squares_hit || 0) +
-      Object.values(data.noteResults).filter((e) => e).length,
-  });
-  console.log("p3");
-
-  // await Promise.all([p1, p2, p3]);
-
-  return NextResponse.json({});
-}
+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(),
+    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: validUser,
+    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)
+    .single();
+
+  if (!userData)
+    return NextResponse.json(
+      {
+        error: "User doesn't exist",
+      },
+      { status: 500 }
+    );
+
+  console.log(userData);
+  let { data: beatmaps, error } = await supabase
+    .from("beatmaps")
+    .select("playcount")
+    .eq("beatmapHash", data.mapHash)
+    .single();
+
+  let newPlaycount = 1;
+
+  if (beatmaps) {
+    newPlaycount = (beatmaps.playcount || 1) + 1;
+  }
+
+  console.log(newPlaycount);
+  const p1 = await supabase.from("beatmaps").upsert({
+    beatmapHash: data.mapHash,
+    title: data.mapTitle,
+    playcount: newPlaycount,
+    difficulty: data.mapDifficulty,
+    noteCount: data.mapNoteCount,
+    length: data.mapLength,
+  });
+
+  console.log("p1");
+  const p2 = await supabase.from("scores").upsert({
+    beatmapHash: data.mapHash,
+    noteResults: data.noteResults,
+    replayHwid: data.relayHwid,
+    songId: data.songId,
+    triggers: data.triggers,
+    userId: userData.id,
+    passed: data.mapNoteCount == Object.keys(data.noteResults).length,
+    misses: Object.values(data.noteResults).filter((e) => !e).length,
+    awarded_sp: 0,
+    rank: "A",
+  });
+  console.log("p2");
+
+  const p3 = await supabase.from("profiles").upsert({
+    id: userData.id,
+    play_count: (userData.play_count || 0) + 1,
+    squares_hit:
+      (userData.squares_hit || 0) +
+      Object.values(data.noteResults).filter((e) => e).length,
+  });
+  console.log("p3");
+
+  // await Promise.all([p1, p2, p3]);
+
+  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

@@ -1,24 +1,29 @@
 import { handleApi } from "./handleApi"
 
+// ./api/getPublicStats.ts API
+import { Schema as GetPublicStats } from "./api/getPublicStats"
+export { Schema as SchemaGetPublicStats } from "./api/getPublicStats"
+export const getPublicStats = handleApi({url:"/api/getPublicStats",...GetPublicStats})
+
+// ./api/getUserScores.ts API
+import { Schema as GetUserScores } from "./api/getUserScores"
+export { Schema as SchemaGetUserScores } from "./api/getUserScores"
+export const getUserScores = handleApi({url:"/api/getUserScores",...GetUserScores})
+
 // ./api/editProfile.ts API
 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/getPublicStats.ts API
-import { Schema as GetPublicStats } from "./api/getPublicStats"
-export { Schema as SchemaGetPublicStats } from "./api/getPublicStats"
-export const getPublicStats = handleApi({url:"/api/getPublicStats",...GetPublicStats})
+// ./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"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "92.0.0",
+  "version": "93.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();