rhythia-api 83.0.0 → 85.0.0

package/api/submitScore.ts

@@ -1,92 +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(),
-      noteCount: 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,
-      beatmapTitle: data.mapTitle,
-      playcount: newPlaycount,
-      difficulty: data.mapDifficulty,
-      noteCount: data.noteCount,
-    })
-    .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.noteCount == Object.keys(data.noteResults).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": "83.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/types/database.ts

@@ -12,27 +12,30 @@ export type Database = {
       beatmaps: {
         Row: {
           beatmapHash: string
-          beatmapTitle: string | null
           created_at: string
           difficulty: number | null
+          length: number | null
           noteCount: number | null
           playcount: number | null
+          title: string | null
         }
         Insert: {
           beatmapHash: string
-          beatmapTitle?: string | null
           created_at?: string
           difficulty?: number | null
+          length?: number | null
           noteCount?: number | null
           playcount?: number | null
+          title?: string | null
         }
         Update: {
           beatmapHash?: string
-          beatmapTitle?: string | null
           created_at?: string
           difficulty?: number | null
+          length?: number | null
           noteCount?: number | null
           playcount?: number | null
+          title?: string | null
         }
         Relationships: []
       }
@@ -97,6 +100,7 @@ export type Database = {
           beatmapHash: string | null
           created_at: string
           id: number
+          misses: number | null
           noteResults: Json | null
           passed: boolean | null
           playedAt: number | null
@@ -109,6 +113,7 @@ export type Database = {
           beatmapHash?: string | null
           created_at?: string
           id?: number
+          misses?: number | null
           noteResults?: Json | null
           passed?: boolean | null
           playedAt?: number | null
@@ -121,6 +126,7 @@ export type Database = {
           beatmapHash?: string | null
           created_at?: string
           id?: number
+          misses?: number | null
           noteResults?: Json | null
           passed?: boolean | null
           playedAt?: number | null