refactor(biome): more format changes

app/src/ws/channels/logs.ts

@@ -0,0 +1,43 @@
+import { Namespace, Socket } from "socket.io";
+import { requireAuth } from "../../pkg/middleware/authMiddleware.js";
+
+export const setupAllLogs = (io: Namespace) => {
+    // Wrap middleware for Socket.IO
+    io.use(async (socket: Socket, next) => {
+        try {
+            // Mock Express req/res object
+            const req = socket.request as any;
+
+            // Create a mini next function that throws an error if unauthorized
+            await new Promise<void>((resolve, reject) => {
+                const fakeRes: any = {
+                    status: () => ({
+                        json: (obj: any) => reject(new Error(obj.error)),
+                    }),
+                };
+                const nextFn = (err?: any) => (err ? reject(err) : resolve());
+
+                // Call your middleware
+                requireAuth("", ["systemAdmin", "admin"])(req, fakeRes, nextFn);
+            });
+
+            // Auth passed
+            next();
+        } catch (err: any) {
+            next(new Error(err.message || "Unauthorized"));
+        }
+    });
+
+    io.on("connection", (socket: Socket) => {
+        console.log(
+            "✅ Authenticated client connected to channel2:",
+            socket.id
+        );
+
+        socket.on("ping", () => socket.emit("pong"));
+
+        socket.on("disconnect", () => {
+            console.log("🔴 Client disconnected from channel2:", socket.id);
+        });
+    });
+};

app/src/ws/channels/scheduler.ts

@@ -0,0 +1,59 @@
+import { formatDate } from "date-fns";
+import type { Server, Socket } from "socket.io";
+import { db } from "../../pkg/db/db.js";
+import { orderScheduler } from "../../pkg/db/schema/orderScheduler.js";
+import { tryCatch } from "../../pkg/utils/tryCatch.js";
+
+let ioInstance: Server | null = null;
+
+export const setupScheduler = (io: Server, socket: Socket) => {
+	ioInstance = io;
+
+	socket.on("joinScheduler", async () => {
+		socket.join("scheduler");
+		//console.log(`Socket ${socket.id} joined room "scheduler"`);
+
+		const { data, error } = await tryCatch(db.select().from(orderScheduler));
+
+		if (error) {
+			setTimeout(() => {
+				io.to("scheduler").emit("scheduler:update", {
+					type: "init",
+					error: error,
+				});
+			}, 1000);
+			return;
+		}
+
+		// initial push
+		setTimeout(() => {
+			io.to("scheduler").emit("scheduler:update", { type: "init", data: data });
+		}, 1000);
+	});
+
+	// socket.on("ping", () => {
+	// 	io.to("scheduler").emit("pong", { from: socket.id });
+	// });
+
+	// setInterval(() => {
+	// 	io.to("scheduler").emit("heartbeat", {
+	// 		ts: formatDate(Date.now(), "M/d/yyyy HH:mm"),
+	// 	});
+	// }, 60_000);
+
+	// add in listen for changes to the db with pg listen?
+};
+
+// --- Change Broadcast Function ---
+export const schedulerChange = async (data: any) => {
+	if (!ioInstance) {
+		console.error("⚠️ schedulerChange called before setupScheduler initialized");
+		return;
+	}
+
+	ioInstance.to("scheduler").emit("scheduler:update", {
+		ts: formatDate(Date.now(), "M/d/yyyy HH:mm"),
+		data,
+	});
+	console.log("📢 Scheduler update broadcasted:", data);
+};

app/src/ws/server.ts

@@ -0,0 +1,66 @@
+import { Server } from "socket.io";
+import type { Server as HttpServer } from "http";
+import { allowedOrigins } from "../pkg/utils/corsController.js";
+import { setupScheduler } from "./channels/scheduler.js";
+
+export const setupIoServer = async (server: HttpServer, basePath: string) => {
+    const io = new Server(server, {
+        path: `${basePath}/api/ws`,
+        cors: {
+            // origin: ["http://localhost:5500"],
+            origin: (origin, callback) => {
+                // Allow non-browser clients (Postman, direct websocket, etc.)
+                if (!origin) return callback(null, true);
+
+                try {
+                    // Check if origin matches any allowed string or regex
+                    const allowed = allowedOrigins.some((o) => {
+                        if (typeof o === "string") return o === origin;
+                        if (o instanceof RegExp) return o.test(origin);
+                        return false;
+                    });
+
+                    if (allowed) {
+                        return callback(null, true);
+                    }
+                } catch (err) {
+                    console.error("Invalid Origin header:", origin);
+                }
+
+                // Deny all others
+                return callback(new Error("Not allowed by CORS: " + origin));
+            },
+            // methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+            credentials: true,
+        },
+        pingInterval: 25_000, // send ping every 25s (default 25s)
+        pingTimeout: 60_000, // wait 60s before disconnecting (default 60s)
+    });
+
+    io.on("connection", (socket) => {
+        console.log("🟢 User connected:", socket.id);
+
+        // Join a room
+        socket.on("joinRoom", (room: string) => {
+            socket.join(room);
+            console.log(`Socket ${socket.id} joined room ${room}`);
+        });
+
+        // Leave a room
+        socket.on("leaveRoom", (room: string) => {
+            socket.leave(room);
+            console.log(`Socket ${socket.id} left room ${room}`);
+        });
+
+        // Example: broadcast a message to a room
+        socket.on("message", ({ room, payload }) => {
+            io.to(room).emit("message", payload);
+        });
+
+        socket.on("disconnect", (reason) => {
+            console.log("🔴 User disconnected:", socket.id, reason);
+        });
+
+        setupScheduler(io, socket);
+    });
+};