rhythia-api 89.0.0 → 90.0.0

package/api/submitScore.ts

@@ -1,101 +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(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)
-    .single();
-
-  if (!userData)
-    return NextResponse.json(
-      {
-        error: "User doesn't exist",
-      },
-      { status: 500 }
-    );
-
-  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;
-  }
-
-  const p1 = supabase.from("beatmaps").upsert({
-    beatmapHash: data.mapHash,
-    title: data.mapTitle,
-    playcount: newPlaycount,
-    difficulty: data.mapDifficulty,
-    noteCount: data.mapNoteCount,
-    length: data.mapLength,
-  });
-
-  const p2 = 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,
-  });
-
-  const p3 = 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,
-  });
-
-  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,
+  });
+  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

@@ -5,15 +5,20 @@ 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/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/searchUsers.ts API
 import { Schema as SearchUsers } from "./api/searchUsers"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "89.0.0",
+  "version": "90.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,55 +1,55 @@
-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 }
-    );
-  }
-}
+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 }
+    );
+  }
+}