Format code with bun format

Author: aahnik

jest.config.ts

@@ -1,20 +1,20 @@
-import type { Config } from 'jest';
+import type { Config } from "jest";
 
 const config: Config = {
-  preset: 'ts-jest',
-  testEnvironment: 'jsdom',
+  preset: "ts-jest",
+  testEnvironment: "jsdom",
   transform: {
-    '^.+\\.(ts|tsx)$': 'ts-jest',
+    "^.+\\.(ts|tsx)$": "ts-jest",
   },
-  setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
+  setupFilesAfterEnv: ["<rootDir>/jest.setup.ts"],
   moduleNameMapper: {
-    '^@/(.*)$': '<rootDir>/$1',  // Changed from src/$1 to match tsconfig
-    '^.+\\.module\\.(css|sass|scss)$': 'identity-obj-proxy',
-    '^.+\\.(jpg|jpeg|png|gif|webp|svg)$': '<rootDir>/__mocks__/fileMock.js',
+    "^@/(.*)$": "<rootDir>/$1", // Changed from src/$1 to match tsconfig
+    "^.+\\.module\\.(css|sass|scss)$": "identity-obj-proxy",
+    "^.+\\.(jpg|jpeg|png|gif|webp|svg)$": "<rootDir>/__mocks__/fileMock.js",
   },
-  transformIgnorePatterns: ['<rootDir>/node_modules/'],
-  modulePaths: ['<rootDir>'],
-  roots: ['<rootDir>'],
+  transformIgnorePatterns: ["<rootDir>/node_modules/"],
+  modulePaths: ["<rootDir>"],
+  roots: ["<rootDir>"],
 };
 
-export default config;
+export default config;

jest.setup.ts

@@ -1,12 +1,12 @@
 // jest.setup.js
-import '@testing-library/jest-dom';
-import { TextEncoder, TextDecoder } from 'util';
-import { fetch, Headers, Request, Response } from 'cross-fetch';
+import "@testing-library/jest-dom";
+import { TextEncoder, TextDecoder } from "util";
+import { fetch, Headers, Request, Response } from "cross-fetch";
 
 // Define the global objects needed for Next.js
 global.TextEncoder = TextEncoder;
 global.TextDecoder = TextDecoder as any;
 global.fetch = fetch;
 global.Headers = Headers;
 global.Request = Request;
-global.Response = Response;
+global.Response = Response;

tests/code.test.ts

@@ -1,33 +1,33 @@
-import { POST } from '@/app/api/code/route'; // adjust the path if needed
-import { NextResponse } from 'next/server';
+import { POST } from "@/app/api/code/route"; // adjust the path if needed
+import { NextResponse } from "next/server";
 
 // Mock global fetch
 global.fetch = jest.fn();
 
-jest.mock('next/server', () => ({
+jest.mock("next/server", () => ({
   NextResponse: {
     json: jest.fn((data, init) => ({ data, status: init?.status || 200 })),
   },
 }));
 
-describe('POST /api/execute', () => {
+describe("POST /api/execute", () => {
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
-  it('should forward the request to Piston API and return the result', async () => {
+  it("should forward the request to Piston API and return the result", async () => {
     const mockBody = {
-      language: 'python',
-      version: '3.10.0',
-      files: [{ name: 'main.py', content: 'print("Hello")' }],
-      stdin: '',
+      language: "python",
+      version: "3.10.0",
+      files: [{ name: "main.py", content: 'print("Hello")' }],
+      stdin: "",
       args: [],
       compile_timeout: 10000,
       run_timeout: 3000,
     };
 
     const mockPistonResponse = {
-      run: { stdout: 'Hello\n', stderr: '', code: 0 },
+      run: { stdout: "Hello\n", stderr: "", code: 0 },
     };
 
     (fetch as jest.Mock).mockResolvedValueOnce({
@@ -42,25 +42,25 @@ describe('POST /api/execute', () => {
 
     expect(mockRequest.json).toHaveBeenCalled();
     expect(fetch).toHaveBeenCalledWith(
-      'https://emkc.org/api/v2/piston/execute',
+      "https://emkc.org/api/v2/piston/execute",
       expect.objectContaining({
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
         body: JSON.stringify(mockBody),
       }),
     );
     expect(response.status).toBe(200);
     expect(response.data).toEqual(mockPistonResponse);
   });
 
-  it('should return 500 on unexpected error', async () => {
+  it("should return 500 on unexpected error", async () => {
     const mockRequest = {
-      json: jest.fn().mockRejectedValue(new Error('Invalid JSON')),
+      json: jest.fn().mockRejectedValue(new Error("Invalid JSON")),
     } as unknown as Request;
 
     const response = await POST(mockRequest);
 
     expect(response.status).toBe(500);
-    expect(response.data).toEqual({ error: 'Failed to execute code' });
+    expect(response.data).toEqual({ error: "Failed to execute code" });
   });
 });

tests/health.test.ts

@@ -1,48 +1,50 @@
-import { GET } from '@/app/api/health/route';
-import { sql } from 'drizzle-orm';
+import { GET } from "@/app/api/health/route";
+import { sql } from "drizzle-orm";
 
-jest.mock('@/db/drizzle', () => ({
+jest.mock("@/db/drizzle", () => ({
   db: {
     execute: jest.fn(),
   },
 }));
 
-jest.mock('next/server', () => ({
+jest.mock("next/server", () => ({
   NextResponse: {
     json: jest.fn((data, init) => ({ data, status: init?.status || 200 })),
   },
 }));
 
-import { db } from '@/db/drizzle';
-import { NextResponse } from 'next/server';
+import { db } from "@/db/drizzle";
+import { NextResponse } from "next/server";
 
-describe('GET /api/health', () => {
+describe("GET /api/health", () => {
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
-  it('should return 200 if DB connection is healthy', async () => {
+  it("should return 200 if DB connection is healthy", async () => {
     (db.execute as jest.Mock).mockResolvedValueOnce(undefined);
 
     const res = await GET();
 
     expect(db.execute).toHaveBeenCalledWith(sql`SELECT 1`);
     expect(res.status).toBe(200);
-    expect(res.data).toHaveProperty('status', 'healthy');
-    expect(res.data).toHaveProperty('timestamp');
+    expect(res.data).toHaveProperty("status", "healthy");
+    expect(res.data).toHaveProperty("timestamp");
   });
 
-  it('should return 503 if DB connection fails', async () => {
-    (db.execute as jest.Mock).mockRejectedValueOnce(new Error('Connection error'));
+  it("should return 503 if DB connection fails", async () => {
+    (db.execute as jest.Mock).mockRejectedValueOnce(
+      new Error("Connection error"),
+    );
 
     const res = await GET();
 
     expect(db.execute).toHaveBeenCalled();
     expect(res.status).toBe(503);
     expect(res.data).toMatchObject({
-      status: 'unhealthy',
-      error: 'Connection error',
+      status: "unhealthy",
+      error: "Connection error",
     });
-    expect(res.data).toHaveProperty('timestamp');
+    expect(res.data).toHaveProperty("timestamp");
   });
 });

tests/login.test.ts

@@ -1,7 +1,7 @@
-import { jest } from '@jest/globals';
+import { jest } from "@jest/globals";
 
 // Mock Next.js modules
-jest.mock('next/server', () => ({
+jest.mock("next/server", () => ({
   NextResponse: {
     json: jest.fn((data, options) => {
       return {
@@ -15,7 +15,7 @@ jest.mock('next/server', () => ({
   },
 }));
 
-jest.mock('@/db/drizzle', () => ({
+jest.mock("@/db/drizzle", () => ({
   db: {
     query: {
       users: {
@@ -25,41 +25,41 @@ jest.mock('@/db/drizzle', () => ({
   },
 }));
 
-jest.mock('@/lib/password', () => ({
+jest.mock("@/lib/password", () => ({
   verifyPassword: jest.fn(),
 }));
 
-jest.mock('@/lib/server/session', () => ({
-  generateSessionToken: jest.fn().mockReturnValue('mock-session-token'),
-  createSession: jest.fn().mockResolvedValue({ 
-    token: 'mock-session-token', 
-    expiresAt: new Date(Date.now() + 86400000) 
+jest.mock("@/lib/server/session", () => ({
+  generateSessionToken: jest.fn().mockReturnValue("mock-session-token"),
+  createSession: jest.fn().mockResolvedValue({
+    token: "mock-session-token",
+    expiresAt: new Date(Date.now() + 86400000),
   }),
 }));
 
-jest.mock('@/lib/server/cookies', () => ({
+jest.mock("@/lib/server/cookies", () => ({
   setSessionTokenCookie: jest.fn(),
 }));
 
-import { NextResponse } from 'next/server';
-import { db } from '@/db/drizzle';
-import { verifyPassword } from '@/lib/password';
-import { generateSessionToken, createSession } from '@/lib/server/session';
-import { setSessionTokenCookie } from '@/lib/server/cookies';
-import { POST } from '@/app/api/auth/login/route';
+import { NextResponse } from "next/server";
+import { db } from "@/db/drizzle";
+import { verifyPassword } from "@/lib/password";
+import { generateSessionToken, createSession } from "@/lib/server/session";
+import { setSessionTokenCookie } from "@/lib/server/cookies";
+import { POST } from "@/app/api/auth/login/route";
 
-describe('POST /api/login', () => {
+describe("POST /api/login", () => {
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
-  it('should return user data on valid credentials', async () => {
+  it("should return user data on valid credentials", async () => {
     // Mock user data
     const mockUser = {
-      id: '1',
-      email: '[email protected]',
-      name: 'Test User',
-      hashedPassword: 'hashed_password',
+      id: "1",
+      email: "[email protected]",
+      name: "Test User",
+      hashedPassword: "hashed_password",
     };
 
     // Set up mocks
@@ -69,8 +69,8 @@ describe('POST /api/login', () => {
     // Create mock request
     const request = {
       json: jest.fn().mockResolvedValue({
-        email: '[email protected]',
-        password: 'password123',
+        email: "[email protected]",
+        password: "password123",
       }),
     } as unknown as Request;
 
@@ -79,27 +79,30 @@ describe('POST /api/login', () => {
 
     // Assertions
     expect(db.query.users.findFirst).toHaveBeenCalled();
-    expect(verifyPassword).toHaveBeenCalledWith('hashed_password', 'password123');
+    expect(verifyPassword).toHaveBeenCalledWith(
+      "hashed_password",
+      "password123",
+    );
     expect(generateSessionToken).toHaveBeenCalled();
     expect(createSession).toHaveBeenCalled();
     expect(setSessionTokenCookie).toHaveBeenCalled();
-    
+
     expect(response.data).toEqual({
-      _id: '1',
-      email: '[email protected]',
-      name: 'Test User',
+      _id: "1",
+      email: "[email protected]",
+      name: "Test User",
     });
   });
 
-  it('should return 401 if user not found', async () => {
+  it("should return 401 if user not found", async () => {
     // Set up mocks
     (db.query.users.findFirst as jest.Mock).mockResolvedValue(null);
 
     // Create mock request
     const request = {
       json: jest.fn().mockResolvedValue({
-        email: '[email protected]',
-        password: 'password123',
+        email: "[email protected]",
+        password: "password123",
       }),
     } as unknown as Request;
 
@@ -108,16 +111,16 @@ describe('POST /api/login', () => {
 
     // Assertions
     expect(response.status).toBe(401);
-    expect(response.data).toEqual({ error: 'Invalid credentials' });
+    expect(response.data).toEqual({ error: "Invalid credentials" });
   });
 
-  it('should return 401 on invalid password', async () => {
+  it("should return 401 on invalid password", async () => {
     // Mock user data
     const mockUser = {
-      id: '1',
-      email: '[email protected]',
-      name: 'Test User',
-      hashedPassword: 'hashed_password',
+      id: "1",
+      email: "[email protected]",
+      name: "Test User",
+      hashedPassword: "hashed_password",
     };
 
     // Set up mocks
@@ -127,8 +130,8 @@ describe('POST /api/login', () => {
     // Create mock request
     const request = {
       json: jest.fn().mockResolvedValue({
-        email: '[email protected]',
-        password: 'wrong_password',
+        email: "[email protected]",
+        password: "wrong_password",
       }),
     } as unknown as Request;
 
@@ -138,20 +141,20 @@ describe('POST /api/login', () => {
     // Assertions
     expect(verifyPassword).toHaveBeenCalled();
     expect(response.status).toBe(401);
-    expect(response.data).toEqual({ error: 'Invalid credentials' });
+    expect(response.data).toEqual({ error: "Invalid credentials" });
   });
 
-  it('should return 400 on invalid request', async () => {
+  it("should return 400 on invalid request", async () => {
     // Create mock request that throws an error when trying to parse JSON
     const request = {
-      json: jest.fn().mockRejectedValue(new Error('Invalid JSON')),
+      json: jest.fn().mockRejectedValue(new Error("Invalid JSON")),
     } as unknown as Request;
 
     // Call the handler
     const response = await POST(request);
 
     // Assertions
     expect(response.status).toBe(400);
-    expect(response.data).toEqual({ error: 'Invalid request' });
+    expect(response.data).toEqual({ error: "Invalid request" });
   });
-});
+});