feat: new user resource integrating postgresql

server/resources/ingredient/IngredientCollection.ts

@@ -1,31 +1,42 @@
-import {StoccaTreDbConn, WithoutId} from "../../database.ts";
-import {IngredientModel} from "./IngredientModel.ts";
-import {Maybe} from "../../Maybe.ts";
+import { StoccaTreDbConn, WithoutId } from "../../database.ts";
+import { IngredientModel } from "./IngredientModel.ts";
+import { Maybe } from "../../Maybe.ts";
 
 export default class IngredientCollection {
-    private dbConnection: StoccaTreDbConn;
+    private db: StoccaTreDbConn;
     private mapById: Map<number, IngredientModel> = new Map<number, IngredientModel>();
-    private allGotten = false;
 
     constructor(database: StoccaTreDbConn) {
-        this.dbConnection = database;
+        this.db = database;
     }
 
-    async addIngredient(ingredient: WithoutId<IngredientModel>): Promise<any> {
-        return await this.dbConnection.query<any>(
-            `INSERT INTO ingredients (id, name, displayName, displayNameDE) VALUES (NULL, '${ingredient.name}', '${ingredient.displayName}', '${ingredient.displayNameDE}');`
+    async addIngredient(ingredient: WithoutId<IngredientModel>): Promise<Maybe<IngredientModel[]>> {
+        return await this.db.query(sql =>
+            sql<IngredientModel[]>`INSERT INTO ingredients ${ sql(ingredient) }`
         );
     }
 
+    async getById(id: number): Promise<Maybe<IngredientModel>> {
+        const found = this.mapById.get(id);
+        if (found) {
+            return { just: found };
+        }
+        const result = await this.db.query(sql => sql<IngredientModel[]>`SELECT * FROM ingredients WHERE id is ${ id }`);
+        if (result.error) {
+            return result;
+        }
+        const ingredient = result.just[0];
+        this.mapById.set(ingredient.id, ingredient);
+        return { just: ingredient };
+    }
     async getAllIngredients(): Promise<Maybe<IterableIterator<IngredientModel>>> {
-        if (!this.allGotten) {
-            const result = await this.dbConnection.query<IngredientModel[]>("SELECT * FROM ingredients");
-            if (!result.error) {
-                result.just.forEach((ingredient: IngredientModel) => this.mapById.set(ingredient.id, ingredient));
-            } else {
-                return result;
-            }
-            this.allGotten = true;
+        const result: Maybe<IngredientModel[]> = await this.db.query(sql =>
+            sql<IngredientModel[]>`SELECT * FROM ingredients`
+        );
+        if (!result.error) {
+            result.just.forEach(ingredient => this.mapById.set(ingredient.id, ingredient));
+        } else {
+            return result;
         }
         return {
             just: this.mapById.values(),

server/resources/ingredient/IngredientModel.ts

@@ -1,6 +1,12 @@
-export type IngredientModel = {
-    id: number,
-    name: string,
-    displayName: string,
-    displayNameDE: string,
-};
+import { z } from "zod";
+
+export const IngredientSchema = z.object({
+    id: z.number(),
+    name: z.string().nonempty(),
+    displayName: z.string().nonempty(),
+    displayNameDE: z.string().nonempty(),
+});
+
+export const IngredientSchemaWithoutId = IngredientSchema.omit({ id: true });
+
+export type IngredientModel = z.infer<typeof IngredientSchema>;

server/resources/ingredient/IngredientResource.ts

@@ -1,45 +1,48 @@
 import {StoccaTreDbConn} from "../../database.ts";
 import IngredientCollection from "./IngredientCollection.ts";
-import StoccaTreRequest from "../../StoccaTreRequest.ts";
+import StoccaTreRequest, {RouteDefinition} from "../../StoccaTreRequest.ts";
 import {Maybe} from "../../Maybe.ts";
 import {JSONObject} from "../../JSON.ts";
-import {IngredientModel} from "./IngredientModel.ts";
+import {IngredientSchemaWithoutId} from "./IngredientModel.ts";
 
 export default class IngredientResource {
     private dbConnection: StoccaTreDbConn;
     private collection: IngredientCollection;
+    private routes: Readonly<Record<string, RouteDefinition>> = {
+        Add: {
+            pattern: /\/add/,
+            method: "POST"
+        },
+        GetAll: {
+            pattern: /\/all/,
+            method: "GET"
+        },
+    } as const;
 
     constructor(dbConnection: StoccaTreDbConn) {
         this.dbConnection = dbConnection;
         this.collection = new IngredientCollection(dbConnection);
     }
 
-    static isIngredient(json: JSONObject): json is IngredientModel {
-        if (json) {
-            return true;
-        }
-        return false;
-    }
-
     async handleRequest(request: StoccaTreRequest): Promise<Maybe<JSONObject>> {
-        switch (request.route) {
-            case "/add":
-                if (request.method === "POST") {
-                    const ingredient = JSON.parse(request.body ?? "");
-                    return await this.collection.addIngredient(JSON.parse(request.body));
-
-
-                }
-                break;
-            case "/all":
-                return await this.allIngredients(request);
-            default:
-                break;
+        if (request.match(this.routes.Add)) {
+            return await this.addIngredient(request);
         }
-        return { error: {message: "Invalid route" }};
+        if (request.match(this.routes.GetAll)) {
+            return await this.allIngredients(request);
+        }
+        return { error: { message: "Invalid route" }};
     }
 
-    async allIngredients(request: StoccaTreRequest): Promise<Maybe<JSONObject>> {
+    private async addIngredient(request: StoccaTreRequest): Promise<Maybe<{ insertedId: number }>> {
+        const ingredient = IngredientSchemaWithoutId.safeParse(JSON.parse(request.body ?? "{}"));
+        if (!ingredient.success) {
+            return { error: new Error("Ingredient was malformed.") };
+        }
+        return await this.collection.addIngredient(ingredient.data);
+    }
+
+    private async allIngredients(request: StoccaTreRequest): Promise<Maybe<JSONObject>> {
         const getAllIngredientResult = await this.collection.getAllIngredients();
         if (getAllIngredientResult.error) {
             return getAllIngredientResult;