Add name and lock client to specific olm

server/routers/olm/createOlm.ts

@@ -3,41 +3,40 @@ import { db } from "@server/db";
 import { hash } from "@node-rs/argon2";
 import HttpCode from "@server/types/HttpCode";
 import { z } from "zod";
-import { newts } from "@server/db";
+import { olms } from "@server/db";
 import createHttpError from "http-errors";
 import response from "@server/lib/response";
 import { SqliteError } from "better-sqlite3";
 import moment from "moment";
-import { generateSessionToken } from "@server/auth/sessions/app";
-import { createNewtSession } from "@server/auth/sessions/newt";
+import { generateId, generateSessionToken } from "@server/auth/sessions/app";
+import { createOlmSession } from "@server/auth/sessions/olm";
 import { fromError } from "zod-validation-error";
 import { hashPassword } from "@server/auth/password";
 
-export const createNewtBodySchema = z.object({});
+export const createOlmBodySchema = z.object({});
 
-export type CreateNewtBody = z.infer<typeof createNewtBodySchema>;
+export type CreateOlmBody = z.infer<typeof createOlmBodySchema>;
 
-export type CreateNewtResponse = {
-    token: string;
-    newtId: string;
+export type CreateOlmResponse = {
+    // token: string;
+    olmId: string;
     secret: string;
 };
 
-const createNewtSchema = z
+const createOlmSchema = z
     .object({
-        newtId: z.string(),
-        secret: z.string()
+        userId: z.string().optional(),
+        name: z.string().min(1).max(255)
     })
     .strict();
 
-export async function createNewt(
+export async function createOlm(
     req: Request,
     res: Response,
     next: NextFunction
 ): Promise<any> {
     try {
-
-        const parsedBody = createNewtSchema.safeParse(req.body);
+        const parsedBody = createOlmSchema.safeParse(req.body);
         if (!parsedBody.success) {
             return next(
                 createHttpError(
@@ -47,60 +46,55 @@ export async function createNewt(
             );
         }
 
-        const { newtId, secret } = parsedBody.data;
+        const { userId, name } = parsedBody.data;
+        let userIdFinal = userId;
 
-        if (req.user && !req.userOrgRoleId) {
-            return next(
-                createHttpError(HttpCode.FORBIDDEN, "User does not have a role")
-            );
-        }
-
-        const secretHash = await hashPassword(secret);
-
-        await db.insert(newts).values({
-            newtId: newtId,
-            secretHash,
-            dateCreated: moment().toISOString(),
-        });
-
-        // give the newt their default permissions:
-        // await db.insert(newtActions).values({
-        //     newtId: newtId,
-        //     actionId: ActionsEnum.createOrg,
-        //     orgId: null,
-        // });
-
-        const token = generateSessionToken();
-        await createNewtSession(token, newtId);
-
-        return response<CreateNewtResponse>(res, {
-            data: {
-                newtId,
-                secret,
-                token,
-            },
-            success: true,
-            error: false,
-            message: "Newt created successfully",
-            status: HttpCode.OK,
-        });
-    } catch (e) {
-        if (e instanceof SqliteError && e.code === "SQLITE_CONSTRAINT_UNIQUE") {
+        if (req.user) { // overwrite the user with the one calling because we want to assign the olm to the user creating it
+            userIdFinal = req.user.userId;
+        } else if (!userIdFinal) {
             return next(
                 createHttpError(
                     HttpCode.BAD_REQUEST,
-                    "A newt with that email address already exists"
-                )
-            );
-        } else {
-            console.error(e);
-
-            return next(
-                createHttpError(
-                    HttpCode.INTERNAL_SERVER_ERROR,
-                    "Failed to create newt"
+                    "Either userId must be provided or request must be authenticated"
                 )
             );
         }
+
+        const olmId = generateId(15);
+        const secret = generateId(48);
+
+        const secretHash = await hashPassword(secret);
+
+        await db.insert(olms).values({
+            olmId: olmId,
+            userId: userId,
+            name,
+            secretHash,
+            dateCreated: moment().toISOString()
+        });
+
+        // const token = generateSessionToken();
+        // await createOlmSession(token, olmId);
+
+        return response<CreateOlmResponse>(res, {
+            data: {
+                olmId,
+                secret
+                // token,
+            },
+            success: true,
+            error: false,
+            message: "Olm created successfully",
+            status: HttpCode.OK
+        });
+    } catch (e) {
+        console.error(e);
+
+        return next(
+            createHttpError(
+                HttpCode.INTERNAL_SERVER_ERROR,
+                "Failed to create olm"
+            )
+        );
     }
 }