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"
+            )
+        );
     }
 }

server/routers/olm/handleOlmRegisterMessage.ts

@@ -30,7 +30,7 @@ export const handleOlmRegisterMessage: MessageHandler = async (context) => {
         return;
     }
 
-    const { publicKey, relay, olmVersion, orgId, deviceName } = message.data;
+    const { publicKey, relay, olmVersion, orgId } = message.data;
     let client: Client;
 
     if (orgId) {
@@ -40,7 +40,7 @@ export const handleOlmRegisterMessage: MessageHandler = async (context) => {
         }
 
         try {
-            client = await getOrCreateOrgClient(orgId, olm.userId, deviceName);
+            client = await getOrCreateOrgClient(orgId, olm.userId, olm.olmId, olm.name || "User Device");
         } catch (err) {
             logger.error(
                 `Error switching olm client ${olm.olmId} to org ${orgId}: ${err}`
@@ -293,7 +293,8 @@ export const handleOlmRegisterMessage: MessageHandler = async (context) => {
 async function getOrCreateOrgClient(
     orgId: string,
     userId: string,
-    deviceName?: string,
+    olmId: string,
+    name: string,
     trx: Transaction | typeof db = db
 ): Promise<Client> {
     let client: Client;
@@ -328,7 +329,13 @@ async function getOrCreateOrgClient(
     const [existingClient] = await trx
         .select()
         .from(clients)
-        .where(and(eq(clients.orgId, orgId), eq(clients.userId, userId)))
+        .where(
+            and(
+                eq(clients.orgId, orgId),
+                eq(clients.userId, userId),
+                eq(clients.olmId, olmId)
+            )
+        ) // checking the olmid here because we want to create a new client PER OLM PER ORG
         .limit(1);
 
     if (!existingClient) {
@@ -364,10 +371,11 @@ async function getOrCreateOrgClient(
             .values({
                 exitNodeId: randomExitNode.exitNodeId,
                 orgId,
-                name: deviceName || "User Device",
+                name,
                 subnet: updatedSubnet,
                 type: "olm",
-                userId: userId
+                userId: userId,
+                olmId: olmId // to lock this client to the olm even as the olm moves between clients in different orgs
             })
             .returning();