chore: prettier the entire codebase

Author: tianzhou

.prettierrc.json

@@ -3,7 +3,7 @@
   "tabWidth": 2,
   "useTabs": false,
   "semi": true,
-  "singleQuote": true,
+  "singleQuote": false,
   "trailingComma": "es5",
   "bracketSpacing": true,
   "arrowParens": "always"

package.json

@@ -27,8 +27,8 @@
     "better-sqlite3": "^11.9.0",
     "dotenv": "^16.4.7",
     "express": "^4.18.2",
-    "mssql": "^11.0.1",
     "mariadb": "^3.4.0",
+    "mssql": "^11.0.1",
     "mysql2": "^3.13.0",
     "pg": "^8.13.3",
     "zod": "^3.24.2"
@@ -40,6 +40,7 @@
     "@types/node": "^22.13.10",
     "@types/pg": "^8.11.11",
     "cross-env": "^7.0.3",
+    "prettier": "^3.5.3",
     "ts-node": "^10.9.2",
     "tsup": "^8.4.0",
     "tsx": "^4.19.3",

pnpm-lock.yaml

@@ -1,12 +1,12 @@
 /**
  * Demo data loader for SQLite in-memory database
- * 
+ *
  * This module loads the sample employee database into the SQLite in-memory database
  * when the --demo flag is specified.
  */
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
 
 // Create __dirname equivalent for ES modules
 const __filename = fileURLToPath(import.meta.url);
@@ -15,21 +15,21 @@ const __dirname = path.dirname(__filename);
 // Path to sample data files - will be bundled with the package
 // Try different paths to find the SQL files in development or production
 let DEMO_DATA_DIR: string;
-const projectRootPath = path.join(__dirname, '..', '..', '..');
-const projectResourcesPath = path.join(projectRootPath, 'resources', 'employee-sqlite');
-const distPath = path.join(__dirname, 'resources', 'employee-sqlite');
+const projectRootPath = path.join(__dirname, "..", "..", "..");
+const projectResourcesPath = path.join(projectRootPath, "resources", "employee-sqlite");
+const distPath = path.join(__dirname, "resources", "employee-sqlite");
 
 // First try the project root resources directory (for development)
 if (fs.existsSync(projectResourcesPath)) {
   DEMO_DATA_DIR = projectResourcesPath;
-} 
+}
 // Then try dist directory (for production)
 else if (fs.existsSync(distPath)) {
   DEMO_DATA_DIR = distPath;
 }
 // Fallback to a relative path from the current directory
 else {
-  DEMO_DATA_DIR = path.join(process.cwd(), 'resources', 'employee-sqlite');
+  DEMO_DATA_DIR = path.join(process.cwd(), "resources", "employee-sqlite");
   if (!fs.existsSync(DEMO_DATA_DIR)) {
     throw new Error(`Could not find employee-sqlite resources in any of the expected locations: 
       - ${projectResourcesPath}
@@ -43,35 +43,35 @@ else {
  */
 export function loadSqlFile(fileName: string): string {
   const filePath = path.join(DEMO_DATA_DIR, fileName);
-  return fs.readFileSync(filePath, 'utf8');
+  return fs.readFileSync(filePath, "utf8");
 }
 
 /**
  * Get SQLite DSN for in-memory database
  */
 export function getInMemorySqliteDSN(): string {
-  return 'sqlite::memory:';
+  return "sqlite::memory:";
 }
 
 /**
  * Load SQL files sequentially
  */
 export function getSqliteInMemorySetupSql(): string {
   // First, load the schema
-  let sql = loadSqlFile('employee.sql');
-  
+  let sql = loadSqlFile("employee.sql");
+
   // Replace .read directives with the actual file contents
   // This is necessary because in-memory SQLite can't use .read
   const readRegex = /\.read\s+([a-zA-Z0-9_]+\.sql)/g;
   let match;
-  
+
   while ((match = readRegex.exec(sql)) !== null) {
     const includePath = match[1];
     const includeContent = loadSqlFile(includePath);
-    
+
     // Replace the .read line with the file contents
     sql = sql.replace(match[0], includeContent);
   }
-  
+
   return sql;
 }

src/config/demo-loader.ts

@@ -1,7 +1,7 @@
 import dotenv from "dotenv";
-import path from 'path';
-import fs from 'fs';
-import { fileURLToPath } from 'url';
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
 
 // Create __dirname equivalent for ES modules
 const __filename = fileURLToPath(import.meta.url);
@@ -12,25 +12,25 @@ export function parseCommandLineArgs() {
   // Check if any args start with '--' (the way tsx passes them)
   const args = process.argv.slice(2);
   const parsedManually: Record<string, string> = {};
-  
+
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg.startsWith('--')) {
-      const [key, value] = arg.substring(2).split('=');
+    if (arg.startsWith("--")) {
+      const [key, value] = arg.substring(2).split("=");
       if (value) {
         // Handle --key=value format
         parsedManually[key] = value;
-      } else if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+      } else if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
         // Handle --key value format
         parsedManually[key] = args[i + 1];
         i++; // Skip the next argument as it's the value
       } else {
         // Handle --key format (boolean flag)
-        parsedManually[key] = 'true';
+        parsedManually[key] = "true";
       }
     }
   }
-  
+
   // Just use the manually parsed args - removed parseArgs dependency for Node.js <18.3.0 compatibility
   return parsedManually;
 }
@@ -41,19 +41,19 @@ export function parseCommandLineArgs() {
  */
 export function loadEnvFiles(): string | null {
   // Determine if we're in development or production mode
-  const isDevelopment = process.env.NODE_ENV === 'development' || process.argv[1]?.includes('tsx');
+  const isDevelopment = process.env.NODE_ENV === "development" || process.argv[1]?.includes("tsx");
 
   // Select environment file names based on environment
-  const envFileNames = isDevelopment 
-    ? ['.env.local', '.env'] // In development, try .env.local first, then .env
-    : ['.env']; // In production, only look for .env
+  const envFileNames = isDevelopment
+    ? [".env.local", ".env"] // In development, try .env.local first, then .env
+    : [".env"]; // In production, only look for .env
 
   // Build paths to check for environment files
   const envPaths = [];
   for (const fileName of envFileNames) {
     envPaths.push(
       fileName, // Current working directory
-      path.join(__dirname, '..', '..', fileName), // Two levels up (src/config -> src -> root)
+      path.join(__dirname, "..", "..", fileName), // Two levels up (src/config -> src -> root)
       path.join(process.cwd(), fileName) // Explicit current working directory
     );
   }
@@ -67,7 +67,7 @@ export function loadEnvFiles(): string | null {
       return path.basename(envPath);
     }
   }
-  
+
   return null;
 }
 
@@ -77,7 +77,7 @@ export function loadEnvFiles(): string | null {
  */
 export function isDemoMode(): boolean {
   const args = parseCommandLineArgs();
-  return args.demo === 'true';
+  return args.demo === "true";
 }
 
 /**
@@ -87,85 +87,85 @@ export function isDemoMode(): boolean {
 export function resolveDSN(): { dsn: string; source: string; isDemo?: boolean } | null {
   // Get command line arguments
   const args = parseCommandLineArgs();
-  
+
   // Check for demo mode first (highest priority)
   if (isDemoMode()) {
     // Will use in-memory SQLite with demo data
-    return { 
-      dsn: 'sqlite::memory:', 
-      source: 'demo mode', 
-      isDemo: true 
+    return {
+      dsn: "sqlite::memory:",
+      source: "demo mode",
+      isDemo: true,
     };
   }
-  
-  // 1. Check command line arguments 
+
+  // 1. Check command line arguments
   if (args.dsn) {
-    return { dsn: args.dsn, source: 'command line argument' };
+    return { dsn: args.dsn, source: "command line argument" };
   }
-  
+
   // 2. Check environment variables before loading .env
   if (process.env.DSN) {
-    return { dsn: process.env.DSN, source: 'environment variable' };
+    return { dsn: process.env.DSN, source: "environment variable" };
   }
-  
+
   // 3. Try loading from .env files
   const loadedEnvFile = loadEnvFiles();
   if (loadedEnvFile && process.env.DSN) {
     return { dsn: process.env.DSN, source: `${loadedEnvFile} file` };
   }
-  
+
   return null;
 }
 
 /**
  * Resolve transport type from command line args or environment variables
  * Returns 'stdio' or 'sse', with 'stdio' as the default
  */
-export function resolveTransport(): { type: 'stdio' | 'sse'; source: string } {
+export function resolveTransport(): { type: "stdio" | "sse"; source: string } {
   // Get command line arguments
   const args = parseCommandLineArgs();
-  
+
   // 1. Check command line arguments first (highest priority)
   if (args.transport) {
-    const type = args.transport === 'sse' ? 'sse' : 'stdio';
-    return { type, source: 'command line argument' };
+    const type = args.transport === "sse" ? "sse" : "stdio";
+    return { type, source: "command line argument" };
   }
-  
+
   // 2. Check environment variables
   if (process.env.TRANSPORT) {
-    const type = process.env.TRANSPORT === 'sse' ? 'sse' : 'stdio';
-    return { type, source: 'environment variable' };
+    const type = process.env.TRANSPORT === "sse" ? "sse" : "stdio";
+    return { type, source: "environment variable" };
   }
-  
+
   // 3. Default to stdio
-  return { type: 'stdio', source: 'default' };
+  return { type: "stdio", source: "default" };
 }
 
 /**
  * Resolve port from command line args or environment variables
  * Returns port number with 8080 as the default
- * 
+ *
  * Note: The port option is only applicable when using --transport=sse
  * as it controls the HTTP server port for SSE connections.
  */
 export function resolvePort(): { port: number; source: string } {
   // Get command line arguments
   const args = parseCommandLineArgs();
-  
+
   // 1. Check command line arguments first (highest priority)
   if (args.port) {
     const port = parseInt(args.port, 10);
-    return { port, source: 'command line argument' };
+    return { port, source: "command line argument" };
   }
-  
+
   // 2. Check environment variables
   if (process.env.PORT) {
     const port = parseInt(process.env.PORT, 10);
-    return { port, source: 'environment variable' };
+    return { port, source: "environment variable" };
   }
-  
+
   // 3. Default to 8080
-  return { port: 8080, source: 'default' };
+  return { port: 8080, source: "default" };
 }
 
 /**
@@ -178,16 +178,16 @@ export function redactDSN(dsn: string): string {
   try {
     // Create a URL object to parse the DSN
     const url = new URL(dsn);
-    
+
     // Replace the password with asterisks
     if (url.password) {
-      url.password = '*******';
+      url.password = "*******";
     }
-    
+
     // Return the sanitized DSN
     return url.toString();
   } catch (error) {
     // If parsing fails, do basic redaction with regex
-    return dsn.replace(/\/\/([^:]+):([^@]+)@/, '//$1:***@');
+    return dsn.replace(/\/\/([^:]+):([^@]+)@/, "//$1:***@");
   }
 }