rhythia-api 201.0.0 → 202.0.0

package/api/acceptInvite.ts

@@ -27,53 +27,5 @@ export async function POST(request: Request) {
 }
 
 export async function handler(data: (typeof Schema)["input"]["_type"]) {
-  const user = (await getUserBySession(data.session)) as User;
-  let { data: queryUserData, error: userError } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("uid", user.id)
-    .single();
-
-  if (!queryUserData) {
-    return NextResponse.json({ error: "Can't find user" });
-  }
-
-  let { data: codeData } = await supabase
-    .from("invites")
-    .select("*")
-    .eq("code", data.code)
-    .single();
-
-  if (!codeData || (codeData && codeData.used)) {
-    return NextResponse.json({ error: "Can't find code, or used" });
-  }
-
-  if (codeData.type == "clan") {
-    if (queryUserData.clan) {
-      return NextResponse.json({
-        error: "You can't join another clan while being in a clan",
-      });
-    }
-
-    let { data: queryClanData, error: clanError } = await supabase
-      .from("clans")
-      .select("*")
-      .eq("id", Number(codeData.resourceId))
-      .single();
-
-    if (!queryClanData) {
-      return NextResponse.json({
-        error: "No such clan",
-      });
-    }
-
-    await supabase.from("profiles").upsert({
-      id: queryUserData.id,
-      clan: queryClanData?.id,
-    });
-
-    return NextResponse.json({});
-  }
-
-  return NextResponse.json({ error: "Unknown invite type" });
+  return NextResponse.json({ error: "Disabled" }, { status: 403 });
 }

package/api/executeAdminOperation.ts

@@ -10,6 +10,7 @@ import { User } from "@supabase/supabase-js";
 const adminOperations = {
   deleteUser: z.object({ userId: z.number() }),
   changeFlag: z.object({ userId: z.number(), flag: z.string() }),
+  changeBadges: z.object({ userId: z.number(), badges: z.string() }),
   excludeUser: z.object({ userId: z.number() }),
   restrictUser: z.object({ userId: z.number() }),
   silenceUser: z.object({ userId: z.number() }),
@@ -62,6 +63,10 @@ const OperationParam = z.discriminatedUnion("operation", [
     operation: z.literal("changeFlag"),
     params: adminOperations.changeFlag,
   }),
+  z.object({
+    operation: z.literal("changeBadges"),
+    params: adminOperations.changeBadges,
+  }),
 ]);
 
 export const Schema = {
@@ -183,7 +188,7 @@ export async function handler(
         break;
 
       case "changeFlag":
-        await supabase
+        result = await supabase
           .from("profiles")
           .upsert({
             id: params.userId,
@@ -191,6 +196,15 @@ export async function handler(
           })
           .select();
         break;
+      case "changeBadges":
+        result = await supabase
+          .from("profiles")
+          .upsert({
+            id: params.userId,
+            badges: JSON.parse(params.badges),
+          })
+          .select();
+        break;
     }
 
     // Log the admin action

package/api/getInventory.ts

@@ -0,0 +1,50 @@
+import { NextResponse } from "next/server";
+import z from "zod";
+import { protectedApi, validUser } from "../utils/requestUtils";
+import { supabase } from "../utils/supabase";
+import { User } from "@supabase/supabase-js";
+import { getUserBySession } from "../utils/getUserBySession";
+
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    inventory: z.any().optional(),
+  }),
+};
+
+export async function POST(request: Request): Promise<NextResponse> {
+  return protectedApi({
+    request,
+    schema: Schema,
+    authorization: () => {},
+    activity: handler,
+  });
+}
+
+export async function handler(
+  data: (typeof Schema)["input"]["_type"]
+): Promise<NextResponse<(typeof Schema)["output"]["_type"]>> {
+  const user = (await getUserBySession(data.session)) as User;
+  let { data: queryData, error } = await supabase
+    .from("profiles")
+    .select("*")
+    .eq("uid", user.id)
+    .single();
+  if (!queryData) {
+    return NextResponse.json({ error: "Can't retrieve user inventory" });
+  }
+
+  let { data: inventoryData, error: inventoryError } = await supabase
+    .from("inventories")
+    .select("*")
+    .eq("id", queryData.id)
+    .single();
+
+  if (!queryData) {
+    NextResponse.json({});
+  }
+  return NextResponse.json({ inventory: inventoryData });
+}

package/index.ts

@@ -735,6 +735,22 @@ import { Schema as GetCollections } from "./api/getCollections"
 export { Schema as SchemaGetCollections } from "./api/getCollections"
 export const getCollections = handleApi({url:"/api/getCollections",...GetCollections})
 
+// ./api/getInventory.ts API
+
+/*
+export const Schema = {
+  input: z.strictObject({
+    session: z.string(),
+  }),
+  output: z.strictObject({
+    error: z.string().optional(),
+    inventory: z.any().optional(),
+  }),
+};*/
+import { Schema as GetInventory } from "./api/getInventory"
+export { Schema as SchemaGetInventory } from "./api/getInventory"
+export const getInventory = handleApi({url:"/api/getInventory",...GetInventory})
+
 // ./api/getLeaderboard.ts API
 
 /*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhythia-api",
-  "version": "201.0.0",
+  "version": "202.0.0",
   "main": "index.ts",
   "author": "online-contributors-cunev",
   "scripts": {

package/types/database.ts

@@ -363,6 +363,29 @@ export type Database = {
         }
         Relationships: []
       }
+      inventories: {
+        Row: {
+          contents: Json
+          id: number
+        }
+        Insert: {
+          contents?: Json
+          id?: number
+        }
+        Update: {
+          contents?: Json
+          id?: number
+        }
+        Relationships: [
+          {
+            foreignKeyName: "inventory_id_fkey"
+            columns: ["id"]
+            isOneToOne: true
+            referencedRelation: "profiles"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
       invites: {
         Row: {
           code: string