Scaffolding for HTTP backend. Add unit tests for Set functionality

aureateAnatidae · aureateAnatidae · commit c52ff1c4a488 · 2025-11-27T18:28:41.000-07:00
diff --git a/backend/.gitignore b/backend/.gitignore
@@ -26,3 +26,6 @@ lerna-debug.log*
 
 # misc
 .DS_Store
+
+# Database file
+*.db
diff --git a/backend/bot_data.db b/backend/bot_data.db
diff --git a/backend/package.json b/backend/package.json
@@ -11,6 +11,7 @@
   },
   "dependencies": {
     "@hono/node-server": "^1.19.6",
+    "@hono/standard-validator": "^0.2.0",
     "@hono/zod-validator": "^0.7.5",
     "better-sqlite3": "^12.4.6",
     "hono": "^4.10.6",
@@ -23,6 +24,8 @@
     "@biomejs/biome": "^2.3.7",
     "@types/node": "^20.11.17",
     "tsx": "^4.7.1",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^4.0.14"
   }
 }
diff --git a/backend/pnpm-lock.yaml b/backend/pnpm-lock.yaml
diff --git a/backend/src/db/init_tables.ts b/backend/src/db/init_tables.ts
@@ -1,5 +1,5 @@
 import { knexDb } from "@db/knexfile";
-import { SetCharacterTable, SetResultTable, SetTable, SSBUCharTable } from "@v1/set/schema";
+import { SetCharacterTable, SetResultTable, SetTable, SSBUCharTable } from "@v1/set/models";
 import type { Knex } from "knex";
 
 import pino from "pino";
@@ -9,7 +9,7 @@ const log = pino();
 const tables = [SetTable, SetResultTable, SetCharacterTable, SSBUCharTable];
 
 async function create_table_if_notexists(
-    db: Knex,
+    db: Knex = knexDb,
     tableName: string,
     callback: (tableBuilder: Knex.CreateTableBuilder) => void,
 ): Promise<Knex.SchemaBuilder> {
@@ -28,17 +28,19 @@ export async function init_tables(db: Knex = knexDb) {
     for (const table of tables) {
         await create_table_if_notexists(trx, table.table_name, table.initialize);
     }
+    await trx.seed.run();
     await trx.commit();
-    await db.seed.run();
 }
 
 export async function teardown(db: Knex = knexDb) {
     if (process.env.NODE_ENV === "production") {
         log.error("`teardown` was called on a production database -- no action will be performed");
         return;
     }
+    const trx = await db.transaction();
     for (const table of tables) {
-        await db.schema.dropTableIfExists(table.table_name);
+        await trx.schema.dropTableIfExists(table.table_name);
     }
+    await trx.commit();
     log.info("Successfully performed `teardown` on database");
 }
diff --git a/backend/src/index.ts b/backend/src/index.ts
@@ -1,22 +1,40 @@
 import { init_tables, teardown } from "@db/init_tables";
 import { serve } from "@hono/node-server";
+import set_router from "@v1/set/router";
+import user_router from "@v1/user/router";
 import { Hono } from "hono";
+import { openAPIRouteHandler } from "hono-openapi";
+import {
+  trimTrailingSlash,
+} from 'hono/trailing-slash'
+
 
 const app = new Hono();
 
 await teardown();
 await init_tables();
 
+
+app.use(trimTrailingSlash())
+
 app.get("/", (c) => {
     return c.text("Hello Hono!");
 });
 
-serve(
-    {
-        fetch: app.fetch,
-        port: 3000,
-    },
-    (info) => {
-        console.log(`Server is running on http://localhost:${info.port}`);
-    },
+app.get(
+    "/docs",
+    openAPIRouteHandler(app, {
+        documentation: {
+            info: {
+                title: "Grindcord REST API",
+                version: "0.0.1",
+                description: "Grindcord OpenAPI Reference",
+            },
+            servers: [{ url: "http://localhost:3000", description: "Local Server" }],
+        },
+    }),
 );
+
+serve({ fetch: app.fetch, port: 3000 }, (info) => {
+    console.log(`Server is running on http://localhost:${info.port}`);
+});
diff --git a/backend/src/tests/common.ts b/backend/src/tests/common.ts
@@ -3,7 +3,10 @@ import knex, { type Knex } from "knex";
 export const test_config = {
     client: "better-sqlite3",
     connection: {
-        filename: "./test.db",
+        filename: ":memory:",
+    },
+    seeds: {
+        director: "./seeds/"
     },
     useNullAsDefault: true,
 };
diff --git a/backend/src/tests/report.test.ts b/backend/src/tests/report.test.ts
diff --git a/backend/src/v1/set/models.ts b/backend/src/v1/set/models.ts
@@ -5,22 +5,19 @@ export const SetTable = {
     initialize(table) {
         table.increments("set_id");
         table.string("guild_id").index("guild_id_idx");
-        table.timestamp("created_at").defaultTo(knexDb.fn.now());
+        // https://github.com/knex/knex/issues/6283
+        table.timestamp("created_at").defaultTo(new Date().toISOString());
     },
 };
 
 export const SetResultTable = {
     table_name: "SetResult",
     initialize(table) {
         table.primary(["set_id", "user_id"]);
-        table.unique(["set_id", "is_win"], {
-            indexName: "set_winner_idx",
-        });
 
         table.integer("set_id").unsigned();
         table.string("user_id");
         table.integer("game_count");
-        table.boolean("is_win");
 
         table.foreign("set_id").references("set_id").inTable("Set");
     },
diff --git a/backend/src/v1/set/router.ts b/backend/src/v1/set/router.ts
@@ -0,0 +1,8 @@
+import { Hono } from "hono";
+import { describeRoute, resolver, validator } from "hono-openapi";
+import type { SetRecord, SetReport } from "@v1/set/schemas";
+
+
+const app = new Hono();
+
+export default app;
diff --git a/backend/src/v1/set/schemas.ts b/backend/src/v1/set/schemas.ts
@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { ssbu_character_names } from "@v1/../../seeds/SSBUCharacters";
+
+export const SetReport = z.object({
+    guild_id: z.string(),
+    
+    winner_id: z.string(),
+    winner_tier: z.int(),
+    winner_count: z.int(),
+    winner_character: z.array(z.enum(ssbu_character_names)),
+
+    loser_id: z.string(),
+    loser_tier: z.int(),
+    loser_count: z.int(),
+    loser_character: z.array(z.enum(ssbu_character_names)),
+});
+export type SetReport = z.infer<typeof SetReport>;
+
+export const SetRecord = z.object({
+    set_id: z.int(),  // should not be exposed
+    guild_id: z.string(),
+    created_at: z.iso.datetime()
+});
+export type SetRecord = z.infer<typeof SetRecord>;
diff --git a/backend/src/v1/set/service.ts b/backend/src/v1/set/service.ts
@@ -1,6 +1,40 @@
-import type { SetRecord, SetReport } from "@v1/set/types";
+import { knexDb } from "@db/knexfile";
+import type { SetReport } from "@v1/set/schemas";
+import type { Knex } from "knex";
 
-export async function reportSet(set_report: SetReport): Promise<SetReport> {}
+/** Report a set.
+ * Transactionally, create a record in the Set table, then create the matching pair
+ * of records in SetResult table.
+ */
+export async function reportSet(set_report: SetReport): Promise<SetReport> {
+    const trx = await knexDb.transaction();
+
+    trx.commit();
+}
+
+/** Create a set, returning the incrementing set_id.
+ * @param {guild_id} string - The guild in which the set was recorded.
+ */
+export async function createSet(guild_id: string, db: Knex = knexDb): Promise<number> {
+    const set_id = await db("Set").insert({ guild_id });
+    return set_id;
+}
+
+/** Create a record in SetResult. */
+export async function createSetResult(
+    set_id: number,
+    user_id: string,
+    game_count: number,
+    db: Knex = knexDb,
+): Promise<void> {
+    return await db("SetResult").insert({ set_id, user_id, game_count });
+}
+
+/** Create a record in SetCharacterTable. */
+export async function createSetCharacter(db: Knex, characters: Array<number>): Promise<number> {
+    await db("SetCharacter").insert({});
+    return;
+}
 
 // Consider some sort of fighly flexible minimal abstraction over SQL so that developer/user can provide any bounds to search in table
 export async function getSets(user_id: string): Promise<Array<SetRecord>> {}
diff --git a/backend/src/v1/set/set.test.ts b/backend/src/v1/set/set.test.ts
@@ -0,0 +1,66 @@
+// would like to rename this file to just "tests.ts"
+import { init_tables, teardown } from "@db/init_tables";
+import { test_knexDb } from "@tests/common";
+import { type SetRecord, SetReport } from "@v1/set/schemas";
+
+import { createSet, createSetReport } from "@v1/set/service";
+import { beforeAll, beforeEach, describe, expect, expectTypeOf, test } from "vitest";
+
+const mockSetReport = SetReport.parse({
+    guild_id: "19283746",
+    winner_id: "12345678",
+    winner_tier: 3,
+    winner_count: 5,
+    winner_character: ["Link"],
+    loser_id: "87654321",
+    loser_tier: 3,
+    loser_count: 2,
+    loser_character: ["Kazuya", "Cloud"],
+});
+
+describe("Set DB operations", () => {
+    beforeAll(async () => {
+        await init_tables(test_knexDb);
+    });
+
+    beforeEach(async () => {
+        await init_tables(test_knexDb);
+    });
+
+    describe("Inserting Set records", async () => {
+        test("Insert a mock Set record", async () => {
+            const set_id = await createSet(mockSetReport.guild_id, test_knexDb);
+            expect(set_id).toStrictEqual([1]);
+        });
+    });
+
+    describe("Verify the created Set record", () => {
+        test("Only one Set record is created", async () => {
+            const all_created_sets = await test_knexDb("Set").select();
+            expect(all_created_sets.length).toBe(1);
+        })
+        test("When retrieved, the Set record is an instance of SetRecord", async () => {
+            const created_set = await test_knexDb("Set").first();
+            expectTypeOf(created_set).toEqualTypeOf<SetRecord>;
+        });
+        test("When retrieved, the Set record has the same data as is provided", async () => {
+            const created_set = await test_knexDb("Set").first();
+            expect(created_set.set_id).toBe(1);
+            expect(created_set.guild_id).toBe(mockSetReport.guild_id);
+        });
+    });
+
+    describe.todo("Inserting SetReport records");
+    describe.todo("Verify the created SetReport records");
+
+    describe.todo("Cannot insert SetResult where [set_id, user_id] is not unique");
+    describe.todo("Cannot insert SetResult where there is no Set record with matching set_id");
+
+    describe.todo("Inserting SetCharacter records");
+    describe.todo("Verify the created SetCharacter records");
+
+    describe.todo(
+        "Cannot insert SetCharacter where [set_id, user_id, fighter_number] is not unique",
+    );
+    describe.todo("Cannot insert SetCharacter where a fighter_number is not in the SSBUCharTable");
+});
diff --git a/backend/src/v1/set/types.ts b/backend/src/v1/set/types.ts
diff --git a/backend/src/v1/user/router.ts b/backend/src/v1/user/router.ts
@@ -0,0 +1,31 @@
+import { getUserPoints } from "@v1/user/service";
+import { Hono } from "hono";
+import { describeRoute, resolver, validator } from "hono-openapi";
+import { z } from "zod";
+
+const app = new Hono();
+
+app.get(
+    "/:user_id",
+    describeRoute({
+        description: "Get a user's points in a guild",
+        responses: {
+            200: {
+                description: "Successful response",
+                content: {
+                    "application/json": {
+                        schema: { points: z.number() },
+                    },
+                },
+            },
+        },
+    }),
+    (c) => {
+        const user_id = c.req.param("user_id");
+        return getUserPoints(user_id);
+    },
+);
+// Get a guild's leaderboard
+// app.get("/:guild_id", c);
+
+export default app;
diff --git a/backend/src/v1/user/schema.ts b/backend/src/v1/user/schema.ts
@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+export const guildMemberQuery = z.object({
+    user_id: z.string(),
+    guild_id: z.string(),
+});
+export type guildMemberQuery = z.infer<typeof guildMemberQueryBase>;
diff --git a/backend/src/v1/user/service.ts b/backend/src/v1/user/service.ts
@@ -1,2 +1,4 @@
-export async function getPoints(user_id: string): Promise<number> {};
-export async function getLeaderboard(tier: number): Promise<Array<string>> {}
+export async function getUserPoints(guild_id: string, user_id: string): Promise<number> {
+    return 69;
+};
+export async function getLeaderboard(guild_id: string, tier: number): Promise<Array<string>> {}
diff --git a/backend/tsconfig.json b/backend/tsconfig.json
@@ -16,6 +16,7 @@
 
         "baseUrl": "src",
         "paths": {
+            "@tests/*":["tests/*"],
             "@db/*": ["db/*"],
             "@v1/*": ["v1/*"]
         }
