insuranceCred half

apps/Backend/src/routes/index.ts

@@ -5,7 +5,7 @@ import userRoutes from './users'
 import staffRoutes from './staffs'
 import pdfExtractionRoutes from './pdfExtraction';
 import claimsRoutes from './claims';
-
+import insuranceCredsRoutes from './insuranceCreds';
 const router = Router();
 
 router.use('/patients', patientRoutes);
@@ -14,5 +14,6 @@ router.use('/users', userRoutes);
 router.use('/staffs', staffRoutes);
 router.use('/pdfExtraction', pdfExtractionRoutes);
 router.use('/claims', claimsRoutes);
+router.use('/insuranceCreds', insuranceCredsRoutes);
 
 export default router;

apps/Backend/src/routes/insuranceCreds.ts

@@ -0,0 +1,79 @@
+import express, { Request, Response, NextFunction } from "express";
+import { storage } from "../storage";
+import { InsuranceCredentialUncheckedCreateInputObjectSchema } from "@repo/db/usedSchemas";
+import { z } from "zod";
+
+const router = express.Router();
+
+// ✅ Types
+type InsuranceCredential = z.infer<typeof InsuranceCredentialUncheckedCreateInputObjectSchema>;
+
+const insertInsuranceCredentialSchema = (
+  InsuranceCredentialUncheckedCreateInputObjectSchema as unknown as z.ZodObject<any>
+).omit({ id: true });
+
+type InsertInsuranceCredential = z.infer<typeof insertInsuranceCredentialSchema>;
+
+// ✅ Get all credentials for a user
+router.get("/", async (req: Request, res: Response):Promise<any> => {
+  try {
+    if (!req.user || !req.user.id) {
+      return res.status(401).json({ message: "Unauthorized: user info missing" });
+    }
+    const userId = req.user.id;
+
+    const credentials = await storage.getInsuranceCredentialsByUser(userId);
+    return res.status(200).json(credentials);
+  } catch (err) {
+    return res.status(500).json({ error: "Failed to fetch credentials", details: String(err) });
+  }
+});
+
+// ✅ Create credential for a user
+router.post("/", async (req: Request, res: Response):Promise<any> => {
+  try {
+    if (!req.user || !req.user.id) {
+      return res.status(401).json({ message: "Unauthorized: user info missing" });
+    }
+    const userId = req.user.id;
+
+    const parseResult = insertInsuranceCredentialSchema.safeParse({ ...req.body, userId });
+    if (!parseResult.success) {
+      return res.status(400).json({ error: parseResult.error.flatten() });
+    }
+
+    const credential = await storage.createInsuranceCredential(parseResult.data);
+    return res.status(201).json(credential);
+  } catch (err) {
+    return res.status(500).json({ error: "Failed to create credential", details: String(err) });
+  }
+});
+
+// ✅ Update credential
+router.put("/:id", async (req: Request, res: Response):Promise<any> => {
+  try {
+    const id = Number(req.params.id);
+    if (isNaN(id)) return res.status(400).send("Invalid credential ID");
+
+    const updates = req.body as Partial<InsuranceCredential>;
+    const credential = await storage.updateInsuranceCredential(id, updates);
+    return res.status(200).json(credential);
+  } catch (err) {
+    return res.status(500).json({ error: "Failed to update credential", details: String(err) });
+  }
+});
+
+// ✅ Delete a credential
+router.delete("/:id", async (req: Request, res: Response):Promise<any> => {
+  try {
+    const id = Number(req.params.id);
+    if (isNaN(id)) return res.status(400).send("Invalid ID");
+
+    await storage.deleteInsuranceCredential(id);
+    return res.status(204).send();
+  } catch (err) {
+    return res.status(500).json({ error: "Failed to delete credential", details: String(err) });
+  }
+});
+
+export default router;

apps/Backend/src/routes/users.ts

@@ -3,6 +3,9 @@ import type { Request, Response } from "express";
 import { storage } from "../storage";
 import { z } from "zod";
 import { UserUncheckedCreateInputObjectSchema } from "@repo/db/usedSchemas";
+import jwt from 'jsonwebtoken';
+import bcrypt from 'bcrypt';  
+
 
 const router = Router();
 
@@ -64,6 +67,13 @@ router.post("/", async (req: Request, res: Response) => {
   }
 });
 
+// Function to hash password using bcrypt
+async function hashPassword(password: string) {
+  const saltRounds = 10;  // Salt rounds for bcrypt
+  const hashedPassword = await bcrypt.hash(password, saltRounds);
+  return hashedPassword;
+}
+
 // PUT: Update user
 router.put("/:id", async (req: Request, res: Response):Promise<any> => {
   try {
@@ -75,6 +85,15 @@ router.put("/:id", async (req: Request, res: Response):Promise<any> => {
 
 
     const updates = userUpdateSchema.parse(req.body);
+
+    // If password is provided and non-empty, hash it
+    if (updates.password && updates.password.trim() !== "") {
+      updates.password = await hashPassword(updates.password);
+    } else {
+      // Remove password field if empty, so it won't overwrite existing password with blank
+      delete updates.password;
+    }
+
     const updatedUser = await storage.updateUser(id, updates);
     if (!updatedUser) return res.status(404).send("User not found");