Merge pull request #9 from numericgraphics/feature/02_use-typescript-2

improve schema

Author: numericgraphics

package-lock.json

@@ -2,9 +2,9 @@ import MongoDB from "../services/MongoDB";
 import Users, { User } from "../services/Users";
 import Scores from "../services/Scores";
 import EVENTS from "../constants/events";
-import type { Db } from "mongodb";
+import type { Db, ObjectId } from "mongodb";
 
-// Narrow message types to exactly the events this method can return
+// Results using literal event types
 type AddUserResult =
   | { message: typeof EVENTS.USER_ALREADY_EXIST }
   | { message: typeof EVENTS.USER_CREATED; list: User[] };
@@ -38,28 +38,47 @@ export default class Global {
     }
   }
 
-  async addUser(user: Omit<User, "_id">): Promise<AddUserResult> {
-    const { email, score } = user;
+  /**
+   * Create a user aligned with the mobile schema: { userName, password }
+   * Optionally seed an initial score in the scores collection.
+   */
+  async addUser(payload: {
+    userName: string;
+    password: string;
+    score?: number;
+  }): Promise<AddUserResult> {
+    const { userName, password, score } = payload;
 
-    if (typeof score !== "number") {
-      throw new Error("Invalid score");
+    if (!userName || !password) {
+      throw new Error("Invalid payload: userName and password are required");
     }
 
-    const oldUser = await this.users.isUserAlreadyExist(email);
-    if (oldUser) {
+    const exists = await this.users.findByUserName(userName);
+    if (exists) {
       return { message: EVENTS.USER_ALREADY_EXIST };
     }
 
     try {
-      const list = await this.users.addUser(user);
+      const created = await this.users.addUser({ userName, password });
+
+      // create an initial score if provided
+      if (typeof score === "number" && !Number.isNaN(score)) {
+        await this.scores.addScore(created._id as ObjectId, score);
+      }
+
+      const list = await this.users.list();
       return { message: EVENTS.USER_CREATED, list };
-    } catch {
+    } catch (e) {
       // eslint-disable-next-line no-console
       console.log("Global Controller - addUser failed !!!");
       throw new Error("Add user failed");
     }
   }
 
+  /**
+   * Check a raw score against the global minimum across the scores collection.
+   * Does not store the score.
+   */
   async checkScore(score: number): Promise<CheckScoreResult> {
     try {
       const ok = await this.scores.checkScores(score);
@@ -70,4 +89,30 @@ export default class Global {
       throw e;
     }
   }
+
+  /**
+   * Add a score to a given user by userName.
+   */
+  async addScoreForUser(
+    userName: string,
+    value: number
+  ): Promise<{ userId?: ObjectId; created?: boolean } & CheckScoreResult> {
+    const user = await this.users.findByUserName(userName);
+    if (!user || !user._id) {
+      return { message: EVENTS.SCORE_REJECTED };
+    }
+
+    // optional: enforce same acceptance rule as checkScore
+    const acceptable = await this.scores.checkScores(value);
+    if (!acceptable) {
+      return {
+        userId: user._id,
+        created: false,
+        message: EVENTS.SCORE_REJECTED,
+      };
+    }
+
+    await this.scores.addScore(user._id, value);
+    return { userId: user._id, created: true, message: EVENTS.SCORED };
+  }
 }

src/controllers/Global.ts

@@ -6,6 +6,7 @@ import EVENTS from "./constants/events";
 
 const app = express();
 const server = http.createServer(app);
+
 const PORT = Number(process.env.API_PORT) || 3000;
 
 const globalController = new Global();
@@ -20,10 +21,10 @@ app.get("/", (_req, res) => {
   res.send("<h1>Hello world</h1>");
 });
 
-type ScoreRequestBody = { score: number };
+// --- Score check endpoint (schema-agnostic): checks against global min, does not persist ---
 app.post(
   "/score",
-  async (req: Request<{}, {}, ScoreRequestBody>, res: Response) => {
+  async (req: Request<{}, {}, { score: number }>, res: Response) => {
     try {
       const { score } = req.body;
       const result = await globalController.checkScore(score);
@@ -37,22 +38,23 @@ app.post(
   }
 );
 
-type AddUserRequestBody = {
-  username: string;
-  score: number;
-  email: string;
-  password: string;
-};
+// --- Create user aligned with mobile schema: { userName, password, score? } ---
 app.post(
   "/adduser",
-  async (req: Request<{}, {}, AddUserRequestBody>, res: Response) => {
+  async (
+    req: Request<
+      {},
+      {},
+      { userName: string; password: string; score?: number }
+    >,
+    res: Response
+  ) => {
     try {
-      const { username, score, email, password } = req.body;
+      const { userName, password, score } = req.body;
       const result = await globalController.addUser({
-        username,
-        score,
-        email,
+        userName,
         password,
+        score,
       });
 
       if (result.message === EVENTS.USER_ALREADY_EXIST) {
@@ -69,6 +71,32 @@ app.post(
   }
 );
 
+// --- Add a score for a specific user ---
+app.post(
+  "/users/:userName/scores",
+  async (
+    req: Request<{ userName: string }, {}, { value: number }>,
+    res: Response
+  ) => {
+    try {
+      const { userName } = req.params;
+      const { value } = req.body;
+
+      if (typeof value !== "number") {
+        return res.status(400).send("value must be a number");
+      }
+
+      const result = await globalController.addScoreForUser(userName, value);
+      if (result.message === EVENTS.SCORED && result.created) {
+        return res.status(201).json({ userId: result.userId, value });
+      }
+      return res.status(409).send();
+    } catch (e) {
+      return res.status(406).send(e);
+    }
+  }
+);
+
 server.listen(PORT, () => {
   console.log(`Listening on ${PORT}`);
 });

src/index.ts

@@ -1,9 +1,14 @@
-import { Collection, Db } from "mongodb";
-import { getCollectionPropertyValue } from "../utils/array";
-import type { User } from "./Users";
+import { Collection, Db, ObjectId } from "mongodb";
+
+export interface Score {
+  _id?: ObjectId;
+  userId: ObjectId;
+  value: number;
+  createdAt?: number;
+}
 
 export default class Scores {
-  private collection!: Collection<User>;
+  private collection!: Collection<Score>;
 
   constructor() {
     // eslint-disable-next-line no-console
@@ -13,47 +18,41 @@ export default class Scores {
   init(db: Db): void {
     // eslint-disable-next-line no-console
     console.log("Scores Class - init");
-    this.collection = db.collection<User>("users");
+    this.collection = db.collection<Score>("scores");
+  }
+
+  async addScore(userId: ObjectId, value: number): Promise<Score> {
+    const doc: Omit<Score, "_id"> = { userId, value, createdAt: Date.now() };
+    const res = await this.collection.insertOne(doc);
+    return { ...doc, _id: res.insertedId };
+  }
+
+  async getMinScore(): Promise<number | null> {
+    const doc = await this.collection.find().sort({ value: 1 }).limit(1).next();
+    return doc ? doc.value : null;
   }
 
-  async getSmallerScores(): Promise<number> {
-    const collection = await this.collection.find().toArray();
-    const scores = getCollectionPropertyValue(collection, "score") as number[];
-    return Math.min(...scores);
+  async getMaxScore(): Promise<number | null> {
+    const doc = await this.collection
+      .find()
+      .sort({ value: -1 })
+      .limit(1)
+      .next();
+    return doc ? doc.value : null;
   }
 
-  async getHigherScores(): Promise<number> {
-    const collection = await this.collection.find().toArray();
-    const scores = getCollectionPropertyValue(collection, "score") as number[];
-    return Math.max(...scores);
+  async topScoreForUser(userId: ObjectId): Promise<number | null> {
+    const doc = await this.collection
+      .find({ userId })
+      .sort({ value: -1 })
+      .limit(1)
+      .next();
+    return doc ? doc.value : null;
   }
 
   async checkScores(score: number): Promise<boolean> {
-    try {
-      const collection = await this.collection.find().toArray();
-      const scores = getCollectionPropertyValue(
-        collection,
-        "score"
-      ) as number[];
-
-      // eslint-disable-next-line no-console
-      console.log("User score --> ", score);
-      // eslint-disable-next-line no-console
-      console.log("-- checkScores - collection User --------------");
-      // eslint-disable-next-line no-console
-      console.log("length", collection.length);
-      // eslint-disable-next-line no-console
-      console.log("min", Math.min(...scores));
-      // eslint-disable-next-line no-console
-      console.log("max", Math.max(...scores));
-      // eslint-disable-next-line no-console
-      console.log("---------------------------");
-
-      return score > Math.min(...scores);
-    } catch (error) {
-      // eslint-disable-next-line no-console
-      console.log("checkScores - ERROR", error);
-      throw error;
-    }
+    const min = await this.getMinScore();
+    if (min === null) return true; // no scores yet -> accept
+    return score > min;
   }
 }