add the backend api

.env.example

@@ -12,3 +12,8 @@
 # Example:
 # SERVERVAR="foo"
 # NEXT_PUBLIC_CLIENTVAR="bar"
+
+# Deployment used by `npx convex dev`
+CONVEX_DEPLOYMENT="..." # team: creative-programmers, project: sketchit-challenge
+
+NEXT_PUBLIC_CONVEX_URL="https://..."

convex/_generated/api.d.ts

@@ -14,6 +14,10 @@ import type {
   FilterApi,
   FunctionReference,
 } from "convex/server";
+import type * as messages from "../messages";
+import type * as openai from "../openai";
+import type * as player from "../player";
+import type * as rooms from "../rooms";
 
 /**
  * A utility for referencing Convex functions in your app's API.
@@ -23,7 +27,12 @@ import type {
  * const myFunctionReference = api.myModule.myFunction;
  * ```
  */
-declare const fullApi: ApiFromModules<{}>;
+declare const fullApi: ApiFromModules<{
+  messages: typeof messages;
+  openai: typeof openai;
+  player: typeof player;
+  rooms: typeof rooms;
+}>;
 export declare const api: FilterApi<
   typeof fullApi,
   FunctionReference<any, "public">

convex/_generated/dataModel.d.ts

@@ -9,29 +9,25 @@
  * @module
  */
 
-import { AnyDataModel } from "convex/server";
+import type { DataModelFromSchemaDefinition } from "convex/server";
+import type { DocumentByName, TableNamesInDataModel } from "convex/server";
 import type { GenericId } from "convex/values";
-
-/**
- * No `schema.ts` file found!
- *
- * This generated code has permissive types like `Doc = any` because
- * Convex doesn't know your schema. If you'd like more type safety, see
- * https://docs.convex.dev/using/schemas for instructions on how to add a
- * schema file.
- *
- * After you change a schema, rerun codegen with `npx convex dev`.
- */
+import schema from "../schema";
 
 /**
  * The names of all of your Convex tables.
  */
-export type TableNames = string;
+export type TableNames = TableNamesInDataModel<DataModel>;
 
 /**
  * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
  */
-export type Doc = any;
+export type Doc<TableName extends TableNames> = DocumentByName<
+  DataModel,
+  TableName
+>;
 
 /**
  * An identifier for a document in Convex.
@@ -43,9 +39,10 @@ export type Doc = any;
  *
  * IDs are just strings at runtime, but this type can be used to distinguish them from other
  * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
  */
-export type Id<TableName extends TableNames = TableNames> =
-  GenericId<TableName>;
+export type Id<TableName extends TableNames> = GenericId<TableName>;
 
 /**
  * A type describing your Convex data model.
@@ -56,4 +53,4 @@ export type Id<TableName extends TableNames = TableNames> =
  * This type is used to parameterize methods like `queryGeneric` and
  * `mutationGeneric` to make them type-safe.
  */
-export type DataModel = AnyDataModel;
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

convex/messages.ts

@@ -0,0 +1,42 @@
+import { query, mutation } from "./_generated/server";
+import { v } from "convex/values";
+
+export const list = query({
+  args: { roomId: v.id("rooms") },
+  handler: async (ctx, args) => {
+    // Grab the most recent messages.
+    const messages = await ctx.db
+      .query("messages")
+      .filter((q) => q.eq(q.field("roomId"), args.roomId))
+      .order("desc")
+      .collect();
+    // Reverse the list so that it's in a chronological order.
+    const messageWithUsername = await Promise.all(
+      messages.map(async (message) => {
+        // Find the likes for each message
+        const player = await ctx.db.get(message.playerId);
+        // Join the count of likes with the message data
+        return {
+          ...message,
+          // Format smileys
+          username: player?.username,
+        };
+      }),
+    );
+    // Reverse the list so that it's in chronological order.
+    return messageWithUsername.reverse();
+  },
+});
+
+// player sends a message in a room
+export const send = mutation({
+  args: { body: v.string(), playerId: v.id("player"), roomId: v.id("rooms") },
+  handler: async (ctx, args) => {
+    // Send a new message.
+    await ctx.db.insert("messages", {
+      body: args.body,
+      playerId: args.playerId,
+      roomId: args.roomId,
+    });
+  },
+});

convex/openai.ts

@@ -0,0 +1,72 @@
+"use node";
+
+import { action } from "./_generated/server";
+import { v } from "convex/values";
+import { api } from "../convex/_generated/api";
+import OpenAI from "openai";
+
+// Initialize the OpenAI client with the given API key
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY, // This is also the default, can be omitted
+});
+// start a game
+export const startGames = action({
+  args: {
+    topic: v.string(),
+    numberOfPlayer: v.number(),
+    roomId: v.id("rooms"),
+  },
+  handler: async (ctx, args) => {
+    try {
+      const checkTopicResponse = await openai.completions.create({
+        model: "text-davinci-003",
+        prompt: `Is the topic ${args.topic} good?
+                 A good topic must be a single or two-word topic like 'animal', 'plants', 'cars', 'celebrities', etc.
+                 Also, a good topic must be a topic from which other words that can be drawn can be found.
+                 Anything that can be suitable for all audiences.
+                 A bad topic is something sexual or harassing or something like "hello" is also a bad topic.
+                 Your answer should just be true or false.`,
+      });
+
+      if (checkTopicResponse.choices[0]?.text.includes("false")) {
+        return {
+          message: "The backend got an error: It's a bad topic!",
+        };
+      }
+
+      const response = await openai.completions.create({
+        model: "text-davinci-003",
+        prompt: `Suggest ${args.numberOfPlayer} words  for an topic that is '${args.topic}'`,
+      });
+
+      // Pull the message content out of the response
+      const words = response.choices[0]?.text;
+      // save the words and the topic into the database
+      if (words && words.length > 0) {
+        await ctx.runMutation(api.player.startGames, {
+          topic: args.topic,
+          words: words,
+          roomId: args.roomId,
+        });
+        return words;
+      } else {
+        console.error("The Open AI return nothing");
+        return {
+          message:
+            "The backend got an error: The maximum amount of users is 8!",
+        };
+      }
+    } catch (error: unknown) {
+      if (error instanceof OpenAI.APIError) {
+        console.error("Status", error.status); // e.g. 401
+        console.error("Message", error.message); // e.g. The authentication token you passed was invalid...
+        console.error("Error Code", error.code); // e.g. 'invalid_api_key'
+        console.error("Error Type", error.type); // e.g. 'invalid_request_error'
+        return { message: "The backend got an error", error: error };
+      } else {
+        console.error(error);
+        return { message: "The backend got an error", error: error };
+      }
+    }
+  },
+});

convex/player.ts

@@ -0,0 +1,55 @@
+import { query, mutation } from "./_generated/server";
+import { v } from "convex/values";
+
+// start a game
+export const startGames = mutation({
+  args: { topic: v.string(), words: v.string(), roomId: v.id("rooms") },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.roomId, {
+      topic: args.topic,
+      words: args.words,
+    });
+    // update the player who in this room
+    const playerList = await ctx.db
+      .query("player")
+      .filter((q) => q.eq(q.field("roomId"), args.roomId))
+      .collect();
+    for (let i = 0; i < playerList.length; i++) {
+      const player = playerList[i];
+      if (player) {
+        await ctx.db.patch(player._id, { roomId: args.roomId, score: 0 });
+      } else {
+        console.error("The data error");
+      }
+    }
+  },
+});
+
+// check the user's word is correct or not
+export const checkWordFromUser = mutation({
+  args: {
+    playerId: v.id("player"),
+    wordFromUser: v.string(),
+    roomId: v.id("rooms"),
+  },
+  handler: async (ctx, args) => {
+    const room = await ctx.db.get(args.roomId);
+    // Update the score
+    if (room?.words?.includes(args.wordFromUser)) {
+      const player = await ctx.db.get(args.playerId);
+      const newScore = player?.score ? player?.score + 1 : 1;
+      ctx.db.patch(args.playerId, { score: newScore });
+    }
+  },
+});
+
+// get all the players in a room
+export const getPlayersByRoomId = query({
+  args: { _id: v.id("rooms") },
+  handler: async (ctx, args) => {
+    await ctx.db
+      .query("player")
+      .filter((q) => q.eq(q.field("roomId"), args._id))
+      .collect();
+  },
+});

convex/rooms.ts

@@ -0,0 +1,50 @@
+import { query, mutation } from "./_generated/server";
+import { v } from "convex/values";
+
+// create room
+export const createRoom = mutation({
+  args: {
+    username: v.string(),
+    timeLimit: v.number(),
+    pairs: v.boolean(),
+    chatEnabled: v.boolean(),
+  },
+  handler: async (ctx, args) => {
+    const roomName = args.username + "'s Room";
+    const roomId = await ctx.db.insert("rooms", {
+      roomName,
+      timeLimit: args.timeLimit,
+      pairs: args.pairs,
+      chatEnabled: args.chatEnabled,
+    });
+    const playerId = await ctx.db.insert("player", {
+      username: args.username,
+      roomId: roomId,
+    });
+    return { playId: playerId, roomId: roomId };
+  },
+});
+
+// let somebody join into room
+export const joinRoomByRoomId = mutation({
+  args: { username: v.string(), roomId: v.id("rooms") },
+  handler: async (ctx, args) => {
+    const players = await ctx.db
+      .query("player")
+      .filter((q) => q.eq(q.field("roomId"), args.roomId))
+      .collect();
+    if (players.length >= 8) {
+      return {
+        message: "The backend got an error: The maximum amount of users is 8!",
+      };
+    }
+    await ctx.db.insert("player", {
+      username: args.username,
+      roomId: args.roomId,
+    });
+    return ctx.db
+      .query("player")
+      .filter((q) => q.eq(q.field("roomId"), args.roomId))
+      .collect();
+  },
+});

convex/schema.ts

@@ -0,0 +1,23 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export default defineSchema({
+  player: defineTable({
+    username: v.string(),
+    roomId: v.id("rooms"),
+    score: v.optional(v.number()),
+  }),
+  rooms: defineTable({
+    roomName: v.string(),
+    topic: v.optional(v.string()),
+    words: v.optional(v.string()),
+    chatEnabled: v.boolean(),
+    timeLimit: v.number(),
+    pairs: v.boolean(),
+  }),
+  messages: defineTable({
+    playerId: v.id("player"),
+    roomId: v.id("rooms"),
+    body: v.string(),
+  }),
+});

package.json

@@ -18,6 +18,7 @@
     "clsx": "^2.0.0",
     "convex": "^1.2.1",
     "next": "^13.4.2",
+    "openai": "^4.5.0",
     "react": "18.2.0",
     "react-dom": "18.2.0",
     "zod": "^3.21.4"