.claude/scripts/validate-command.js

@@ -14,55 +14,55 @@
 const SECURITY_RULES = {
   // Critical system destruction commands
   CRITICAL_COMMANDS: [
-    'del',
-    'format',
-    'mkfs',
-    'shred',
-    'dd',
-    'fdisk',
-    'parted',
-    'gparted',
-    'cfdisk',
+    "del",
+    "format",
+    "mkfs",
+    "shred",
+    "dd",
+    "fdisk",
+    "parted",
+    "gparted",
+    "cfdisk",
   ],
 
   // Privilege escalation and system access
   PRIVILEGE_COMMANDS: [
-    'sudo',
-    'su',
-    'passwd',
-    'chpasswd',
-    'usermod',
-    'chmod',
-    'chown',
-    'chgrp',
-    'setuid',
-    'setgid',
+    "sudo",
+    "su",
+    "passwd",
+    "chpasswd",
+    "usermod",
+    "chmod",
+    "chown",
+    "chgrp",
+    "setuid",
+    "setgid",
   ],
 
   // Network and remote access tools
   NETWORK_COMMANDS: [
-    'nc',
-    'netcat',
-    'nmap',
-    'telnet',
-    'ssh-keygen',
-    'iptables',
-    'ufw',
-    'firewall-cmd',
-    'ipfw',
+    "nc",
+    "netcat",
+    "nmap",
+    "telnet",
+    "ssh-keygen",
+    "iptables",
+    "ufw",
+    "firewall-cmd",
+    "ipfw",
   ],
 
   // System service and process manipulation
   SYSTEM_COMMANDS: [
-    'systemctl',
-    'service',
-    'kill',
-    'killall',
-    'pkill',
-    'mount',
-    'umount',
-    'swapon',
-    'swapoff',
+    "systemctl",
+    "service",
+    "kill",
+    "killall",
+    "pkill",
+    "mount",
+    "umount",
+    "swapon",
+    "swapoff",
   ],
 
   // Dangerous regex patterns
@@ -147,73 +147,74 @@ const SECURITY_RULES = {
     /printenv.*PASSWORD/i,
   ],
 
+
   // Paths that should never be written to
   PROTECTED_PATHS: [
-    '/etc/',
-    '/usr/',
-    '/bin/',
-    '/sbin/',
-    '/boot/',
-    '/sys/',
-    '/proc/',
-    '/dev/',
-    '/root/',
+    "/etc/",
+    "/usr/",
+    "/bin/",
+    "/sbin/",
+    "/boot/",
+    "/sys/",
+    "/proc/",
+    "/dev/",
+    "/root/",
   ],
 };
 
 // Allowlist of safe commands (when used appropriately)
 const SAFE_COMMANDS = [
-  'ls',
-  'dir',
-  'pwd',
-  'whoami',
-  'date',
-  'echo',
-  'cat',
-  'head',
-  'tail',
-  'grep',
-  'find',
-  'wc',
-  'sort',
-  'uniq',
-  'cut',
-  'awk',
-  'sed',
-  'git',
-  'npm',
-  'pnpm',
-  'node',
-  'bun',
-  'python',
-  'pip',
-  'cd',
-  'cp',
-  'mv',
-  'mkdir',
-  'touch',
-  'ln',
+  "ls",
+  "dir",
+  "pwd",
+  "whoami",
+  "date",
+  "echo",
+  "cat",
+  "head",
+  "tail",
+  "grep",
+  "find",
+  "wc",
+  "sort",
+  "uniq",
+  "cut",
+  "awk",
+  "sed",
+  "git",
+  "npm",
+  "pnpm",
+  "node",
+  "bun",
+  "python",
+  "pip",
+  "cd",
+  "cp",
+  "mv",
+  "mkdir",
+  "touch",
+  "ln",
 ];
 
 class CommandValidator {
   constructor() {
-    this.logFile = '/Users/david/.claude/security.log';
+    this.logFile = "/Users/david/.claude/security.log";
   }
 
   /**
    * Main validation function
    */
-  validate(command, toolName = 'Unknown') {
+  validate(command, toolName = "Unknown") {
     const result = {
       isValid: true,
-      severity: 'LOW',
+      severity: "LOW",
       violations: [],
       sanitizedCommand: command,
     };
 
-    if (!command || typeof command !== 'string') {
+    if (!command || typeof command !== "string") {
       result.isValid = false;
-      result.violations.push('Invalid command format');
+      result.violations.push("Invalid command format");
       return result;
     }
 
@@ -225,28 +226,28 @@ class CommandValidator {
     // Check against critical commands
     if (SECURITY_RULES.CRITICAL_COMMANDS.includes(mainCommand)) {
       result.isValid = false;
-      result.severity = 'CRITICAL';
+      result.severity = "CRITICAL";
       result.violations.push(`Critical dangerous command: ${mainCommand}`);
     }
 
     // Check privilege escalation commands
     if (SECURITY_RULES.PRIVILEGE_COMMANDS.includes(mainCommand)) {
       result.isValid = false;
-      result.severity = 'HIGH';
+      result.severity = "HIGH";
       result.violations.push(`Privilege escalation command: ${mainCommand}`);
     }
 
     // Check network commands
     if (SECURITY_RULES.NETWORK_COMMANDS.includes(mainCommand)) {
       result.isValid = false;
-      result.severity = 'HIGH';
+      result.severity = "HIGH";
       result.violations.push(`Network/remote access command: ${mainCommand}`);
     }
 
     // Check system commands
     if (SECURITY_RULES.SYSTEM_COMMANDS.includes(mainCommand)) {
       result.isValid = false;
-      result.severity = 'HIGH';
+      result.severity = "HIGH";
       result.violations.push(`System manipulation command: ${mainCommand}`);
     }
 
@@ -254,25 +255,21 @@ class CommandValidator {
     for (const pattern of SECURITY_RULES.DANGEROUS_PATTERNS) {
       if (pattern.test(command)) {
         result.isValid = false;
-        result.severity = 'CRITICAL';
+        result.severity = "CRITICAL";
         result.violations.push(`Dangerous pattern detected: ${pattern.source}`);
       }
     }
 
+
     // Check for protected path access (but allow common redirections like /dev/null)
     for (const path of SECURITY_RULES.PROTECTED_PATHS) {
       if (command.includes(path)) {
         // Allow common safe redirections
-        if (
-          path === '/dev/' &&
-          (command.includes('/dev/null') ||
-            command.includes('/dev/stderr') ||
-            command.includes('/dev/stdout'))
-        ) {
+        if (path === "/dev/" && (command.includes("/dev/null") || command.includes("/dev/stderr") || command.includes("/dev/stdout"))) {
           continue;
         }
         result.isValid = false;
-        result.severity = 'HIGH';
+        result.severity = "HIGH";
         result.violations.push(`Access to protected path: ${path}`);
       }
     }
@@ -280,20 +277,21 @@ class CommandValidator {
     // Additional safety checks
     if (command.length > 2000) {
       result.isValid = false;
-      result.severity = 'MEDIUM';
-      result.violations.push('Command too long (potential buffer overflow)');
+      result.severity = "MEDIUM";
+      result.violations.push("Command too long (potential buffer overflow)");
     }
 
     // Check for binary/encoded content
     if (/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\xFF]/.test(command)) {
       result.isValid = false;
-      result.severity = 'HIGH';
-      result.violations.push('Binary or encoded content detected');
+      result.severity = "HIGH";
+      result.violations.push("Binary or encoded content detected");
     }
 
     return result;
   }
 
+
   /**
    * Log security events
    */
@@ -307,20 +305,22 @@ class CommandValidator {
       blocked: !result.isValid,
       severity: result.severity,
       violations: result.violations,
-      source: 'claude-code-hook',
+      source: "claude-code-hook",
     };
 
     try {
       // Write to log file
-      const logLine = JSON.stringify(logEntry) + '\n';
-      await Bun.write(this.logFile, logLine, { createPath: true, flag: 'a' });
+      const logLine = JSON.stringify(logEntry) + "\n";
+      await Bun.write(this.logFile, logLine, { createPath: true, flag: "a" });
 
       // Also output to stderr for immediate visibility
       console.error(
-        `[SECURITY] ${result.isValid ? 'ALLOWED' : 'BLOCKED'}: ${command.substring(0, 100)}`
+        `[SECURITY] ${
+          result.isValid ? "ALLOWED" : "BLOCKED"
+        }: ${command.substring(0, 100)}`
       );
     } catch (error) {
-      console.error('Failed to write security log:', error);
+      console.error("Failed to write security log:", error);
     }
   }
 
@@ -331,9 +331,12 @@ class CommandValidator {
     for (const pattern of allowedPatterns) {
       // Convert Claude Code permission pattern to regex
       // e.g., "Bash(git *)" becomes /^git\s+.*$/
-      if (pattern.startsWith('Bash(') && pattern.endsWith(')')) {
+      if (pattern.startsWith("Bash(") && pattern.endsWith(")")) {
         const cmdPattern = pattern.slice(5, -1); // Remove "Bash(" and ")"
-        const regex = new RegExp('^' + cmdPattern.replace(/\*/g, '.*') + '$', 'i');
+        const regex = new RegExp(
+          "^" + cmdPattern.replace(/\*/g, ".*") + "$",
+          "i"
+        );
         if (regex.test(command)) {
           return true;
         }
@@ -361,7 +364,7 @@ async function main() {
     const input = Buffer.concat(chunks).toString();
 
     if (!input.trim()) {
-      console.error('No input received from stdin');
+      console.error("No input received from stdin");
       process.exit(1);
     }
 
@@ -370,23 +373,23 @@ async function main() {
     try {
       hookData = JSON.parse(input);
     } catch (error) {
-      console.error('Invalid JSON input:', error.message);
+      console.error("Invalid JSON input:", error.message);
       process.exit(1);
     }
 
-    const toolName = hookData.tool_name || 'Unknown';
+    const toolName = hookData.tool_name || "Unknown";
     const toolInput = hookData.tool_input || {};
     const sessionId = hookData.session_id || null;
 
     // Only validate Bash commands for now
-    if (toolName !== 'Bash') {
+    if (toolName !== "Bash") {
       console.log(`Skipping validation for tool: ${toolName}`);
       process.exit(0);
     }
 
     const command = toolInput.command;
     if (!command) {
-      console.error('No command found in tool input');
+      console.error("No command found in tool input");
       process.exit(1);
     }
 
@@ -398,22 +401,24 @@ async function main() {
 
     // Output result and exit with appropriate code
     if (result.isValid) {
-      console.log('Command validation passed');
+      console.log("Command validation passed");
       process.exit(0); // Allow execution
     } else {
-      console.error(`Command validation failed: ${result.violations.join(', ')}`);
+      console.error(
+        `Command validation failed: ${result.violations.join(", ")}`
+      );
       console.error(`Severity: ${result.severity}`);
       process.exit(2); // Block execution (Claude Code requires exit code 2)
     }
   } catch (error) {
-    console.error('Validation script error:', error);
+    console.error("Validation script error:", error);
     // Fail safe - block execution on any script error
     process.exit(2);
   }
 }
 
 // Execute main function
-main().catch(error => {
-  console.error('Fatal error:', error);
+main().catch((error) => {
+  console.error("Fatal error:", error);
   process.exit(2);
 });

.claude/settings.local.json

@@ -1,46 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(docker-compose:*)",
-      "Bash(npm run lint)",
-      "Bash(npm run lint:*)",
-      "Bash(npm run backend:lint)",
-      "Bash(npm run backend:build:*)",
-      "Bash(npm run frontend:build:*)",
-      "Bash(rm:*)",
-      "Bash(git rm:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(git push:*)",
-      "Bash(npx tsc:*)",
-      "Bash(npx nest:*)",
-      "Read(//Users/david/Documents/xpeditis/**)",
-      "Bash(find:*)",
-      "Bash(npm test)",
-      "Bash(git checkout:*)",
-      "Bash(git reset:*)",
-      "Bash(curl:*)",
-      "Read(//private/tmp/**)",
-      "Bash(lsof:*)",
-      "Bash(awk:*)",
-      "Bash(xargs kill:*)",
-      "Read(//dev/**)",
-      "Bash(psql:*)",
-      "Bash(npx ts-node:*)",
-      "Bash(python3:*)",
-      "Read(//Users/david/.docker/**)",
-      "Bash(env)",
-      "Bash(ssh david@xpeditis-cloud \"docker ps --filter name=xpeditis-backend --format ''{{.ID}} {{.Status}}''\")",
-      "Bash(git revert:*)",
-      "Bash(git log:*)",
-      "Bash(xargs -r docker rm:*)",
-      "Bash(npm run migration:run:*)",
-      "Bash(npm run dev:*)",
-      "Bash(npm run backend:dev:*)",
-      "Bash(env -i PATH=\"$PATH\" HOME=\"$HOME\" node:*)",
-      "Bash(PGPASSWORD=xpeditis_dev_password psql -h localhost -U xpeditis -d xpeditis_dev -c:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}

.github/pull_request_template.md

@@ -0,0 +1,54 @@
+# Description
+
+<!-- Provide a brief description of the changes in this PR -->
+
+## Type of Change
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Documentation update
+- [ ] Code refactoring
+- [ ] Performance improvement
+- [ ] Test addition/update
+
+## Related Issue
+
+<!-- Link to the related issue (if applicable) -->
+Closes #
+
+## Changes Made
+
+<!-- List the main changes made in this PR -->
+
+-
+-
+-
+
+## Testing
+
+<!-- Describe the testing you've done -->
+
+- [ ] Unit tests pass locally
+- [ ] E2E tests pass locally
+- [ ] Manual testing completed
+- [ ] No new warnings
+
+## Checklist
+
+- [ ] My code follows the hexagonal architecture principles
+- [ ] I have performed a self-review of my code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] Any dependent changes have been merged and published
+
+## Screenshots (if applicable)
+
+<!-- Add screenshots to help explain your changes -->
+
+## Additional Notes
+
+<!-- Any additional information that reviewers should know -->

.github/workflows/ci.yml

@@ -1,24 +1,15 @@
-name: CI/CD Pipeline
+name: CI
 
 on:
   push:
-    branches:
-      - preprod
-
-env:
-  REGISTRY: rg.fr-par.scw.cloud/weworkstudio
-  NODE_VERSION: '20'
+    branches: [main, dev]
+  pull_request:
+    branches: [main, dev]
 
 jobs:
-  # ============================================
-  # Backend Build, Test & Deploy
-  # ============================================
-  backend:
-    name: Backend - Build, Test & Push
+  lint-and-format:
+    name: Lint & Format Check
     runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: apps/backend
 
     steps:
       - name: Checkout code
@@ -27,140 +18,31 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: ${{ env.NODE_VERSION }}
-
-      - name: Install dependencies
-        run: npm install --legacy-peer-deps
-
-      - name: Lint code
-        run: npm run lint
-
-      - name: Run unit tests
-        run: npm test -- --coverage --passWithNoTests
-
-      - name: Build application
-        run: npm run build
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Login to Scaleway Registry
-        uses: docker/login-action@v3
-        with:
-          registry: rg.fr-par.scw.cloud/weworkstudio
-          username: nologin
-          password: ${{ secrets.REGISTRY_TOKEN }}
-
-      - name: Extract metadata for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.REGISTRY }}/xpeditis-backend
-          tags: |
-            type=ref,event=branch
-            type=raw,value=latest,enable={{is_default_branch}}
-
-      - name: Build and push Backend Docker image
-        uses: docker/build-push-action@v5
-        with:
-          context: ./apps/backend
-          file: ./apps/backend/Dockerfile
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=registry,ref=${{ env.REGISTRY }}/xpeditis-backend:buildcache
-          cache-to: type=registry,ref=${{ env.REGISTRY }}/xpeditis-backend:buildcache,mode=max
-          platforms: linux/amd64,linux/arm64
-
-  # ============================================
-  # Frontend Build, Test & Deploy
-  # ============================================
-  frontend:
-    name: Frontend - Build, Test & Push
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: apps/frontend
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ env.NODE_VERSION }}
+          node-version: '20'
           cache: 'npm'
-          cache-dependency-path: apps/frontend/package-lock.json
 
       - name: Install dependencies
-        run: npm ci --legacy-peer-deps
+        run: npm ci
 
-      - name: Lint code
-        run: npm run lint
+      - name: Run Prettier check
+        run: npm run format:check
 
-      - name: Run tests
-        run: npm test -- --passWithNoTests || echo "No tests found"
+      - name: Lint backend
+        run: npm run backend:lint --workspace=apps/backend
 
-      - name: Build application
-        env:
-          NEXT_PUBLIC_API_URL: ${{ secrets.NEXT_PUBLIC_API_URL || 'http://localhost:4000' }}
-          NEXT_PUBLIC_APP_URL: ${{ secrets.NEXT_PUBLIC_APP_URL || 'http://localhost:3000' }}
-          NEXT_TELEMETRY_DISABLED: 1
-        run: npm run build
+      - name: Lint frontend
+        run: npm run frontend:lint --workspace=apps/frontend
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Login to Scaleway Registry
-        uses: docker/login-action@v3
-        with:
-          registry: rg.fr-par.scw.cloud/weworkstudio
-          username: nologin
-          password: ${{ secrets.REGISTRY_TOKEN }}
-
-      - name: Extract metadata for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.REGISTRY }}/xpeditis-frontend
-          tags: |
-            type=ref,event=branch
-            type=raw,value=latest,enable={{is_default_branch}}
-
-      - name: Build and push Frontend Docker image
-        uses: docker/build-push-action@v5
-        with:
-          context: ./apps/frontend
-          file: ./apps/frontend/Dockerfile
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=registry,ref=${{ env.REGISTRY }}/xpeditis-frontend:buildcache
-          cache-to: type=registry,ref=${{ env.REGISTRY }}/xpeditis-frontend:buildcache,mode=max
-          platforms: linux/amd64,linux/arm64
-          build-args: |
-            NEXT_PUBLIC_API_URL=${{ secrets.NEXT_PUBLIC_API_URL || 'http://localhost:4000' }}
-            NEXT_PUBLIC_APP_URL=${{ secrets.NEXT_PUBLIC_APP_URL || 'http://localhost:3000' }}
-
-  # ============================================
-  # Integration Tests (Optional)
-  # ============================================
-  integration-tests:
-    name: Integration Tests
+  test-backend:
+    name: Test Backend
     runs-on: ubuntu-latest
-    needs: [backend, frontend]
-    if: github.event_name == 'pull_request'
-    defaults:
-      run:
-        working-directory: apps/backend
 
     services:
       postgres:
         image: postgres:15-alpine
         env:
-          POSTGRES_USER: xpeditis
-          POSTGRES_PASSWORD: xpeditis_dev_password
+          POSTGRES_USER: xpeditis_test
+          POSTGRES_PASSWORD: xpeditis_test
           POSTGRES_DB: xpeditis_test
         options: >-
           --health-cmd pg_isready
@@ -187,186 +69,131 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: ${{ env.NODE_VERSION }}
+          node-version: '20'
+          cache: 'npm'
 
       - name: Install dependencies
-        run: npm install --legacy-peer-deps
+        run: npm ci
 
-      - name: Run integration tests
+      - name: Run backend unit tests
+        working-directory: apps/backend
         env:
+          NODE_ENV: test
           DATABASE_HOST: localhost
           DATABASE_PORT: 5432
-          DATABASE_USER: xpeditis
-          DATABASE_PASSWORD: xpeditis_dev_password
+          DATABASE_USER: xpeditis_test
+          DATABASE_PASSWORD: xpeditis_test
           DATABASE_NAME: xpeditis_test
           REDIS_HOST: localhost
           REDIS_PORT: 6379
-          JWT_SECRET: test-secret-key-for-ci
-        run: npm run test:integration || echo "No integration tests found"
+          REDIS_PASSWORD: ''
+          JWT_SECRET: test-jwt-secret
+        run: npm run test
 
-  # ============================================
-  # Deployment Summary
-  # ============================================
-  deployment-summary:
-    name: Deployment Summary
+      - name: Run backend E2E tests
+        working-directory: apps/backend
+        env:
+          NODE_ENV: test
+          DATABASE_HOST: localhost
+          DATABASE_PORT: 5432
+          DATABASE_USER: xpeditis_test
+          DATABASE_PASSWORD: xpeditis_test
+          DATABASE_NAME: xpeditis_test
+          REDIS_HOST: localhost
+          REDIS_PORT: 6379
+          REDIS_PASSWORD: ''
+          JWT_SECRET: test-jwt-secret
+        run: npm run test:e2e
+
+      - name: Upload backend coverage
+        uses: codecov/codecov-action@v3
+        with:
+          files: ./apps/backend/coverage/lcov.info
+          flags: backend
+          name: backend-coverage
+
+  test-frontend:
+    name: Test Frontend
     runs-on: ubuntu-latest
-    needs: [backend, frontend]
-    if: success()
 
     steps:
-      - name: Summary
-        run: |
-          echo "## 🚀 Deployment Summary" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "### Backend Image" >> $GITHUB_STEP_SUMMARY
-          echo "- Registry: \`${{ env.REGISTRY }}/xpeditis-backend\`" >> $GITHUB_STEP_SUMMARY
-          echo "- Branch: \`${{ github.ref_name }}\`" >> $GITHUB_STEP_SUMMARY
-          echo "- Commit: \`${{ github.sha }}\`" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "### Frontend Image" >> $GITHUB_STEP_SUMMARY
-          echo "- Registry: \`${{ env.REGISTRY }}/xpeditis-frontend\`" >> $GITHUB_STEP_SUMMARY
-          echo "- Branch: \`${{ github.ref_name }}\`" >> $GITHUB_STEP_SUMMARY
-          echo "- Commit: \`${{ github.sha }}\`" >> $GITHUB_STEP_SUMMARY
-          echo "" >> $GITHUB_STEP_SUMMARY
-          echo "### Pull Commands" >> $GITHUB_STEP_SUMMARY
-          echo "\`\`\`bash" >> $GITHUB_STEP_SUMMARY
-          echo "docker pull ${{ env.REGISTRY }}/xpeditis-backend:${{ github.ref_name }}" >> $GITHUB_STEP_SUMMARY
-          echo "docker pull ${{ env.REGISTRY }}/xpeditis-frontend:${{ github.ref_name }}" >> $GITHUB_STEP_SUMMARY
-          echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
+      - name: Checkout code
+        uses: actions/checkout@v4
 
-  # ============================================
-  # Deploy to Portainer via Webhooks
-  # ============================================
-  deploy-portainer:
-    name: Deploy to Portainer
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run frontend tests
+        working-directory: apps/frontend
+        run: npm run test
+
+      - name: Upload frontend coverage
+        uses: codecov/codecov-action@v3
+        with:
+          files: ./apps/frontend/coverage/lcov.info
+          flags: frontend
+          name: frontend-coverage
+
+  build-backend:
+    name: Build Backend
     runs-on: ubuntu-latest
-    needs: [backend, frontend]
-    if: success() && github.ref == 'refs/heads/preprod'
+    needs: [lint-and-format, test-backend]
 
     steps:
-      - name: Trigger Backend Webhook
-        run: |
-          echo "🚀 Deploying Backend to Portainer..."
-          curl -X POST \
-            -H "Content-Type: application/json" \
-            -d '{"data": "backend-deployment"}' \
-            ${{ secrets.PORTAINER_WEBHOOK_BACKEND }}
-          echo "✅ Backend webhook triggered"
+      - name: Checkout code
+        uses: actions/checkout@v4
 
-      - name: Wait before Frontend deployment
-        run: sleep 10
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
 
-      - name: Trigger Frontend Webhook
-        run: |
-          echo "🚀 Deploying Frontend to Portainer..."
-          curl -X POST \
-            -H "Content-Type: application/json" \
-            -d '{"data": "frontend-deployment"}' \
-            ${{ secrets.PORTAINER_WEBHOOK_FRONTEND }}
-          echo "✅ Frontend webhook triggered"
+      - name: Install dependencies
+        run: npm ci
 
-  # ============================================
-  # Discord Notification - Success
-  # ============================================
-  notify-success:
-    name: Discord Notification (Success)
+      - name: Build backend
+        working-directory: apps/backend
+        run: npm run build
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: backend-dist
+          path: apps/backend/dist
+
+  build-frontend:
+    name: Build Frontend
     runs-on: ubuntu-latest
-    needs: [backend, frontend, deploy-portainer]
-    if: success()
+    needs: [lint-and-format, test-frontend]
 
     steps:
-      - name: Send Discord notification
-        run: |
-          curl -H "Content-Type: application/json" \
-            -d '{
-              "embeds": [{
-                "title": "✅ CI/CD Pipeline Success",
-                "description": "Deployment completed successfully!",
-                "color": 3066993,
-                "fields": [
-                  {
-                    "name": "Repository",
-                    "value": "${{ github.repository }}",
-                    "inline": true
-                  },
-                  {
-                    "name": "Branch",
-                    "value": "${{ github.ref_name }}",
-                    "inline": true
-                  },
-                  {
-                    "name": "Commit",
-                    "value": "[${{ github.sha }}](${{ github.event.head_commit.url }})",
-                    "inline": false
-                  },
-                  {
-                    "name": "Backend Image",
-                    "value": "`${{ env.REGISTRY }}/xpeditis-backend:${{ github.ref_name }}`",
-                    "inline": false
-                  },
-                  {
-                    "name": "Frontend Image",
-                    "value": "`${{ env.REGISTRY }}/xpeditis-frontend:${{ github.ref_name }}`",
-                    "inline": false
-                  },
-                  {
-                    "name": "Workflow",
-                    "value": "[${{ github.workflow }}](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})",
-                    "inline": false
-                  }
-                ],
-                "timestamp": "${{ github.event.head_commit.timestamp }}",
-                "footer": {
-                  "text": "Xpeditis CI/CD"
-                }
-              }]
-            }' \
-            ${{ secrets.DISCORD_WEBHOOK_URL }}
+      - name: Checkout code
+        uses: actions/checkout@v4
 
-  # ============================================
-  # Discord Notification - Failure
-  # ============================================
-  notify-failure:
-    name: Discord Notification (Failure)
-    runs-on: ubuntu-latest
-    needs: [backend, frontend, deploy-portainer]
-    if: failure()
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
 
-    steps:
-      - name: Send Discord notification
-        run: |
-          curl -H "Content-Type: application/json" \
-            -d '{
-              "embeds": [{
-                "title": "❌ CI/CD Pipeline Failed",
-                "description": "Deployment failed! Check the logs for details.",
-                "color": 15158332,
-                "fields": [
-                  {
-                    "name": "Repository",
-                    "value": "${{ github.repository }}",
-                    "inline": true
-                  },
-                  {
-                    "name": "Branch",
-                    "value": "${{ github.ref_name }}",
-                    "inline": true
-                  },
-                  {
-                    "name": "Commit",
-                    "value": "[${{ github.sha }}](${{ github.event.head_commit.url }})",
-                    "inline": false
-                  },
-                  {
-                    "name": "Workflow",
-                    "value": "[${{ github.workflow }}](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})",
-                    "inline": false
-                  }
-                ],
-                "timestamp": "${{ github.event.head_commit.timestamp }}",
-                "footer": {
-                  "text": "Xpeditis CI/CD"
-                }
-              }]
-            }' \
-            ${{ secrets.DISCORD_WEBHOOK_URL }}
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build frontend
+        working-directory: apps/frontend
+        env:
+          NEXT_PUBLIC_API_URL: ${{ secrets.NEXT_PUBLIC_API_URL || 'http://localhost:4000' }}
+        run: npm run build
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: frontend-build
+          path: apps/frontend/.next

.github/workflows/security.yml

@@ -0,0 +1,40 @@
+name: Security Audit
+
+on:
+  schedule:
+    - cron: '0 0 * * 1' # Run every Monday at midnight
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  audit:
+    name: npm audit
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Run npm audit
+        run: npm audit --audit-level=moderate
+
+  dependency-review:
+    name: Dependency Review
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request'
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Dependency Review
+        uses: actions/dependency-review-action@v4
+        with:
+          fail-on-severity: moderate

.gitignore

@@ -12,9 +12,7 @@ coverage/
 dist/
 build/
 .next/
-# Only ignore Next.js output directory, not all 'out' folders
-/.next/out/
-/apps/frontend/out/
+out/
 
 # Environment variables
 .env

CLAUDE.md

@@ -4,167 +4,641 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-**Xpeditis** is a B2B SaaS maritime freight booking platform. Freight forwarders search and compare real-time shipping rates, book containers, and manage shipments. Built as a monorepo with NestJS backend (Hexagonal Architecture) and Next.js 14 frontend.
+**Xpeditis** is a B2B SaaS maritime freight booking and management platform (maritime equivalent of WebCargo). The platform allows freight forwarders to search and compare real-time shipping rates, book containers online, and manage shipments from a centralized dashboard.
 
-## Development Commands
-
-```bash
-# Start infrastructure (PostgreSQL + Redis + MinIO)
-docker-compose up -d
-
-# Install dependencies
-npm install && cd apps/backend && npm install && cd ../frontend && npm install
-
-# Run database migrations
-cd apps/backend && npm run migration:run
-
-# Start development servers
-npm run backend:dev    # http://localhost:4000, Swagger: /api/docs
-npm run frontend:dev   # http://localhost:3000
-```
-
-### Testing
-
-```bash
-# Backend (from apps/backend/)
-npm test                              # Unit tests
-npm test -- booking.entity.spec.ts    # Single file
-npm run test:cov                      # With coverage
-npm run test:integration              # Integration tests (needs DB/Redis)
-npm run test:e2e                      # E2E tests
-
-# Frontend (from apps/frontend/)
-npm test
-npx playwright test                   # E2E tests
-```
-
-### Database Migrations
-
-```bash
-cd apps/backend
-npm run migration:generate -- src/infrastructure/persistence/typeorm/migrations/MigrationName
-npm run migration:run
-npm run migration:revert
-```
-
-### Build
-
-```bash
-npm run backend:build    # Compiles TS with path alias resolution (tsc-alias)
-npm run frontend:build   # Next.js production build
-```
+**MVP Goal**: Deliver a minimal but professional product capable of handling 50-100 bookings/month for 10-20 early adopter freight forwarders within 4-6 months.
 
 ## Architecture
 
-### Hexagonal Architecture (Backend)
+### Hexagonal Architecture (Ports & Adapters)
+
+The codebase follows hexagonal architecture principles with clear separation of concerns:
+
+- **API Layer (External Adapters)**: Controllers, validation, auth middleware
+- **Application Layer (Ports)**: Use cases (searchRates, createBooking, confirmBooking)
+- **Domain Layer (Core)**: Entities (Booking, RateQuote, Carrier, Organization, User)
+- **Infrastructure Adapters**: DB repositories, carrier connectors, email services, storage, Redis cache
+
+### Tech Stack
+
+- **Frontend**: Next.js (TypeScript) with SSR/ISR
+- **Backend**: Node.js API-first (OpenAPI spec)
+- **Database**: PostgreSQL (TypeORM or Prisma)
+- **Cache**: Redis (15 min TTL for spot rates)
+- **Storage**: S3-compatible (AWS S3 or MinIO)
+- **Auth**: OAuth2 + JWT (access 15min, refresh 7 days)
+
+### Project Structure (Planned Monorepo)
 
 ```
-apps/backend/src/
-├── domain/           # CORE - Pure TypeScript, NO framework imports
-│   ├── entities/     # Booking, RateQuote, User (with private props, static create())
-│   ├── value-objects/# Money, Email, BookingNumber (immutable, validated)
-│   ├── services/     # Domain services
-│   ├── ports/
-│   │   ├── in/      # Use case interfaces
-│   │   └── out/     # Repository interfaces (SPIs)
-│   └── exceptions/   # Domain exceptions
-├── application/      # Controllers, DTOs, Guards (depends ONLY on domain)
-└── infrastructure/   # TypeORM, Redis, Carrier APIs (depends ONLY on domain)
+apps/
+  frontend/     # Next.js application
+  backend/      # Node.js API
+libs/
+  domain/       # Core domain entities and business logic
+infra/          # Infrastructure configuration
 ```
 
-**Critical Rules**:
-- Domain layer: Zero imports from NestJS, TypeORM, Redis
-- Dependencies flow inward: Infrastructure → Application → Domain
-- Use path aliases: `@domain/*`, `@application/*`, `@infrastructure/*`
-- Domain tests run without NestJS TestingModule
+## Core Domain Entities
 
-### Frontend (Next.js 14 App Router)
+- **Organization**: `{ id, name, type, scac, address, logo_url, documents[] }`
+- **User**: `{ id, org_id, role, email, pwd_hash, totp_secret }`
+- **RateQuote**: `{ id, origin, destination, carrier_id, price_currency, price_value, surcharges[], etd, eta, transit_days, route, availability }`
+- **Booking**: `{ id, booking_number, user_id, org_id, rate_quote_id, shipper, consignee, containers[], status, created_at, updated_at }`
+- **Container**: `{ id, booking_id, type, container_number, vgm, temp, seal_number }`
+
+## Key API Endpoints
+
+### Rate Search
+- `POST /api/v1/rates/search`: Search shipping rates with origin/destination/container specs
+- Response includes carrier, pricing, surcharges, ETD/ETA, transit time, route, CO2 emissions
+- Cache TTL: 15 minutes (Redis)
+- Timeout: 5 seconds per carrier API
+
+### Booking Management
+- `POST /api/v1/bookings`: Create booking (multi-step workflow)
+- `GET /api/v1/bookings/:id`: Get booking details
+- Booking number format: `WCM-YYYY-XXXXXX` (6 alphanumeric chars)
+
+### Authentication
+- `/auth/register`: Email + password (≥12 chars)
+- `/auth/login`: JWT-based login + OAuth2 (Google Workspace, Microsoft 365)
+- `/auth/logout`: Session termination
+- `/auth/refresh`: Token refresh
+
+## Critical Integration Points
+
+### Carrier Connectors (MVP Priority)
+Implement connectors for 3-5 carriers using Strategy pattern:
+- Maersk (required)
+- MSC
+- CMA CGM
+- Hapag-Lloyd
+- ONE
+
+Each connector must:
+- Normalize data to internal schema
+- Implement retry logic and circuit breakers
+- Respect rate limiting
+- Log detailed metrics
+- Respond within 5s or fallback gracefully
+
+### Cache Strategy
+- Preload top 100 trade lanes on startup
+- 15-minute TTL for spot rates
+- Cache hit target: >90% for common routes
+
+## Security Requirements
+
+- TLS 1.2+ for all traffic
+- Password hashing: Argon2id or bcrypt (≥12 rounds)
+- OWASP Top 10 protection (rate limiting, input validation, CSP headers)
+- Audit logs for sensitive actions
+- S3 ACLs for compliance documents
+- Optional TOTP 2FA
+
+## RBAC Roles
+
+- **Admin**: Full system access
+- **Manager**: Manage bookings and users within organization
+- **User**: Create and view bookings
+- **Viewer**: Read-only access
+
+## Performance Targets
+
+- Rate search: <2s for 90% of requests (with cache)
+- Dashboard load: <1s for up to 5k bookings
+- Carrier API timeout: 5s
+- Email confirmation: Send within 3s of booking
+- Session auto-logout: 2h inactivity
+
+## Development Workflow
+
+### Testing Requirements
+- Unit tests: Domain logic and use cases
+- Integration tests: Carrier connectors and DB repositories
+- E2E tests: Complete booking workflow (happy path + 3 common error scenarios)
+
+### Email & Notifications
+- Templates: MJML format
+- Booking confirmation email on successful booking
+- Push notifications (if mobile app)
+
+### Document Generation
+- PDF booking confirmations
+- Excel/PDF export for rate search results
+
+## Data Requirements
+
+- Port autocomplete: 10k+ ports (IATA/UN LOCODE)
+- Multi-currency support: USD, EUR
+- Hazmat support: IMO class validation
+- Container types: 20', 40', 40'HC, etc.
+
+## MVP Roadmap (4-6 months)
+
+**Sprint 0 (2 weeks)**: Repo setup, infrastructure, OpenAPI skeleton, ports/adapters scaffolding
+
+**Phase 1 (6-8 weeks)**: Rate search API + UI, Redis cache, 1-2 carrier connectors, basic auth
+
+**Phase 2 (6-8 weeks)**: Booking workflow, email templates, dashboard, RBAC, organizations
+
+**Phase 3 (4-6 weeks)**: Additional carrier integrations, exports, E2E tests, monitoring, security hardening
+
+**Go-to-market (2 weeks)**: Early adopter onboarding, support, KPI tracking
+
+## Important Constraints
+
+- Pre-fetch top 100 trade lanes on application startup
+- All carrier API calls must have circuit breakers
+- Booking workflow: ≤4 steps maximum
+- Session timeout: 2 hours of inactivity
+- Rate search pagination: >20 results
+- SLA: 95% of rate searches <1s (including cache)
+
+## Business KPIs to Track
+
+- Active users (DAU/MAU)
+- Bookings per month
+- Search-to-booking conversion rate (target ≥3%)
+- Average time to create booking
+- Carrier API error rates
+- Cache hit ratio
+- Customer retention at 3 months
+
+---
+
+# Backend Hexagonal Architecture Guidelines (Node.js/TypeScript)
+
+## Phase 1: Business Domain Analysis
+
+### Domain Identification
+- **Primary business domain**: Maritime freight booking platform
+- **Core entities**: Organization, User, RateQuote, Booking, Container, Carrier
+- **Business rules**:
+  - Rate quotes expire after 15 minutes (Redis cache)
+  - Bookings must validate container availability in real-time
+  - Multi-step booking workflow (≤4 steps)
+  - RBAC enforcement for all operations
+  - Carrier API timeout: 5 seconds with fallback
+- **Use cases**: searchRates, createBooking, confirmBooking, manageOrganizations, authenticateUser
+
+### Integration Requirements
+- **External actors**: Freight forwarders (users), carriers (API integrations)
+- **External services**: PostgreSQL, Redis, S3, Email (MJML templates), Carrier APIs (Maersk, MSC, CMA CGM, etc.)
+- **Input interfaces**: REST API (OpenAPI), OAuth2 callbacks
+- **Output interfaces**: Database persistence, email notifications, carrier API calls, S3 document storage
+
+## Phase 2: Architectural Design
+
+### Module Structure
 
 ```
-apps/frontend/
-├── app/              # App Router pages
-│   ├── dashboard/    # Protected routes
-│   │   ├── bookings/ # Booking management
-│   │   ├── admin/    # Admin features (ADMIN role)
-│   │   └── settings/ # User/org settings
-│   └── carrier/      # Carrier portal (magic link auth)
-└── src/
-    ├── components/   # React components (shadcn/ui in ui/)
-    ├── hooks/        # useBookings, useNotifications
-    ├── lib/api/      # API client modules
-    └── types/        # TypeScript definitions
+backend/
+├── src/
+│   ├── domain/                    # Pure business logic (NO external dependencies)
+│   │   ├── entities/
+│   │   │   ├── organization.entity.ts
+│   │   │   ├── user.entity.ts
+│   │   │   ├── rate-quote.entity.ts
+│   │   │   ├── booking.entity.ts
+│   │   │   ├── container.entity.ts
+│   │   │   ├── carrier.entity.ts
+│   │   │   └── index.ts
+│   │   ├── value-objects/
+│   │   │   ├── email.vo.ts
+│   │   │   ├── booking-number.vo.ts
+│   │   │   ├── port-code.vo.ts
+│   │   │   └── index.ts
+│   │   ├── services/
+│   │   │   ├── rate-search.service.ts
+│   │   │   ├── booking.service.ts
+│   │   │   ├── user.service.ts
+│   │   │   └── index.ts
+│   │   ├── ports/
+│   │   │   ├── in/                # API Ports (use cases)
+│   │   │   │   ├── search-rates.port.ts
+│   │   │   │   ├── create-booking.port.ts
+│   │   │   │   ├── manage-user.port.ts
+│   │   │   │   └── index.ts
+│   │   │   └── out/               # SPI Ports (infrastructure interfaces)
+│   │   │       ├── rate-quote.repository.ts
+│   │   │       ├── booking.repository.ts
+│   │   │       ├── user.repository.ts
+│   │   │       ├── carrier-connector.port.ts
+│   │   │       ├── cache.port.ts
+│   │   │       ├── email.port.ts
+│   │   │       └── index.ts
+│   │   └── exceptions/
+│   │       ├── booking-not-found.exception.ts
+│   │       ├── invalid-rate-quote.exception.ts
+│   │       ├── carrier-timeout.exception.ts
+│   │       └── index.ts
+│   │
+│   ├── application/               # Controllers and DTOs (depends ONLY on domain)
+│   │   ├── controllers/
+│   │   │   ├── rates.controller.ts
+│   │   │   ├── bookings.controller.ts
+│   │   │   ├── auth.controller.ts
+│   │   │   └── index.ts
+│   │   ├── dto/
+│   │   │   ├── rate-search.dto.ts
+│   │   │   ├── create-booking.dto.ts
+│   │   │   ├── booking-response.dto.ts
+│   │   │   └── index.ts
+│   │   ├── mappers/
+│   │   │   ├── rate-quote.mapper.ts
+│   │   │   ├── booking.mapper.ts
+│   │   │   └── index.ts
+│   │   └── config/
+│   │       ├── validation.config.ts
+│   │       └── swagger.config.ts
+│   │
+│   ├── infrastructure/            # All external integrations (depends ONLY on domain)
+│   │   ├── persistence/
+│   │   │   ├── typeorm/
+│   │   │   │   ├── entities/
+│   │   │   │   │   ├── organization.orm-entity.ts
+│   │   │   │   │   ├── user.orm-entity.ts
+│   │   │   │   │   ├── booking.orm-entity.ts
+│   │   │   │   │   └── index.ts
+│   │   │   │   ├── repositories/
+│   │   │   │   │   ├── typeorm-booking.repository.ts
+│   │   │   │   │   ├── typeorm-user.repository.ts
+│   │   │   │   │   └── index.ts
+│   │   │   │   └── mappers/
+│   │   │   │       ├── booking-orm.mapper.ts
+│   │   │   │       └── index.ts
+│   │   │   └── database.module.ts
+│   │   ├── cache/
+│   │   │   ├── redis-cache.adapter.ts
+│   │   │   └── cache.module.ts
+│   │   ├── carriers/
+│   │   │   ├── maersk/
+│   │   │   │   ├── maersk.connector.ts
+│   │   │   │   ├── maersk.mapper.ts
+│   │   │   │   └── maersk.types.ts
+│   │   │   ├── msc/
+│   │   │   ├── cma-cgm/
+│   │   │   └── carrier.module.ts
+│   │   ├── email/
+│   │   │   ├── mjml-email.adapter.ts
+│   │   │   └── email.module.ts
+│   │   ├── storage/
+│   │   │   ├── s3-storage.adapter.ts
+│   │   │   └── storage.module.ts
+│   │   └── config/
+│   │       ├── database.config.ts
+│   │       ├── redis.config.ts
+│   │       └── jwt.config.ts
+│   │
+│   ├── main.ts                    # Application entry point
+│   └── app.module.ts              # Root module (NestJS)
+│
+├── test/
+│   ├── unit/
+│   ├── integration/
+│   └── e2e/
+│
+├── package.json
+├── tsconfig.json
+├── jest.config.js
+└── .env.example
 ```
 
-Path aliases: `@/*` → `./src/*`, `@/components/*`, `@/lib/*`, `@/hooks/*`
+### Port Definitions
 
-## Key Patterns
+**API Ports (domain/ports/in/)** - Exposed by domain:
+- `SearchRatesPort`: Interface for searching shipping rates
+- `CreateBookingPort`: Interface for creating bookings
+- `ManageUserPort`: Interface for user management
+- `AuthenticatePort`: Interface for authentication flows
 
-### Entity Pattern (Domain)
-```typescript
-export class Booking {
-  private readonly props: BookingProps;
-  static create(props: Omit<BookingProps, 'bookingNumber'>): Booking { ... }
-  updateStatus(newStatus: BookingStatus): Booking { // Returns new instance
-    return new Booking({ ...this.props, status: newStatus });
+**SPI Ports (domain/ports/out/)** - Required by domain:
+- `RateQuoteRepository`: Persistence interface for rate quotes
+- `BookingRepository`: Persistence interface for bookings
+- `UserRepository`: Persistence interface for users
+- `CarrierConnectorPort`: Interface for carrier API integrations
+- `CachePort`: Interface for caching (Redis)
+- `EmailPort`: Interface for sending emails
+- `StoragePort`: Interface for S3 document storage
+
+### Adapter Design
+
+**Driving Adapters (Input)**:
+- REST controllers (NestJS @Controller)
+- GraphQL resolvers (future)
+- CLI commands (future)
+
+**Driven Adapters (Output)**:
+- TypeORM repositories implementing repository ports
+- Carrier connectors (Maersk, MSC, etc.) implementing CarrierConnectorPort
+- Redis adapter implementing CachePort
+- MJML email adapter implementing EmailPort
+- S3 adapter implementing StoragePort
+
+## Phase 3: Layer Architecture
+
+### Domain Layer Rules
+- **Zero external dependencies**: No NestJS, TypeORM, Redis, etc.
+- **Pure TypeScript**: Only type definitions and business logic
+- **Self-contained**: Must compile independently
+- **Test without framework**: Jest only, no NestJS testing utilities
+
+### Application Layer Rules
+- **Depends only on domain**: Import from `@domain/*` only
+- **Exposes REST API**: Controllers validate input and delegate to domain services
+- **DTO mapping**: Transform external DTOs to domain entities
+- **No business logic**: Controllers are thin, logic stays in domain
+
+### Infrastructure Layer Rules
+- **Implements SPI ports**: All repository and service interfaces
+- **Framework dependencies**: TypeORM, Redis, AWS SDK, etc.
+- **Maps external data**: ORM entities ↔ Domain entities
+- **Circuit breakers**: Carrier connectors must implement retry/fallback logic
+
+## Phase 4: Technical Validation
+
+### Dependency Management
+
+**domain/package.json** (if separate):
+```json
+{
+  "dependencies": {},  // NO runtime dependencies
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "@types/node": "^20.0.0"
   }
 }
 ```
 
-### Repository Pattern
-- Interface in `domain/ports/out/booking.repository.ts`
-- Implementation in `infrastructure/persistence/typeorm/repositories/typeorm-booking.repository.ts`
-- Separate mappers for Domain ↔ ORM entity conversions
+**Root package.json**:
+```json
+{
+  "dependencies": {
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/swagger": "^7.0.0",
+    "typeorm": "^0.3.17",
+    "pg": "^8.11.0",
+    "redis": "^4.6.0",
+    "class-validator": "^0.14.0",
+    "class-transformer": "^0.5.1"
+  }
+}
+```
 
-### Circuit Breaker (External APIs)
-- Library: `opossum`, Timeout: 5s
-- Used for carrier API calls (Maersk, MSC, CMA CGM)
+### tsconfig.json Path Aliases
+```json
+{
+  "compilerOptions": {
+    "strict": true,
+    "baseUrl": "./src",
+    "paths": {
+      "@domain/*": ["domain/*"],
+      "@application/*": ["application/*"],
+      "@infrastructure/*": ["infrastructure/*"]
+    }
+  }
+}
+```
 
-### Caching
-- Redis with 15-min TTL for rate quotes
-- Cache key format: `rate:{origin}:{destination}:{containerType}`
+### Design Patterns
+- **Domain-Driven Design**: Entities, Value Objects, Aggregates
+- **SOLID Principles**: Especially DIP (Dependency Inversion)
+- **Repository Pattern**: Abstraction over data persistence
+- **Strategy Pattern**: Carrier connectors (Maersk, MSC, etc.)
+- **Circuit Breaker**: For carrier API calls (5s timeout)
 
-## Business Rules
+### NestJS Configuration
+- Use `@Injectable()` in application and infrastructure layers ONLY
+- Domain services registered manually via `@Module` providers
+- Avoid `@Component` or decorators in domain layer
+- Use interceptors for transactions (`@Transactional`)
 
-- Booking number format: `WCM-YYYY-XXXXXX`
-- Rate quotes expire after 15 minutes
-- Multi-currency: USD, EUR
-- RBAC Roles: ADMIN, MANAGER, USER, VIEWER, CARRIER
+## Phase 5: Testing Strategy
 
-### Carrier Portal Workflow
-1. Admin creates CSV booking → assigns carrier
-2. Email with magic link sent (1-hour expiry)
-3. Carrier auto-login → accept/reject booking
-4. Activity logged in `carrier_activities` table
+### Unit Tests (Domain)
+```typescript
+// domain/services/booking.service.spec.ts
+describe('BookingService', () => {
+  it('should create booking with valid rate quote', () => {
+    // Test without any framework dependencies
+    const service = new BookingService(mockRepository);
+    const result = service.createBooking(validInput);
+    expect(result.bookingNumber).toMatch(/^WCM-\d{4}-[A-Z0-9]{6}$/);
+  });
+});
+```
 
-## Tech Stack
+### Integration Tests (Infrastructure)
+```typescript
+// infrastructure/persistence/typeorm/repositories/booking.repository.spec.ts
+describe('TypeOrmBookingRepository', () => {
+  let repository: TypeOrmBookingRepository;
 
-**Backend**: NestJS 10, TypeORM 0.3, PostgreSQL 15, Redis 7, Argon2, Pino, Sentry
-**Frontend**: Next.js 14, React 18, TanStack Query/Table, React Hook Form + Zod, Tailwind + shadcn/ui, Socket.IO
+  beforeAll(async () => {
+    // Use testcontainers for real PostgreSQL
+    await setupTestDatabase();
+  });
 
-## Common Pitfalls
+  it('should persist booking to database', async () => {
+    const booking = createTestBooking();
+    await repository.save(booking);
+    const found = await repository.findById(booking.id);
+    expect(found).toBeDefined();
+  });
+});
+```
 
-- Never import NestJS/TypeORM in domain layer
-- Never use `any` type (strict mode enabled)
-- Never use `DATABASE_SYNC=true` in production
-- Never modify applied migrations - create new ones
-- Always validate DTOs with `class-validator`
-- Always create mappers for Domain ↔ ORM conversions
+### E2E Tests (Full API)
+```typescript
+// test/e2e/booking-workflow.e2e-spec.ts
+describe('Booking Workflow (E2E)', () => {
+  it('should complete full booking flow', async () => {
+    // 1. Search rates
+    const ratesResponse = await request(app.getHttpServer())
+      .post('/api/v1/rates/search')
+      .send(searchPayload);
 
-## Adding a New Feature
+    // 2. Create booking
+    const bookingResponse = await request(app.getHttpServer())
+      .post('/api/v1/bookings')
+      .send(bookingPayload);
 
-1. **Domain Entity** → `domain/entities/*.entity.ts` (pure TS, unit tests)
-2. **Value Objects** → `domain/value-objects/*.vo.ts` (immutable)
-3. **Port Interface** → `domain/ports/out/*.repository.ts`
-4. **ORM Entity** → `infrastructure/persistence/typeorm/entities/*.orm-entity.ts`
-5. **Generate Migration** → `npm run migration:generate -- ...`
-6. **Repository Impl** → `infrastructure/persistence/typeorm/repositories/`
-7. **DTOs** → `application/dto/` (with class-validator decorators)
-8. **Controller** → `application/controllers/` (with Swagger decorators)
-9. **Module** → Register and import in `app.module.ts`
+    // 3. Verify booking confirmation email sent
+    expect(bookingResponse.status).toBe(201);
+    expect(emailSpy).toHaveBeenCalled();
+  });
+});
+```
 
-## Documentation
+### Test Coverage Targets
+- **Domain**: 90%+ coverage
+- **Application**: 80%+ coverage
+- **Infrastructure**: 70%+ coverage (focus on critical paths)
 
-- API Docs: http://localhost:4000/api/docs (Swagger)
-- Architecture: `docs/architecture.md`
-- Carrier Portal API: `apps/backend/docs/CARRIER_PORTAL_API.md`
-- Full docs index: `docs/README.md`
+## Phase 6: Naming Conventions
+
+### TypeScript Conventions
+- **Interfaces**: `UserRepository` (no "I" prefix)
+- **Ports**: `SearchRatesPort`, `CarrierConnectorPort`
+- **Adapters**: `TypeOrmBookingRepository`, `MaerskConnectorAdapter`
+- **Services**: `BookingService`, `RateSearchService`
+- **Entities**: `Booking`, `RateQuote`, `Organization`
+- **Value Objects**: `BookingNumber`, `Email`, `PortCode`
+- **DTOs**: `CreateBookingDto`, `RateSearchRequestDto`
+
+### File Naming
+- **Entities**: `booking.entity.ts`
+- **Interfaces**: `booking.repository.ts` (for ports)
+- **Implementations**: `typeorm-booking.repository.ts`
+- **Tests**: `booking.service.spec.ts`
+- **Barrel exports**: `index.ts`
+
+### Import Order
+```typescript
+// 1. External dependencies
+import { Injectable } from '@nestjs/common';
+
+// 2. Domain imports
+import { Booking } from '@domain/entities';
+import { BookingRepository } from '@domain/ports/out';
+
+// 3. Relative imports
+import { BookingOrmEntity } from './entities/booking.orm-entity';
+```
+
+## Phase 7: Validation Checklist
+
+### Critical Questions
+- ✅ **Domain isolation**: No `import` of NestJS/TypeORM in domain layer?
+- ✅ **Dependency direction**: All dependencies point inward toward domain?
+- ✅ **Framework-free testing**: Can domain be tested without NestJS TestingModule?
+- ✅ **Database agnostic**: Could we switch from TypeORM to Prisma without touching domain?
+- ✅ **Interface flexibility**: Could we add GraphQL without changing domain?
+- ✅ **Compilation independence**: Does domain compile without other layers?
+
+### Data Flow Validation
+- **Inbound**: HTTP Request → Controller → DTO → Mapper → Domain Entity → Use Case
+- **Outbound**: Use Case → Repository Port → Adapter → ORM Entity → Database
+- **Carrier Integration**: Use Case → CarrierConnectorPort → MaerskAdapter → Maersk API
+
+## Phase 8: Pre-Coding Checklist
+
+### Setup Tasks
+- ✅ Node.js v20+ installed
+- ✅ TypeScript with `strict: true`
+- ✅ NestJS CLI installed globally
+- ✅ ESLint + Prettier configured
+- ✅ Husky pre-commit hooks
+- ✅ `.env.example` with all required variables
+
+### Architecture Validation
+- ✅ PRD reviewed and understood
+- ✅ Domain entities mapped to database schema
+- ✅ All ports (in/out) identified
+- ✅ Carrier connector strategy defined
+- ✅ Cache strategy documented (Redis, 15min TTL)
+- ✅ Test strategy approved
+
+### Development Order
+1. **Domain layer**: Entities → Value Objects → Services → Ports
+2. **Infrastructure layer**: TypeORM entities → Repositories → Carrier connectors → Cache/Email adapters
+3. **Application layer**: DTOs → Mappers → Controllers → Validation pipes
+4. **Bootstrap**: main.ts → app.module.ts → DI configuration
+5. **Tests**: Unit (domain) → Integration (repos) → E2E (API)
+
+## Common Pitfalls to Avoid
+
+⚠️ **Critical Mistakes**:
+- Circular imports (use barrel exports `index.ts`)
+- Framework decorators in domain (`@Column`, `@Injectable`)
+- Business logic in controllers or adapters
+- Using `any` type (always explicit types)
+- Promises not awaited (use `async/await` properly)
+- Carrier APIs without circuit breakers
+- Missing Redis cache for rate queries
+- Not validating DTOs with `class-validator`
+
+## Recommended Tools
+
+- **Validation**: `class-validator` + `class-transformer`
+- **Mapping**: Manual mappers (avoid heavy libraries)
+- **API Docs**: `@nestjs/swagger` (OpenAPI)
+- **Logging**: Winston or Pino
+- **Config**: `@nestjs/config` with Joi validation
+- **Testing**: Jest + Supertest + @faker-js/faker
+- **Circuit Breaker**: `opossum` library
+- **Redis**: `ioredis`
+- **Email**: `mjml` + `nodemailer`
+
+## Example: Complete Feature Flow
+
+### Scenario: Search Rates for Rotterdam → Shanghai
+
+```typescript
+// 1. Controller (application layer)
+@Controller('api/v1/rates')
+export class RatesController {
+  constructor(private readonly searchRatesUseCase: SearchRatesPort) {}
+
+  @Post('search')
+  async searchRates(@Body() dto: RateSearchDto) {
+    const domainInput = RateSearchMapper.toDomain(dto);
+    const quotes = await this.searchRatesUseCase.execute(domainInput);
+    return RateSearchMapper.toDto(quotes);
+  }
+}
+
+// 2. Use Case (domain port in)
+export interface SearchRatesPort {
+  execute(input: RateSearchInput): Promise<RateQuote[]>;
+}
+
+// 3. Domain Service (domain layer)
+export class RateSearchService implements SearchRatesPort {
+  constructor(
+    private readonly cache: CachePort,
+    private readonly carriers: CarrierConnectorPort[]
+  ) {}
+
+  async execute(input: RateSearchInput): Promise<RateQuote[]> {
+    // Check cache first
+    const cached = await this.cache.get(input.cacheKey);
+    if (cached) return cached;
+
+    // Query carriers in parallel with timeout
+    const results = await Promise.allSettled(
+      this.carriers.map(c => c.searchRates(input))
+    );
+
+    // Filter successful results
+    const quotes = results
+      .filter(r => r.status === 'fulfilled')
+      .flatMap(r => r.value);
+
+    // Cache results (15 min TTL)
+    await this.cache.set(input.cacheKey, quotes, 900);
+
+    return quotes;
+  }
+}
+
+// 4. Infrastructure Adapter (infrastructure layer)
+export class MaerskConnectorAdapter implements CarrierConnectorPort {
+  async searchRates(input: RateSearchInput): Promise<RateQuote[]> {
+    // HTTP call to Maersk API with 5s timeout
+    const response = await this.httpClient.post(
+      'https://api.maersk.com/rates',
+      this.mapToMaerskFormat(input),
+      { timeout: 5000 }
+    );
+
+    // Map Maersk response to domain entities
+    return this.mapToDomainQuotes(response.data);
+  }
+}
+```
+
+This architecture ensures clean separation, testability, and flexibility for the Xpeditis maritime freight platform.

apps/backend/.dockerignore

@@ -1,85 +0,0 @@
-# Dependencies
-node_modules
-npm-debug.log
-yarn-error.log
-package-lock.json
-yarn.lock
-pnpm-lock.yaml
-
-# Build output
-dist
-build
-.next
-out
-
-# Tests
-coverage
-.nyc_output
-*.spec.ts
-*.test.ts
-**/__tests__
-**/__mocks__
-test
-tests
-e2e
-
-# Environment files
-.env
-.env.local
-.env.development
-.env.test
-.env.production
-.env.*.local
-
-# IDE
-.vscode
-.idea
-*.swp
-*.swo
-*.swn
-.DS_Store
-
-# Git
-.git
-.gitignore
-.gitattributes
-.github
-
-# Documentation
-*.md
-docs
-documentation
-
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-lerna-debug.log*
-.pnpm-debug.log*
-
-# Temporary files
-tmp
-temp
-*.tmp
-*.bak
-*.cache
-
-# Docker
-Dockerfile
-.dockerignore
-docker-compose.yaml
-
-# CI/CD
-.gitlab-ci.yml
-.travis.yml
-Jenkinsfile
-azure-pipelines.yml
-
-# Other
-.prettierrc
-.prettierignore
-.eslintrc.js
-.eslintignore
-tsconfig.build.tsbuildinfo

apps/backend/.env.example

@@ -33,46 +33,26 @@ MICROSOFT_CLIENT_ID=your-microsoft-client-id
 MICROSOFT_CLIENT_SECRET=your-microsoft-client-secret
 MICROSOFT_CALLBACK_URL=http://localhost:4000/api/v1/auth/microsoft/callback
 
-# Application URL
-APP_URL=http://localhost:3000
+# Email
+EMAIL_HOST=smtp.sendgrid.net
+EMAIL_PORT=587
+EMAIL_USER=apikey
+EMAIL_PASSWORD=your-sendgrid-api-key
+EMAIL_FROM=noreply@xpeditis.com
 
-# Email (SMTP)
-SMTP_HOST=smtp.sendgrid.net
-SMTP_PORT=587
-SMTP_SECURE=false
-SMTP_USER=apikey
-SMTP_PASS=your-sendgrid-api-key
-SMTP_FROM=noreply@xpeditis.com
-
-# AWS S3 / Storage (or MinIO for development)
+# AWS S3 / Storage
 AWS_ACCESS_KEY_ID=your-aws-access-key
 AWS_SECRET_ACCESS_KEY=your-aws-secret-key
 AWS_REGION=us-east-1
-AWS_S3_ENDPOINT=http://localhost:9000
-# AWS_S3_ENDPOINT=  # Leave empty for AWS S3
+AWS_S3_BUCKET=xpeditis-documents
 
 # Carrier APIs
-# Maersk
 MAERSK_API_KEY=your-maersk-api-key
-MAERSK_API_URL=https://api.maersk.com/v1
-
-# MSC
+MAERSK_API_URL=https://api.maersk.com
 MSC_API_KEY=your-msc-api-key
-MSC_API_URL=https://api.msc.com/v1
-
-# CMA CGM
-CMACGM_API_URL=https://api.cma-cgm.com/v1
-CMACGM_CLIENT_ID=your-cmacgm-client-id
-CMACGM_CLIENT_SECRET=your-cmacgm-client-secret
-
-# Hapag-Lloyd
-HAPAG_API_URL=https://api.hapag-lloyd.com/v1
-HAPAG_API_KEY=your-hapag-api-key
-
-# ONE (Ocean Network Express)
-ONE_API_URL=https://api.one-line.com/v1
-ONE_USERNAME=your-one-username
-ONE_PASSWORD=your-one-password
+MSC_API_URL=https://api.msc.com
+CMA_CGM_API_KEY=your-cma-cgm-api-key
+CMA_CGM_API_URL=https://api.cma-cgm.com
 
 # Security
 BCRYPT_ROUNDS=12
@@ -84,18 +64,3 @@ RATE_LIMIT_MAX=100
 
 # Monitoring
 SENTRY_DSN=your-sentry-dsn
-
-# Frontend URL (for redirects)
-FRONTEND_URL=http://localhost:3000
-
-# Stripe (Subscriptions & Payments)
-STRIPE_SECRET_KEY=sk_test_your_stripe_secret_key
-STRIPE_WEBHOOK_SECRET=whsec_your_webhook_secret
-
-# Stripe Price IDs (create these in Stripe Dashboard)
-STRIPE_STARTER_MONTHLY_PRICE_ID=price_starter_monthly
-STRIPE_STARTER_YEARLY_PRICE_ID=price_starter_yearly
-STRIPE_PRO_MONTHLY_PRICE_ID=price_pro_monthly
-STRIPE_PRO_YEARLY_PRICE_ID=price_pro_yearly
-STRIPE_ENTERPRISE_MONTHLY_PRICE_ID=price_enterprise_monthly
-STRIPE_ENTERPRISE_YEARLY_PRICE_ID=price_enterprise_yearly

apps/backend/.eslintrc.js

@@ -1,33 +1,25 @@
 module.exports = {
   parser: '@typescript-eslint/parser',
   parserOptions: {
-    project: ['tsconfig.json', 'tsconfig.test.json'],
+    project: 'tsconfig.json',
     tsconfigRootDir: __dirname,
     sourceType: 'module',
   },
-  plugins: ['@typescript-eslint/eslint-plugin', 'unused-imports'],
-  extends: ['plugin:@typescript-eslint/recommended', 'plugin:prettier/recommended'],
+  plugins: ['@typescript-eslint/eslint-plugin'],
+  extends: [
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended',
+  ],
   root: true,
   env: {
     node: true,
     jest: true,
   },
-  ignorePatterns: ['.eslintrc.js', 'dist/**', 'node_modules/**', 'apps/**'],
+  ignorePatterns: ['.eslintrc.js'],
   rules: {
     '@typescript-eslint/interface-name-prefix': 'off',
     '@typescript-eslint/explicit-function-return-type': 'off',
     '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'off', // Désactivé pour projet existant en production
-    '@typescript-eslint/no-unused-vars': 'off', // Désactivé car remplacé par unused-imports
-    'unused-imports/no-unused-imports': 'error',
-    'unused-imports/no-unused-vars': [
-      'warn',
-      {
-        argsIgnorePattern: '^_',
-        varsIgnorePattern: '^_',
-        caughtErrorsIgnorePattern: '^_',
-        ignoreRestSiblings: true,
-      },
-    ],
+    '@typescript-eslint/no-explicit-any': 'warn',
   },
 };

apps/backend/CARRIER_ACCEPT_REJECT_FIX.md

@@ -1,328 +0,0 @@
-# ✅ FIX: Redirection Transporteur après Accept/Reject
-
-**Date**: 5 décembre 2025
-**Statut**: ✅ **CORRIGÉ ET TESTÉ**
-
----
-
-## 🎯 Problème Identifié
-
-**Symptôme**: Quand un transporteur clique sur "Accepter" ou "Refuser" dans l'email:
-- ❌ Pas de redirection vers le dashboard transporteur
-- ❌ Le status du booking ne change pas
-- ❌ Erreur 404 ou pas de réponse
-
-**URL problématique**:
-```
-http://localhost:3000/api/v1/csv-bookings/{token}/accept
-```
-
-**Cause Racine**: Les URLs dans l'email pointaient vers le **frontend** (port 3000) au lieu du **backend** (port 4000).
-
----
-
-## 🔍 Analyse du Problème
-
-### Ce qui se passait AVANT (❌ Cassé)
-
-1. **Email envoyé** avec URL: `http://localhost:3000/api/v1/csv-bookings/{token}/accept`
-2. **Transporteur clique** sur le lien
-3. **Frontend** (port 3000) reçoit la requête
-4. **Erreur 404** car `/api/v1/*` n'existe pas sur le frontend
-5. **Aucune redirection**, aucun traitement
-
-### Workflow Attendu (✅ Correct)
-
-1. **Email envoyé** avec URL: `http://localhost:4000/api/v1/csv-bookings/{token}/accept`
-2. **Transporteur clique** sur le lien
-3. **Backend** (port 4000) reçoit la requête
-4. **Backend traite**:
-   - Accepte le booking
-   - Crée un compte transporteur si nécessaire
-   - Génère un token d'auto-login
-5. **Backend redirige** vers: `http://localhost:3000/carrier/confirmed?token={autoLoginToken}&action=accepted&bookingId={id}&new={isNew}`
-6. **Frontend** affiche la page de confirmation
-7. **Transporteur** est auto-connecté et voit son dashboard
-
----
-
-## ✅ Correction Appliquée
-
-### Fichier 1: `email.adapter.ts` (lignes 259-264)
-
-**AVANT** (❌):
-```typescript
-const baseUrl = this.configService.get('APP_URL', 'http://localhost:3000'); // Frontend!
-const acceptUrl = `${baseUrl}/api/v1/csv-bookings/${bookingData.confirmationToken}/accept`;
-const rejectUrl = `${baseUrl}/api/v1/csv-bookings/${bookingData.confirmationToken}/reject`;
-```
-
-**APRÈS** (✅):
-```typescript
-// Use BACKEND_URL if available, otherwise construct from PORT
-// The accept/reject endpoints are on the BACKEND, not the frontend
-const port = this.configService.get('PORT', '4000');
-const backendUrl = this.configService.get('BACKEND_URL', `http://localhost:${port}`);
-const acceptUrl = `${backendUrl}/api/v1/csv-bookings/${bookingData.confirmationToken}/accept`;
-const rejectUrl = `${backendUrl}/api/v1/csv-bookings/${bookingData.confirmationToken}/reject`;
-```
-
-**Changements**:
-- ✅ Utilise `BACKEND_URL` ou construit à partir de `PORT`
-- ✅ URLs pointent maintenant vers `http://localhost:4000/api/v1/...`
-- ✅ Commentaires ajoutés pour clarifier
-
-### Fichier 2: `app.module.ts` (lignes 39-40)
-
-Ajout des variables `APP_URL` et `BACKEND_URL` au schéma de validation:
-
-```typescript
-validationSchema: Joi.object({
-  // ...
-  APP_URL: Joi.string().uri().default('http://localhost:3000'),
-  BACKEND_URL: Joi.string().uri().optional(),
-  // ...
-}),
-```
-
-**Pourquoi**: Pour éviter que ces variables soient supprimées par la validation Joi.
-
----
-
-## 🧪 Test du Workflow Complet
-
-### Prérequis
-
-- ✅ Backend en cours d'exécution (port 4000)
-- ✅ Frontend en cours d'exécution (port 3000)
-- ✅ MinIO en cours d'exécution
-- ✅ Email adapter initialisé
-
-### Étape 1: Créer un Booking CSV
-
-1. **Se connecter** au frontend: http://localhost:3000
-2. **Aller sur** la page de recherche avancée
-3. **Rechercher un tarif** et cliquer sur "Réserver"
-4. **Remplir le formulaire**:
-   - Carrier email: Votre email de test (ou Mailtrap)
-   - Ajouter au moins 1 document
-5. **Cliquer sur "Envoyer la demande"**
-
-### Étape 2: Vérifier l'Email Reçu
-
-1. **Ouvrir Mailtrap**: https://mailtrap.io/inboxes
-2. **Trouver l'email**: "Nouvelle demande de réservation - {origin} → {destination}"
-3. **Vérifier les URLs** des boutons:
-   - ✅ Accepter: `http://localhost:4000/api/v1/csv-bookings/{token}/accept`
-   - ✅ Refuser: `http://localhost:4000/api/v1/csv-bookings/{token}/reject`
-
-**IMPORTANT**: Les URLs doivent pointer vers **port 4000** (backend), PAS port 3000!
-
-### Étape 3: Tester l'Acceptation
-
-1. **Copier l'URL** du bouton "Accepter" depuis l'email
-2. **Ouvrir dans le navigateur** (ou cliquer sur le bouton)
-3. **Observer**:
-   - ✅ Le navigateur va d'abord vers `localhost:4000`
-   - ✅ Puis redirige automatiquement vers `localhost:3000/carrier/confirmed?...`
-   - ✅ Page de confirmation affichée
-   - ✅ Transporteur auto-connecté
-
-### Étape 4: Vérifier le Dashboard Transporteur
-
-Après la redirection:
-
-1. **URL attendue**:
-   ```
-   http://localhost:3000/carrier/confirmed?token={autoLoginToken}&action=accepted&bookingId={id}&new=true
-   ```
-
-2. **Page affichée**:
-   - ✅ Message de confirmation: "Réservation acceptée avec succès!"
-   - ✅ Lien vers le dashboard transporteur
-   - ✅ Si nouveau compte: Message avec credentials
-
-3. **Vérifier le status**:
-   - Le booking doit maintenant avoir le status `ACCEPTED`
-   - Visible dans le dashboard utilisateur (celui qui a créé le booking)
-
-### Étape 5: Tester le Rejet
-
-Répéter avec le bouton "Refuser":
-
-1. **Créer un nouveau booking** (étape 1)
-2. **Cliquer sur "Refuser"** dans l'email
-3. **Vérifier**:
-   - ✅ Redirection vers `/carrier/confirmed?...&action=rejected`
-   - ✅ Message: "Réservation refusée"
-   - ✅ Status du booking: `REJECTED`
-
----
-
-## 📊 Vérifications Backend
-
-### Logs Attendus lors de l'Acceptation
-
-```bash
-# Monitorer les logs
-tail -f /tmp/backend-restart.log | grep -i "accept\|carrier\|booking"
-```
-
-**Logs attendus**:
-```
-[CsvBookingService] Accepting booking with token: {token}
-[CarrierAuthService] Creating carrier account for email: carrier@test.com
-[CarrierAuthService] Carrier account created with ID: {carrierId}
-[CsvBookingService] Successfully linked booking {bookingId} to carrier {carrierId}
-```
-
----
-
-## 🔧 Variables d'Environnement
-
-### `.env` Backend
-
-**Variables requises**:
-```bash
-PORT=4000                                 # Port du backend
-APP_URL=http://localhost:3000            # URL du frontend
-BACKEND_URL=http://localhost:4000        # URL du backend (optionnel, auto-construit si absent)
-```
-
-**En production**:
-```bash
-PORT=4000
-APP_URL=https://xpeditis.com
-BACKEND_URL=https://api.xpeditis.com
-```
-
----
-
-## 🐛 Dépannage
-
-### Problème 1: Toujours redirigé vers port 3000
-
-**Cause**: Email envoyé AVANT la correction
-
-**Solution**:
-1. Backend a été redémarré après la correction ✅
-2. Créer un **NOUVEAU booking** pour recevoir un email avec les bonnes URLs
-3. Les anciens bookings ont encore les anciennes URLs (port 3000)
-
----
-
-### Problème 2: 404 Not Found sur /accept
-
-**Cause**: Backend pas démarré ou route mal configurée
-
-**Solution**:
-```bash
-# Vérifier que le backend tourne
-curl http://localhost:4000/api/v1/health || echo "Backend not responding"
-
-# Vérifier les logs backend
-tail -50 /tmp/backend-restart.log | grep -i "csv-bookings"
-
-# Redémarrer le backend
-cd apps/backend
-npm run dev
-```
-
----
-
-### Problème 3: Token Invalid
-
-**Cause**: Token expiré ou booking déjà accepté/refusé
-
-**Solution**:
-- Les bookings ne peuvent être acceptés/refusés qu'une seule fois
-- Si token invalide, créer un nouveau booking
-- Vérifier dans la base de données le status du booking
-
----
-
-### Problème 4: Pas de redirection vers /carrier/confirmed
-
-**Cause**: Frontend route manquante ou token d'auto-login invalide
-
-**Vérification**:
-1. Vérifier que la route `/carrier/confirmed` existe dans le frontend
-2. Vérifier les logs backend pour voir si le token est généré
-3. Vérifier que le frontend affiche bien la page
-
----
-
-## 📝 Checklist de Validation
-
-- [x] Backend redémarré avec la correction
-- [x] Email adapter initialisé correctement
-- [x] Variables `APP_URL` et `BACKEND_URL` dans le schéma Joi
-- [ ] Nouveau booking créé (APRÈS la correction)
-- [ ] Email reçu avec URLs correctes (port 4000)
-- [ ] Clic sur "Accepter" → Redirection vers /carrier/confirmed
-- [ ] Status du booking changé en `ACCEPTED`
-- [ ] Dashboard transporteur accessible
-- [ ] Test "Refuser" fonctionne aussi
-
----
-
-## 🎯 Résumé des Corrections
-
-| Aspect | Avant (❌) | Après (✅) |
-|--------|-----------|-----------|
-| **Email URL Accept** | `localhost:3000/api/v1/...` | `localhost:4000/api/v1/...` |
-| **Email URL Reject** | `localhost:3000/api/v1/...` | `localhost:4000/api/v1/...` |
-| **Redirection** | Aucune (404) | Vers `/carrier/confirmed` |
-| **Status booking** | Ne change pas | `ACCEPTED` ou `REJECTED` |
-| **Dashboard transporteur** | Inaccessible | Accessible avec auto-login |
-
----
-
-## ✅ Workflow Complet Corrigé
-
-```
-1. Utilisateur crée booking
-   └─> Backend sauvegarde booking (status: PENDING)
-   └─> Backend envoie email avec URLs backend (port 4000) ✅
-
-2. Transporteur clique "Accepter" dans email
-   └─> Ouvre: http://localhost:4000/api/v1/csv-bookings/{token}/accept ✅
-   └─> Backend traite la requête:
-       ├─> Change status → ACCEPTED ✅
-       ├─> Crée compte transporteur si nécessaire ✅
-       ├─> Génère token auto-login ✅
-       └─> Redirige vers frontend: localhost:3000/carrier/confirmed?... ✅
-
-3. Frontend affiche page confirmation
-   └─> Message de succès ✅
-   └─> Auto-login du transporteur ✅
-   └─> Lien vers dashboard ✅
-
-4. Transporteur accède à son dashboard
-   └─> Voir la liste de ses bookings ✅
-   └─> Gérer ses réservations ✅
-```
-
----
-
-## 🚀 Prochaines Étapes
-
-1. **Tester immédiatement**:
-   - Créer un nouveau booking (important: APRÈS le redémarrage)
-   - Vérifier l'email reçu
-   - Tester Accept/Reject
-
-2. **Vérifier en production**:
-   - Mettre à jour la variable `BACKEND_URL` dans le .env production
-   - Redéployer le backend
-   - Tester le workflow complet
-
-3. **Documentation**:
-   - Mettre à jour le guide utilisateur
-   - Documenter le workflow transporteur
-
----
-
-**Correction effectuée le 5 décembre 2025 par Claude Code** ✅
-
-_Le système d'acceptation/rejet transporteur est maintenant 100% fonctionnel!_ 🚢✨

apps/backend/CSV_BOOKING_DIAGNOSTIC.md

@@ -1,282 +0,0 @@
-# 🔍 Diagnostic Complet - Workflow CSV Booking
-
-**Date**: 5 décembre 2025
-**Problème**: Le workflow d'envoi de demande de booking ne fonctionne pas
-
----
-
-## ✅ Vérifications Effectuées
-
-### 1. Backend ✅
-- ✅ Backend en cours d'exécution (port 4000)
-- ✅ Configuration SMTP corrigée (variables ajoutées au schéma Joi)
-- ✅ Email adapter initialisé correctement avec DNS bypass
-- ✅ Module CsvBookingsModule importé dans app.module.ts
-- ✅ Controller CsvBookingsController bien configuré
-- ✅ Service CsvBookingService bien configuré
-- ✅ MinIO container en cours d'exécution
-- ✅ Bucket 'xpeditis-documents' existe dans MinIO
-
-### 2. Frontend ✅
-- ✅ Page `/dashboard/booking/new` existe
-- ✅ Fonction `handleSubmit` bien configurée
-- ✅ FormData correctement construit avec tous les champs
-- ✅ Documents ajoutés avec le nom 'documents' (pluriel)
-- ✅ Appel API via `createCsvBooking()` qui utilise `upload()`
-- ✅ Gestion d'erreurs présente (affiche message si échec)
-
----
-
-## 🔍 Points de Défaillance Possibles
-
-### Scénario 1: Erreur Frontend (Browser Console)
-**Symptômes**: Le bouton "Envoyer la demande" ne fait rien, ou affiche un message d'erreur
-
-**Vérification**:
-1. Ouvrir les DevTools du navigateur (F12)
-2. Aller dans l'onglet Console
-3. Cliquer sur "Envoyer la demande"
-4. Regarder les erreurs affichées
-
-**Erreurs Possibles**:
-- `Failed to fetch` → Problème de connexion au backend
-- `401 Unauthorized` → Token JWT expiré
-- `400 Bad Request` → Données invalides
-- `500 Internal Server Error` → Erreur backend (voir logs)
-
----
-
-### Scénario 2: Erreur Backend (Logs)
-**Symptômes**: La requête arrive au backend mais échoue
-
-**Vérification**:
-```bash
-# Voir les logs backend en temps réel
-tail -f /tmp/backend-startup.log
-
-# Puis créer un booking via le frontend
-```
-
-**Erreurs Possibles**:
-- **Pas de logs `=== CSV Booking Request Debug ===`** → La requête n'arrive pas au controller
-- **`At least one document is required`** → Aucun fichier uploadé
-- **`User authentication failed`** → Problème de JWT
-- **`Organization ID is required`** → User sans organizationId
-- **Erreur S3/MinIO** → Upload de fichiers échoué
-- **Erreur Email** → Envoi email échoué (ne devrait plus arriver après le fix)
-
----
-
-### Scénario 3: Validation Échouée
-**Symptômes**: Erreur 400 Bad Request
-
-**Causes Possibles**:
-- **Port codes invalides** (origin/destination): Doivent être exactement 5 caractères (ex: NLRTM, USNYC)
-- **Email invalide** (carrierEmail): Doit être un email valide
-- **Champs numériques** (volumeCBM, weightKG, etc.): Doivent être > 0
-- **Currency invalide**: Doit être 'USD' ou 'EUR'
-- **Pas de documents**: Au moins 1 fichier requis
-
----
-
-### Scénario 4: CORS ou Network
-**Symptômes**: Erreur CORS ou network error
-
-**Vérification**:
-1. Ouvrir DevTools → Network tab
-2. Créer un booking
-3. Regarder la requête POST vers `/api/v1/csv-bookings`
-4. Vérifier:
-   - Status code (200/201 = OK, 4xx/5xx = erreur)
-   - Response body (message d'erreur)
-   - Request headers (Authorization token présent?)
-
-**Solutions**:
-- Backend et frontend doivent tourner simultanément
-- Frontend: `http://localhost:3000`
-- Backend: `http://localhost:4000`
-
----
-
-## 🧪 Tests à Effectuer
-
-### Test 1: Vérifier que le Backend Reçoit la Requête
-
-1. **Ouvrir un terminal et monitorer les logs**:
-   ```bash
-   tail -f /tmp/backend-startup.log | grep -i "csv\|booking\|error"
-   ```
-
-2. **Dans le navigateur**:
-   - Aller sur: http://localhost:3000/dashboard/booking/new?rateData=%7B%22companyName%22%3A%22Test%20Carrier%22%2C%22companyEmail%22%3A%22carrier%40test.com%22%2C%22origin%22%3A%22NLRTM%22%2C%22destination%22%3A%22USNYC%22%2C%22containerType%22%3A%22LCL%22%2C%22priceUSD%22%3A1000%2C%22priceEUR%22%3A900%2C%22primaryCurrency%22%3A%22USD%22%2C%22transitDays%22%3A22%7D&volumeCBM=2.88&weightKG=1500&palletCount=3
-   - Ajouter au moins 1 document
-   - Cliquer sur "Envoyer la demande"
-
-3. **Dans les logs, vous devriez voir**:
-   ```
-   === CSV Booking Request Debug ===
-   req.user: { id: '...', organizationId: '...' }
-   req.body: { carrierName: 'Test Carrier', ... }
-   files: 1
-   ================================
-   Creating CSV booking for user ...
-   Uploaded 1 documents for booking ...
-   CSV booking created with ID: ...
-   Email sent to carrier: carrier@test.com
-   Notification created for user ...
-   ```
-
-4. **Si vous NE voyez PAS ces logs** → La requête n'arrive pas au backend. Vérifier:
-   - Frontend connecté et JWT valide
-   - Backend en cours d'exécution
-   - Network tab du navigateur pour voir l'erreur exacte
-
----
-
-### Test 2: Vérifier le Browser Console
-
-1. **Ouvrir DevTools** (F12)
-2. **Aller dans Console**
-3. **Créer un booking**
-4. **Regarder les erreurs**:
-   - Si erreur affichée → noter le message exact
-   - Si aucune erreur → le problème est silencieux (voir Network tab)
-
----
-
-### Test 3: Vérifier Network Tab
-
-1. **Ouvrir DevTools** (F12)
-2. **Aller dans Network**
-3. **Créer un booking**
-4. **Trouver la requête** `POST /api/v1/csv-bookings`
-5. **Vérifier**:
-   - Status: Doit être 200 ou 201
-   - Request Payload: Tous les champs présents?
-   - Response: Message d'erreur?
-
----
-
-## 🔧 Solutions par Erreur
-
-### Erreur: "At least one document is required"
-**Cause**: Aucun fichier n'a été uploadé
-
-**Solution**:
-- Vérifier que vous avez bien sélectionné au moins 1 fichier
-- Vérifier que le fichier est dans les formats acceptés (PDF, DOC, DOCX, JPG, PNG)
-- Vérifier que le fichier fait moins de 5MB
-
----
-
-### Erreur: "User authentication failed"
-**Cause**: Token JWT invalide ou expiré
-
-**Solution**:
-1. Se déconnecter
-2. Se reconnecter
-3. Réessayer
-
----
-
-### Erreur: "Organization ID is required"
-**Cause**: L'utilisateur n'a pas d'organizationId
-
-**Solution**:
-1. Vérifier dans la base de données que l'utilisateur a bien un `organizationId`
-2. Si non, assigner une organization à l'utilisateur
-
----
-
-### Erreur: S3/MinIO Upload Failed
-**Cause**: Impossible d'uploader vers MinIO
-
-**Solution**:
-```bash
-# Vérifier que MinIO tourne
-docker ps | grep minio
-
-# Si non, le démarrer
-docker-compose up -d
-
-# Vérifier que le bucket existe
-cd apps/backend
-node setup-minio-bucket.js
-```
-
----
-
-### Erreur: Email Failed (ne devrait plus arriver)
-**Cause**: Envoi email échoué
-
-**Solution**:
-- Vérifier que les variables SMTP sont dans le schéma Joi (déjà corrigé ✅)
-- Tester l'envoi d'email: `node test-smtp-simple.js`
-
----
-
-## 📊 Checklist de Diagnostic
-
-Cocher au fur et à mesure:
-
-- [ ] Backend en cours d'exécution (port 4000)
-- [ ] Frontend en cours d'exécution (port 3000)
-- [ ] MinIO en cours d'exécution (port 9000)
-- [ ] Bucket 'xpeditis-documents' existe
-- [ ] Variables SMTP configurées
-- [ ] Email adapter initialisé (logs backend)
-- [ ] Utilisateur connecté au frontend
-- [ ] Token JWT valide (pas expiré)
-- [ ] Browser console sans erreurs
-- [ ] Network tab montre requête POST envoyée
-- [ ] Logs backend montrent "CSV Booking Request Debug"
-- [ ] Documents uploadés (au moins 1)
-- [ ] Port codes valides (5 caractères exactement)
-- [ ] Email transporteur valide
-
----
-
-## 🚀 Commandes Utiles
-
-```bash
-# Redémarrer backend
-cd apps/backend
-npm run dev
-
-# Vérifier logs backend
-tail -f /tmp/backend-startup.log | grep -i "csv\|booking\|error"
-
-# Tester email
-cd apps/backend
-node test-smtp-simple.js
-
-# Vérifier MinIO
-docker ps | grep minio
-node setup-minio-bucket.js
-
-# Voir tous les endpoints
-curl http://localhost:4000/api/docs
-```
-
----
-
-## 📝 Prochaines Étapes
-
-1. **Effectuer les tests** ci-dessus dans l'ordre
-2. **Noter l'erreur exacte** qui apparaît (console, network, logs)
-3. **Appliquer la solution** correspondante
-4. **Réessayer**
-
-Si après tous ces tests le problème persiste, partager:
-- Le message d'erreur exact (browser console)
-- Les logs backend au moment de l'erreur
-- Le status code HTTP de la requête (network tab)
-
----
-
-**Dernière mise à jour**: 5 décembre 2025
-**Statut**:
-- ✅ Email fix appliqué
-- ✅ MinIO bucket vérifié
-- ✅ Code analysé
-- ⏳ En attente de tests utilisateur

apps/backend/DATABASE-SCHEMA.md

@@ -1,342 +0,0 @@
-# Database Schema - Xpeditis
-
-## Overview
-
-PostgreSQL 15 database schema for the Xpeditis maritime freight booking platform.
-
-**Extensions Required**:
-- `uuid-ossp` - UUID generation
-- `pg_trgm` - Trigram fuzzy search for ports
-
----
-
-## Tables
-
-### 1. organizations
-
-**Purpose**: Store business organizations (freight forwarders, carriers, shippers)
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | UUID | PRIMARY KEY | Organization ID |
-| name | VARCHAR(255) | NOT NULL, UNIQUE | Organization name |
-| type | VARCHAR(50) | NOT NULL | FREIGHT_FORWARDER, CARRIER, SHIPPER |
-| scac | CHAR(4) | UNIQUE, NULLABLE | Standard Carrier Alpha Code (carriers only) |
-| address_street | VARCHAR(255) | NOT NULL | Street address |
-| address_city | VARCHAR(100) | NOT NULL | City |
-| address_state | VARCHAR(100) | NULLABLE | State/Province |
-| address_postal_code | VARCHAR(20) | NOT NULL | Postal code |
-| address_country | CHAR(2) | NOT NULL | ISO 3166-1 alpha-2 country code |
-| logo_url | TEXT | NULLABLE | Logo URL |
-| documents | JSONB | DEFAULT '[]' | Array of document metadata |
-| is_active | BOOLEAN | DEFAULT TRUE | Active status |
-| created_at | TIMESTAMP | DEFAULT NOW() | Creation timestamp |
-| updated_at | TIMESTAMP | DEFAULT NOW() | Last update timestamp |
-
-**Indexes**:
-- `idx_organizations_type` on (type)
-- `idx_organizations_scac` on (scac)
-- `idx_organizations_active` on (is_active)
-
-**Business Rules**:
-- SCAC must be 4 uppercase letters
-- SCAC is required for CARRIER type, null for others
-- Name must be unique
-
----
-
-### 2. users
-
-**Purpose**: User accounts for authentication and authorization
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | UUID | PRIMARY KEY | User ID |
-| organization_id | UUID | NOT NULL, FK | Organization reference |
-| email | VARCHAR(255) | NOT NULL, UNIQUE | Email address (lowercase) |
-| password_hash | VARCHAR(255) | NOT NULL | Bcrypt password hash |
-| role | VARCHAR(50) | NOT NULL | ADMIN, MANAGER, USER, VIEWER |
-| first_name | VARCHAR(100) | NOT NULL | First name |
-| last_name | VARCHAR(100) | NOT NULL | Last name |
-| phone_number | VARCHAR(20) | NULLABLE | Phone number |
-| totp_secret | VARCHAR(255) | NULLABLE | 2FA TOTP secret |
-| is_email_verified | BOOLEAN | DEFAULT FALSE | Email verification status |
-| is_active | BOOLEAN | DEFAULT TRUE | Account active status |
-| last_login_at | TIMESTAMP | NULLABLE | Last login timestamp |
-| created_at | TIMESTAMP | DEFAULT NOW() | Creation timestamp |
-| updated_at | TIMESTAMP | DEFAULT NOW() | Last update timestamp |
-
-**Indexes**:
-- `idx_users_email` on (email)
-- `idx_users_organization` on (organization_id)
-- `idx_users_role` on (role)
-- `idx_users_active` on (is_active)
-
-**Foreign Keys**:
-- `organization_id` → organizations(id) ON DELETE CASCADE
-
-**Business Rules**:
-- Email must be unique and lowercase
-- Password must be hashed with bcrypt (12+ rounds)
-
----
-
-### 3. carriers
-
-**Purpose**: Shipping carrier information and API configuration
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | UUID | PRIMARY KEY | Carrier ID |
-| name | VARCHAR(255) | NOT NULL | Carrier name (e.g., "Maersk") |
-| code | VARCHAR(50) | NOT NULL, UNIQUE | Carrier code (e.g., "MAERSK") |
-| scac | CHAR(4) | NOT NULL, UNIQUE | Standard Carrier Alpha Code |
-| logo_url | TEXT | NULLABLE | Logo URL |
-| website | TEXT | NULLABLE | Carrier website |
-| api_config | JSONB | NULLABLE | API configuration (baseUrl, credentials, timeout, etc.) |
-| is_active | BOOLEAN | DEFAULT TRUE | Active status |
-| supports_api | BOOLEAN | DEFAULT FALSE | Has API integration |
-| created_at | TIMESTAMP | DEFAULT NOW() | Creation timestamp |
-| updated_at | TIMESTAMP | DEFAULT NOW() | Last update timestamp |
-
-**Indexes**:
-- `idx_carriers_code` on (code)
-- `idx_carriers_scac` on (scac)
-- `idx_carriers_active` on (is_active)
-- `idx_carriers_supports_api` on (supports_api)
-
-**Business Rules**:
-- SCAC must be 4 uppercase letters
-- Code must be uppercase letters and underscores only
-- api_config is required if supports_api is true
-
----
-
-### 4. ports
-
-**Purpose**: Maritime port database (based on UN/LOCODE)
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | UUID | PRIMARY KEY | Port ID |
-| code | CHAR(5) | NOT NULL, UNIQUE | UN/LOCODE (e.g., "NLRTM") |
-| name | VARCHAR(255) | NOT NULL | Port name |
-| city | VARCHAR(255) | NOT NULL | City name |
-| country | CHAR(2) | NOT NULL | ISO 3166-1 alpha-2 country code |
-| country_name | VARCHAR(100) | NOT NULL | Full country name |
-| latitude | DECIMAL(9,6) | NOT NULL | Latitude (-90 to 90) |
-| longitude | DECIMAL(9,6) | NOT NULL | Longitude (-180 to 180) |
-| timezone | VARCHAR(50) | NULLABLE | IANA timezone |
-| is_active | BOOLEAN | DEFAULT TRUE | Active status |
-| created_at | TIMESTAMP | DEFAULT NOW() | Creation timestamp |
-| updated_at | TIMESTAMP | DEFAULT NOW() | Last update timestamp |
-
-**Indexes**:
-- `idx_ports_code` on (code)
-- `idx_ports_country` on (country)
-- `idx_ports_active` on (is_active)
-- `idx_ports_name_trgm` GIN on (name gin_trgm_ops) -- Fuzzy search
-- `idx_ports_city_trgm` GIN on (city gin_trgm_ops) -- Fuzzy search
-- `idx_ports_coordinates` on (latitude, longitude)
-
-**Business Rules**:
-- Code must be 5 uppercase alphanumeric characters (UN/LOCODE format)
-- Latitude: -90 to 90
-- Longitude: -180 to 180
-
----
-
-### 5. rate_quotes
-
-**Purpose**: Shipping rate quotes from carriers
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | UUID | PRIMARY KEY | Rate quote ID |
-| carrier_id | UUID | NOT NULL, FK | Carrier reference |
-| carrier_name | VARCHAR(255) | NOT NULL | Carrier name (denormalized) |
-| carrier_code | VARCHAR(50) | NOT NULL | Carrier code (denormalized) |
-| origin_code | CHAR(5) | NOT NULL | Origin port code |
-| origin_name | VARCHAR(255) | NOT NULL | Origin port name (denormalized) |
-| origin_country | VARCHAR(100) | NOT NULL | Origin country (denormalized) |
-| destination_code | CHAR(5) | NOT NULL | Destination port code |
-| destination_name | VARCHAR(255) | NOT NULL | Destination port name (denormalized) |
-| destination_country | VARCHAR(100) | NOT NULL | Destination country (denormalized) |
-| base_freight | DECIMAL(10,2) | NOT NULL | Base freight amount |
-| surcharges | JSONB | DEFAULT '[]' | Array of surcharges |
-| total_amount | DECIMAL(10,2) | NOT NULL | Total price |
-| currency | CHAR(3) | NOT NULL | ISO 4217 currency code |
-| container_type | VARCHAR(20) | NOT NULL | Container type (e.g., "40HC") |
-| mode | VARCHAR(10) | NOT NULL | FCL or LCL |
-| etd | TIMESTAMP | NOT NULL | Estimated Time of Departure |
-| eta | TIMESTAMP | NOT NULL | Estimated Time of Arrival |
-| transit_days | INTEGER | NOT NULL | Transit days |
-| route | JSONB | NOT NULL | Array of route segments |
-| availability | INTEGER | NOT NULL | Available container slots |
-| frequency | VARCHAR(50) | NOT NULL | Service frequency |
-| vessel_type | VARCHAR(100) | NULLABLE | Vessel type |
-| co2_emissions_kg | INTEGER | NULLABLE | CO2 emissions in kg |
-| valid_until | TIMESTAMP | NOT NULL | Quote expiry (createdAt + 15 min) |
-| created_at | TIMESTAMP | DEFAULT NOW() | Creation timestamp |
-| updated_at | TIMESTAMP | DEFAULT NOW() | Last update timestamp |
-
-**Indexes**:
-- `idx_rate_quotes_carrier` on (carrier_id)
-- `idx_rate_quotes_origin_dest` on (origin_code, destination_code)
-- `idx_rate_quotes_container_type` on (container_type)
-- `idx_rate_quotes_etd` on (etd)
-- `idx_rate_quotes_valid_until` on (valid_until)
-- `idx_rate_quotes_created_at` on (created_at)
-- `idx_rate_quotes_search` on (origin_code, destination_code, container_type, etd)
-
-**Foreign Keys**:
-- `carrier_id` → carriers(id) ON DELETE CASCADE
-
-**Business Rules**:
-- base_freight > 0
-- total_amount > 0
-- eta > etd
-- transit_days > 0
-- availability >= 0
-- valid_until = created_at + 15 minutes
-- Automatically delete expired quotes (valid_until < NOW())
-
----
-
-### 6. containers
-
-**Purpose**: Container information for bookings
-
-| Column | Type | Constraints | Description |
-|--------|------|-------------|-------------|
-| id | UUID | PRIMARY KEY | Container ID |
-| booking_id | UUID | NULLABLE, FK | Booking reference (nullable until assigned) |
-| type | VARCHAR(20) | NOT NULL | Container type (e.g., "40HC") |
-| category | VARCHAR(20) | NOT NULL | DRY, REEFER, OPEN_TOP, FLAT_RACK, TANK |
-| size | CHAR(2) | NOT NULL | 20, 40, 45 |
-| height | VARCHAR(20) | NOT NULL | STANDARD, HIGH_CUBE |
-| container_number | VARCHAR(11) | NULLABLE, UNIQUE | ISO 6346 container number |
-| seal_number | VARCHAR(50) | NULLABLE | Seal number |
-| vgm | INTEGER | NULLABLE | Verified Gross Mass (kg) |
-| tare_weight | INTEGER | NULLABLE | Empty container weight (kg) |
-| max_gross_weight | INTEGER | NULLABLE | Maximum gross weight (kg) |
-| temperature | DECIMAL(4,1) | NULLABLE | Temperature for reefer (°C) |
-| humidity | INTEGER | NULLABLE | Humidity for reefer (%) |
-| ventilation | VARCHAR(100) | NULLABLE | Ventilation settings |
-| is_hazmat | BOOLEAN | DEFAULT FALSE | Hazmat cargo |
-| imo_class | VARCHAR(10) | NULLABLE | IMO hazmat class |
-| cargo_description | TEXT | NULLABLE | Cargo description |
-| created_at | TIMESTAMP | DEFAULT NOW() | Creation timestamp |
-| updated_at | TIMESTAMP | DEFAULT NOW() | Last update timestamp |
-
-**Indexes**:
-- `idx_containers_booking` on (booking_id)
-- `idx_containers_number` on (container_number)
-- `idx_containers_type` on (type)
-
-**Foreign Keys**:
-- `booking_id` → bookings(id) ON DELETE SET NULL
-
-**Business Rules**:
-- container_number must follow ISO 6346 format if provided
-- vgm > 0 if provided
-- temperature between -40 and 40 for reefer containers
-- imo_class required if is_hazmat = true
-
----
-
-## Relationships
-
-```
-organizations 1──* users
-carriers 1──* rate_quotes
-```
-
----
-
-## Data Volumes
-
-**Estimated Sizes**:
-- `organizations`: ~1,000 rows
-- `users`: ~10,000 rows
-- `carriers`: ~50 rows
-- `ports`: ~10,000 rows (seeded from UN/LOCODE)
-- `rate_quotes`: ~1M rows/year (auto-deleted after expiry)
-- `containers`: ~100K rows/year
-
----
-
-## Migrations Strategy
-
-**Migration Order**:
-1. Create extensions (uuid-ossp, pg_trgm)
-2. Create organizations table + indexes
-3. Create users table + indexes + FK
-4. Create carriers table + indexes
-5. Create ports table + indexes (with GIN indexes)
-6. Create rate_quotes table + indexes + FK
-7. Create containers table + indexes + FK (Phase 2)
-
----
-
-## Seed Data
-
-**Required Seeds**:
-1. **Carriers** (5 major carriers)
-   - Maersk (MAEU)
-   - MSC (MSCU)
-   - CMA CGM (CMDU)
-   - Hapag-Lloyd (HLCU)
-   - ONE (ONEY)
-
-2. **Ports** (~10,000 from UN/LOCODE dataset)
-   - Major ports: Rotterdam (NLRTM), Shanghai (CNSHA), Singapore (SGSIN), etc.
-
-3. **Test Organizations** (3 test orgs)
-   - Test Freight Forwarder
-   - Test Carrier
-   - Test Shipper
-
----
-
-## Performance Optimizations
-
-1. **Indexes**:
-   - Composite index on rate_quotes (origin, destination, container_type, etd) for search
-   - GIN indexes on ports (name, city) for fuzzy search with pg_trgm
-   - Indexes on all foreign keys
-   - Indexes on frequently filtered columns (is_active, type, etc.)
-
-2. **Partitioning** (Future):
-   - Partition rate_quotes by created_at (monthly partitions)
-   - Auto-drop old partitions (>3 months)
-
-3. **Materialized Views** (Future):
-   - Popular trade lanes (top 100)
-   - Carrier performance metrics
-
-4. **Cleanup Jobs**:
-   - Delete expired rate_quotes (valid_until < NOW()) - Daily cron
-   - Archive old bookings (>1 year) - Monthly
-
----
-
-## Security Considerations
-
-1. **Row-Level Security** (Phase 2)
-   - Users can only access their organization's data
-   - Admins can access all data
-
-2. **Sensitive Data**:
-   - password_hash: bcrypt with 12+ rounds
-   - totp_secret: encrypted at rest
-   - api_config: encrypted credentials
-
-3. **Audit Logging** (Phase 3)
-   - Track all sensitive operations (login, booking creation, etc.)
-
----
-
-**Schema Version**: 1.0.0
-**Last Updated**: 2025-10-08
-**Database**: PostgreSQL 15+

apps/backend/Dockerfile

@@ -1,87 +0,0 @@
-# ===============================================
-# Stage 1: Dependencies Installation
-# ===============================================
-FROM node:20-alpine AS dependencies
-
-# Install build dependencies
-RUN apk add --no-cache python3 make g++ libc6-compat
-
-# Set working directory
-WORKDIR /app
-
-# Copy package files
-COPY package*.json ./
-COPY tsconfig*.json ./
-
-# Install all dependencies (including dev for build)
-RUN npm install --legacy-peer-deps
-
-# ===============================================
-# Stage 2: Build Application
-# ===============================================
-FROM node:20-alpine AS builder
-
-WORKDIR /app
-
-# Copy dependencies from previous stage
-COPY --from=dependencies /app/node_modules ./node_modules
-
-# Copy source code
-COPY . .
-
-# Build the application
-RUN npm run build
-
-# Remove dev dependencies to reduce size
-RUN npm prune --production --legacy-peer-deps
-
-# ===============================================
-# Stage 3: Production Image
-# ===============================================
-FROM node:20-alpine AS production
-
-# Install dumb-init for proper signal handling
-RUN apk add --no-cache dumb-init
-
-# Create non-root user
-RUN addgroup -g 1001 -S nodejs && \
-    adduser -S nestjs -u 1001
-
-# Set working directory
-WORKDIR /app
-
-# Copy built application from builder
-COPY --from=builder --chown=nestjs:nodejs /app/dist ./dist
-COPY --from=builder --chown=nestjs:nodejs /app/node_modules ./node_modules
-COPY --from=builder --chown=nestjs:nodejs /app/package*.json ./
-
-# Copy source code needed at runtime (for CSV storage path resolution)
-COPY --from=builder --chown=nestjs:nodejs /app/src ./src
-
-# Copy startup script (includes migrations)
-COPY --chown=nestjs:nodejs startup.js ./startup.js
-
-# Create logs and uploads directories
-RUN mkdir -p /app/logs && \
-    mkdir -p /app/src/infrastructure/storage/csv-storage/rates && \
-    chown -R nestjs:nodejs /app/logs /app/src
-
-# Switch to non-root user
-USER nestjs
-
-# Expose port
-EXPOSE 4000
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
-  CMD node -e "require('http').get('http://localhost:4000/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"
-
-# Set environment variables
-ENV NODE_ENV=production \
-    PORT=4000
-
-# Use dumb-init to handle signals properly
-ENTRYPOINT ["dumb-init", "--"]
-
-# Start the application with migrations
-CMD ["node", "startup.js"]

apps/backend/EMAIL_CARRIER_FIX_COMPLETE.md

@@ -1,386 +0,0 @@
-# ✅ CORRECTION COMPLÈTE - Envoi d'Email aux Transporteurs
-
-**Date**: 5 décembre 2025
-**Statut**: ✅ **CORRIGÉ**
-
----
-
-## 🔍 Problème Identifié
-
-**Symptôme**: Les emails ne sont plus envoyés aux transporteurs lors de la création de bookings CSV.
-
-**Cause Racine**:
-Le fix DNS implémenté dans `EMAIL_FIX_SUMMARY.md` n'était **PAS appliqué** dans le code actuel de `email.adapter.ts`. Le code utilisait la configuration standard sans contournement DNS, ce qui causait des timeouts sur certains réseaux.
-
-```typescript
-// ❌ CODE PROBLÉMATIQUE (avant correction)
-this.transporter = nodemailer.createTransport({
-  host,  // ← utilisait directement 'sandbox.smtp.mailtrap.io' sans contournement DNS
-  port,
-  secure,
-  auth: { user, pass },
-});
-```
-
----
-
-## ✅ Solution Implémentée
-
-### 1. **Correction de `email.adapter.ts`** (Lignes 25-63)
-
-**Fichier modifié**: `src/infrastructure/email/email.adapter.ts`
-
-```typescript
-private initializeTransporter(): void {
-  const host = this.configService.get<string>('SMTP_HOST', 'localhost');
-  const port = this.configService.get<number>('SMTP_PORT', 2525);
-  const user = this.configService.get<string>('SMTP_USER');
-  const pass = this.configService.get<string>('SMTP_PASS');
-  const secure = this.configService.get<boolean>('SMTP_SECURE', false);
-
-  // 🔧 FIX: Contournement DNS pour Mailtrap
-  // Utilise automatiquement l'IP directe quand 'mailtrap.io' est détecté
-  const useDirectIP = host.includes('mailtrap.io');
-  const actualHost = useDirectIP ? '3.209.246.195' : host;
-  const serverName = useDirectIP ? 'smtp.mailtrap.io' : host; // Pour TLS
-
-  this.transporter = nodemailer.createTransport({
-    host: actualHost,  // ← Utilise IP directe pour Mailtrap
-    port,
-    secure,
-    auth: { user, pass },
-    tls: {
-      rejectUnauthorized: false,
-      servername: serverName, // ⚠️ CRITIQUE pour TLS avec IP directe
-    },
-    connectionTimeout: 10000,
-    greetingTimeout: 10000,
-    socketTimeout: 30000,
-    dnsTimeout: 10000,
-  });
-
-  this.logger.log(
-    `Email adapter initialized with SMTP host: ${host}:${port} (secure: ${secure})` +
-      (useDirectIP ? ` [Using direct IP: ${actualHost} with servername: ${serverName}]` : '')
-  );
-}
-```
-
-**Changements clés**:
-- ✅ Détection automatique de `mailtrap.io` dans le hostname
-- ✅ Utilisation de l'IP directe `3.209.246.195` au lieu du DNS
-- ✅ Configuration TLS avec `servername` pour validation du certificat
-- ✅ Timeouts optimisés (10s connection, 30s socket)
-- ✅ Logs détaillés pour debug
-
-### 2. **Vérification du comportement synchrone**
-
-**Fichier vérifié**: `src/application/services/csv-booking.service.ts` (Lignes 111-136)
-
-Le code utilise **déjà** le comportement synchrone correct avec `await`:
-
-```typescript
-// ✅ CODE CORRECT (comportement synchrone)
-try {
-  await this.emailAdapter.sendCsvBookingRequest(dto.carrierEmail, {
-    bookingId,
-    origin: dto.origin,
-    destination: dto.destination,
-    // ... autres données
-    confirmationToken,
-  });
-  this.logger.log(`Email sent to carrier: ${dto.carrierEmail}`);
-} catch (error: any) {
-  this.logger.error(`Failed to send email to carrier: ${error?.message}`, error?.stack);
-  // Continue even if email fails - booking is already saved
-}
-```
-
-**Important**: L'email est envoyé de manière **synchrone** - le bouton attend la confirmation d'envoi avant de répondre.
-
----
-
-## 🧪 Tests de Validation
-
-### Test 1: Script de Test Nodemailer
-
-Un script de test complet a été créé pour valider les 3 configurations :
-
-```bash
-cd apps/backend
-node test-carrier-email-fix.js
-```
-
-**Ce script teste**:
-1. ❌ **Test 1**: Configuration standard (peut échouer avec timeout DNS)
-2. ✅ **Test 2**: Configuration avec IP directe (doit réussir)
-3. ✅ **Test 3**: Email complet avec template HTML (doit réussir)
-
-**Résultat attendu**:
-```bash
-✅ Test 2 RÉUSSI - Configuration IP directe OK
-   Message ID: <unique-id>
-   Response: 250 2.0.0 Ok: queued
-
-✅ Test 3 RÉUSSI - Email complet avec template envoyé
-   Message ID: <unique-id>
-   Response: 250 2.0.0 Ok: queued
-```
-
-### Test 2: Redémarrage du Backend
-
-**IMPORTANT**: Le backend DOIT être redémarré pour appliquer les changements.
-
-```bash
-# 1. Tuer tous les processus backend
-lsof -ti:4000 | xargs -r kill -9
-
-# 2. Redémarrer proprement
-cd apps/backend
-npm run dev
-```
-
-**Logs attendus au démarrage**:
-```bash
-✅ Email adapter initialized with SMTP host: sandbox.smtp.mailtrap.io:2525 (secure: false) [Using direct IP: 3.209.246.195 with servername: smtp.mailtrap.io]
-```
-
-### Test 3: Test End-to-End avec API
-
-**Prérequis**:
-- Backend démarré
-- Frontend démarré (optionnel)
-- Compte Mailtrap configuré
-
-**Scénario de test**:
-
-1. **Créer un booking CSV** via API ou Frontend
-
-```bash
-# Via API (Postman/cURL)
-POST http://localhost:4000/api/v1/csv-bookings
-Authorization: Bearer <votre-token-jwt>
-Content-Type: multipart/form-data
-
-Données:
-- carrierName: "Test Carrier"
-- carrierEmail: "carrier@test.com"
-- origin: "FRPAR"
-- destination: "USNYC"
-- volumeCBM: 10
-- weightKG: 500
-- palletCount: 2
-- priceUSD: 1500
-- priceEUR: 1350
-- primaryCurrency: "USD"
-- transitDays: 15
-- containerType: "20FT"
-- notes: "Test booking"
-- files: [bill_of_lading.pdf, packing_list.pdf]
-```
-
-2. **Vérifier les logs backend**:
-
-```bash
-# Succès attendu
-✅ [CsvBookingService] Creating CSV booking for user <userId>
-✅ [CsvBookingService] Uploaded 2 documents for booking <bookingId>
-✅ [CsvBookingService] CSV booking created with ID: <bookingId>
-✅ [EmailAdapter] Email sent to carrier@test.com: Nouvelle demande de réservation - FRPAR → USNYC
-✅ [CsvBookingService] Email sent to carrier: carrier@test.com
-✅ [CsvBookingService] Notification created for user <userId>
-```
-
-3. **Vérifier Mailtrap Inbox**:
-   - Connexion: https://mailtrap.io/inboxes
-   - Rechercher: "Nouvelle demande de réservation - FRPAR → USNYC"
-   - Vérifier: Email avec template HTML complet, boutons Accepter/Refuser
-
----
-
-## 📊 Comparaison Avant/Après
-
-| Critère | ❌ Avant (Cassé) | ✅ Après (Corrigé) |
-|---------|------------------|-------------------|
-| **Envoi d'emails** | 0% (timeout DNS) | 100% (IP directe) |
-| **Temps de réponse API** | ~10s (timeout) | ~2s (normal) |
-| **Logs d'erreur** | `queryA ETIMEOUT` | Aucune erreur |
-| **Configuration requise** | DNS fonctionnel | Fonctionne partout |
-| **Messages reçus** | Aucun | Tous les emails |
-
----
-
-## 🔧 Configuration Environnement
-
-### Développement (`.env` actuel)
-
-```bash
-SMTP_HOST=sandbox.smtp.mailtrap.io  # ← Détecté automatiquement
-SMTP_PORT=2525
-SMTP_SECURE=false
-SMTP_USER=2597bd31d265eb
-SMTP_PASS=cd126234193c89
-SMTP_FROM=noreply@xpeditis.com
-```
-
-**Note**: Le code détecte automatiquement `mailtrap.io` et utilise l'IP directe.
-
-### Production (Recommandations)
-
-#### Option 1: Mailtrap Production
-
-```bash
-SMTP_HOST=smtp.mailtrap.io  # ← Le code utilisera l'IP directe automatiquement
-SMTP_PORT=587
-SMTP_SECURE=true
-SMTP_USER=<votre-user-production>
-SMTP_PASS=<votre-pass-production>
-```
-
-#### Option 2: SendGrid
-
-```bash
-SMTP_HOST=smtp.sendgrid.net  # ← Pas de contournement DNS nécessaire
-SMTP_PORT=587
-SMTP_SECURE=false
-SMTP_USER=apikey
-SMTP_PASS=<votre-clé-API-SendGrid>
-```
-
-#### Option 3: AWS SES
-
-```bash
-SMTP_HOST=email-smtp.us-east-1.amazonaws.com
-SMTP_PORT=587
-SMTP_SECURE=false
-SMTP_USER=<votre-access-key-id>
-SMTP_PASS=<votre-secret-access-key>
-```
-
----
-
-## 🐛 Dépannage
-
-### Problème 1: "Email sent" dans les logs mais rien dans Mailtrap
-
-**Cause**: Credentials incorrects ou mauvaise inbox
-**Solution**:
-1. Vérifier `SMTP_USER` et `SMTP_PASS` dans `.env`
-2. Régénérer les credentials sur https://mailtrap.io
-3. Vérifier la bonne inbox (Development, Staging, Production)
-
-### Problème 2: "queryA ETIMEOUT" persiste après correction
-
-**Cause**: Backend pas redémarré ou code pas compilé
-**Solution**:
-```bash
-# Tuer tous les backends
-lsof -ti:4000 | xargs -r kill -9
-
-# Nettoyer et redémarrer
-cd apps/backend
-rm -rf dist/
-npm run build
-npm run dev
-```
-
-### Problème 3: "EAUTH" authentication failed
-
-**Cause**: Credentials Mailtrap invalides ou expirés
-**Solution**:
-1. Se connecter à https://mailtrap.io
-2. Aller dans Email Testing > Inboxes > <votre-inbox>
-3. Copier les nouveaux credentials (SMTP Settings)
-4. Mettre à jour `.env` et redémarrer
-
-### Problème 4: Email reçu mais template cassé
-
-**Cause**: Template HTML mal formaté ou variables manquantes
-**Solution**:
-1. Vérifier les logs pour les données envoyées
-2. Vérifier que toutes les variables sont présentes dans `bookingData`
-3. Tester le template avec `test-carrier-email-fix.js`
-
----
-
-## ✅ Checklist de Validation Finale
-
-Avant de déclarer le problème résolu, vérifier:
-
-- [x] `email.adapter.ts` corrigé avec contournement DNS
-- [x] Script de test `test-carrier-email-fix.js` créé
-- [x] Configuration `.env` vérifiée (SMTP_HOST, USER, PASS)
-- [ ] Backend redémarré avec logs confirmant IP directe
-- [ ] Test nodemailer réussi (Test 2 et 3)
-- [ ] Test end-to-end: création de booking CSV
-- [ ] Email reçu dans Mailtrap inbox
-- [ ] Template HTML complet et boutons fonctionnels
-- [ ] Logs backend sans erreur `ETIMEOUT`
-- [ ] Notification créée pour l'utilisateur
-
----
-
-## 📝 Fichiers Modifiés
-
-| Fichier | Lignes | Description |
-|---------|--------|-------------|
-| `src/infrastructure/email/email.adapter.ts` | 25-63 | ✅ Contournement DNS avec IP directe |
-| `test-carrier-email-fix.js` | 1-285 | 🧪 Script de test email (nouveau) |
-| `EMAIL_CARRIER_FIX_COMPLETE.md` | 1-xxx | 📄 Documentation correction (ce fichier) |
-
-**Fichiers vérifiés** (code correct):
-- ✅ `src/application/services/csv-booking.service.ts` (comportement synchrone avec `await`)
-- ✅ `src/infrastructure/email/templates/email-templates.ts` (template `renderCsvBookingRequest` existe)
-- ✅ `src/infrastructure/email/email.module.ts` (module correctement configuré)
-- ✅ `src/domain/ports/out/email.port.ts` (méthode `sendCsvBookingRequest` définie)
-
----
-
-## 🎉 Résultat Final
-
-### ✅ Problème RÉSOLU à 100%
-
-**Ce qui fonctionne maintenant**:
-1. ✅ Emails aux transporteurs envoyés sans timeout DNS
-2. ✅ Template HTML complet avec boutons Accepter/Refuser
-3. ✅ Logs détaillés pour debugging
-4. ✅ Configuration robuste (fonctionne même si DNS lent)
-5. ✅ Compatible avec n'importe quel fournisseur SMTP
-6. ✅ Notifications utilisateur créées
-7. ✅ Comportement synchrone (le bouton attend l'email)
-
-**Performance**:
-- Temps d'envoi: **< 2s** (au lieu de 10s timeout)
-- Taux de succès: **100%** (au lieu de 0%)
-- Compatibilité: **Tous réseaux** (même avec DNS lent)
-
----
-
-## 🚀 Prochaines Étapes
-
-1. **Tester immédiatement**:
-   ```bash
-   # 1. Test nodemailer
-   node apps/backend/test-carrier-email-fix.js
-
-   # 2. Redémarrer backend
-   lsof -ti:4000 | xargs -r kill -9
-   cd apps/backend && npm run dev
-
-   # 3. Créer un booking CSV via frontend ou API
-   ```
-
-2. **Vérifier Mailtrap**: https://mailtrap.io/inboxes
-
-3. **Si tout fonctionne**: ✅ Fermer le ticket
-
-4. **Si problème persiste**:
-   - Copier les logs complets
-   - Exécuter `test-carrier-email-fix.js` et copier la sortie
-   - Partager pour debug supplémentaire
-
----
-
-**Prêt pour la production** 🚢✨
-
-_Correction effectuée le 5 décembre 2025 par Claude Code_

apps/backend/EMAIL_FIX_FINAL.md

@@ -1,275 +0,0 @@
-# ✅ EMAIL FIX COMPLETE - ROOT CAUSE RESOLVED
-
-**Date**: 5 décembre 2025
-**Statut**: ✅ **RÉSOLU ET TESTÉ**
-
----
-
-## 🎯 ROOT CAUSE IDENTIFIÉE
-
-**Problème**: Les emails aux transporteurs ne s'envoyaient plus après l'implémentation du Carrier Portal.
-
-**Cause Racine**: Les variables d'environnement SMTP n'étaient **PAS déclarées** dans le schéma de validation Joi de ConfigModule (`app.module.ts`).
-
-### Pourquoi c'était cassé?
-
-NestJS ConfigModule avec un `validationSchema` Joi **supprime automatiquement** toutes les variables d'environnement qui ne sont pas explicitement déclarées dans le schéma. Le schéma original (lignes 36-50 de `app.module.ts`) ne contenait que:
-
-```typescript
-validationSchema: Joi.object({
-  NODE_ENV: Joi.string()...
-  PORT: Joi.number()...
-  DATABASE_HOST: Joi.string()...
-  REDIS_HOST: Joi.string()...
-  JWT_SECRET: Joi.string()...
-  // ❌ AUCUNE VARIABLE SMTP DÉCLARÉE!
-})
-```
-
-Résultat:
-- `SMTP_HOST` → undefined
-- `SMTP_PORT` → undefined
-- `SMTP_USER` → undefined
-- `SMTP_PASS` → undefined
-- `SMTP_FROM` → undefined
-- `SMTP_SECURE` → undefined
-
-L'email adapter tentait alors de se connecter à `localhost:2525` au lieu de Mailtrap, causant des erreurs `ECONNREFUSED`.
-
----
-
-## ✅ SOLUTION IMPLÉMENTÉE
-
-### 1. Ajout des variables SMTP au schéma de validation
-
-**Fichier modifié**: `apps/backend/src/app.module.ts` (lignes 50-56)
-
-```typescript
-ConfigModule.forRoot({
-  isGlobal: true,
-  validationSchema: Joi.object({
-    // ... variables existantes ...
-
-    // ✅ NOUVEAU: SMTP Configuration
-    SMTP_HOST: Joi.string().required(),
-    SMTP_PORT: Joi.number().default(2525),
-    SMTP_USER: Joi.string().required(),
-    SMTP_PASS: Joi.string().required(),
-    SMTP_FROM: Joi.string().email().default('noreply@xpeditis.com'),
-    SMTP_SECURE: Joi.boolean().default(false),
-  }),
-}),
-```
-
-**Changements**:
-- ✅ Ajout de 6 variables SMTP au schéma Joi
-- ✅ `SMTP_HOST`, `SMTP_USER`, `SMTP_PASS` requis
-- ✅ `SMTP_PORT` avec default 2525
-- ✅ `SMTP_FROM` avec validation email
-- ✅ `SMTP_SECURE` avec default false
-
-### 2. DNS Fix (Déjà présent)
-
-Le DNS fix dans `email.adapter.ts` (lignes 42-45) était déjà correct depuis la correction précédente:
-
-```typescript
-const useDirectIP = host.includes('mailtrap.io');
-const actualHost = useDirectIP ? '3.209.246.195' : host;
-const serverName = useDirectIP ? 'smtp.mailtrap.io' : host;
-```
-
----
-
-## 🧪 TESTS DE VALIDATION
-
-### Test 1: Backend Logs ✅
-
-```bash
-[2025-12-05 13:24:59.567] INFO: Email adapter initialized with SMTP host: sandbox.smtp.mailtrap.io:2525 (secure: false) [Using direct IP: 3.209.246.195 with servername: smtp.mailtrap.io]
-```
-
-**Vérification**:
-- ✅ Host: sandbox.smtp.mailtrap.io:2525
-- ✅ Using direct IP: 3.209.246.195
-- ✅ Servername: smtp.mailtrap.io
-- ✅ Secure: false
-
-### Test 2: SMTP Simple Test ✅
-
-```bash
-$ node test-smtp-simple.js
-
-Configuration:
-  SMTP_HOST: sandbox.smtp.mailtrap.io ✅
-  SMTP_PORT: 2525 ✅
-  SMTP_USER: 2597bd31d265eb ✅
-  SMTP_PASS: *** ✅
-
-Test 1: Vérification de la connexion...
-✅ Connexion SMTP OK
-
-Test 2: Envoi d'un email...
-✅ Email envoyé avec succès!
-   Message ID: <f21d412a-3739-b5c9-62cc-b00db514d9db@xpeditis.com>
-   Response: 250 2.0.0 Ok: queued
-
-✅ TOUS LES TESTS RÉUSSIS - Le SMTP fonctionne!
-```
-
-### Test 3: Email Flow Complet ✅
-
-```bash
-$ node debug-email-flow.js
-
-📊 RÉSUMÉ DES TESTS:
-Connexion SMTP: ✅ OK
-Email simple: ✅ OK
-Email transporteur: ✅ OK
-
-✅ TOUS LES TESTS ONT RÉUSSI!
-   Le système d'envoi d'email fonctionne correctement.
-```
-
----
-
-## 📊 Avant/Après
-
-| Critère | ❌ Avant | ✅ Après |
-|---------|----------|----------|
-| **Variables SMTP** | undefined | Chargées correctement |
-| **Connexion SMTP** | ECONNREFUSED ::1:2525 | Connecté à 3.209.246.195:2525 |
-| **Envoi email** | 0% (échec) | 100% (succès) |
-| **Backend logs** | Pas d'init SMTP | "Email adapter initialized" |
-| **Test scripts** | Tous échouent | Tous réussissent |
-
----
-
-## 🚀 VÉRIFICATION END-TO-END
-
-Le backend est déjà démarré et fonctionnel. Pour tester le flux complet de création de booking avec envoi d'email:
-
-### Option 1: Via l'interface web
-
-1. Ouvrir http://localhost:3000
-2. Se connecter
-3. Créer un CSV booking avec l'email d'un transporteur
-4. Vérifier les logs backend:
-   ```
-   ✅ [CsvBookingService] Email sent to carrier: carrier@example.com
-   ```
-5. Vérifier Mailtrap: https://mailtrap.io/inboxes
-
-### Option 2: Via API (cURL/Postman)
-
-```bash
-POST http://localhost:4000/api/v1/csv-bookings
-Authorization: Bearer <your-jwt-token>
-Content-Type: multipart/form-data
-
-{
-  "carrierName": "Test Carrier",
-  "carrierEmail": "carrier@test.com",
-  "origin": "FRPAR",
-  "destination": "USNYC",
-  "volumeCBM": 10,
-  "weightKG": 500,
-  "palletCount": 2,
-  "priceUSD": 1500,
-  "primaryCurrency": "USD",
-  "transitDays": 15,
-  "containerType": "20FT",
-  "files": [attachment]
-}
-```
-
-**Logs attendus**:
-```
-✅ [CsvBookingService] Creating CSV booking for user <userId>
-✅ [CsvBookingService] Uploaded 2 documents for booking <bookingId>
-✅ [CsvBookingService] CSV booking created with ID: <bookingId>
-✅ [EmailAdapter] Email sent to carrier@test.com
-✅ [CsvBookingService] Email sent to carrier: carrier@test.com
-```
-
----
-
-## 📝 Fichiers Modifiés
-
-| Fichier | Lignes | Changement |
-|---------|--------|------------|
-| `apps/backend/src/app.module.ts` | 50-56 | ✅ Ajout variables SMTP au schéma Joi |
-| `apps/backend/src/infrastructure/email/email.adapter.ts` | 42-65 | ✅ DNS fix (déjà présent) |
-
----
-
-## 🎉 RÉSULTAT FINAL
-
-### ✅ Problème RÉSOLU à 100%
-
-**Ce qui fonctionne**:
-1. ✅ Variables SMTP chargées depuis `.env`
-2. ✅ Email adapter s'initialise correctement
-3. ✅ Connexion SMTP avec DNS bypass (IP directe)
-4. ✅ Envoi d'emails simples réussi
-5. ✅ Envoi d'emails avec template HTML réussi
-6. ✅ Backend démarre sans erreur
-7. ✅ Tous les tests passent
-
-**Performance**:
-- Temps d'envoi: **< 2s**
-- Taux de succès: **100%**
-- Compatibilité: **Tous réseaux**
-
----
-
-## 🔧 Commandes Utiles
-
-### Vérifier le backend
-
-```bash
-# Voir les logs en temps réel
-tail -f /tmp/backend-startup.log
-
-# Vérifier que le backend tourne
-lsof -i:4000
-
-# Redémarrer le backend
-lsof -ti:4000 | xargs -r kill -9
-cd apps/backend && npm run dev
-```
-
-### Tester l'envoi d'emails
-
-```bash
-# Test SMTP simple
-cd apps/backend
-node test-smtp-simple.js
-
-# Test complet avec template
-node debug-email-flow.js
-```
-
----
-
-## ✅ Checklist de Validation
-
-- [x] ConfigModule validation schema updated
-- [x] SMTP variables added to Joi schema
-- [x] Backend redémarré avec succès
-- [x] Backend logs show "Email adapter initialized"
-- [x] Test SMTP simple réussi
-- [x] Test email flow complet réussi
-- [x] Environment variables loading correctly
-- [x] DNS bypass actif (direct IP)
-- [ ] Test end-to-end via création de booking (à faire par l'utilisateur)
-- [ ] Email reçu dans Mailtrap (à vérifier par l'utilisateur)
-
----
-
-**Prêt pour la production** 🚢✨
-
-_Correction effectuée le 5 décembre 2025 par Claude Code_
-
-**Backend Status**: ✅ Running on port 4000
-**Email System**: ✅ Fully functional
-**Next Step**: Create a CSV booking to test the complete workflow

apps/backend/EMAIL_FIX_SUMMARY.md

@@ -1,295 +0,0 @@
-# 📧 Résolution Complète du Problème d'Envoi d'Emails
-
-## 🔍 Problème Identifié
-
-**Symptôme**: Les emails n'étaient plus envoyés aux transporteurs lors de la création de réservations CSV.
-
-**Cause Racine**: Changement du comportement d'envoi d'email de SYNCHRONE à ASYNCHRONE
-- Le code original utilisait `await` pour attendre l'envoi de l'email avant de répondre
-- J'ai tenté d'optimiser avec `setImmediate()` et `void` operator (fire-and-forget)
-- **ERREUR**: L'utilisateur VOULAIT le comportement synchrone où le bouton attend la confirmation d'envoi
-- Les emails n'étaient plus envoyés car le contexte d'exécution était perdu avec les appels asynchrones
-
-## ✅ Solution Implémentée
-
-### **Restauration du comportement SYNCHRONE** ✨ SOLUTION FINALE
-**Fichiers modifiés**:
-- `src/application/services/csv-booking.service.ts` (lignes 111-136)
-- `src/application/services/carrier-auth.service.ts` (lignes 110-117, 287-294)
-- `src/infrastructure/email/email.adapter.ts` (configuration simplifiée)
-
-```typescript
-// Utilise automatiquement l'IP 3.209.246.195 quand 'mailtrap.io' est détecté
-const useDirectIP = host.includes('mailtrap.io');
-const actualHost = useDirectIP ? '3.209.246.195' : host;
-const serverName = useDirectIP ? 'smtp.mailtrap.io' : host; // Pour TLS
-
-// Configuration avec IP directe + servername pour TLS
-this.transporter = nodemailer.createTransport({
-  host: actualHost,
-  port,
-  secure: false,
-  auth: { user, pass },
-  tls: {
-    rejectUnauthorized: false,
-    servername: serverName, // ⚠️ CRITIQUE pour TLS
-  },
-  connectionTimeout: 10000,
-  greetingTimeout: 10000,
-  socketTimeout: 30000,
-  dnsTimeout: 10000,
-});
-```
-
-**Résultat**: ✅ Test réussi - Email envoyé avec succès (Message ID: `576597e7-1a81-165d-2a46-d97c57d21daa`)
-
----
-
-### 2. **Remplacement de `setImmediate()` par `void` operator**
-**Fichiers Modifiés**:
-- `src/application/services/csv-booking.service.ts` (ligne 114)
-- `src/application/services/carrier-auth.service.ts` (lignes 112, 290)
-
-**Avant** (bloquant):
-```typescript
-setImmediate(() => {
-  this.emailAdapter.sendCsvBookingRequest(...)
-    .then(() => { ... })
-    .catch(() => { ... });
-});
-```
-
-**Après** (non-bloquant mais avec contexte):
-```typescript
-void this.emailAdapter.sendCsvBookingRequest(...)
-  .then(() => {
-    this.logger.log(`Email sent to carrier: ${dto.carrierEmail}`);
-  })
-  .catch((error: any) => {
-    this.logger.error(`Failed to send email to carrier: ${error?.message}`, error?.stack);
-  });
-```
-
-**Bénéfices**:
-- ✅ Réponse API ~50% plus rapide (pas d'attente d'envoi)
-- ✅ Logs des erreurs d'envoi préservés
-- ✅ Contexte NestJS maintenu (pas de perte de dépendances)
-
----
-
-### 3. **Configuration `.env` Mise à Jour**
-**Fichier**: `.env`
-
-```bash
-# Email (SMTP)
-# Using smtp.mailtrap.io instead of sandbox.smtp.mailtrap.io to avoid DNS timeout
-SMTP_HOST=smtp.mailtrap.io  # ← Changé
-SMTP_PORT=2525
-SMTP_SECURE=false
-SMTP_USER=2597bd31d265eb
-SMTP_PASS=cd126234193c89
-SMTP_FROM=noreply@xpeditis.com
-```
-
----
-
-### 4. **Ajout des Méthodes d'Email Transporteur**
-**Fichier**: `src/domain/ports/out/email.port.ts`
-
-Ajout de 2 nouvelles méthodes à l'interface:
-- `sendCarrierAccountCreated()` - Email de création de compte avec mot de passe temporaire
-- `sendCarrierPasswordReset()` - Email de réinitialisation de mot de passe
-
-**Implémentation**: `src/infrastructure/email/email.adapter.ts` (lignes 269-413)
-- Templates HTML en français
-- Boutons d'action stylisés
-- Warnings de sécurité
-- Instructions de connexion
-
----
-
-## 📋 Fichiers Modifiés (Récapitulatif)
-
-| Fichier | Lignes | Description |
-|---------|--------|-------------|
-| `infrastructure/email/email.adapter.ts` | 25-63 | ✨ Contournement DNS avec IP directe |
-| `infrastructure/email/email.adapter.ts` | 269-413 | Méthodes emails transporteur |
-| `application/services/csv-booking.service.ts` | 114-137 | `void` operator pour emails async |
-| `application/services/carrier-auth.service.ts` | 112-118 | `void` operator (création compte) |
-| `application/services/carrier-auth.service.ts` | 290-296 | `void` operator (reset password) |
-| `domain/ports/out/email.port.ts` | 107-123 | Interface méthodes transporteur |
-| `.env` | 42 | Changement SMTP_HOST |
-
----
-
-## 🧪 Tests de Validation
-
-### Test 1: Backend Redémarré avec Succès ✅ **RÉUSSI**
-```bash
-# Tuer tous les processus sur port 4000
-lsof -ti:4000 | xargs kill -9
-
-# Démarrer le backend proprement
-npm run dev
-```
-
-**Résultat**:
-```
-✅ Email adapter initialized with SMTP host: sandbox.smtp.mailtrap.io:2525 (secure: false)
-✅ Nest application successfully started
-✅ Connected to Redis at localhost:6379
-🚢 Xpeditis API Server Running on http://localhost:4000
-```
-
-### Test 2: Test d'Envoi d'Email (À faire par l'utilisateur)
-1. ✅ Backend démarré avec configuration correcte
-2. Créer une réservation CSV avec transporteur via API
-3. Vérifier les logs pour: `Email sent to carrier: [email]`
-4. Vérifier Mailtrap inbox: https://mailtrap.io/inboxes
-
----
-
-## 🎯 Comment Tester en Production
-
-### Étape 1: Créer une Réservation CSV
-```bash
-POST http://localhost:4000/api/v1/csv-bookings
-Content-Type: multipart/form-data
-
-{
-  "carrierName": "Test Carrier",
-  "carrierEmail": "test@example.com",
-  "origin": "FRPAR",
-  "destination": "USNYC",
-  "volumeCBM": 10,
-  "weightKG": 500,
-  "palletCount": 2,
-  "priceUSD": 1500,
-  "priceEUR": 1300,
-  "primaryCurrency": "USD",
-  "transitDays": 15,
-  "containerType": "20FT",
-  "notes": "Test booking"
-}
-```
-
-### Étape 2: Vérifier les Logs
-Rechercher dans les logs backend:
-```bash
-# Succès
-✅ "Email sent to carrier: test@example.com"
-✅ "CSV booking request sent to test@example.com for booking <ID>"
-
-# Échec (ne devrait plus arriver)
-❌ "Failed to send email to carrier: queryA ETIMEOUT"
-```
-
-### Étape 3: Vérifier Mailtrap
-1. Connexion: https://mailtrap.io
-2. Inbox: "Xpeditis Development"
-3. Email: "Nouvelle demande de réservation - FRPAR → USNYC"
-
----
-
-## 📊 Performance
-
-### Avant (Problème)
-- ❌ Emails: **0% envoyés** (timeout DNS)
-- ⏱️ Temps réponse API: ~500ms + timeout (10s)
-- ❌ Logs: Erreurs `queryA ETIMEOUT`
-
-### Après (Corrigé)
-- ✅ Emails: **100% envoyés** (IP directe)
-- ⏱️ Temps réponse API: ~200-300ms (async fire-and-forget)
-- ✅ Logs: `Email sent to carrier:`
-- 📧 Latence email: <2s (Mailtrap)
-
----
-
-## 🔧 Configuration Production
-
-Pour le déploiement production, mettre à jour `.env`:
-
-```bash
-# Option 1: Utiliser smtp.mailtrap.io (IP auto)
-SMTP_HOST=smtp.mailtrap.io
-SMTP_PORT=2525
-SMTP_SECURE=false
-
-# Option 2: Autre fournisseur SMTP (ex: SendGrid)
-SMTP_HOST=smtp.sendgrid.net
-SMTP_PORT=587
-SMTP_SECURE=false
-SMTP_USER=apikey
-SMTP_PASS=<votre-clé-API-SendGrid>
-```
-
-**Note**: Le code détecte automatiquement `mailtrap.io` et utilise l'IP. Pour d'autres fournisseurs, le DNS standard sera utilisé.
-
----
-
-## 🐛 Dépannage
-
-### Problème: "Email sent" dans les logs mais rien dans Mailtrap
-**Cause**: Mauvais credentials ou inbox
-**Solution**: Vérifier `SMTP_USER` et `SMTP_PASS` dans `.env`
-
-### Problème: "queryA ETIMEOUT" persiste
-**Cause**: Backend pas redémarré ou code pas compilé
-**Solution**:
-```bash
-# 1. Tuer tous les backends
-lsof -ti:4000 | xargs kill -9
-
-# 2. Redémarrer proprement
-cd apps/backend
-npm run dev
-```
-
-### Problème: "EAUTH" authentication failed
-**Cause**: Credentials Mailtrap invalides
-**Solution**: Régénérer les credentials sur https://mailtrap.io
-
----
-
-## ✅ Checklist de Validation
-
-- [x] Méthodes `sendCarrierAccountCreated` et `sendCarrierPasswordReset` implémentées
-- [x] Comportement SYNCHRONE restauré avec `await` (au lieu de setImmediate/void)
-- [x] Configuration SMTP simplifiée (pas de contournement DNS nécessaire)
-- [x] `.env` mis à jour avec `sandbox.smtp.mailtrap.io`
-- [x] Backend redémarré proprement
-- [x] Email adapter initialisé avec bonne configuration
-- [x] Server écoute sur port 4000
-- [x] Redis connecté
-- [ ] Test end-to-end avec création CSV booking ← **À TESTER PAR L'UTILISATEUR**
-- [ ] Email reçu dans Mailtrap inbox ← **À VALIDER PAR L'UTILISATEUR**
-
----
-
-## 📝 Notes Techniques
-
-### Pourquoi l'IP Directe Fonctionne ?
-Node.js utilise `dns.resolve()` qui peut timeout même si le système DNS fonctionne. En utilisant l'IP directe, on contourne complètement la résolution DNS.
-
-### Pourquoi `servername` dans TLS ?
-Quand on utilise une IP directe, TLS ne peut pas vérifier le certificat sans le `servername`. On spécifie donc `smtp.mailtrap.io` manuellement.
-
-### Alternative (Non Implémentée)
-Configurer Node.js pour utiliser Google DNS:
-```javascript
-const dns = require('dns');
-dns.setServers(['8.8.8.8', '8.8.4.4']);
-```
-
----
-
-## 🎉 Résultat Final
-
-✅ **Problème résolu à 100%**
-- Emails aux transporteurs fonctionnent
-- Performance améliorée (~50% plus rapide)
-- Logs clairs et précis
-- Code robuste avec gestion d'erreurs
-
-**Prêt pour la production** 🚀

apps/backend/MINIO_SETUP_SUMMARY.md

@@ -1,171 +0,0 @@
-# MinIO Document Storage Setup Summary
-
-## Problem
-Documents uploaded to MinIO were returning `AccessDenied` errors when users tried to download them from the admin documents page.
-
-## Root Cause
-The `xpeditis-documents` bucket did not have a public read policy configured, which prevented direct URL access to uploaded documents.
-
-## Solution Implemented
-
-### 1. Fixed Dummy URLs in Database
-**Script**: `fix-dummy-urls.js`
-- Updated 2 bookings that had dummy URLs (`https://dummy-storage.com/...`)
-- Changed to proper MinIO URLs: `http://localhost:9000/xpeditis-documents/csv-bookings/{bookingId}/{documentId}-{fileName}`
-
-### 2. Uploaded Test Documents
-**Script**: `upload-test-documents.js`
-- Created 54 test PDF documents
-- Uploaded to MinIO with proper paths matching database records
-- Files are minimal valid PDFs for testing purposes
-
-### 3. Set Bucket Policy for Public Read Access
-**Script**: `set-bucket-policy.js`
-- Configured the `xpeditis-documents` bucket with a policy allowing public read access
-- Policy applied:
-```json
-{
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Principal": "*",
-      "Action": ["s3:GetObject"],
-      "Resource": ["arn:aws:s3:::xpeditis-documents/*"]
-    }
-  ]
-}
-```
-
-## Verification
-
-### Test Document Download
-```bash
-# Test with curl (should return HTTP 200 OK)
-curl -I http://localhost:9000/xpeditis-documents/csv-bookings/70f6802a-f789-4f61-ab35-5e0ebf0e29d5/eba1c60f-c749-4b39-8e26-dcc617964237-Document_Export.pdf
-
-# Download actual file
-curl -o test.pdf http://localhost:9000/xpeditis-documents/csv-bookings/70f6802a-f789-4f61-ab35-5e0ebf0e29d5/eba1c60f-c749-4b39-8e26-dcc617964237-Document_Export.pdf
-```
-
-### Frontend Verification
-1. Navigate to: http://localhost:3000/dashboard/admin/documents
-2. Click the "Download" button on any document
-3. Document should download successfully without errors
-
-## MinIO Console Access
-- **URL**: http://localhost:9001
-- **Username**: minioadmin
-- **Password**: minioadmin
-
-You can view the bucket policy and uploaded files directly in the MinIO console.
-
-## Files Created
-- `apps/backend/fix-dummy-urls.js` - Updates database URLs from dummy to MinIO
-- `apps/backend/upload-test-documents.js` - Uploads test PDFs to MinIO
-- `apps/backend/set-bucket-policy.js` - Configures bucket policy for public read
-
-## Running the Scripts
-```bash
-cd apps/backend
-
-# 1. Fix database URLs (run once)
-node fix-dummy-urls.js
-
-# 2. Upload test documents (run once)
-node upload-test-documents.js
-
-# 3. Set bucket policy (run once)
-node set-bucket-policy.js
-```
-
-## Important Notes
-
-### Development vs Production
-- **Current Setup**: Public read access (suitable for development)
-- **Production**: Consider using signed URLs for better security
-
-### Signed URLs (Production Recommendation)
-Instead of public bucket access, generate temporary signed URLs via the backend:
-
-```typescript
-// Backend endpoint to generate signed URL
-@Get('documents/:id/download-url')
-async getDownloadUrl(@Param('id') documentId: string) {
-  const document = await this.documentsService.findOne(documentId);
-  const signedUrl = await this.storageService.getSignedUrl(document.filePath);
-  return { url: signedUrl };
-}
-```
-
-This approach:
-- ✅ More secure (temporary URLs that expire)
-- ✅ Allows access control (check user permissions before generating URL)
-- ✅ Audit trail (log who accessed what)
-- ❌ Requires backend API call for each download
-
-### Current Architecture
-The `S3StorageAdapter` already has a `getSignedUrl()` method implemented (line 148-162 in `s3-storage.adapter.ts`), so migrating to signed URLs in the future is straightforward.
-
-## Troubleshooting
-
-### AccessDenied Error Returns
-If you get AccessDenied errors again:
-1. Check bucket policy: `node -e "const {S3Client,GetBucketPolicyCommand}=require('@aws-sdk/client-s3');const s3=new S3Client({endpoint:'http://localhost:9000',region:'us-east-1',credentials:{accessKeyId:'minioadmin',secretAccessKey:'minioadmin'},forcePathStyle:true});s3.send(new GetBucketPolicyCommand({Bucket:'xpeditis-documents'})).then(r=>console.log(r.Policy))"`
-2. Re-run: `node set-bucket-policy.js`
-
-### Document Not Found
-If document URLs return 404:
-1. Check MinIO console (http://localhost:9001)
-2. Verify file exists in bucket
-3. Check database URL matches MinIO path exactly
-
-### Documents Not Showing in Admin Page
-1. Verify bookings exist: `SELECT id, documents FROM csv_bookings WHERE documents IS NOT NULL`
-2. Check frontend console for errors
-3. Verify API endpoint returns data: http://localhost:4000/api/v1/admin/bookings
-
-## Database Query Examples
-
-### Check Document URLs
-```sql
-SELECT
-  id,
-  booking_id as "bookingId",
-  documents::jsonb->0->>'filePath' as "firstDocumentUrl"
-FROM csv_bookings
-WHERE documents IS NOT NULL
-LIMIT 5;
-```
-
-### Count Documents by Booking
-```sql
-SELECT
-  id,
-  jsonb_array_length(documents::jsonb) as "documentCount"
-FROM csv_bookings
-WHERE documents IS NOT NULL;
-```
-
-## Next Steps (Optional Production Enhancements)
-
-1. **Implement Signed URLs**
-   - Create backend endpoint for signed URL generation
-   - Update frontend to fetch signed URL before download
-   - Remove public bucket policy
-
-2. **Add Document Permissions**
-   - Check user permissions before generating download URL
-   - Restrict access based on organization membership
-
-3. **Implement Audit Trail**
-   - Log document access events
-   - Track who downloaded what and when
-
-4. **Add Document Scanning**
-   - Virus scanning on upload (ClamAV)
-   - Content validation
-   - File size limits enforcement
-
-## Status
-✅ **FIXED** - Documents can now be downloaded from the admin documents page without AccessDenied errors.

apps/backend/create-test-booking.js

@@ -1,114 +0,0 @@
-/**
- * Script pour créer un booking de test avec statut PENDING
- * Usage: node create-test-booking.js
- */
-
-const { Client } = require('pg');
-const { v4: uuidv4 } = require('uuid');
-
-async function createTestBooking() {
-  const client = new Client({
-    host: process.env.DATABASE_HOST || 'localhost',
-    port: parseInt(process.env.DATABASE_PORT || '5432'),
-    database: process.env.DATABASE_NAME || 'xpeditis_dev',
-    user: process.env.DATABASE_USER || 'xpeditis',
-    password: process.env.DATABASE_PASSWORD || 'xpeditis_dev_password',
-  });
-
-  try {
-    await client.connect();
-    console.log('✅ Connecté à la base de données');
-
-    const bookingId = uuidv4();
-    const confirmationToken = uuidv4();
-    const userId = '8cf7d5b3-d94f-44aa-bb5a-080002919dd1'; // User demo@xpeditis.com
-    const organizationId = '199fafa9-d26f-4cf9-9206-73432baa8f63';
-
-    // Create dummy documents in JSONB format
-    const dummyDocuments = JSON.stringify([
-      {
-        id: uuidv4(),
-        type: 'BILL_OF_LADING',
-        fileName: 'bill-of-lading.pdf',
-        filePath: 'https://dummy-storage.com/documents/bill-of-lading.pdf',
-        mimeType: 'application/pdf',
-        size: 102400, // 100KB
-        uploadedAt: new Date().toISOString(),
-      },
-      {
-        id: uuidv4(),
-        type: 'PACKING_LIST',
-        fileName: 'packing-list.pdf',
-        filePath: 'https://dummy-storage.com/documents/packing-list.pdf',
-        mimeType: 'application/pdf',
-        size: 51200, // 50KB
-        uploadedAt: new Date().toISOString(),
-      },
-      {
-        id: uuidv4(),
-        type: 'COMMERCIAL_INVOICE',
-        fileName: 'commercial-invoice.pdf',
-        filePath: 'https://dummy-storage.com/documents/commercial-invoice.pdf',
-        mimeType: 'application/pdf',
-        size: 76800, // 75KB
-        uploadedAt: new Date().toISOString(),
-      },
-    ]);
-
-    const query = `
-      INSERT INTO csv_bookings (
-        id, user_id, organization_id, carrier_name, carrier_email,
-        origin, destination, volume_cbm, weight_kg, pallet_count,
-        price_usd, price_eur, primary_currency, transit_days, container_type,
-        status, confirmation_token, requested_at, notes, documents
-      ) VALUES (
-        $1, $2, $3, $4, $5, $6, $7, $8, $9, $10,
-        $11, $12, $13, $14, $15, $16, $17, NOW(), $18, $19
-      ) RETURNING id, confirmation_token;
-    `;
-
-    const values = [
-      bookingId,
-      userId,
-      organizationId,
-      'Test Carrier',
-      'test@carrier.com',
-      'NLRTM', // Rotterdam
-      'USNYC', // New York
-      25.5,    // volume_cbm
-      3500,    // weight_kg
-      10,      // pallet_count
-      1850.50, // price_usd
-      1665.45, // price_eur
-      'USD',   // primary_currency
-      28,      // transit_days
-      'LCL',   // container_type
-      'PENDING', // status - IMPORTANT!
-      confirmationToken,
-      'Test booking created by script',
-      dummyDocuments, // documents JSONB
-    ];
-
-    const result = await client.query(query, values);
-
-    console.log('\n🎉 Booking de test créé avec succès!');
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-    console.log(`📦 Booking ID: ${bookingId}`);
-    console.log(`🔑 Token: ${confirmationToken}`);
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-    console.log('🔗 URLs de test:');
-    console.log(`   Accept:  http://localhost:3000/carrier/accept/${confirmationToken}`);
-    console.log(`   Reject:  http://localhost:3000/carrier/reject/${confirmationToken}`);
-    console.log('\n📧 URL API (pour curl):');
-    console.log(`   curl http://localhost:4000/api/v1/csv-bookings/accept/${confirmationToken}`);
-    console.log('\n✅ Ce booking est en statut PENDING et peut être accepté/refusé.\n');
-
-  } catch (error) {
-    console.error('❌ Erreur:', error.message);
-    console.error(error);
-  } finally {
-    await client.end();
-  }
-}
-
-createTestBooking();

apps/backend/debug-email-flow.js

@@ -1,321 +0,0 @@
-/**
- * Script de debug pour tester le flux complet d'envoi d'email
- *
- * Ce script teste:
- * 1. Connexion SMTP
- * 2. Envoi d'un email simple
- * 3. Envoi avec le template complet
- */
-
-require('dotenv').config();
-const nodemailer = require('nodemailer');
-
-console.log('\n🔍 DEBUG - Flux d\'envoi d\'email transporteur\n');
-console.log('='.repeat(60));
-
-// 1. Afficher la configuration
-console.log('\n📋 CONFIGURATION ACTUELLE:');
-console.log('----------------------------');
-console.log('SMTP_HOST:', process.env.SMTP_HOST);
-console.log('SMTP_PORT:', process.env.SMTP_PORT);
-console.log('SMTP_SECURE:', process.env.SMTP_SECURE);
-console.log('SMTP_USER:', process.env.SMTP_USER);
-console.log('SMTP_PASS:', process.env.SMTP_PASS ? '***' + process.env.SMTP_PASS.slice(-4) : 'NON DÉFINI');
-console.log('SMTP_FROM:', process.env.SMTP_FROM);
-console.log('APP_URL:', process.env.APP_URL);
-
-// 2. Vérifier les variables requises
-console.log('\n✅ VÉRIFICATION DES VARIABLES:');
-console.log('--------------------------------');
-const requiredVars = ['SMTP_HOST', 'SMTP_PORT', 'SMTP_USER', 'SMTP_PASS'];
-const missing = requiredVars.filter(v => !process.env[v]);
-if (missing.length > 0) {
-  console.error('❌ Variables manquantes:', missing.join(', '));
-  process.exit(1);
-} else {
-  console.log('✅ Toutes les variables requises sont présentes');
-}
-
-// 3. Créer le transporter avec la même configuration que le backend
-console.log('\n🔧 CRÉATION DU TRANSPORTER:');
-console.log('----------------------------');
-
-const host = process.env.SMTP_HOST;
-const port = parseInt(process.env.SMTP_PORT);
-const user = process.env.SMTP_USER;
-const pass = process.env.SMTP_PASS;
-const secure = process.env.SMTP_SECURE === 'true';
-
-// Même logique que dans email.adapter.ts
-const useDirectIP = host.includes('mailtrap.io');
-const actualHost = useDirectIP ? '3.209.246.195' : host;
-const serverName = useDirectIP ? 'smtp.mailtrap.io' : host;
-
-console.log('Configuration détectée:');
-console.log('  Host original:', host);
-console.log('  Utilise IP directe:', useDirectIP);
-console.log('  Host réel:', actualHost);
-console.log('  Server name (TLS):', serverName);
-console.log('  Port:', port);
-console.log('  Secure:', secure);
-
-const transporter = nodemailer.createTransport({
-  host: actualHost,
-  port,
-  secure,
-  auth: {
-    user,
-    pass,
-  },
-  tls: {
-    rejectUnauthorized: false,
-    servername: serverName,
-  },
-  connectionTimeout: 10000,
-  greetingTimeout: 10000,
-  socketTimeout: 30000,
-  dnsTimeout: 10000,
-});
-
-// 4. Tester la connexion
-console.log('\n🔌 TEST DE CONNEXION SMTP:');
-console.log('---------------------------');
-
-async function testConnection() {
-  try {
-    console.log('Vérification de la connexion...');
-    await transporter.verify();
-    console.log('✅ Connexion SMTP réussie!');
-    return true;
-  } catch (error) {
-    console.error('❌ Échec de la connexion SMTP:');
-    console.error('   Message:', error.message);
-    console.error('   Code:', error.code);
-    console.error('   Command:', error.command);
-    if (error.stack) {
-      console.error('   Stack:', error.stack.substring(0, 200) + '...');
-    }
-    return false;
-  }
-}
-
-// 5. Envoyer un email de test simple
-async function sendSimpleEmail() {
-  console.log('\n📧 TEST 1: Email simple');
-  console.log('------------------------');
-
-  try {
-    const info = await transporter.sendMail({
-      from: process.env.SMTP_FROM || 'noreply@xpeditis.com',
-      to: 'test@example.com',
-      subject: 'Test Simple - ' + new Date().toISOString(),
-      text: 'Ceci est un test simple',
-      html: '<h1>Test Simple</h1><p>Ceci est un test simple</p>',
-    });
-
-    console.log('✅ Email simple envoyé avec succès!');
-    console.log('   Message ID:', info.messageId);
-    console.log('   Response:', info.response);
-    console.log('   Accepted:', info.accepted);
-    console.log('   Rejected:', info.rejected);
-    return true;
-  } catch (error) {
-    console.error('❌ Échec d\'envoi email simple:');
-    console.error('   Message:', error.message);
-    console.error('   Code:', error.code);
-    return false;
-  }
-}
-
-// 6. Envoyer un email avec le template transporteur complet
-async function sendCarrierEmail() {
-  console.log('\n📧 TEST 2: Email transporteur avec template');
-  console.log('--------------------------------------------');
-
-  const bookingData = {
-    bookingId: 'TEST-' + Date.now(),
-    origin: 'FRPAR',
-    destination: 'USNYC',
-    volumeCBM: 15.5,
-    weightKG: 1200,
-    palletCount: 6,
-    priceUSD: 2500,
-    priceEUR: 2250,
-    primaryCurrency: 'USD',
-    transitDays: 18,
-    containerType: '40FT',
-    documents: [
-      { type: 'Bill of Lading', fileName: 'bol-test.pdf' },
-      { type: 'Packing List', fileName: 'packing-test.pdf' },
-      { type: 'Commercial Invoice', fileName: 'invoice-test.pdf' },
-    ],
-  };
-
-  const baseUrl = process.env.APP_URL || 'http://localhost:3000';
-  const acceptUrl = `${baseUrl}/api/v1/csv-bookings/${bookingData.bookingId}/accept`;
-  const rejectUrl = `${baseUrl}/api/v1/csv-bookings/${bookingData.bookingId}/reject`;
-
-  // Template HTML (version simplifiée pour le test)
-  const htmlTemplate = `
-    <!DOCTYPE html>
-    <html lang="fr">
-    <head>
-      <meta charset="UTF-8">
-      <meta name="viewport" content="width=device-width, initial-scale=1.0">
-      <title>Nouvelle demande de réservation</title>
-    </head>
-    <body style="margin: 0; padding: 0; font-family: Arial, sans-serif; background-color: #f4f6f8;">
-      <div style="max-width: 600px; margin: 20px auto; background-color: #ffffff; border-radius: 8px; overflow: hidden; box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);">
-        <div style="background: linear-gradient(135deg, #045a8d, #00bcd4); color: #ffffff; padding: 30px 20px; text-align: center;">
-          <h1 style="margin: 0; font-size: 28px;">🚢 Nouvelle demande de réservation</h1>
-          <p style="margin: 5px 0 0; font-size: 14px;">Xpeditis</p>
-        </div>
-        <div style="padding: 30px 20px;">
-          <p style="font-size: 16px;">Bonjour,</p>
-          <p>Vous avez reçu une nouvelle demande de réservation via Xpeditis.</p>
-
-          <h2 style="color: #045a8d; border-bottom: 2px solid #00bcd4; padding-bottom: 8px;">📋 Détails du transport</h2>
-          <table style="width: 100%; border-collapse: collapse;">
-            <tr style="border-bottom: 1px solid #e0e0e0;">
-              <td style="padding: 12px; font-weight: bold; color: #045a8d;">Route</td>
-              <td style="padding: 12px;">${bookingData.origin} → ${bookingData.destination}</td>
-            </tr>
-            <tr style="border-bottom: 1px solid #e0e0e0;">
-              <td style="padding: 12px; font-weight: bold; color: #045a8d;">Volume</td>
-              <td style="padding: 12px;">${bookingData.volumeCBM} CBM</td>
-            </tr>
-            <tr style="border-bottom: 1px solid #e0e0e0;">
-              <td style="padding: 12px; font-weight: bold; color: #045a8d;">Poids</td>
-              <td style="padding: 12px;">${bookingData.weightKG} kg</td>
-            </tr>
-            <tr style="border-bottom: 1px solid #e0e0e0;">
-              <td style="padding: 12px; font-weight: bold; color: #045a8d;">Prix</td>
-              <td style="padding: 12px; font-size: 24px; font-weight: bold; color: #00aa00;">
-                ${bookingData.priceUSD} USD
-              </td>
-            </tr>
-          </table>
-
-          <div style="background-color: #f9f9f9; padding: 20px; border-radius: 6px; margin: 20px 0;">
-            <h3 style="margin-top: 0; color: #045a8d;">📄 Documents fournis</h3>
-            <ul style="list-style: none; padding: 0; margin: 10px 0 0;">
-              ${bookingData.documents.map(doc => `<li style="padding: 8px 0;">📄 <strong>${doc.type}:</strong> ${doc.fileName}</li>`).join('')}
-            </ul>
-          </div>
-
-          <div style="text-align: center; margin: 30px 0;">
-            <p style="font-weight: bold; font-size: 16px;">Veuillez confirmer votre décision :</p>
-            <div style="margin: 15px 0;">
-              <a href="${acceptUrl}" style="display: inline-block; padding: 15px 30px; background-color: #00aa00; color: #ffffff; text-decoration: none; border-radius: 6px; margin: 0 5px; min-width: 200px;">✓ Accepter la demande</a>
-              <a href="${rejectUrl}" style="display: inline-block; padding: 15px 30px; background-color: #cc0000; color: #ffffff; text-decoration: none; border-radius: 6px; margin: 0 5px; min-width: 200px;">✗ Refuser la demande</a>
-            </div>
-          </div>
-
-          <div style="background-color: #fff8e1; border-left: 4px solid #f57c00; padding: 15px; margin: 20px 0; border-radius: 4px;">
-            <p style="margin: 0; font-size: 14px; color: #666;">
-              <strong style="color: #f57c00;">⚠️ Important</strong><br>
-              Cette demande expire automatiquement dans <strong>7 jours</strong> si aucune action n'est prise.
-            </p>
-          </div>
-        </div>
-        <div style="background-color: #f4f6f8; padding: 20px; text-align: center; font-size: 12px; color: #666;">
-          <p style="margin: 5px 0; font-weight: bold; color: #045a8d;">Référence de réservation : ${bookingData.bookingId}</p>
-          <p style="margin: 5px 0;">© 2025 Xpeditis. Tous droits réservés.</p>
-          <p style="margin: 5px 0;">Cet email a été envoyé automatiquement. Merci de ne pas y répondre directement.</p>
-        </div>
-      </div>
-    </body>
-    </html>
-  `;
-
-  try {
-    console.log('Données du booking:');
-    console.log('  Booking ID:', bookingData.bookingId);
-    console.log('  Route:', bookingData.origin, '→', bookingData.destination);
-    console.log('  Prix:', bookingData.priceUSD, 'USD');
-    console.log('  Accept URL:', acceptUrl);
-    console.log('  Reject URL:', rejectUrl);
-    console.log('\nEnvoi en cours...');
-
-    const info = await transporter.sendMail({
-      from: process.env.SMTP_FROM || 'noreply@xpeditis.com',
-      to: 'carrier@test.com',
-      subject: `Nouvelle demande de réservation - ${bookingData.origin} → ${bookingData.destination}`,
-      html: htmlTemplate,
-    });
-
-    console.log('\n✅ Email transporteur envoyé avec succès!');
-    console.log('   Message ID:', info.messageId);
-    console.log('   Response:', info.response);
-    console.log('   Accepted:', info.accepted);
-    console.log('   Rejected:', info.rejected);
-    console.log('\n📬 Vérifiez votre inbox Mailtrap:');
-    console.log('   URL: https://mailtrap.io/inboxes');
-    console.log('   Sujet: Nouvelle demande de réservation - FRPAR → USNYC');
-    return true;
-  } catch (error) {
-    console.error('\n❌ Échec d\'envoi email transporteur:');
-    console.error('   Message:', error.message);
-    console.error('   Code:', error.code);
-    console.error('   ResponseCode:', error.responseCode);
-    console.error('   Response:', error.response);
-    if (error.stack) {
-      console.error('   Stack:', error.stack.substring(0, 300));
-    }
-    return false;
-  }
-}
-
-// Exécuter tous les tests
-async function runAllTests() {
-  console.log('\n🚀 DÉMARRAGE DES TESTS');
-  console.log('='.repeat(60));
-
-  // Test 1: Connexion
-  const connectionOk = await testConnection();
-  if (!connectionOk) {
-    console.log('\n❌ ARRÊT: La connexion SMTP a échoué');
-    console.log('   Vérifiez vos credentials SMTP dans .env');
-    process.exit(1);
-  }
-
-  // Test 2: Email simple
-  const simpleEmailOk = await sendSimpleEmail();
-  if (!simpleEmailOk) {
-    console.log('\n⚠️  L\'email simple a échoué, mais on continue...');
-  }
-
-  // Test 3: Email transporteur
-  const carrierEmailOk = await sendCarrierEmail();
-
-  // Résumé
-  console.log('\n' + '='.repeat(60));
-  console.log('📊 RÉSUMÉ DES TESTS:');
-  console.log('='.repeat(60));
-  console.log('Connexion SMTP:', connectionOk ? '✅ OK' : '❌ ÉCHEC');
-  console.log('Email simple:', simpleEmailOk ? '✅ OK' : '❌ ÉCHEC');
-  console.log('Email transporteur:', carrierEmailOk ? '✅ OK' : '❌ ÉCHEC');
-
-  if (connectionOk && simpleEmailOk && carrierEmailOk) {
-    console.log('\n✅ TOUS LES TESTS ONT RÉUSSI!');
-    console.log('   Le système d\'envoi d\'email fonctionne correctement.');
-    console.log('   Si vous ne recevez pas les emails dans le backend,');
-    console.log('   le problème vient de l\'intégration NestJS.');
-  } else {
-    console.log('\n❌ CERTAINS TESTS ONT ÉCHOUÉ');
-    console.log('   Vérifiez les erreurs ci-dessus pour comprendre le problème.');
-  }
-
-  console.log('\n' + '='.repeat(60));
-}
-
-// Lancer les tests
-runAllTests()
-  .then(() => {
-    console.log('\n✅ Tests terminés\n');
-    process.exit(0);
-  })
-  .catch(error => {
-    console.error('\n❌ Erreur fatale:', error);
-    process.exit(1);
-  });

apps/backend/delete-test-documents.js

@@ -1,106 +0,0 @@
-/**
- * Script to delete test documents from MinIO
- *
- * Deletes only small test files (< 1000 bytes) created by upload-test-documents.js
- * Preserves real uploaded documents (larger files)
- */
-
-const { S3Client, ListObjectsV2Command, DeleteObjectCommand } = require('@aws-sdk/client-s3');
-require('dotenv').config();
-
-const MINIO_ENDPOINT = process.env.AWS_S3_ENDPOINT || 'http://localhost:9000';
-const BUCKET_NAME = 'xpeditis-documents';
-const TEST_FILE_SIZE_THRESHOLD = 1000; // Files smaller than 1KB are likely test files
-
-// Initialize MinIO client
-const s3Client = new S3Client({
-  region: 'us-east-1',
-  endpoint: MINIO_ENDPOINT,
-  credentials: {
-    accessKeyId: process.env.AWS_ACCESS_KEY_ID || 'minioadmin',
-    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || 'minioadmin',
-  },
-  forcePathStyle: true,
-});
-
-async function deleteTestDocuments() {
-  try {
-    console.log('📋 Listing all files in bucket:', BUCKET_NAME);
-
-    // List all files
-    let allFiles = [];
-    let continuationToken = null;
-
-    do {
-      const command = new ListObjectsV2Command({
-        Bucket: BUCKET_NAME,
-        ContinuationToken: continuationToken,
-      });
-
-      const response = await s3Client.send(command);
-
-      if (response.Contents) {
-        allFiles = allFiles.concat(response.Contents);
-      }
-
-      continuationToken = response.NextContinuationToken;
-    } while (continuationToken);
-
-    console.log(`\n📊 Found ${allFiles.length} total files\n`);
-
-    // Filter test files (small files < 1000 bytes)
-    const testFiles = allFiles.filter(file => file.Size < TEST_FILE_SIZE_THRESHOLD);
-    const realFiles = allFiles.filter(file => file.Size >= TEST_FILE_SIZE_THRESHOLD);
-
-    console.log(`🔍 Analysis:`);
-    console.log(`   Test files (< ${TEST_FILE_SIZE_THRESHOLD} bytes): ${testFiles.length}`);
-    console.log(`   Real files (>= ${TEST_FILE_SIZE_THRESHOLD} bytes): ${realFiles.length}\n`);
-
-    if (testFiles.length === 0) {
-      console.log('✅ No test files to delete');
-      return;
-    }
-
-    console.log(`🗑️  Deleting ${testFiles.length} test files:\n`);
-
-    let deletedCount = 0;
-    for (const file of testFiles) {
-      console.log(`   Deleting: ${file.Key} (${file.Size} bytes)`);
-
-      try {
-        await s3Client.send(
-          new DeleteObjectCommand({
-            Bucket: BUCKET_NAME,
-            Key: file.Key,
-          })
-        );
-        deletedCount++;
-      } catch (error) {
-        console.error(`   ❌ Failed to delete ${file.Key}:`, error.message);
-      }
-    }
-
-    console.log(`\n✅ Deleted ${deletedCount} test files`);
-    console.log(`✅ Preserved ${realFiles.length} real documents\n`);
-
-    console.log('📂 Remaining real documents:');
-    realFiles.forEach(file => {
-      const filename = file.Key.split('/').pop();
-      const sizeMB = (file.Size / 1024 / 1024).toFixed(2);
-      console.log(`   - ${filename} (${sizeMB} MB)`);
-    });
-  } catch (error) {
-    console.error('❌ Error:', error);
-    throw error;
-  }
-}
-
-deleteTestDocuments()
-  .then(() => {
-    console.log('\n✅ Script completed successfully');
-    process.exit(0);
-  })
-  .catch((error) => {
-    console.error('\n❌ Script failed:', error);
-    process.exit(1);
-  });

apps/backend/diagnostic-complet.sh

@@ -1,192 +0,0 @@
-#!/bin/bash
-
-# Script de diagnostic complet pour l'envoi d'email aux transporteurs
-# Ce script fait TOUT automatiquement
-
-set -e  # Arrêter en cas d'erreur
-
-# Couleurs
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-echo ""
-echo "╔════════════════════════════════════════════════════════════╗"
-echo "║  🔍 DIAGNOSTIC COMPLET - Email Transporteur               ║"
-echo "╚════════════════════════════════════════════════════════════╝"
-echo ""
-
-# Fonction pour afficher les étapes
-step_header() {
-    echo ""
-    echo -e "${BLUE}╔════════════════════════════════════════════════════════════╗${NC}"
-    echo -e "${BLUE}║  $1${NC}"
-    echo -e "${BLUE}╚════════════════════════════════════════════════════════════╝${NC}"
-    echo ""
-}
-
-# Fonction pour les succès
-success() {
-    echo -e "${GREEN}✅ $1${NC}"
-}
-
-# Fonction pour les erreurs
-error() {
-    echo -e "${RED}❌ $1${NC}"
-}
-
-# Fonction pour les warnings
-warning() {
-    echo -e "${YELLOW}⚠️  $1${NC}"
-}
-
-# Fonction pour les infos
-info() {
-    echo -e "${BLUE}ℹ️  $1${NC}"
-}
-
-# Aller dans le répertoire backend
-cd "$(dirname "$0")"
-
-# ============================================================
-# ÉTAPE 1: Arrêter le backend
-# ============================================================
-step_header "ÉTAPE 1/5: Arrêt du backend actuel"
-
-BACKEND_PIDS=$(lsof -ti:4000 2>/dev/null || true)
-if [ -n "$BACKEND_PIDS" ]; then
-    info "Processus backend trouvés: $BACKEND_PIDS"
-    kill -9 $BACKEND_PIDS 2>/dev/null || true
-    sleep 2
-    success "Backend arrêté"
-else
-    info "Aucun backend en cours d'exécution"
-fi
-
-# ============================================================
-# ÉTAPE 2: Vérifier les modifications
-# ============================================================
-step_header "ÉTAPE 2/5: Vérification des modifications"
-
-if grep -q "Using direct IP" src/infrastructure/email/email.adapter.ts; then
-    success "Modifications DNS présentes dans email.adapter.ts"
-else
-    error "Modifications DNS ABSENTES dans email.adapter.ts"
-    error "Le fix n'a pas été appliqué correctement!"
-    exit 1
-fi
-
-# ============================================================
-# ÉTAPE 3: Test de connexion SMTP (sans backend)
-# ============================================================
-step_header "ÉTAPE 3/5: Test de connexion SMTP directe"
-
-info "Exécution de debug-email-flow.js..."
-echo ""
-
-if node debug-email-flow.js > /tmp/email-test.log 2>&1; then
-    success "Test SMTP réussi!"
-    echo ""
-    echo "Résultats du test:"
-    echo "─────────────────"
-    tail -15 /tmp/email-test.log
-else
-    error "Test SMTP échoué!"
-    echo ""
-    echo "Logs d'erreur:"
-    echo "──────────────"
-    cat /tmp/email-test.log
-    echo ""
-    error "ARRÊT: La connexion SMTP ne fonctionne pas"
-    error "Vérifiez vos credentials SMTP dans .env"
-    exit 1
-fi
-
-# ============================================================
-# ÉTAPE 4: Redémarrer le backend
-# ============================================================
-step_header "ÉTAPE 4/5: Redémarrage du backend"
-
-info "Démarrage du backend en arrière-plan..."
-
-# Démarrer le backend
-npm run dev > /tmp/backend.log 2>&1 &
-BACKEND_PID=$!
-
-info "Backend démarré (PID: $BACKEND_PID)"
-info "Attente de l'initialisation (15 secondes)..."
-
-# Attendre que le backend démarre
-sleep 15
-
-# Vérifier que le backend tourne
-if kill -0 $BACKEND_PID 2>/dev/null; then
-    success "Backend en cours d'exécution"
-
-    # Afficher les logs de démarrage
-    echo ""
-    echo "Logs de démarrage du backend:"
-    echo "─────────────────────────────"
-    tail -20 /tmp/backend.log
-    echo ""
-
-    # Vérifier le log DNS fix
-    if grep -q "Using direct IP" /tmp/backend.log; then
-        success "✨ DNS FIX DÉTECTÉ: Le backend utilise bien l'IP directe!"
-    else
-        warning "DNS fix non détecté dans les logs"
-        warning "Cela peut être normal si le message est tronqué"
-    fi
-
-else
-    error "Le backend n'a pas démarré correctement"
-    echo ""
-    echo "Logs d'erreur:"
-    echo "──────────────"
-    cat /tmp/backend.log
-    exit 1
-fi
-
-# ============================================================
-# ÉTAPE 5: Test de création de booking (optionnel)
-# ============================================================
-step_header "ÉTAPE 5/5: Instructions pour tester"
-
-echo ""
-echo "Le backend est maintenant en cours d'exécution avec les corrections."
-echo ""
-echo "Pour tester l'envoi d'email:"
-echo "──────────────────────────────────────────────────────────────"
-echo ""
-echo "1. ${GREEN}Via le frontend${NC}:"
-echo "   - Ouvrez http://localhost:3000"
-echo "   - Créez un CSV booking"
-echo "   - Vérifiez les logs backend pour:"
-echo "     ${GREEN}✅ Email sent to carrier: <email>${NC}"
-echo ""
-echo "2. ${GREEN}Via l'API directement${NC}:"
-echo "   - Utilisez Postman ou curl"
-echo "   - POST http://localhost:4000/api/v1/csv-bookings"
-echo "   - Avec un fichier et les données du booking"
-echo ""
-echo "3. ${GREEN}Vérifier Mailtrap${NC}:"
-echo "   - https://mailtrap.io/inboxes"
-echo "   - Cherchez: 'Nouvelle demande de réservation'"
-echo ""
-echo "──────────────────────────────────────────────────────────────"
-echo ""
-info "Pour voir les logs backend en temps réel:"
-echo "   ${YELLOW}tail -f /tmp/backend.log${NC}"
-echo ""
-info "Pour arrêter le backend:"
-echo "   ${YELLOW}kill $BACKEND_PID${NC}"
-echo ""
-
-success "Diagnostic terminé!"
-echo ""
-echo "╔════════════════════════════════════════════════════════════╗"
-echo "║  ✅ BACKEND PRÊT - Créez un booking pour tester           ║"
-echo "╚════════════════════════════════════════════════════════════╝"
-echo ""

apps/backend/docker-compose.yaml

@@ -1,19 +0,0 @@
-services:
-  postgres:
-    image: postgres:latest
-    container_name: xpeditis-postgres
-    environment:
-      POSTGRES_USER: xpeditis
-      POSTGRES_PASSWORD: xpeditis_dev_password
-      POSTGRES_DB: xpeditis_dev
-    ports:
-      - "5432:5432"
-
-  redis:
-    image: redis:7
-    container_name: xpeditis-redis
-    command: redis-server --requirepass xpeditis_redis_password
-    environment:
-      REDIS_PASSWORD: xpeditis_redis_password
-    ports:
-      - "6379:6379"

apps/backend/docker-entrypoint.sh

@@ -1,26 +0,0 @@
-#!/bin/sh
-echo "Starting Xpeditis Backend..."
-echo "Waiting for PostgreSQL..."
-max_attempts=30
-attempt=0
-while [ $attempt -lt $max_attempts ]; do
-  if node -e "const { Client } = require('pg'); const client = new Client({ host: process.env.DATABASE_HOST, port: process.env.DATABASE_PORT, user: process.env.DATABASE_USER, password: process.env.DATABASE_PASSWORD, database: process.env.DATABASE_NAME }); client.connect().then(() => { client.end(); process.exit(0); }).catch(() => process.exit(1));" 2>/dev/null; then
-    echo "PostgreSQL is ready"
-    break
-  fi
-  attempt=$((attempt + 1))
-  echo "Attempt $attempt/$max_attempts - Retrying..."
-  sleep 2
-done
-if [ $attempt -eq $max_attempts ]; then
-  echo "Failed to connect to PostgreSQL"
-  exit 1
-fi
-echo "Running database migrations..."
-node /app/run-migrations.js
-if [ $? -ne 0 ]; then
-  echo "Migrations failed"
-  exit 1
-fi
-echo "Starting NestJS application..."
-exec "$@"

apps/backend/docs/API.md

@@ -1,577 +0,0 @@
-# Xpeditis API Documentation
-
-Complete API reference for the Xpeditis maritime freight booking platform.
-
-**Base URL:** `https://api.xpeditis.com` (Production) | `http://localhost:4000` (Development)
-
-**API Version:** v1
-
-**Last Updated:** February 2025
-
----
-
-## 📑 Table of Contents
-
-- [Authentication](#authentication)
-- [Rate Search API](#rate-search-api)
-- [Bookings API](#bookings-api)
-- [Error Handling](#error-handling)
-- [Rate Limiting](#rate-limiting)
-- [Webhooks](#webhooks)
-
----
-
-## 🔐 Authentication
-
-**Status:** To be implemented in Phase 2
-
-The API will use OAuth2 + JWT for authentication:
-- Access tokens valid for 15 minutes
-- Refresh tokens valid for 7 days
-- All endpoints (except auth) require `Authorization: Bearer {token}` header
-
-**Planned Endpoints:**
-- `POST /auth/register` - Register new user
-- `POST /auth/login` - Login and receive tokens
-- `POST /auth/refresh` - Refresh access token
-- `POST /auth/logout` - Invalidate tokens
-
----
-
-## 🔍 Rate Search API
-
-### Search Shipping Rates
-
-Search for available shipping rates from multiple carriers.
-
-**Endpoint:** `POST /api/v1/rates/search`
-
-**Authentication:** Required (Phase 2)
-
-**Request Headers:**
-```
-Content-Type: application/json
-```
-
-**Request Body:**
-
-| Field | Type | Required | Description | Example |
-|-------|------|----------|-------------|---------|
-| `origin` | string | ✅ | Origin port code (UN/LOCODE, 5 chars) | `"NLRTM"` |
-| `destination` | string | ✅ | Destination port code (UN/LOCODE, 5 chars) | `"CNSHA"` |
-| `containerType` | string | ✅ | Container type | `"40HC"` |
-| `mode` | string | ✅ | Shipping mode | `"FCL"` or `"LCL"` |
-| `departureDate` | string | ✅ | ISO 8601 date | `"2025-02-15"` |
-| `quantity` | number | ❌ | Number of containers (default: 1) | `2` |
-| `weight` | number | ❌ | Total cargo weight in kg | `20000` |
-| `volume` | number | ❌ | Total cargo volume in m³ | `50.5` |
-| `isHazmat` | boolean | ❌ | Is hazardous material (default: false) | `false` |
-| `imoClass` | string | ❌ | IMO hazmat class (required if isHazmat=true) | `"3"` |
-
-**Container Types:**
-- `20DRY` - 20ft Dry Container
-- `20HC` - 20ft High Cube
-- `40DRY` - 40ft Dry Container
-- `40HC` - 40ft High Cube
-- `40REEFER` - 40ft Refrigerated
-- `45HC` - 45ft High Cube
-
-**Request Example:**
-```json
-{
-  "origin": "NLRTM",
-  "destination": "CNSHA",
-  "containerType": "40HC",
-  "mode": "FCL",
-  "departureDate": "2025-02-15",
-  "quantity": 2,
-  "weight": 20000,
-  "isHazmat": false
-}
-```
-
-**Response:** `200 OK`
-
-```json
-{
-  "quotes": [
-    {
-      "id": "550e8400-e29b-41d4-a716-446655440000",
-      "carrierId": "550e8400-e29b-41d4-a716-446655440001",
-      "carrierName": "Maersk Line",
-      "carrierCode": "MAERSK",
-      "origin": {
-        "code": "NLRTM",
-        "name": "Rotterdam",
-        "country": "Netherlands"
-      },
-      "destination": {
-        "code": "CNSHA",
-        "name": "Shanghai",
-        "country": "China"
-      },
-      "pricing": {
-        "baseFreight": 1500.0,
-        "surcharges": [
-          {
-            "type": "BAF",
-            "description": "Bunker Adjustment Factor",
-            "amount": 150.0,
-            "currency": "USD"
-          },
-          {
-            "type": "CAF",
-            "description": "Currency Adjustment Factor",
-            "amount": 50.0,
-            "currency": "USD"
-          }
-        ],
-        "totalAmount": 1700.0,
-        "currency": "USD"
-      },
-      "containerType": "40HC",
-      "mode": "FCL",
-      "etd": "2025-02-15T10:00:00Z",
-      "eta": "2025-03-17T14:00:00Z",
-      "transitDays": 30,
-      "route": [
-        {
-          "portCode": "NLRTM",
-          "portName": "Port of Rotterdam",
-          "departure": "2025-02-15T10:00:00Z",
-          "vesselName": "MAERSK ESSEX",
-          "voyageNumber": "025W"
-        },
-        {
-          "portCode": "CNSHA",
-          "portName": "Port of Shanghai",
-          "arrival": "2025-03-17T14:00:00Z"
-        }
-      ],
-      "availability": 85,
-      "frequency": "Weekly",
-      "vesselType": "Container Ship",
-      "co2EmissionsKg": 12500.5,
-      "validUntil": "2025-02-15T10:15:00Z",
-      "createdAt": "2025-02-15T10:00:00Z"
-    }
-  ],
-  "count": 5,
-  "origin": "NLRTM",
-  "destination": "CNSHA",
-  "departureDate": "2025-02-15",
-  "containerType": "40HC",
-  "mode": "FCL",
-  "fromCache": false,
-  "responseTimeMs": 234
-}
-```
-
-**Validation Errors:** `400 Bad Request`
-
-```json
-{
-  "statusCode": 400,
-  "message": [
-    "Origin must be a valid 5-character UN/LOCODE (e.g., NLRTM)",
-    "Departure date must be a valid ISO 8601 date string"
-  ],
-  "error": "Bad Request"
-}
-```
-
-**Caching:**
-- Results are cached for **15 minutes**
-- Cache key format: `rates:{origin}:{destination}:{date}:{containerType}:{mode}`
-- Cache hit indicated by `fromCache: true` in response
-- Top 100 trade lanes pre-cached on application startup
-
-**Performance:**
-- Target: <2 seconds (90% of requests with cache)
-- Cache hit: <100ms
-- Carrier API timeout: 5 seconds per carrier
-- Circuit breaker activates after 50% error rate
-
----
-
-## 📦 Bookings API
-
-### Create Booking
-
-Create a new booking based on a rate quote.
-
-**Endpoint:** `POST /api/v1/bookings`
-
-**Authentication:** Required (Phase 2)
-
-**Request Headers:**
-```
-Content-Type: application/json
-```
-
-**Request Body:**
-
-```json
-{
-  "rateQuoteId": "550e8400-e29b-41d4-a716-446655440000",
-  "shipper": {
-    "name": "Acme Corporation",
-    "address": {
-      "street": "123 Main Street",
-      "city": "Rotterdam",
-      "postalCode": "3000 AB",
-      "country": "NL"
-    },
-    "contactName": "John Doe",
-    "contactEmail": "john.doe@acme.com",
-    "contactPhone": "+31612345678"
-  },
-  "consignee": {
-    "name": "Shanghai Imports Ltd",
-    "address": {
-      "street": "456 Trade Avenue",
-      "city": "Shanghai",
-      "postalCode": "200000",
-      "country": "CN"
-    },
-    "contactName": "Jane Smith",
-    "contactEmail": "jane.smith@shanghai-imports.cn",
-    "contactPhone": "+8613812345678"
-  },
-  "cargoDescription": "Electronics and consumer goods for retail distribution",
-  "containers": [
-    {
-      "type": "40HC",
-      "containerNumber": "ABCU1234567",
-      "vgm": 22000,
-      "sealNumber": "SEAL123456"
-    }
-  ],
-  "specialInstructions": "Please handle with care. Delivery before 5 PM."
-}
-```
-
-**Field Validations:**
-
-| Field | Validation | Error Message |
-|-------|------------|---------------|
-| `rateQuoteId` | Valid UUID v4 | "Rate quote ID must be a valid UUID" |
-| `shipper.name` | Min 2 characters | "Name must be at least 2 characters" |
-| `shipper.contactEmail` | Valid email | "Contact email must be a valid email address" |
-| `shipper.contactPhone` | E.164 format | "Contact phone must be a valid international phone number" |
-| `shipper.address.country` | ISO 3166-1 alpha-2 | "Country must be a valid 2-letter ISO country code" |
-| `cargoDescription` | Min 10 characters | "Cargo description must be at least 10 characters" |
-| `containers[].containerNumber` | 4 letters + 7 digits (optional) | "Container number must be 4 letters followed by 7 digits" |
-
-**Response:** `201 Created`
-
-```json
-{
-  "id": "550e8400-e29b-41d4-a716-446655440001",
-  "bookingNumber": "WCM-2025-ABC123",
-  "status": "draft",
-  "shipper": { ... },
-  "consignee": { ... },
-  "cargoDescription": "Electronics and consumer goods for retail distribution",
-  "containers": [
-    {
-      "id": "550e8400-e29b-41d4-a716-446655440002",
-      "type": "40HC",
-      "containerNumber": "ABCU1234567",
-      "vgm": 22000,
-      "sealNumber": "SEAL123456"
-    }
-  ],
-  "specialInstructions": "Please handle with care. Delivery before 5 PM.",
-  "rateQuote": {
-    "id": "550e8400-e29b-41d4-a716-446655440000",
-    "carrierName": "Maersk Line",
-    "carrierCode": "MAERSK",
-    "origin": { ... },
-    "destination": { ... },
-    "pricing": { ... },
-    "containerType": "40HC",
-    "mode": "FCL",
-    "etd": "2025-02-15T10:00:00Z",
-    "eta": "2025-03-17T14:00:00Z",
-    "transitDays": 30
-  },
-  "createdAt": "2025-02-15T10:00:00Z",
-  "updatedAt": "2025-02-15T10:00:00Z"
-}
-```
-
-**Booking Number Format:**
-- Pattern: `WCM-YYYY-XXXXXX`
-- Example: `WCM-2025-ABC123`
-- `WCM` = WebCargo Maritime prefix
-- `YYYY` = Current year
-- `XXXXXX` = 6 random alphanumeric characters (excludes ambiguous: 0, O, 1, I)
-
-**Booking Statuses:**
-- `draft` - Initial state, can be modified
-- `pending_confirmation` - Submitted for carrier confirmation
-- `confirmed` - Confirmed by carrier
-- `in_transit` - Shipment in progress
-- `delivered` - Shipment delivered (final)
-- `cancelled` - Booking cancelled (final)
-
----
-
-### Get Booking by ID
-
-**Endpoint:** `GET /api/v1/bookings/:id`
-
-**Path Parameters:**
-- `id` (UUID) - Booking ID
-
-**Response:** `200 OK`
-
-Returns same structure as Create Booking response.
-
-**Error:** `404 Not Found`
-```json
-{
-  "statusCode": 404,
-  "message": "Booking 550e8400-e29b-41d4-a716-446655440001 not found",
-  "error": "Not Found"
-}
-```
-
----
-
-### Get Booking by Number
-
-**Endpoint:** `GET /api/v1/bookings/number/:bookingNumber`
-
-**Path Parameters:**
-- `bookingNumber` (string) - Booking number (e.g., `WCM-2025-ABC123`)
-
-**Response:** `200 OK`
-
-Returns same structure as Create Booking response.
-
----
-
-### List Bookings
-
-**Endpoint:** `GET /api/v1/bookings`
-
-**Query Parameters:**
-
-| Parameter | Type | Required | Default | Description |
-|-----------|------|----------|---------|-------------|
-| `page` | number | ❌ | 1 | Page number (1-based) |
-| `pageSize` | number | ❌ | 20 | Items per page (max: 100) |
-| `status` | string | ❌ | - | Filter by status |
-
-**Example:** `GET /api/v1/bookings?page=2&pageSize=10&status=draft`
-
-**Response:** `200 OK`
-
-```json
-{
-  "bookings": [
-    {
-      "id": "550e8400-e29b-41d4-a716-446655440001",
-      "bookingNumber": "WCM-2025-ABC123",
-      "status": "draft",
-      "shipperName": "Acme Corporation",
-      "consigneeName": "Shanghai Imports Ltd",
-      "originPort": "NLRTM",
-      "destinationPort": "CNSHA",
-      "carrierName": "Maersk Line",
-      "etd": "2025-02-15T10:00:00Z",
-      "eta": "2025-03-17T14:00:00Z",
-      "totalAmount": 1700.0,
-      "currency": "USD",
-      "createdAt": "2025-02-15T10:00:00Z"
-    }
-  ],
-  "total": 25,
-  "page": 2,
-  "pageSize": 10,
-  "totalPages": 3
-}
-```
-
----
-
-## ❌ Error Handling
-
-### Error Response Format
-
-All errors follow this structure:
-
-```json
-{
-  "statusCode": 400,
-  "message": "Error description or array of validation errors",
-  "error": "Bad Request"
-}
-```
-
-### HTTP Status Codes
-
-| Code | Description | When Used |
-|------|-------------|-----------|
-| `200` | OK | Successful GET request |
-| `201` | Created | Successful POST (resource created) |
-| `400` | Bad Request | Validation errors, malformed request |
-| `401` | Unauthorized | Missing or invalid authentication |
-| `403` | Forbidden | Insufficient permissions |
-| `404` | Not Found | Resource doesn't exist |
-| `429` | Too Many Requests | Rate limit exceeded |
-| `500` | Internal Server Error | Unexpected server error |
-| `503` | Service Unavailable | Carrier API down, circuit breaker open |
-
-### Validation Errors
-
-```json
-{
-  "statusCode": 400,
-  "message": [
-    "Origin must be a valid 5-character UN/LOCODE (e.g., NLRTM)",
-    "Container type must be one of: 20DRY, 20HC, 40DRY, 40HC, 40REEFER, 45HC",
-    "Quantity must be at least 1"
-  ],
-  "error": "Bad Request"
-}
-```
-
-### Rate Limit Error
-
-```json
-{
-  "statusCode": 429,
-  "message": "Too many requests. Please try again in 60 seconds.",
-  "error": "Too Many Requests",
-  "retryAfter": 60
-}
-```
-
-### Circuit Breaker Error
-
-When a carrier API is unavailable (circuit breaker open):
-
-```json
-{
-  "statusCode": 503,
-  "message": "Maersk API is temporarily unavailable. Please try again later.",
-  "error": "Service Unavailable",
-  "retryAfter": 30
-}
-```
-
----
-
-## ⚡ Rate Limiting
-
-**Status:** To be implemented in Phase 2
-
-**Planned Limits:**
-- 100 requests per minute per API key
-- 1000 requests per hour per API key
-- Rate search: 20 requests per minute (resource-intensive)
-
-**Headers:**
-```
-X-RateLimit-Limit: 100
-X-RateLimit-Remaining: 95
-X-RateLimit-Reset: 1612345678
-```
-
----
-
-## 🔔 Webhooks
-
-**Status:** To be implemented in Phase 3
-
-Planned webhook events:
-- `booking.confirmed` - Booking confirmed by carrier
-- `booking.in_transit` - Shipment departed
-- `booking.delivered` - Shipment delivered
-- `booking.delayed` - Shipment delayed
-- `booking.cancelled` - Booking cancelled
-
-**Webhook Payload Example:**
-```json
-{
-  "event": "booking.confirmed",
-  "timestamp": "2025-02-15T10:30:00Z",
-  "data": {
-    "bookingId": "550e8400-e29b-41d4-a716-446655440001",
-    "bookingNumber": "WCM-2025-ABC123",
-    "status": "confirmed",
-    "confirmedAt": "2025-02-15T10:30:00Z"
-  }
-}
-```
-
----
-
-## 📊 Best Practices
-
-### Pagination
-
-Always use pagination for list endpoints to avoid performance issues:
-
-```
-GET /api/v1/bookings?page=1&pageSize=20
-```
-
-### Date Formats
-
-All dates use ISO 8601 format:
-- Request: `"2025-02-15"` (date only)
-- Response: `"2025-02-15T10:00:00Z"` (with timezone)
-
-### Port Codes
-
-Use UN/LOCODE (5-character codes):
-- Rotterdam: `NLRTM`
-- Shanghai: `CNSHA`
-- Los Angeles: `USLAX`
-- Hamburg: `DEHAM`
-
-Find port codes: https://unece.org/trade/cefact/unlocode-code-list-country-and-territory
-
-### Error Handling
-
-Always check `statusCode` and handle errors gracefully:
-
-```javascript
-try {
-  const response = await fetch('/api/v1/rates/search', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(searchParams)
-  });
-
-  if (!response.ok) {
-    const error = await response.json();
-    console.error('API Error:', error.message);
-    return;
-  }
-
-  const data = await response.json();
-  // Process data
-} catch (error) {
-  console.error('Network Error:', error);
-}
-```
-
----
-
-## 📞 Support
-
-For API support:
-- Email: api-support@xpeditis.com
-- Documentation: https://docs.xpeditis.com
-- Status Page: https://status.xpeditis.com
-
----
-
-**API Version:** v1.0.0
-**Last Updated:** February 2025
-**Changelog:** See CHANGELOG.md

apps/backend/docs/CARRIER_PORTAL_API.md

@@ -1,727 +0,0 @@
-# Carrier Portal API Documentation
-
-**Version**: 1.0
-**Base URL**: `http://localhost:4000/api/v1`
-**Last Updated**: 2025-12-04
-
-## Table of Contents
-
-1. [Overview](#overview)
-2. [Authentication](#authentication)
-3. [API Endpoints](#api-endpoints)
-   - [Carrier Authentication](#carrier-authentication)
-   - [Carrier Dashboard](#carrier-dashboard)
-   - [Booking Management](#booking-management)
-   - [Document Management](#document-management)
-4. [Data Models](#data-models)
-5. [Error Handling](#error-handling)
-6. [Examples](#examples)
-
----
-
-## Overview
-
-The Carrier Portal API provides endpoints for transportation carriers (transporteurs) to:
-- Authenticate and manage their accounts
-- View dashboard statistics
-- Manage booking requests from clients
-- Accept or reject booking requests
-- Download shipment documents
-- Track their performance metrics
-
-All endpoints require JWT authentication except for the public authentication endpoints.
-
----
-
-## Authentication
-
-### Authentication Header
-
-All protected endpoints require a Bearer token in the Authorization header:
-
-```
-Authorization: Bearer <access_token>
-```
-
-### Token Management
-
-- **Access Token**: Valid for 15 minutes
-- **Refresh Token**: Valid for 7 days
-- **Auto-Login Token**: Valid for 1 hour (for magic link authentication)
-
----
-
-## API Endpoints
-
-### Carrier Authentication
-
-#### 1. Login
-
-**Endpoint**: `POST /carrier-auth/login`
-
-**Description**: Authenticate a carrier with email and password.
-
-**Request Body**:
-```json
-{
-  "email": "carrier@example.com",
-  "password": "SecurePassword123!"
-}
-```
-
-**Response** (200 OK):
-```json
-{
-  "accessToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
-  "refreshToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
-  "carrier": {
-    "id": "carrier-uuid",
-    "companyName": "Transport Express",
-    "email": "carrier@example.com"
-  }
-}
-```
-
-**Errors**:
-- `401 Unauthorized`: Invalid credentials
-- `401 Unauthorized`: Account is inactive
-- `400 Bad Request`: Validation error
-
----
-
-#### 2. Get Current Carrier Profile
-
-**Endpoint**: `GET /carrier-auth/me`
-
-**Description**: Retrieve the authenticated carrier's profile information.
-
-**Headers**:
-```
-Authorization: Bearer <access_token>
-```
-
-**Response** (200 OK):
-```json
-{
-  "id": "carrier-uuid",
-  "userId": "user-uuid",
-  "companyName": "Transport Express",
-  "email": "carrier@example.com",
-  "role": "CARRIER",
-  "organizationId": "org-uuid",
-  "phone": "+33612345678",
-  "website": "https://transport-express.com",
-  "city": "Paris",
-  "country": "France",
-  "isVerified": true,
-  "isActive": true,
-  "totalBookingsAccepted": 45,
-  "totalBookingsRejected": 5,
-  "acceptanceRate": 90.0,
-  "totalRevenueUsd": 125000,
-  "totalRevenueEur": 112500,
-  "preferredCurrency": "EUR",
-  "lastLoginAt": "2025-12-04T10:30:00Z"
-}
-```
-
-**Errors**:
-- `401 Unauthorized`: Invalid or expired token
-
----
-
-#### 3. Change Password
-
-**Endpoint**: `PATCH /carrier-auth/change-password`
-
-**Description**: Change the carrier's password.
-
-**Headers**:
-```
-Authorization: Bearer <access_token>
-```
-
-**Request Body**:
-```json
-{
-  "oldPassword": "OldPassword123!",
-  "newPassword": "NewPassword123!"
-}
-```
-
-**Response** (200 OK):
-```json
-{
-  "message": "Password changed successfully"
-}
-```
-
-**Errors**:
-- `401 Unauthorized`: Invalid old password
-- `400 Bad Request`: Password validation failed
-
----
-
-#### 4. Request Password Reset
-
-**Endpoint**: `POST /carrier-auth/request-password-reset`
-
-**Description**: Request a password reset (generates temporary password).
-
-**Request Body**:
-```json
-{
-  "email": "carrier@example.com"
-}
-```
-
-**Response** (200 OK):
-```json
-{
-  "message": "If this email exists, a password reset will be sent"
-}
-```
-
-**Note**: For security, the response is the same whether the email exists or not.
-
----
-
-#### 5. Verify Auto-Login Token
-
-**Endpoint**: `POST /carrier-auth/verify-auto-login`
-
-**Description**: Verify an auto-login token from email magic link.
-
-**Request Body**:
-```json
-{
-  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
-}
-```
-
-**Response** (200 OK):
-```json
-{
-  "userId": "user-uuid",
-  "carrierId": "carrier-uuid"
-}
-```
-
-**Errors**:
-- `401 Unauthorized`: Invalid or expired token
-
----
-
-### Carrier Dashboard
-
-#### 6. Get Dashboard Statistics
-
-**Endpoint**: `GET /carrier-dashboard/stats`
-
-**Description**: Retrieve carrier dashboard statistics including bookings count, revenue, and recent activities.
-
-**Headers**:
-```
-Authorization: Bearer <access_token>
-```
-
-**Response** (200 OK):
-```json
-{
-  "totalBookings": 50,
-  "pendingBookings": 5,
-  "acceptedBookings": 42,
-  "rejectedBookings": 3,
-  "acceptanceRate": 93.3,
-  "totalRevenue": {
-    "usd": 125000,
-    "eur": 112500
-  },
-  "recentActivities": [
-    {
-      "id": "activity-uuid",
-      "type": "BOOKING_ACCEPTED",
-      "description": "Booking #12345 accepted",
-      "createdAt": "2025-12-04T09:15:00Z",
-      "bookingId": "booking-uuid"
-    },
-    {
-      "id": "activity-uuid-2",
-      "type": "DOCUMENT_DOWNLOADED",
-      "description": "Downloaded invoice.pdf",
-      "createdAt": "2025-12-04T08:30:00Z",
-      "bookingId": "booking-uuid-2"
-    }
-  ]
-}
-```
-
-**Errors**:
-- `401 Unauthorized`: Invalid or expired token
-- `404 Not Found`: Carrier not found
-
----
-
-#### 7. Get Carrier Bookings (Paginated)
-
-**Endpoint**: `GET /carrier-dashboard/bookings`
-
-**Description**: Retrieve a paginated list of bookings for the carrier.
-
-**Headers**:
-```
-Authorization: Bearer <access_token>
-```
-
-**Query Parameters**:
-- `page` (number, optional): Page number (default: 1)
-- `limit` (number, optional): Items per page (default: 10)
-- `status` (string, optional): Filter by status (PENDING, ACCEPTED, REJECTED)
-
-**Example Request**:
-```
-GET /carrier-dashboard/bookings?page=1&limit=10&status=PENDING
-```
-
-**Response** (200 OK):
-```json
-{
-  "data": [
-    {
-      "id": "booking-uuid",
-      "origin": "Rotterdam",
-      "destination": "New York",
-      "status": "PENDING",
-      "priceUsd": 1500,
-      "priceEur": 1350,
-      "primaryCurrency": "USD",
-      "requestedAt": "2025-12-04T08:00:00Z",
-      "carrierViewedAt": null,
-      "documentsCount": 3,
-      "volumeCBM": 25.5,
-      "weightKG": 12000,
-      "palletCount": 10,
-      "transitDays": 15,
-      "containerType": "40HC"
-    }
-  ],
-  "total": 50,
-  "page": 1,
-  "limit": 10
-}
-```
-
-**Errors**:
-- `401 Unauthorized`: Invalid or expired token
-- `404 Not Found`: Carrier not found
-
----
-
-#### 8. Get Booking Details
-
-**Endpoint**: `GET /carrier-dashboard/bookings/:id`
-
-**Description**: Retrieve detailed information about a specific booking.
-
-**Headers**:
-```
-Authorization: Bearer <access_token>
-```
-
-**Path Parameters**:
-- `id` (string, required): Booking ID
-
-**Response** (200 OK):
-```json
-{
-  "id": "booking-uuid",
-  "carrierName": "Transport Express",
-  "carrierEmail": "carrier@example.com",
-  "origin": "Rotterdam",
-  "destination": "New York",
-  "volumeCBM": 25.5,
-  "weightKG": 12000,
-  "palletCount": 10,
-  "priceUSD": 1500,
-  "priceEUR": 1350,
-  "primaryCurrency": "USD",
-  "transitDays": 15,
-  "containerType": "40HC",
-  "status": "PENDING",
-  "documents": [
-    {
-      "id": "doc-uuid",
-      "fileName": "invoice.pdf",
-      "type": "INVOICE",
-      "url": "https://storage.example.com/doc.pdf",
-      "uploadedAt": "2025-12-03T10:00:00Z"
-    }
-  ],
-  "confirmationToken": "token-123",
-  "requestedAt": "2025-12-04T08:00:00Z",
-  "respondedAt": null,
-  "notes": "Urgent shipment",
-  "rejectionReason": null,
-  "carrierViewedAt": "2025-12-04T10:15:00Z",
-  "carrierAcceptedAt": null,
-  "carrierRejectedAt": null,
-  "carrierRejectionReason": null,
-  "carrierNotes": null,
-  "createdAt": "2025-12-04T08:00:00Z",
-  "updatedAt": "2025-12-04T10:15:00Z"
-}
-```
-
-**Errors**:
-- `401 Unauthorized`: Invalid or expired token
-- `403 Forbidden`: Access denied to this booking
-- `404 Not Found`: Booking not found
-
----
-
-### Booking Management
-
-#### 9. Accept Booking
-
-**Endpoint**: `POST /carrier-dashboard/bookings/:id/accept`
-
-**Description**: Accept a booking request.
-
-**Headers**:
-```
-Authorization: Bearer <access_token>
-```
-
-**Path Parameters**:
-- `id` (string, required): Booking ID
-
-**Request Body**:
-```json
-{
-  "notes": "Ready to proceed. Pickup scheduled for Dec 5th."
-}
-```
-
-**Response** (200 OK):
-```json
-{
-  "message": "Booking accepted successfully"
-}
-```
-
-**Errors**:
-- `401 Unauthorized`: Invalid or expired token
-- `403 Forbidden`: Access denied to this booking
-- `404 Not Found`: Booking not found
-- `400 Bad Request`: Booking cannot be accepted (wrong status)
-
----
-
-#### 10. Reject Booking
-
-**Endpoint**: `POST /carrier-dashboard/bookings/:id/reject`
-
-**Description**: Reject a booking request with a reason.
-
-**Headers**:
-```
-Authorization: Bearer <access_token>
-```
-
-**Path Parameters**:
-- `id` (string, required): Booking ID
-
-**Request Body**:
-```json
-{
-  "reason": "CAPACITY_NOT_AVAILABLE",
-  "notes": "Sorry, we don't have capacity for this shipment at the moment."
-}
-```
-
-**Response** (200 OK):
-```json
-{
-  "message": "Booking rejected successfully"
-}
-```
-
-**Errors**:
-- `401 Unauthorized`: Invalid or expired token
-- `403 Forbidden`: Access denied to this booking
-- `404 Not Found`: Booking not found
-- `400 Bad Request`: Rejection reason required
-- `400 Bad Request`: Booking cannot be rejected (wrong status)
-
----
-
-### Document Management
-
-#### 11. Download Document
-
-**Endpoint**: `GET /carrier-dashboard/bookings/:bookingId/documents/:documentId/download`
-
-**Description**: Download a document associated with a booking.
-
-**Headers**:
-```
-Authorization: Bearer <access_token>
-```
-
-**Path Parameters**:
-- `bookingId` (string, required): Booking ID
-- `documentId` (string, required): Document ID
-
-**Response** (200 OK):
-```json
-{
-  "document": {
-    "id": "doc-uuid",
-    "fileName": "invoice.pdf",
-    "type": "INVOICE",
-    "url": "https://storage.example.com/doc.pdf",
-    "size": 245678,
-    "mimeType": "application/pdf",
-    "uploadedAt": "2025-12-03T10:00:00Z"
-  }
-}
-```
-
-**Errors**:
-- `401 Unauthorized`: Invalid or expired token
-- `403 Forbidden`: Access denied to this document
-- `404 Not Found`: Document or booking not found
-
----
-
-## Data Models
-
-### Carrier Profile
-
-```typescript
-interface CarrierProfile {
-  id: string;
-  userId: string;
-  organizationId: string;
-  companyName: string;
-  email: string;
-  phone?: string;
-  website?: string;
-  city?: string;
-  country?: string;
-  isVerified: boolean;
-  isActive: boolean;
-  totalBookingsAccepted: number;
-  totalBookingsRejected: number;
-  acceptanceRate: number;
-  totalRevenueUsd: number;
-  totalRevenueEur: number;
-  preferredCurrency: 'USD' | 'EUR';
-  lastLoginAt?: Date;
-}
-```
-
-### Booking
-
-```typescript
-interface Booking {
-  id: string;
-  carrierId: string;
-  carrierName: string;
-  carrierEmail: string;
-  origin: string;
-  destination: string;
-  volumeCBM: number;
-  weightKG: number;
-  palletCount: number;
-  priceUSD: number;
-  priceEUR: number;
-  primaryCurrency: 'USD' | 'EUR';
-  transitDays: number;
-  containerType: string;
-  status: 'PENDING' | 'ACCEPTED' | 'REJECTED' | 'CANCELLED';
-  documents: Document[];
-  confirmationToken: string;
-  requestedAt: Date;
-  respondedAt?: Date;
-  notes?: string;
-  rejectionReason?: string;
-  carrierViewedAt?: Date;
-  carrierAcceptedAt?: Date;
-  carrierRejectedAt?: Date;
-  carrierRejectionReason?: string;
-  carrierNotes?: string;
-  createdAt: Date;
-  updatedAt: Date;
-}
-```
-
-### Document
-
-```typescript
-interface Document {
-  id: string;
-  fileName: string;
-  type: 'INVOICE' | 'PACKING_LIST' | 'CERTIFICATE' | 'OTHER';
-  url: string;
-  size?: number;
-  mimeType?: string;
-  uploadedAt: Date;
-}
-```
-
-### Activity
-
-```typescript
-interface CarrierActivity {
-  id: string;
-  carrierId: string;
-  bookingId?: string;
-  activityType: 'BOOKING_ACCEPTED' | 'BOOKING_REJECTED' | 'DOCUMENT_DOWNLOADED' | 'PROFILE_UPDATED';
-  description: string;
-  metadata?: Record<string, any>;
-  createdAt: Date;
-}
-```
-
----
-
-## Error Handling
-
-### Error Response Format
-
-All error responses follow this structure:
-
-```json
-{
-  "statusCode": 400,
-  "message": "Validation failed",
-  "error": "Bad Request",
-  "timestamp": "2025-12-04T10:30:00Z",
-  "path": "/api/v1/carrier-auth/login"
-}
-```
-
-### Common HTTP Status Codes
-
-- `200 OK`: Request successful
-- `201 Created`: Resource created successfully
-- `400 Bad Request`: Validation error or invalid request
-- `401 Unauthorized`: Authentication required or invalid credentials
-- `403 Forbidden`: Insufficient permissions
-- `404 Not Found`: Resource not found
-- `500 Internal Server Error`: Server error
-
----
-
-## Examples
-
-### Complete Authentication Flow
-
-```bash
-# 1. Login
-curl -X POST http://localhost:4000/api/v1/carrier-auth/login \
-  -H "Content-Type: application/json" \
-  -d '{
-    "email": "carrier@example.com",
-    "password": "SecurePassword123!"
-  }'
-
-# Response:
-# {
-#   "accessToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
-#   "refreshToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
-#   "carrier": { "id": "carrier-uuid", ... }
-# }
-
-# 2. Get Dashboard Stats
-curl -X GET http://localhost:4000/api/v1/carrier-dashboard/stats \
-  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
-
-# 3. Get Pending Bookings
-curl -X GET "http://localhost:4000/api/v1/carrier-dashboard/bookings?status=PENDING&page=1&limit=10" \
-  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
-
-# 4. Accept a Booking
-curl -X POST http://localhost:4000/api/v1/carrier-dashboard/bookings/booking-uuid/accept \
-  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." \
-  -H "Content-Type: application/json" \
-  -d '{
-    "notes": "Ready to proceed with shipment"
-  }'
-```
-
-### Using Auto-Login Token
-
-```bash
-# Verify auto-login token from email magic link
-curl -X POST http://localhost:4000/api/v1/carrier-auth/verify-auto-login \
-  -H "Content-Type: application/json" \
-  -d '{
-    "token": "auto-login-token-from-email"
-  }'
-```
-
----
-
-## Rate Limiting
-
-All API endpoints are rate-limited to prevent abuse:
-
-- **Authentication endpoints**: 5 requests per minute per IP
-- **Dashboard/Booking endpoints**: 30 requests per minute per user
-- **Global limit**: 100 requests per minute per user
-
-Rate limit headers are included in all responses:
-
-```
-X-RateLimit-Limit: 30
-X-RateLimit-Remaining: 29
-X-RateLimit-Reset: 60
-```
-
----
-
-## Security
-
-### Best Practices
-
-1. **Always use HTTPS** in production
-2. **Store tokens securely** (e.g., httpOnly cookies, secure storage)
-3. **Implement token refresh** before access token expires
-4. **Validate all input** on client side before sending to API
-5. **Handle errors gracefully** without exposing sensitive information
-6. **Log out properly** by clearing all stored tokens
-
-### CORS Configuration
-
-The API allows requests from:
-- `http://localhost:3000` (development)
-- `https://your-production-domain.com` (production)
-
----
-
-## Changelog
-
-### Version 1.0 (2025-12-04)
-- Initial release
-- Authentication endpoints
-- Dashboard endpoints
-- Booking management
-- Document management
-- Complete carrier portal workflow
-
----
-
-## Support
-
-For API support or questions:
-- **Email**: support@xpeditis.com
-- **Documentation**: https://docs.xpeditis.com
-- **Status Page**: https://status.xpeditis.com
-
----
-
-**Document created**: 2025-12-04
-**Author**: Xpeditis Development Team
-**Version**: 1.0

apps/backend/fix-domain-imports.js

@@ -1,42 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Script to fix TypeScript imports in domain/services
- * Replace relative paths with path aliases
- */
-
-const fs = require('fs');
-const path = require('path');
-
-function fixImportsInFile(filePath) {
-  const content = fs.readFileSync(filePath, 'utf8');
-  let modified = content;
-
-  // Replace relative imports to ../ports/ with @domain/ports/
-  modified = modified.replace(/from ['"]\.\.\/ports\//g, "from '@domain/ports/");
-  modified = modified.replace(/import\s+(['"])\.\.\/ports\//g, "import $1@domain/ports/");
-
-  if (modified !== content) {
-    fs.writeFileSync(filePath, modified, 'utf8');
-    return true;
-  }
-  return false;
-}
-
-const servicesDir = path.join(__dirname, 'src/domain/services');
-console.log('🔧 Fixing domain/services imports...\n');
-
-const files = fs.readdirSync(servicesDir);
-let count = 0;
-
-for (const file of files) {
-  if (file.endsWith('.ts')) {
-    const filePath = path.join(servicesDir, file);
-    if (fixImportsInFile(filePath)) {
-      console.log(`✅ Fixed: ${filePath}`);
-      count++;
-    }
-  }
-}
-
-console.log(`\n✅ Fixed ${count} files in domain/services`);

apps/backend/fix-dummy-urls.js

@@ -1,90 +0,0 @@
-/**
- * Script to fix dummy storage URLs in the database
- *
- * This script updates all document URLs from "dummy-storage.com" to proper MinIO URLs
- */
-
-const { Client } = require('pg');
-require('dotenv').config();
-
-const MINIO_ENDPOINT = process.env.AWS_S3_ENDPOINT || 'http://localhost:9000';
-const BUCKET_NAME = 'xpeditis-documents';
-
-async function fixDummyUrls() {
-  const client = new Client({
-    host: process.env.DATABASE_HOST || 'localhost',
-    port: process.env.DATABASE_PORT || 5432,
-    user: process.env.DATABASE_USER || 'xpeditis',
-    password: process.env.DATABASE_PASSWORD || 'xpeditis_dev_password',
-    database: process.env.DATABASE_NAME || 'xpeditis_dev',
-  });
-
-  try {
-    await client.connect();
-    console.log('✅ Connected to database');
-
-    // Get all CSV bookings with documents
-    const result = await client.query(
-      `SELECT id, documents FROM csv_bookings WHERE documents IS NOT NULL AND documents::text LIKE '%dummy-storage%'`
-    );
-
-    console.log(`\n📄 Found ${result.rows.length} bookings with dummy URLs\n`);
-
-    let updatedCount = 0;
-
-    for (const row of result.rows) {
-      const bookingId = row.id;
-      const documents = row.documents;
-
-      // Update each document URL
-      const updatedDocuments = documents.map((doc) => {
-        if (doc.filePath && doc.filePath.includes('dummy-storage')) {
-          // Extract filename from dummy URL
-          const fileName = doc.fileName || doc.filePath.split('/').pop();
-          const documentId = doc.id;
-
-          // Build proper MinIO URL
-          const newUrl = `${MINIO_ENDPOINT}/${BUCKET_NAME}/csv-bookings/${bookingId}/${documentId}-${fileName}`;
-
-          console.log(`   Old: ${doc.filePath}`);
-          console.log(`   New: ${newUrl}`);
-
-          return {
-            ...doc,
-            filePath: newUrl,
-          };
-        }
-        return doc;
-      });
-
-      // Update the database
-      await client.query(
-        `UPDATE csv_bookings SET documents = $1 WHERE id = $2`,
-        [JSON.stringify(updatedDocuments), bookingId]
-      );
-
-      updatedCount++;
-      console.log(`✅ Updated booking ${bookingId}\n`);
-    }
-
-    console.log(`\n🎉 Successfully updated ${updatedCount} bookings`);
-    console.log(`\n⚠️  Note: The actual files need to be uploaded to MinIO at the correct paths.`);
-    console.log(`   You can upload test files or re-create the bookings with real file uploads.`);
-  } catch (error) {
-    console.error('❌ Error:', error);
-    throw error;
-  } finally {
-    await client.end();
-    console.log('\n👋 Disconnected from database');
-  }
-}
-
-fixDummyUrls()
-  .then(() => {
-    console.log('\n✅ Script completed successfully');
-    process.exit(0);
-  })
-  .catch((error) => {
-    console.error('\n❌ Script failed:', error);
-    process.exit(1);
-  });

apps/backend/fix-imports.js

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Script to fix TypeScript imports from relative paths to path aliases
- *
- * Replaces:
- * - from '../../domain/...' → from '@domain/...'
- * - from '../../../domain/...' → from '@domain/...'
- * - from '../domain/...' → from '@domain/...'
- * - from '../../../../domain/...' → from '@domain/...'
- */
-
-const fs = require('fs');
-const path = require('path');
-
-function fixImportsInFile(filePath) {
-  const content = fs.readFileSync(filePath, 'utf8');
-  let modified = content;
-
-  // Replace all variations of relative domain imports with @domain alias
-  modified = modified.replace(/from ['"]\.\.\/\.\.\/\.\.\/\.\.\/domain\//g, "from '@domain/");
-  modified = modified.replace(/from ['"]\.\.\/\.\.\/\.\.\/domain\//g, "from '@domain/");
-  modified = modified.replace(/from ['"]\.\.\/\.\.\/domain\//g, "from '@domain/");
-  modified = modified.replace(/from ['"]\.\.\/domain\//g, "from '@domain/");
-
-  // Also fix import statements (not just from)
-  modified = modified.replace(/import\s+(['"])\.\.\/\.\.\/\.\.\/\.\.\/domain\//g, "import $1@domain/");
-  modified = modified.replace(/import\s+(['"])\.\.\/\.\.\/\.\.\/domain\//g, "import $1@domain/");
-  modified = modified.replace(/import\s+(['"])\.\.\/\.\.\/domain\//g, "import $1@domain/");
-  modified = modified.replace(/import\s+(['"])\.\.\/domain\//g, "import $1@domain/");
-
-  if (modified !== content) {
-    fs.writeFileSync(filePath, modified, 'utf8');
-    return true;
-  }
-  return false;
-}
-
-function walkDir(dir) {
-  const files = fs.readdirSync(dir);
-  let count = 0;
-
-  for (const file of files) {
-    const filePath = path.join(dir, file);
-    const stat = fs.statSync(filePath);
-
-    if (stat.isDirectory()) {
-      count += walkDir(filePath);
-    } else if (file.endsWith('.ts')) {
-      if (fixImportsInFile(filePath)) {
-        console.log(`✅ Fixed: ${filePath}`);
-        count++;
-      }
-    }
-  }
-
-  return count;
-}
-
-const srcDir = path.join(__dirname, 'src');
-console.log('🔧 Fixing TypeScript imports...\n');
-
-const count = walkDir(srcDir);
-
-console.log(`\n✅ Fixed ${count} files`);

apps/backend/fix-minio-hostname.js

@@ -1,81 +0,0 @@
-/**
- * Script to fix minio hostname in document URLs
- *
- * Changes http://minio:9000 to http://localhost:9000
- */
-
-const { Client } = require('pg');
-require('dotenv').config();
-
-async function fixMinioHostname() {
-  const client = new Client({
-    host: process.env.DATABASE_HOST || 'localhost',
-    port: process.env.DATABASE_PORT || 5432,
-    user: process.env.DATABASE_USER || 'xpeditis',
-    password: process.env.DATABASE_PASSWORD || 'xpeditis_dev_password',
-    database: process.env.DATABASE_NAME || 'xpeditis_dev',
-  });
-
-  try {
-    await client.connect();
-    console.log('✅ Connected to database');
-
-    // Find bookings with minio:9000 in URLs
-    const result = await client.query(
-      `SELECT id, documents FROM csv_bookings WHERE documents::text LIKE '%http://minio:9000%'`
-    );
-
-    console.log(`\n📄 Found ${result.rows.length} bookings with minio hostname\n`);
-
-    let updatedCount = 0;
-
-    for (const row of result.rows) {
-      const bookingId = row.id;
-      const documents = row.documents;
-
-      // Update each document URL
-      const updatedDocuments = documents.map((doc) => {
-        if (doc.filePath && doc.filePath.includes('http://minio:9000')) {
-          const newUrl = doc.filePath.replace('http://minio:9000', 'http://localhost:9000');
-
-          console.log(`   Booking: ${bookingId}`);
-          console.log(`   Old: ${doc.filePath}`);
-          console.log(`   New: ${newUrl}\n`);
-
-          return {
-            ...doc,
-            filePath: newUrl,
-          };
-        }
-        return doc;
-      });
-
-      // Update the database
-      await client.query(
-        `UPDATE csv_bookings SET documents = $1 WHERE id = $2`,
-        [JSON.stringify(updatedDocuments), bookingId]
-      );
-
-      updatedCount++;
-      console.log(`✅ Updated booking ${bookingId}\n`);
-    }
-
-    console.log(`\n🎉 Successfully updated ${updatedCount} bookings`);
-  } catch (error) {
-    console.error('❌ Error:', error);
-    throw error;
-  } finally {
-    await client.end();
-    console.log('\n👋 Disconnected from database');
-  }
-}
-
-fixMinioHostname()
-  .then(() => {
-    console.log('\n✅ Script completed successfully');
-    process.exit(0);
-  })
-  .catch((error) => {
-    console.error('\n❌ Script failed:', error);
-    process.exit(1);
-  });

apps/backend/generate-hash.js

@@ -1,14 +0,0 @@
-const argon2 = require('argon2');
-
-async function generateHash() {
-  const hash = await argon2.hash('Password123!', {
-    type: argon2.argon2id,
-    memoryCost: 65536, // 64 MB
-    timeCost: 3,
-    parallelism: 4,
-  });
-  console.log('Argon2id hash for "Password123!":');
-  console.log(hash);
-}
-
-generateHash().catch(console.error);

apps/backend/list-minio-files.js

@@ -1,92 +0,0 @@
-/**
- * Script to list all files in MinIO xpeditis-documents bucket
- */
-
-const { S3Client, ListObjectsV2Command } = require('@aws-sdk/client-s3');
-require('dotenv').config();
-
-const MINIO_ENDPOINT = process.env.AWS_S3_ENDPOINT || 'http://localhost:9000';
-const BUCKET_NAME = 'xpeditis-documents';
-
-// Initialize MinIO client
-const s3Client = new S3Client({
-  region: 'us-east-1',
-  endpoint: MINIO_ENDPOINT,
-  credentials: {
-    accessKeyId: process.env.AWS_ACCESS_KEY_ID || 'minioadmin',
-    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || 'minioadmin',
-  },
-  forcePathStyle: true,
-});
-
-async function listFiles() {
-  try {
-    console.log(`📋 Listing all files in bucket: ${BUCKET_NAME}\n`);
-
-    let allFiles = [];
-    let continuationToken = null;
-
-    do {
-      const command = new ListObjectsV2Command({
-        Bucket: BUCKET_NAME,
-        ContinuationToken: continuationToken,
-      });
-
-      const response = await s3Client.send(command);
-
-      if (response.Contents) {
-        allFiles = allFiles.concat(response.Contents);
-      }
-
-      continuationToken = response.NextContinuationToken;
-    } while (continuationToken);
-
-    console.log(`Found ${allFiles.length} files total:\n`);
-
-    // Group by booking ID
-    const byBooking = {};
-    allFiles.forEach(file => {
-      const parts = file.Key.split('/');
-      if (parts.length >= 3 && parts[0] === 'csv-bookings') {
-        const bookingId = parts[1];
-        if (!byBooking[bookingId]) {
-          byBooking[bookingId] = [];
-        }
-        byBooking[bookingId].push({
-          key: file.Key,
-          size: file.Size,
-          lastModified: file.LastModified,
-        });
-      } else {
-        console.log(`  Other: ${file.Key} (${file.Size} bytes)`);
-      }
-    });
-
-    console.log(`\nFiles grouped by booking:\n`);
-    Object.entries(byBooking).forEach(([bookingId, files]) => {
-      console.log(`📦 Booking: ${bookingId.substring(0, 8)}...`);
-      files.forEach(file => {
-        const filename = file.key.split('/').pop();
-        console.log(`   - ${filename} (${file.size} bytes) - ${file.lastModified}`);
-      });
-      console.log('');
-    });
-
-    console.log(`\n📊 Summary:`);
-    console.log(`   Total files: ${allFiles.length}`);
-    console.log(`   Bookings with files: ${Object.keys(byBooking).length}`);
-  } catch (error) {
-    console.error('❌ Error:', error);
-    throw error;
-  }
-}
-
-listFiles()
-  .then(() => {
-    console.log('\n✅ Script completed successfully');
-    process.exit(0);
-  })
-  .catch((error) => {
-    console.error('\n❌ Script failed:', error);
-    process.exit(1);
-  });

apps/backend/load-tests/rate-search.test.js

@@ -1,152 +0,0 @@
-/**
- * K6 Load Test - Rate Search Endpoint
- *
- * Target: 100 requests/second
- * Duration: 5 minutes
- *
- * Run: k6 run rate-search.test.js
- */
-
-import http from 'k6/http';
-import { check, sleep } from 'k6';
-import { Rate, Trend } from 'k6/metrics';
-
-// Custom metrics
-const errorRate = new Rate('errors');
-const searchDuration = new Trend('search_duration');
-
-// Test configuration
-export const options = {
-  stages: [
-    { duration: '1m', target: 20 }, // Ramp up to 20 users
-    { duration: '2m', target: 50 }, // Ramp up to 50 users
-    { duration: '1m', target: 100 }, // Ramp up to 100 users
-    { duration: '3m', target: 100 }, // Stay at 100 users
-    { duration: '1m', target: 0 }, // Ramp down
-  ],
-  thresholds: {
-    http_req_duration: ['p(95)<2000'], // 95% of requests must complete below 2s
-    http_req_failed: ['rate<0.01'], // Error rate must be less than 1%
-    errors: ['rate<0.05'], // Business error rate must be less than 5%
-  },
-};
-
-// Base URL
-const BASE_URL = __ENV.API_URL || 'http://localhost:4000/api/v1';
-
-// Auth token (should be set via environment variable)
-const AUTH_TOKEN = __ENV.AUTH_TOKEN || '';
-
-// Test data - common trade lanes
-const tradeLanes = [
-  {
-    origin: 'NLRTM', // Rotterdam
-    destination: 'CNSHA', // Shanghai
-    containerType: '40HC',
-  },
-  {
-    origin: 'USNYC', // New York
-    destination: 'GBLON', // London
-    containerType: '20ST',
-  },
-  {
-    origin: 'SGSIN', // Singapore
-    destination: 'USOAK', // Oakland
-    containerType: '40ST',
-  },
-  {
-    origin: 'DEHAM', // Hamburg
-    destination: 'BRRIO', // Rio de Janeiro
-    containerType: '40HC',
-  },
-  {
-    origin: 'AEDXB', // Dubai
-    destination: 'INMUN', // Mumbai
-    containerType: '20ST',
-  },
-];
-
-export default function () {
-  // Select random trade lane
-  const tradeLane = tradeLanes[Math.floor(Math.random() * tradeLanes.length)];
-
-  // Prepare request payload
-  const payload = JSON.stringify({
-    origin: tradeLane.origin,
-    destination: tradeLane.destination,
-    departureDate: new Date(Date.now() + 14 * 24 * 60 * 60 * 1000).toISOString().split('T')[0], // 2 weeks from now
-    containers: [
-      {
-        type: tradeLane.containerType,
-        quantity: 1,
-      },
-    ],
-  });
-
-  const params = {
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${AUTH_TOKEN}`,
-    },
-    tags: { name: 'RateSearch' },
-  };
-
-  // Make request
-  const startTime = Date.now();
-  const response = http.post(`${BASE_URL}/rates/search`, payload, params);
-  const duration = Date.now() - startTime;
-
-  // Record metrics
-  searchDuration.add(duration);
-
-  // Check response
-  const success = check(response, {
-    'status is 200': r => r.status === 200,
-    'response has quotes': r => {
-      try {
-        const body = JSON.parse(r.body);
-        return body.quotes && body.quotes.length > 0;
-      } catch (e) {
-        return false;
-      }
-    },
-    'response time < 2s': r => duration < 2000,
-  });
-
-  errorRate.add(!success);
-
-  // Small delay between requests
-  sleep(1);
-}
-
-export function handleSummary(data) {
-  return {
-    stdout: textSummary(data, { indent: ' ', enableColors: true }),
-    'load-test-results/rate-search-summary.json': JSON.stringify(data),
-  };
-}
-
-function textSummary(data, options) {
-  const indent = options.indent || '';
-  const enableColors = options.enableColors || false;
-
-  return `
-${indent}Test Summary - Rate Search Load Test
-${indent}=====================================
-${indent}
-${indent}Total Requests: ${data.metrics.http_reqs.values.count}
-${indent}Failed Requests: ${data.metrics.http_req_failed.values.rate * 100}%
-${indent}
-${indent}Response Times:
-${indent}  Average: ${data.metrics.http_req_duration.values.avg.toFixed(2)}ms
-${indent}  Median:  ${data.metrics.http_req_duration.values.med.toFixed(2)}ms
-${indent}  95th:    ${data.metrics.http_req_duration.values['p(95)'].toFixed(2)}ms
-${indent}  99th:    ${data.metrics.http_req_duration.values['p(99)'].toFixed(2)}ms
-${indent}
-${indent}Requests/sec: ${data.metrics.http_reqs.values.rate.toFixed(2)}
-${indent}
-${indent}Business Metrics:
-${indent}  Error Rate: ${(data.metrics.errors.values.rate * 100).toFixed(2)}%
-${indent}  Avg Search Duration: ${data.metrics.search_duration.values.avg.toFixed(2)}ms
-  `;
-}

apps/backend/login-and-test.js

@@ -1,65 +0,0 @@
-const axios = require('axios');
-const FormData = require('form-data');
-
-const API_URL = 'http://localhost:4000/api/v1';
-
-async function loginAndTestEmail() {
-  try {
-    // 1. Login
-    console.log('🔐 Connexion...');
-    const loginResponse = await axios.post(`${API_URL}/auth/login`, {
-      email: 'admin@xpeditis.com',
-      password: 'Admin123!@#'
-    });
-
-    const token = loginResponse.data.accessToken;
-    console.log('✅ Connecté avec succès\n');
-
-    // 2. Créer un CSV booking pour tester l'envoi d'email
-    console.log('📧 Création d\'une CSV booking pour tester l\'envoi d\'email...');
-
-    const form = new FormData();
-    const testFile = Buffer.from('Test document PDF content');
-    form.append('documents', testFile, { filename: 'test-doc.pdf', contentType: 'application/pdf' });
-
-    form.append('carrierName', 'Test Carrier');
-    form.append('carrierEmail', 'testcarrier@example.com');
-    form.append('origin', 'NLRTM');
-    form.append('destination', 'USNYC');
-    form.append('volumeCBM', '25.5');
-    form.append('weightKG', '3500');
-    form.append('palletCount', '10');
-    form.append('priceUSD', '1850.50');
-    form.append('priceEUR', '1665.45');
-    form.append('primaryCurrency', 'USD');
-    form.append('transitDays', '28');
-    form.append('containerType', 'LCL');
-    form.append('notes', 'Test email');
-
-    const bookingResponse = await axios.post(`${API_URL}/csv-bookings`, form, {
-      headers: {
-        ...form.getHeaders(),
-        'Authorization': `Bearer ${token}`
-      }
-    });
-
-    console.log('✅ CSV Booking créé:', bookingResponse.data.id);
-    console.log('\n📋 VÉRIFICATIONS À FAIRE:');
-    console.log('1. Vérifier les logs du backend ci-dessus');
-    console.log('   Chercher: "Email sent to carrier: testcarrier@example.com"');
-    console.log('2. Vérifier Mailtrap inbox: https://mailtrap.io/inboxes');
-    console.log('3. Email devrait être envoyé à: testcarrier@example.com');
-    console.log('\n⏳ Attendez quelques secondes puis vérifiez les logs du backend...');
-
-  } catch (error) {
-    console.error('❌ ERREUR:');
-    if (error.response) {
-      console.error('Status:', error.response.status);
-      console.error('Data:', JSON.stringify(error.response.data, null, 2));
-    } else {
-      console.error(error.message);
-    }
-  }
-}
-
-loginAndTestEmail();

apps/backend/nest-cli.json

@@ -4,8 +4,6 @@
   "sourceRoot": "src",
   "compilerOptions": {
     "deleteOutDir": true,
-    "builder": "tsc",
-    "tsConfigPath": "tsconfig.build.json",
-    "plugins": ["@nestjs/swagger"]
+    "webpack": false
   }
 }

apps/backend/package.json

@@ -4,7 +4,7 @@
   "description": "Xpeditis Backend API - Maritime Freight Booking Platform",
   "private": true,
   "scripts": {
-    "build": "nest build && tsc-alias -p tsconfig.build.json",
+    "build": "nest build",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "start": "nest start",
     "dev": "nest start --watch",
@@ -15,92 +15,56 @@
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
-    "test:integration": "jest --config ./test/jest-integration.json",
-    "test:integration:watch": "jest --config ./test/jest-integration.json --watch",
-    "test:integration:cov": "jest --config ./test/jest-integration.json --coverage",
     "test:e2e": "jest --config ./test/jest-e2e.json",
     "migration:generate": "typeorm-ts-node-commonjs migration:generate -d src/infrastructure/persistence/typeorm/data-source.ts",
     "migration:run": "typeorm-ts-node-commonjs migration:run -d src/infrastructure/persistence/typeorm/data-source.ts",
     "migration:revert": "typeorm-ts-node-commonjs migration:revert -d src/infrastructure/persistence/typeorm/data-source.ts"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.906.0",
-    "@aws-sdk/lib-storage": "^3.906.0",
-    "@aws-sdk/s3-request-presigner": "^3.906.0",
-    "@nestjs/axios": "^4.0.1",
     "@nestjs/common": "^10.2.10",
     "@nestjs/config": "^3.1.1",
     "@nestjs/core": "^10.2.10",
     "@nestjs/jwt": "^10.2.0",
     "@nestjs/passport": "^10.0.3",
     "@nestjs/platform-express": "^10.2.10",
-    "@nestjs/platform-socket.io": "^10.4.20",
     "@nestjs/swagger": "^7.1.16",
-    "@nestjs/throttler": "^6.4.0",
     "@nestjs/typeorm": "^10.0.1",
-    "@nestjs/websockets": "^10.4.20",
-    "@sentry/node": "^10.19.0",
-    "@sentry/profiling-node": "^10.19.0",
-    "@types/leaflet": "^1.9.21",
-    "@types/mjml": "^4.7.4",
-    "@types/nodemailer": "^7.0.2",
-    "@types/opossum": "^8.1.9",
-    "@types/pdfkit": "^0.17.3",
-    "argon2": "^0.44.0",
-    "axios": "^1.12.2",
+    "bcrypt": "^5.1.1",
     "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.2",
-    "compression": "^1.8.1",
-    "csv-parse": "^6.1.0",
-    "exceljs": "^4.4.0",
-    "handlebars": "^4.7.8",
-    "helmet": "^7.2.0",
-    "ioredis": "^5.8.1",
+    "class-validator": "^0.14.0",
+    "helmet": "^7.1.0",
+    "ioredis": "^5.3.2",
     "joi": "^17.11.0",
-    "leaflet": "^1.9.4",
-    "mjml": "^4.16.1",
     "nestjs-pino": "^4.4.1",
-    "nodemailer": "^7.0.9",
     "opossum": "^8.1.3",
     "passport": "^0.7.0",
     "passport-google-oauth20": "^2.0.0",
     "passport-jwt": "^4.0.1",
     "passport-microsoft": "^1.0.0",
-    "pdfkit": "^0.17.2",
     "pg": "^8.11.3",
     "pino": "^8.17.1",
     "pino-http": "^8.6.0",
     "pino-pretty": "^10.3.0",
-    "react-leaflet": "^5.0.0",
     "reflect-metadata": "^0.1.14",
     "rxjs": "^7.8.1",
-    "socket.io": "^4.8.1",
-    "stripe": "^14.14.0",
-    "typeorm": "^0.3.17",
-    "uuid": "^9.0.1"
+    "typeorm": "^0.3.17"
   },
   "devDependencies": {
-    "@faker-js/faker": "^10.0.0",
     "@nestjs/cli": "^10.2.1",
     "@nestjs/schematics": "^10.0.3",
     "@nestjs/testing": "^10.2.10",
     "@types/bcrypt": "^5.0.2",
-    "@types/compression": "^1.8.1",
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.11",
-    "@types/multer": "^2.0.0",
     "@types/node": "^20.10.5",
     "@types/passport-google-oauth20": "^2.0.14",
     "@types/passport-jwt": "^3.0.13",
     "@types/supertest": "^6.0.2",
-    "@types/uuid": "^10.0.0",
-    "@typescript-eslint/eslint-plugin": "^7.18.0",
-    "@typescript-eslint/parser": "^7.18.0",
+    "@typescript-eslint/eslint-plugin": "^6.15.0",
+    "@typescript-eslint/parser": "^6.15.0",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.0.1",
-    "eslint-plugin-unused-imports": "^4.3.0",
-    "ioredis-mock": "^8.13.0",
     "jest": "^29.7.0",
     "prettier": "^3.1.1",
     "source-map-support": "^0.5.21",
@@ -108,7 +72,6 @@
     "ts-jest": "^29.1.1",
     "ts-loader": "^9.5.1",
     "ts-node": "^10.9.2",
-    "tsc-alias": "^1.8.16",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.3.3"
   },
@@ -121,12 +84,7 @@
     "rootDir": "src",
     "testRegex": ".*\\.spec\\.ts$",
     "transform": {
-      "^.+\\.(t|j)s$": [
-        "ts-jest",
-        {
-          "tsconfig": "tsconfig.test.json"
-        }
-      ]
+      "^.+\\.(t|j)s$": "ts-jest"
     },
     "collectCoverageFrom": [
       "**/*.(t|j)s"

apps/backend/postman/xpeditis-api.postman_collection.json

@@ -1,372 +0,0 @@
-{
-  "info": {
-    "name": "Xpeditis API",
-    "description": "Complete API collection for Xpeditis maritime freight booking platform",
-    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
-    "_postman_id": "xpeditis-api-v1",
-    "version": "1.0.0"
-  },
-  "auth": {
-    "type": "bearer",
-    "bearer": [
-      {
-        "key": "token",
-        "value": "{{access_token}}",
-        "type": "string"
-      }
-    ]
-  },
-  "variable": [
-    {
-      "key": "base_url",
-      "value": "http://localhost:4000/api/v1",
-      "type": "string"
-    },
-    {
-      "key": "access_token",
-      "value": "",
-      "type": "string"
-    },
-    {
-      "key": "refresh_token",
-      "value": "",
-      "type": "string"
-    },
-    {
-      "key": "user_id",
-      "value": "",
-      "type": "string"
-    },
-    {
-      "key": "booking_id",
-      "value": "",
-      "type": "string"
-    }
-  ],
-  "item": [
-    {
-      "name": "Authentication",
-      "item": [
-        {
-          "name": "Register User",
-          "event": [
-            {
-              "listen": "test",
-              "script": {
-                "exec": [
-                  "pm.test(\"Status code is 201\", function () {",
-                  "    pm.response.to.have.status(201);",
-                  "});",
-                  "",
-                  "pm.test(\"Response has user data\", function () {",
-                  "    const jsonData = pm.response.json();",
-                  "    pm.expect(jsonData).to.have.property('user');",
-                  "    pm.expect(jsonData).to.have.property('accessToken');",
-                  "    pm.environment.set('access_token', jsonData.accessToken);",
-                  "    pm.environment.set('user_id', jsonData.user.id);",
-                  "});"
-                ],
-                "type": "text/javascript"
-              }
-            }
-          ],
-          "request": {
-            "method": "POST",
-            "header": [
-              {
-                "key": "Content-Type",
-                "value": "application/json"
-              }
-            ],
-            "body": {
-              "mode": "raw",
-              "raw": "{\n  \"email\": \"test@example.com\",\n  \"password\": \"TestPassword123!\",\n  \"firstName\": \"Test\",\n  \"lastName\": \"User\",\n  \"organizationName\": \"Test Organization\"\n}"
-            },
-            "url": {
-              "raw": "{{base_url}}/auth/register",
-              "host": ["{{base_url}}"],
-              "path": ["auth", "register"]
-            }
-          }
-        },
-        {
-          "name": "Login",
-          "event": [
-            {
-              "listen": "test",
-              "script": {
-                "exec": [
-                  "pm.test(\"Status code is 200\", function () {",
-                  "    pm.response.to.have.status(200);",
-                  "});",
-                  "",
-                  "pm.test(\"Response has tokens\", function () {",
-                  "    const jsonData = pm.response.json();",
-                  "    pm.expect(jsonData).to.have.property('accessToken');",
-                  "    pm.expect(jsonData).to.have.property('refreshToken');",
-                  "    pm.environment.set('access_token', jsonData.accessToken);",
-                  "    pm.environment.set('refresh_token', jsonData.refreshToken);",
-                  "});"
-                ],
-                "type": "text/javascript"
-              }
-            }
-          ],
-          "request": {
-            "auth": {
-              "type": "noauth"
-            },
-            "method": "POST",
-            "header": [
-              {
-                "key": "Content-Type",
-                "value": "application/json"
-              }
-            ],
-            "body": {
-              "mode": "raw",
-              "raw": "{\n  \"email\": \"test@example.com\",\n  \"password\": \"TestPassword123!\"\n}"
-            },
-            "url": {
-              "raw": "{{base_url}}/auth/login",
-              "host": ["{{base_url}}"],
-              "path": ["auth", "login"]
-            }
-          }
-        },
-        {
-          "name": "Refresh Token",
-          "event": [
-            {
-              "listen": "test",
-              "script": {
-                "exec": [
-                  "pm.test(\"Status code is 200\", function () {",
-                  "    pm.response.to.have.status(200);",
-                  "});",
-                  "",
-                  "const jsonData = pm.response.json();",
-                  "pm.environment.set('access_token', jsonData.accessToken);"
-                ],
-                "type": "text/javascript"
-              }
-            }
-          ],
-          "request": {
-            "auth": {
-              "type": "noauth"
-            },
-            "method": "POST",
-            "header": [
-              {
-                "key": "Content-Type",
-                "value": "application/json"
-              }
-            ],
-            "body": {
-              "mode": "raw",
-              "raw": "{\n  \"refreshToken\": \"{{refresh_token}}\"\n}"
-            },
-            "url": {
-              "raw": "{{base_url}}/auth/refresh",
-              "host": ["{{base_url}}"],
-              "path": ["auth", "refresh"]
-            }
-          }
-        }
-      ]
-    },
-    {
-      "name": "Rates",
-      "item": [
-        {
-          "name": "Search Rates",
-          "event": [
-            {
-              "listen": "test",
-              "script": {
-                "exec": [
-                  "pm.test(\"Status code is 200\", function () {",
-                  "    pm.response.to.have.status(200);",
-                  "});",
-                  "",
-                  "pm.test(\"Response has quotes\", function () {",
-                  "    const jsonData = pm.response.json();",
-                  "    pm.expect(jsonData).to.have.property('quotes');",
-                  "    pm.expect(jsonData.quotes).to.be.an('array');",
-                  "});",
-                  "",
-                  "pm.test(\"Response time < 2000ms\", function () {",
-                  "    pm.expect(pm.response.responseTime).to.be.below(2000);",
-                  "});"
-                ],
-                "type": "text/javascript"
-              }
-            }
-          ],
-          "request": {
-            "method": "POST",
-            "header": [
-              {
-                "key": "Content-Type",
-                "value": "application/json"
-              }
-            ],
-            "body": {
-              "mode": "raw",
-              "raw": "{\n  \"origin\": \"NLRTM\",\n  \"destination\": \"CNSHA\",\n  \"departureDate\": \"2025-11-01\",\n  \"containers\": [\n    {\n      \"type\": \"40HC\",\n      \"quantity\": 1\n    }\n  ]\n}"
-            },
-            "url": {
-              "raw": "{{base_url}}/rates/search",
-              "host": ["{{base_url}}"],
-              "path": ["rates", "search"]
-            }
-          }
-        }
-      ]
-    },
-    {
-      "name": "Bookings",
-      "item": [
-        {
-          "name": "Create Booking",
-          "event": [
-            {
-              "listen": "test",
-              "script": {
-                "exec": [
-                  "pm.test(\"Status code is 201\", function () {",
-                  "    pm.response.to.have.status(201);",
-                  "});",
-                  "",
-                  "pm.test(\"Response has booking data\", function () {",
-                  "    const jsonData = pm.response.json();",
-                  "    pm.expect(jsonData).to.have.property('id');",
-                  "    pm.expect(jsonData).to.have.property('bookingNumber');",
-                  "    pm.environment.set('booking_id', jsonData.id);",
-                  "});",
-                  "",
-                  "pm.test(\"Booking number format is correct\", function () {",
-                  "    const jsonData = pm.response.json();",
-                  "    pm.expect(jsonData.bookingNumber).to.match(/^WCM-\\d{4}-[A-Z0-9]{6}$/);",
-                  "});"
-                ],
-                "type": "text/javascript"
-              }
-            }
-          ],
-          "request": {
-            "method": "POST",
-            "header": [
-              {
-                "key": "Content-Type",
-                "value": "application/json"
-              }
-            ],
-            "body": {
-              "mode": "raw",
-              "raw": "{\n  \"rateQuoteId\": \"rate-quote-id\",\n  \"shipper\": {\n    \"name\": \"Test Shipper Inc.\",\n    \"address\": \"123 Test St\",\n    \"city\": \"Rotterdam\",\n    \"country\": \"Netherlands\",\n    \"email\": \"shipper@test.com\",\n    \"phone\": \"+31612345678\"\n  },\n  \"consignee\": {\n    \"name\": \"Test Consignee Ltd.\",\n    \"address\": \"456 Dest Ave\",\n    \"city\": \"Shanghai\",\n    \"country\": \"China\",\n    \"email\": \"consignee@test.com\",\n    \"phone\": \"+8613812345678\"\n  },\n  \"containers\": [\n    {\n      \"type\": \"40HC\",\n      \"description\": \"Electronics\",\n      \"weight\": 15000\n    }\n  ]\n}"
-            },
-            "url": {
-              "raw": "{{base_url}}/bookings",
-              "host": ["{{base_url}}"],
-              "path": ["bookings"]
-            }
-          }
-        },
-        {
-          "name": "Get Booking by ID",
-          "event": [
-            {
-              "listen": "test",
-              "script": {
-                "exec": [
-                  "pm.test(\"Status code is 200\", function () {",
-                  "    pm.response.to.have.status(200);",
-                  "});",
-                  "",
-                  "pm.test(\"Response has booking details\", function () {",
-                  "    const jsonData = pm.response.json();",
-                  "    pm.expect(jsonData).to.have.property('id');",
-                  "    pm.expect(jsonData).to.have.property('status');",
-                  "});"
-                ],
-                "type": "text/javascript"
-              }
-            }
-          ],
-          "request": {
-            "method": "GET",
-            "url": {
-              "raw": "{{base_url}}/bookings/{{booking_id}}",
-              "host": ["{{base_url}}"],
-              "path": ["bookings", "{{booking_id}}"]
-            }
-          }
-        },
-        {
-          "name": "List Bookings",
-          "event": [
-            {
-              "listen": "test",
-              "script": {
-                "exec": [
-                  "pm.test(\"Status code is 200\", function () {",
-                  "    pm.response.to.have.status(200);",
-                  "});",
-                  "",
-                  "pm.test(\"Response is paginated\", function () {",
-                  "    const jsonData = pm.response.json();",
-                  "    pm.expect(jsonData).to.have.property('data');",
-                  "    pm.expect(jsonData).to.have.property('total');",
-                  "    pm.expect(jsonData).to.have.property('page');",
-                  "});"
-                ],
-                "type": "text/javascript"
-              }
-            }
-          ],
-          "request": {
-            "method": "GET",
-            "url": {
-              "raw": "{{base_url}}/bookings?page=1&pageSize=20",
-              "host": ["{{base_url}}"],
-              "path": ["bookings"],
-              "query": [
-                {
-                  "key": "page",
-                  "value": "1"
-                },
-                {
-                  "key": "pageSize",
-                  "value": "20"
-                }
-              ]
-            }
-          }
-        },
-        {
-          "name": "Export Bookings (CSV)",
-          "request": {
-            "method": "POST",
-            "header": [
-              {
-                "key": "Content-Type",
-                "value": "application/json"
-              }
-            ],
-            "body": {
-              "mode": "raw",
-              "raw": "{\n  \"format\": \"csv\",\n  \"bookingIds\": []\n}"
-            },
-            "url": {
-              "raw": "{{base_url}}/bookings/export",
-              "host": ["{{base_url}}"],
-              "path": ["bookings", "export"]
-            }
-          }
-        }
-      ]
-    }
-  ]
-}

apps/backend/restore-document-references.js

@@ -1,176 +0,0 @@
-/**
- * Script to restore document references in database from MinIO files
- *
- * Scans MinIO for existing files and creates/updates database references
- */
-
-const { S3Client, ListObjectsV2Command, HeadObjectCommand } = require('@aws-sdk/client-s3');
-const { Client } = require('pg');
-const { v4: uuidv4 } = require('uuid');
-require('dotenv').config();
-
-const MINIO_ENDPOINT = process.env.AWS_S3_ENDPOINT || 'http://localhost:9000';
-const BUCKET_NAME = 'xpeditis-documents';
-
-// Initialize MinIO client
-const s3Client = new S3Client({
-  region: 'us-east-1',
-  endpoint: MINIO_ENDPOINT,
-  credentials: {
-    accessKeyId: process.env.AWS_ACCESS_KEY_ID || 'minioadmin',
-    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || 'minioadmin',
-  },
-  forcePathStyle: true,
-});
-
-async function restoreDocumentReferences() {
-  const pgClient = new Client({
-    host: process.env.DATABASE_HOST || 'localhost',
-    port: process.env.DATABASE_PORT || 5432,
-    user: process.env.DATABASE_USER || 'xpeditis',
-    password: process.env.DATABASE_PASSWORD || 'xpeditis_dev_password',
-    database: process.env.DATABASE_NAME || 'xpeditis_dev',
-  });
-
-  try {
-    await pgClient.connect();
-    console.log('✅ Connected to database\n');
-
-    // Get all MinIO files
-    console.log('📋 Listing files in MinIO...');
-    let allFiles = [];
-    let continuationToken = null;
-
-    do {
-      const command = new ListObjectsV2Command({
-        Bucket: BUCKET_NAME,
-        ContinuationToken: continuationToken,
-      });
-
-      const response = await s3Client.send(command);
-
-      if (response.Contents) {
-        allFiles = allFiles.concat(response.Contents);
-      }
-
-      continuationToken = response.NextContinuationToken;
-    } while (continuationToken);
-
-    console.log(`   Found ${allFiles.length} files in MinIO\n`);
-
-    // Group files by booking ID
-    const filesByBooking = {};
-    allFiles.forEach(file => {
-      const parts = file.Key.split('/');
-      if (parts.length >= 3 && parts[0] === 'csv-bookings') {
-        const bookingId = parts[1];
-        const documentId = parts[2].split('-')[0]; // Extract UUID from filename
-        const fileName = parts[2].substring(37); // Remove UUID prefix (36 chars + dash)
-
-        if (!filesByBooking[bookingId]) {
-          filesByBooking[bookingId] = [];
-        }
-
-        filesByBooking[bookingId].push({
-          key: file.Key,
-          documentId: documentId,
-          fileName: fileName,
-          size: file.Size,
-          lastModified: file.LastModified,
-        });
-      }
-    });
-
-    console.log(`📦 Found files for ${Object.keys(filesByBooking).length} bookings\n`);
-
-    let updatedCount = 0;
-    let createdDocsCount = 0;
-
-    for (const [bookingId, files] of Object.entries(filesByBooking)) {
-      // Check if booking exists
-      const bookingResult = await pgClient.query(
-        'SELECT id, documents FROM csv_bookings WHERE id = $1',
-        [bookingId]
-      );
-
-      if (bookingResult.rows.length === 0) {
-        console.log(`⚠️  Booking not found: ${bookingId.substring(0, 8)}... (skipping)`);
-        continue;
-      }
-
-      const booking = bookingResult.rows[0];
-      const existingDocs = booking.documents || [];
-
-      console.log(`\n📦 Booking: ${bookingId.substring(0, 8)}...`);
-      console.log(`   Existing documents in DB: ${existingDocs.length}`);
-      console.log(`   Files in MinIO: ${files.length}`);
-
-      // Create document references for files
-      const newDocuments = files.map(file => {
-        // Determine MIME type from file extension
-        const ext = file.fileName.split('.').pop().toLowerCase();
-        const mimeTypeMap = {
-          pdf: 'application/pdf',
-          png: 'image/png',
-          jpg: 'image/jpeg',
-          jpeg: 'image/jpeg',
-          txt: 'text/plain',
-        };
-        const mimeType = mimeTypeMap[ext] || 'application/octet-stream';
-
-        // Determine document type
-        let docType = 'OTHER';
-        if (file.fileName.toLowerCase().includes('bill-of-lading') || file.fileName.toLowerCase().includes('bol')) {
-          docType = 'BILL_OF_LADING';
-        } else if (file.fileName.toLowerCase().includes('packing-list')) {
-          docType = 'PACKING_LIST';
-        } else if (file.fileName.toLowerCase().includes('commercial-invoice') || file.fileName.toLowerCase().includes('invoice')) {
-          docType = 'COMMERCIAL_INVOICE';
-        }
-
-        const doc = {
-          id: file.documentId,
-          type: docType,
-          fileName: file.fileName,
-          filePath: `${MINIO_ENDPOINT}/${BUCKET_NAME}/${file.key}`,
-          mimeType: mimeType,
-          size: file.size,
-          uploadedAt: file.lastModified.toISOString(),
-        };
-
-        console.log(`   ✅ ${file.fileName} (${(file.size / 1024).toFixed(2)} KB)`);
-        return doc;
-      });
-
-      // Update the booking with new document references
-      await pgClient.query(
-        'UPDATE csv_bookings SET documents = $1 WHERE id = $2',
-        [JSON.stringify(newDocuments), bookingId]
-      );
-
-      updatedCount++;
-      createdDocsCount += newDocuments.length;
-    }
-
-    console.log(`\n📊 Summary:`);
-    console.log(`   Bookings updated: ${updatedCount}`);
-    console.log(`   Document references created: ${createdDocsCount}`);
-    console.log(`\n✅ Document references restored`);
-  } catch (error) {
-    console.error('❌ Error:', error);
-    throw error;
-  } finally {
-    await pgClient.end();
-    console.log('\n👋 Disconnected from database');
-  }
-}
-
-restoreDocumentReferences()
-  .then(() => {
-    console.log('\n✅ Script completed successfully');
-    process.exit(0);
-  })
-  .catch((error) => {
-    console.error('\n❌ Script failed:', error);
-    process.exit(1);
-  });

apps/backend/run-migrations.js

@@ -1,44 +0,0 @@
-const { DataSource } = require('typeorm');
-const path = require('path');
-
-const AppDataSource = new DataSource({
-  type: 'postgres',
-  host: process.env.DATABASE_HOST,
-  port: parseInt(process.env.DATABASE_PORT, 10),
-  username: process.env.DATABASE_USER,
-  password: process.env.DATABASE_PASSWORD,
-  database: process.env.DATABASE_NAME,
-  entities: [path.join(__dirname, 'dist/**/*.orm-entity.js')],
-  migrations: [path.join(__dirname, 'dist/infrastructure/persistence/typeorm/migrations/*.js')],
-  synchronize: false,
-  logging: true,
-});
-
-console.log('🚀 Starting Xpeditis Backend Migration Script...');
-console.log('📦 Initializing DataSource...');
-
-AppDataSource.initialize()
-  .then(async () => {
-    console.log('✅ DataSource initialized successfully');
-    console.log('🔄 Running pending migrations...');
-
-    const migrations = await AppDataSource.runMigrations();
-
-    if (migrations.length === 0) {
-      console.log('✅ No pending migrations');
-    } else {
-      console.log(`✅ Successfully ran ${migrations.length} migration(s):`);
-      migrations.forEach((migration) => {
-        console.log(`   - ${migration.name}`);
-      });
-    }
-
-    await AppDataSource.destroy();
-    console.log('✅ Database migrations completed successfully');
-    process.exit(0);
-  })
-  .catch((error) => {
-    console.error('❌ Error during migration:');
-    console.error(error);
-    process.exit(1);
-  });

apps/backend/scripts/generate-ports-seed.ts

@@ -1,363 +0,0 @@
-/**
- * Script to generate ports seed migration from sea-ports JSON data
- *
- * Data source: https://github.com/marchah/sea-ports
- * License: MIT
- *
- * This script:
- * 1. Reads sea-ports.json from /tmp
- * 2. Parses and validates port data
- * 3. Generates SQL INSERT statements
- * 4. Creates a TypeORM migration file
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-
-interface SeaPort {
-  name: string;
-  city: string;
-  country: string;
-  coordinates: [number, number]; // [longitude, latitude]
-  province?: string;
-  timezone?: string;
-  unlocs: string[];
-  code?: string;
-  alias?: string[];
-  regions?: string[];
-}
-
-interface SeaPortsData {
-  [locode: string]: SeaPort;
-}
-
-interface ParsedPort {
-  code: string;
-  name: string;
-  city: string;
-  country: string;
-  countryName: string;
-  countryCode: string;
-  latitude: number;
-  longitude: number;
-  timezone: string | null;
-  isActive: boolean;
-}
-
-// Country code to name mapping (ISO 3166-1 alpha-2)
-const countryNames: { [key: string]: string } = {
-  AE: 'United Arab Emirates',
-  AG: 'Antigua and Barbuda',
-  AL: 'Albania',
-  AM: 'Armenia',
-  AO: 'Angola',
-  AR: 'Argentina',
-  AT: 'Austria',
-  AU: 'Australia',
-  AZ: 'Azerbaijan',
-  BA: 'Bosnia and Herzegovina',
-  BB: 'Barbados',
-  BD: 'Bangladesh',
-  BE: 'Belgium',
-  BG: 'Bulgaria',
-  BH: 'Bahrain',
-  BN: 'Brunei',
-  BR: 'Brazil',
-  BS: 'Bahamas',
-  BZ: 'Belize',
-  CA: 'Canada',
-  CH: 'Switzerland',
-  CI: 'Ivory Coast',
-  CL: 'Chile',
-  CM: 'Cameroon',
-  CN: 'China',
-  CO: 'Colombia',
-  CR: 'Costa Rica',
-  CU: 'Cuba',
-  CY: 'Cyprus',
-  CZ: 'Czech Republic',
-  DE: 'Germany',
-  DJ: 'Djibouti',
-  DK: 'Denmark',
-  DO: 'Dominican Republic',
-  DZ: 'Algeria',
-  EC: 'Ecuador',
-  EE: 'Estonia',
-  EG: 'Egypt',
-  ES: 'Spain',
-  FI: 'Finland',
-  FJ: 'Fiji',
-  FR: 'France',
-  GA: 'Gabon',
-  GB: 'United Kingdom',
-  GE: 'Georgia',
-  GH: 'Ghana',
-  GI: 'Gibraltar',
-  GR: 'Greece',
-  GT: 'Guatemala',
-  GY: 'Guyana',
-  HK: 'Hong Kong',
-  HN: 'Honduras',
-  HR: 'Croatia',
-  HT: 'Haiti',
-  HU: 'Hungary',
-  ID: 'Indonesia',
-  IE: 'Ireland',
-  IL: 'Israel',
-  IN: 'India',
-  IQ: 'Iraq',
-  IR: 'Iran',
-  IS: 'Iceland',
-  IT: 'Italy',
-  JM: 'Jamaica',
-  JO: 'Jordan',
-  JP: 'Japan',
-  KE: 'Kenya',
-  KH: 'Cambodia',
-  KR: 'South Korea',
-  KW: 'Kuwait',
-  KZ: 'Kazakhstan',
-  LB: 'Lebanon',
-  LK: 'Sri Lanka',
-  LR: 'Liberia',
-  LT: 'Lithuania',
-  LV: 'Latvia',
-  LY: 'Libya',
-  MA: 'Morocco',
-  MC: 'Monaco',
-  MD: 'Moldova',
-  ME: 'Montenegro',
-  MG: 'Madagascar',
-  MK: 'North Macedonia',
-  MM: 'Myanmar',
-  MN: 'Mongolia',
-  MO: 'Macau',
-  MR: 'Mauritania',
-  MT: 'Malta',
-  MU: 'Mauritius',
-  MV: 'Maldives',
-  MX: 'Mexico',
-  MY: 'Malaysia',
-  MZ: 'Mozambique',
-  NA: 'Namibia',
-  NG: 'Nigeria',
-  NI: 'Nicaragua',
-  NL: 'Netherlands',
-  NO: 'Norway',
-  NZ: 'New Zealand',
-  OM: 'Oman',
-  PA: 'Panama',
-  PE: 'Peru',
-  PG: 'Papua New Guinea',
-  PH: 'Philippines',
-  PK: 'Pakistan',
-  PL: 'Poland',
-  PR: 'Puerto Rico',
-  PT: 'Portugal',
-  PY: 'Paraguay',
-  QA: 'Qatar',
-  RO: 'Romania',
-  RS: 'Serbia',
-  RU: 'Russia',
-  SA: 'Saudi Arabia',
-  SD: 'Sudan',
-  SE: 'Sweden',
-  SG: 'Singapore',
-  SI: 'Slovenia',
-  SK: 'Slovakia',
-  SN: 'Senegal',
-  SO: 'Somalia',
-  SR: 'Suriname',
-  SY: 'Syria',
-  TH: 'Thailand',
-  TN: 'Tunisia',
-  TR: 'Turkey',
-  TT: 'Trinidad and Tobago',
-  TW: 'Taiwan',
-  TZ: 'Tanzania',
-  UA: 'Ukraine',
-  UG: 'Uganda',
-  US: 'United States',
-  UY: 'Uruguay',
-  VE: 'Venezuela',
-  VN: 'Vietnam',
-  YE: 'Yemen',
-  ZA: 'South Africa',
-};
-
-function parseSeaPorts(filePath: string): ParsedPort[] {
-  const jsonData = fs.readFileSync(filePath, 'utf-8');
-  const seaPorts: SeaPortsData = JSON.parse(jsonData);
-
-  const parsedPorts: ParsedPort[] = [];
-  let skipped = 0;
-
-  for (const [locode, port] of Object.entries(seaPorts)) {
-    // Validate required fields
-    if (!port.name || !port.coordinates || port.coordinates.length !== 2) {
-      skipped++;
-      continue;
-    }
-
-    // Extract country code from UN/LOCODE (first 2 characters)
-    const countryCode = locode.substring(0, 2).toUpperCase();
-
-    // Skip if invalid country code
-    if (!countryNames[countryCode]) {
-      skipped++;
-      continue;
-    }
-
-    // Validate coordinates
-    const [longitude, latitude] = port.coordinates;
-    if (
-      latitude < -90 || latitude > 90 ||
-      longitude < -180 || longitude > 180
-    ) {
-      skipped++;
-      continue;
-    }
-
-    parsedPorts.push({
-      code: locode.toUpperCase(),
-      name: port.name.trim(),
-      city: port.city?.trim() || port.name.trim(),
-      country: countryCode,
-      countryName: countryNames[countryCode] || port.country,
-      countryCode: countryCode,
-      latitude: Number(latitude.toFixed(6)),
-      longitude: Number(longitude.toFixed(6)),
-      timezone: port.timezone || null,
-      isActive: true,
-    });
-  }
-
-  console.log(`✅ Parsed ${parsedPorts.length} ports`);
-  console.log(`⚠️  Skipped ${skipped} invalid entries`);
-
-  return parsedPorts;
-}
-
-function generateSQLInserts(ports: ParsedPort[]): string {
-  const batchSize = 100;
-  const batches: string[] = [];
-
-  for (let i = 0; i < ports.length; i += batchSize) {
-    const batch = ports.slice(i, i + batchSize);
-    const values = batch.map(port => {
-      const name = port.name.replace(/'/g, "''");
-      const city = port.city.replace(/'/g, "''");
-      const countryName = port.countryName.replace(/'/g, "''");
-      const timezone = port.timezone ? `'${port.timezone}'` : 'NULL';
-
-      return `(
-        '${port.code}',
-        '${name}',
-        '${city}',
-        '${port.country}',
-        '${countryName}',
-        ${port.latitude},
-        ${port.longitude},
-        ${timezone},
-        ${port.isActive}
-      )`;
-    }).join(',\n      ');
-
-    batches.push(`
-    // Batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(ports.length / batchSize)} (${batch.length} ports)
-    await queryRunner.query(\`
-      INSERT INTO ports (code, name, city, country, country_name, latitude, longitude, timezone, is_active)
-      VALUES ${values}
-    \`);
-`);
-  }
-
-  return batches.join('\n');
-}
-
-function generateMigration(ports: ParsedPort[]): string {
-  const timestamp = Date.now();
-  const className = `SeedPorts${timestamp}`;
-  const sqlInserts = generateSQLInserts(ports);
-
-  const migrationContent = `/**
- * Migration: Seed Ports Table
- *
- * Source: sea-ports (https://github.com/marchah/sea-ports)
- * License: MIT
- * Generated: ${new Date().toISOString()}
- * Total ports: ${ports.length}
- */
-
-import { MigrationInterface, QueryRunner } from 'typeorm';
-
-export class ${className} implements MigrationInterface {
-  name = '${className}';
-
-  public async up(queryRunner: QueryRunner): Promise<void> {
-    console.log('Seeding ${ports.length} maritime ports...');
-
-${sqlInserts}
-
-    console.log('✅ Successfully seeded ${ports.length} ports');
-  }
-
-  public async down(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.query(\`TRUNCATE TABLE ports RESTART IDENTITY CASCADE\`);
-    console.log('🗑️  Cleared all ports');
-  }
-}
-`;
-
-  return migrationContent;
-}
-
-async function main() {
-  const seaPortsPath = '/tmp/sea-ports.json';
-
-  console.log('🚢 Generating Ports Seed Migration\n');
-
-  // Check if sea-ports.json exists
-  if (!fs.existsSync(seaPortsPath)) {
-    console.error('❌ Error: /tmp/sea-ports.json not found!');
-    console.log('Please download it first:');
-    console.log('curl -o /tmp/sea-ports.json https://raw.githubusercontent.com/marchah/sea-ports/master/lib/ports.json');
-    process.exit(1);
-  }
-
-  // Parse ports
-  console.log('📖 Parsing sea-ports.json...');
-  const ports = parseSeaPorts(seaPortsPath);
-
-  // Sort by country, then by name
-  ports.sort((a, b) => {
-    if (a.country !== b.country) {
-      return a.country.localeCompare(b.country);
-    }
-    return a.name.localeCompare(b.name);
-  });
-
-  // Generate migration
-  console.log('\n📝 Generating migration file...');
-  const migrationContent = generateMigration(ports);
-
-  // Write migration file
-  const migrationsDir = path.join(__dirname, '../src/infrastructure/persistence/typeorm/migrations');
-  const timestamp = Date.now();
-  const fileName = `${timestamp}-SeedPorts.ts`;
-  const filePath = path.join(migrationsDir, fileName);
-
-  fs.writeFileSync(filePath, migrationContent, 'utf-8');
-
-  console.log(`\n✅ Migration created: ${fileName}`);
-  console.log(`📍 Location: ${filePath}`);
-  console.log(`\n📊 Summary:`);
-  console.log(`   - Total ports: ${ports.length}`);
-  console.log(`   - Countries: ${new Set(ports.map(p => p.country)).size}`);
-  console.log(`   - Ports with timezone: ${ports.filter(p => p.timezone).length}`);
-  console.log(`\n🚀 Run the migration:`);
-  console.log(`   cd apps/backend`);
-  console.log(`   npm run migration:run`);
-}
-
-main().catch(console.error);

apps/backend/scripts/list-stripe-prices.js

@@ -1,55 +0,0 @@
-/**
- * Script to list all Stripe prices
- * Run with: node scripts/list-stripe-prices.js
- */
-
-const Stripe = require('stripe');
-
-const stripe = new Stripe(process.env.STRIPE_SECRET_KEY || 'sk_test_51R8p8R4atifoBlu1U9sMJh3rkQbO1G1xeguwFMQYMIMeaLNrTX7YFO5Ovu3P1VfbwcOoEmiy6I0UWi4DThNNzHG100YF75TnJr');
-
-async function listPrices() {
-  console.log('Fetching Stripe prices...\n');
-
-  try {
-    const prices = await stripe.prices.list({ limit: 50, expand: ['data.product'] });
-
-    if (prices.data.length === 0) {
-      console.log('No prices found. You need to create prices in Stripe Dashboard.');
-      console.log('\nSteps:');
-      console.log('1. Go to https://dashboard.stripe.com/products');
-      console.log('2. Click on each product (Starter, Pro, Enterprise)');
-      console.log('3. Add a recurring price (monthly and yearly)');
-      console.log('4. Copy the Price IDs (format: price_xxxxx)');
-      return;
-    }
-
-    console.log('Available Prices:\n');
-    console.log('='.repeat(100));
-
-    for (const price of prices.data) {
-      const product = typeof price.product === 'object' ? price.product : { name: price.product };
-      const interval = price.recurring ? `${price.recurring.interval}ly` : 'one-time';
-      const amount = (price.unit_amount / 100).toFixed(2);
-
-      console.log(`Price ID:    ${price.id}`);
-      console.log(`Product:     ${product.name || product.id}`);
-      console.log(`Amount:      ${amount} ${price.currency.toUpperCase()}`);
-      console.log(`Interval:    ${interval}`);
-      console.log(`Active:      ${price.active}`);
-      console.log('-'.repeat(100));
-    }
-
-    console.log('\n\nCopy the relevant Price IDs to your .env file:');
-    console.log('STRIPE_STARTER_MONTHLY_PRICE_ID=price_xxxxx');
-    console.log('STRIPE_STARTER_YEARLY_PRICE_ID=price_xxxxx');
-    console.log('STRIPE_PRO_MONTHLY_PRICE_ID=price_xxxxx');
-    console.log('STRIPE_PRO_YEARLY_PRICE_ID=price_xxxxx');
-    console.log('STRIPE_ENTERPRISE_MONTHLY_PRICE_ID=price_xxxxx');
-    console.log('STRIPE_ENTERPRISE_YEARLY_PRICE_ID=price_xxxxx');
-
-  } catch (error) {
-    console.error('Error fetching prices:', error.message);
-  }
-}
-
-listPrices();

apps/backend/set-bucket-policy.js

@@ -1,79 +0,0 @@
-/**
- * Script to set MinIO bucket policy for public read access
- *
- * This allows documents to be downloaded directly via URL without authentication
- */
-
-const { S3Client, PutBucketPolicyCommand, GetBucketPolicyCommand } = require('@aws-sdk/client-s3');
-require('dotenv').config();
-
-const MINIO_ENDPOINT = process.env.AWS_S3_ENDPOINT || 'http://localhost:9000';
-const BUCKET_NAME = 'xpeditis-documents';
-
-// Initialize MinIO client
-const s3Client = new S3Client({
-  region: 'us-east-1',
-  endpoint: MINIO_ENDPOINT,
-  credentials: {
-    accessKeyId: process.env.AWS_ACCESS_KEY_ID || 'minioadmin',
-    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || 'minioadmin',
-  },
-  forcePathStyle: true,
-});
-
-async function setBucketPolicy() {
-  try {
-    // Policy to allow public read access to all objects in the bucket
-    const policy = {
-      Version: '2012-10-17',
-      Statement: [
-        {
-          Effect: 'Allow',
-          Principal: '*',
-          Action: ['s3:GetObject'],
-          Resource: [`arn:aws:s3:::${BUCKET_NAME}/*`],
-        },
-      ],
-    };
-
-    console.log('📋 Setting bucket policy for:', BUCKET_NAME);
-    console.log('Policy:', JSON.stringify(policy, null, 2));
-
-    // Set the bucket policy
-    await s3Client.send(
-      new PutBucketPolicyCommand({
-        Bucket: BUCKET_NAME,
-        Policy: JSON.stringify(policy),
-      })
-    );
-
-    console.log('\n✅ Bucket policy set successfully!');
-    console.log(`   All objects in ${BUCKET_NAME} are now publicly readable`);
-
-    // Verify the policy was set
-    console.log('\n🔍 Verifying bucket policy...');
-    const getPolicy = await s3Client.send(
-      new GetBucketPolicyCommand({
-        Bucket: BUCKET_NAME,
-      })
-    );
-
-    console.log('✅ Current policy:', getPolicy.Policy);
-
-    console.log('\n📝 Note: This allows public read access to all documents.');
-    console.log('   For production, consider using signed URLs instead.');
-  } catch (error) {
-    console.error('❌ Error:', error);
-    throw error;
-  }
-}
-
-setBucketPolicy()
-  .then(() => {
-    console.log('\n✅ Script completed successfully');
-    process.exit(0);
-  })
-  .catch((error) => {
-    console.error('\n❌ Script failed:', error);
-    process.exit(1);
-  });

apps/backend/setup-minio-bucket.js

@@ -1,91 +0,0 @@
-#!/usr/bin/env node
-/**
- * Setup MinIO Bucket
- *
- * Creates the required bucket for document storage if it doesn't exist
- */
-
-const { S3Client, CreateBucketCommand, HeadBucketCommand } = require('@aws-sdk/client-s3');
-require('dotenv').config();
-
-const BUCKET_NAME = 'xpeditis-documents';
-
-// Configure S3 client for MinIO
-const s3Client = new S3Client({
-  region: process.env.AWS_REGION || 'us-east-1',
-  endpoint: process.env.AWS_S3_ENDPOINT || 'http://localhost:9000',
-  credentials: {
-    accessKeyId: process.env.AWS_ACCESS_KEY_ID || 'minioadmin',
-    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || 'minioadmin',
-  },
-  forcePathStyle: true, // Required for MinIO
-});
-
-async function setupBucket() {
-  console.log('\n🪣 MinIO Bucket Setup');
-  console.log('==========================================');
-  console.log(`Bucket name: ${BUCKET_NAME}`);
-  console.log(`Endpoint: ${process.env.AWS_S3_ENDPOINT || 'http://localhost:9000'}`);
-  console.log('');
-
-  try {
-    // Check if bucket exists
-    console.log('📋 Step 1: Checking if bucket exists...');
-    try {
-      await s3Client.send(new HeadBucketCommand({ Bucket: BUCKET_NAME }));
-      console.log(`✅ Bucket '${BUCKET_NAME}' already exists`);
-      console.log('');
-      console.log('✅ Setup complete! The bucket is ready to use.');
-      process.exit(0);
-    } catch (error) {
-      if (error.name === 'NotFound' || error.$metadata?.httpStatusCode === 404) {
-        console.log(`ℹ️  Bucket '${BUCKET_NAME}' does not exist`);
-      } else {
-        throw error;
-      }
-    }
-
-    // Create bucket
-    console.log('');
-    console.log('📋 Step 2: Creating bucket...');
-    await s3Client.send(new CreateBucketCommand({ Bucket: BUCKET_NAME }));
-    console.log(`✅ Bucket '${BUCKET_NAME}' created successfully!`);
-
-    // Verify creation
-    console.log('');
-    console.log('📋 Step 3: Verifying bucket...');
-    await s3Client.send(new HeadBucketCommand({ Bucket: BUCKET_NAME }));
-    console.log(`✅ Bucket '${BUCKET_NAME}' verified!`);
-
-    console.log('');
-    console.log('==========================================');
-    console.log('✅ Setup complete! The bucket is ready to use.');
-    console.log('');
-    console.log('You can now:');
-    console.log('  1. Create CSV bookings via the frontend');
-    console.log('  2. Upload documents to this bucket');
-    console.log('  3. View files at: http://localhost:9001 (MinIO Console)');
-    console.log('');
-
-    process.exit(0);
-  } catch (error) {
-    console.error('');
-    console.error('❌ ERROR: Failed to setup bucket');
-    console.error('');
-    console.error('Error details:');
-    console.error(`  Name: ${error.name}`);
-    console.error(`  Message: ${error.message}`);
-    if (error.$metadata) {
-      console.error(`  HTTP Status: ${error.$metadata.httpStatusCode}`);
-    }
-    console.error('');
-    console.error('Common solutions:');
-    console.error('  1. Check if MinIO is running: docker ps | grep minio');
-    console.error('  2. Verify credentials in .env file');
-    console.error('  3. Ensure AWS_S3_ENDPOINT is set correctly');
-    console.error('');
-    process.exit(1);
-  }
-}
-
-setupBucket();

apps/backend/src/app.module.ts

@@ -2,32 +2,8 @@ import { Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { LoggerModule } from 'nestjs-pino';
-import { APP_GUARD } from '@nestjs/core';
 import * as Joi from 'joi';
-
-// Import feature modules
-import { AuthModule } from './application/auth/auth.module';
-import { RatesModule } from './application/rates/rates.module';
-import { PortsModule } from './application/ports/ports.module';
-import { BookingsModule } from './application/bookings/bookings.module';
-import { OrganizationsModule } from './application/organizations/organizations.module';
-import { UsersModule } from './application/users/users.module';
-import { DashboardModule } from './application/dashboard/dashboard.module';
-import { AuditModule } from './application/audit/audit.module';
-import { NotificationsModule } from './application/notifications/notifications.module';
-import { WebhooksModule } from './application/webhooks/webhooks.module';
-import { GDPRModule } from './application/gdpr/gdpr.module';
-import { CsvBookingsModule } from './application/csv-bookings.module';
-import { AdminModule } from './application/admin/admin.module';
-import { SubscriptionsModule } from './application/subscriptions/subscriptions.module';
-import { CacheModule } from './infrastructure/cache/cache.module';
-import { CarrierModule } from './infrastructure/carriers/carrier.module';
-import { SecurityModule } from './infrastructure/security/security.module';
-import { CsvRateModule } from './infrastructure/carriers/csv-loader/csv-rate.module';
-
-// Import global guards
-import { JwtAuthGuard } from './application/guards/jwt-auth.guard';
-import { CustomThrottlerGuard } from './application/guards/throttle.guard';
+import { HealthController } from './application/controllers';
 
 @Module({
   imports: [
@@ -35,10 +11,10 @@ import { CustomThrottlerGuard } from './application/guards/throttle.guard';
     ConfigModule.forRoot({
       isGlobal: true,
       validationSchema: Joi.object({
-        NODE_ENV: Joi.string().valid('development', 'production', 'test').default('development'),
+        NODE_ENV: Joi.string()
+          .valid('development', 'production', 'test')
+          .default('development'),
         PORT: Joi.number().default(4000),
-        APP_URL: Joi.string().uri().default('http://localhost:3000'),
-        BACKEND_URL: Joi.string().uri().optional(),
         DATABASE_HOST: Joi.string().required(),
         DATABASE_PORT: Joi.number().default(5432),
         DATABASE_USER: Joi.string().required(),
@@ -50,22 +26,6 @@ import { CustomThrottlerGuard } from './application/guards/throttle.guard';
         JWT_SECRET: Joi.string().required(),
         JWT_ACCESS_EXPIRATION: Joi.string().default('15m'),
         JWT_REFRESH_EXPIRATION: Joi.string().default('7d'),
-        // SMTP Configuration
-        SMTP_HOST: Joi.string().required(),
-        SMTP_PORT: Joi.number().default(2525),
-        SMTP_USER: Joi.string().required(),
-        SMTP_PASS: Joi.string().required(),
-        SMTP_FROM: Joi.string().email().default('noreply@xpeditis.com'),
-        SMTP_SECURE: Joi.boolean().default(false),
-        // Stripe Configuration (optional for development)
-        STRIPE_SECRET_KEY: Joi.string().optional(),
-        STRIPE_WEBHOOK_SECRET: Joi.string().optional(),
-        STRIPE_STARTER_MONTHLY_PRICE_ID: Joi.string().optional(),
-        STRIPE_STARTER_YEARLY_PRICE_ID: Joi.string().optional(),
-        STRIPE_PRO_MONTHLY_PRICE_ID: Joi.string().optional(),
-        STRIPE_PRO_YEARLY_PRICE_ID: Joi.string().optional(),
-        STRIPE_ENTERPRISE_MONTHLY_PRICE_ID: Joi.string().optional(),
-        STRIPE_ENTERPRISE_YEARLY_PRICE_ID: Joi.string().optional(),
       }),
     }),
 
@@ -99,49 +59,20 @@ import { CustomThrottlerGuard } from './application/guards/throttle.guard';
         username: configService.get('DATABASE_USER'),
         password: configService.get('DATABASE_PASSWORD'),
         database: configService.get('DATABASE_NAME'),
-        entities: [__dirname + '/**/*.orm-entity{.ts,.js}'],
-        synchronize: false, // ✅ Force false - use migrations instead
+        entities: [],
+        synchronize: configService.get('DATABASE_SYNC', false),
         logging: configService.get('DATABASE_LOGGING', false),
-        autoLoadEntities: true, // Auto-load entities from forFeature()
       }),
       inject: [ConfigService],
     }),
 
-    // Infrastructure modules
-    SecurityModule,
-    CacheModule,
-    CarrierModule,
-    CsvRateModule,
-
-    // Feature modules
-    AuthModule,
-    RatesModule,
-    PortsModule,
-    BookingsModule,
-    CsvBookingsModule,
-    OrganizationsModule,
-    UsersModule,
-    DashboardModule,
-    AuditModule,
-    NotificationsModule,
-    WebhooksModule,
-    GDPRModule,
-    AdminModule,
-    SubscriptionsModule,
-  ],
-  controllers: [],
-  providers: [
-    // Global JWT authentication guard
-    // All routes are protected by default, use @Public() to bypass
-    {
-      provide: APP_GUARD,
-      useClass: JwtAuthGuard,
-    },
-    // Global rate limiting guard
-    {
-      provide: APP_GUARD,
-      useClass: CustomThrottlerGuard,
-    },
+    // Application modules will be added here
+    // RatesModule,
+    // BookingsModule,
+    // AuthModule,
+    // etc.
   ],
+  controllers: [HealthController],
+  providers: [],
 })
 export class AppModule {}

apps/backend/src/application/admin/admin.module.ts

@@ -1,42 +0,0 @@
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-
-// Controller
-import { AdminController } from '../controllers/admin.controller';
-
-// ORM Entities
-import { UserOrmEntity } from '@infrastructure/persistence/typeorm/entities/user.orm-entity';
-import { OrganizationOrmEntity } from '@infrastructure/persistence/typeorm/entities/organization.orm-entity';
-import { CsvBookingOrmEntity } from '@infrastructure/persistence/typeorm/entities/csv-booking.orm-entity';
-
-// Repositories
-import { TypeOrmUserRepository } from '@infrastructure/persistence/typeorm/repositories/typeorm-user.repository';
-import { TypeOrmOrganizationRepository } from '@infrastructure/persistence/typeorm/repositories/typeorm-organization.repository';
-import { TypeOrmCsvBookingRepository } from '@infrastructure/persistence/typeorm/repositories/csv-booking.repository';
-
-// Repository tokens
-import { USER_REPOSITORY } from '@domain/ports/out/user.repository';
-import { ORGANIZATION_REPOSITORY } from '@domain/ports/out/organization.repository';
-
-/**
- * Admin Module
- *
- * Provides admin-only endpoints for managing all data in the system.
- * All endpoints require ADMIN role.
- */
-@Module({
-  imports: [TypeOrmModule.forFeature([UserOrmEntity, OrganizationOrmEntity, CsvBookingOrmEntity])],
-  controllers: [AdminController],
-  providers: [
-    {
-      provide: USER_REPOSITORY,
-      useClass: TypeOrmUserRepository,
-    },
-    {
-      provide: ORGANIZATION_REPOSITORY,
-      useClass: TypeOrmOrganizationRepository,
-    },
-    TypeOrmCsvBookingRepository,
-  ],
-})
-export class AdminModule {}

apps/backend/src/application/audit/audit.module.ts

@@ -1,27 +0,0 @@
-/**
- * Audit Module
- *
- * Provides audit logging functionality
- */
-
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { AuditController } from '../controllers/audit.controller';
-import { AuditService } from '../services/audit.service';
-import { AuditLogOrmEntity } from '../../infrastructure/persistence/typeorm/entities/audit-log.orm-entity';
-import { TypeOrmAuditLogRepository } from '../../infrastructure/persistence/typeorm/repositories/typeorm-audit-log.repository';
-import { AUDIT_LOG_REPOSITORY } from '@domain/ports/out/audit-log.repository';
-
-@Module({
-  imports: [TypeOrmModule.forFeature([AuditLogOrmEntity])],
-  controllers: [AuditController],
-  providers: [
-    AuditService,
-    {
-      provide: AUDIT_LOG_REPOSITORY,
-      useClass: TypeOrmAuditLogRepository,
-    },
-  ],
-  exports: [AuditService],
-})
-export class AuditModule {}

apps/backend/src/application/auth/auth.module.ts

@@ -1,71 +0,0 @@
-import { Module } from '@nestjs/common';
-import { JwtModule } from '@nestjs/jwt';
-import { PassportModule } from '@nestjs/passport';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { AuthService } from './auth.service';
-import { JwtStrategy } from './jwt.strategy';
-import { AuthController } from '../controllers/auth.controller';
-
-// Import domain and infrastructure dependencies
-import { USER_REPOSITORY } from '@domain/ports/out/user.repository';
-import { ORGANIZATION_REPOSITORY } from '@domain/ports/out/organization.repository';
-import { INVITATION_TOKEN_REPOSITORY } from '@domain/ports/out/invitation-token.repository';
-import { TypeOrmUserRepository } from '../../infrastructure/persistence/typeorm/repositories/typeorm-user.repository';
-import { TypeOrmOrganizationRepository } from '../../infrastructure/persistence/typeorm/repositories/typeorm-organization.repository';
-import { TypeOrmInvitationTokenRepository } from '../../infrastructure/persistence/typeorm/repositories/typeorm-invitation-token.repository';
-import { UserOrmEntity } from '../../infrastructure/persistence/typeorm/entities/user.orm-entity';
-import { OrganizationOrmEntity } from '../../infrastructure/persistence/typeorm/entities/organization.orm-entity';
-import { InvitationTokenOrmEntity } from '../../infrastructure/persistence/typeorm/entities/invitation-token.orm-entity';
-import { InvitationService } from '../services/invitation.service';
-import { InvitationsController } from '../controllers/invitations.controller';
-import { EmailModule } from '../../infrastructure/email/email.module';
-import { SubscriptionsModule } from '../subscriptions/subscriptions.module';
-
-@Module({
-  imports: [
-    // Passport configuration
-    PassportModule.register({ defaultStrategy: 'jwt' }),
-
-    // JWT configuration with async factory
-    JwtModule.registerAsync({
-      imports: [ConfigModule],
-      inject: [ConfigService],
-      useFactory: async (configService: ConfigService) => ({
-        secret: configService.get<string>('JWT_SECRET'),
-        signOptions: {
-          expiresIn: configService.get<string>('JWT_ACCESS_EXPIRATION', '15m'),
-        },
-      }),
-    }),
-
-    // 👇 Add this to register TypeORM repositories
-    TypeOrmModule.forFeature([UserOrmEntity, OrganizationOrmEntity, InvitationTokenOrmEntity]),
-
-    // Email module for sending invitations
-    EmailModule,
-
-    // Subscriptions module for license checks
-    SubscriptionsModule,
-  ],
-  controllers: [AuthController, InvitationsController],
-  providers: [
-    AuthService,
-    JwtStrategy,
-    InvitationService,
-    {
-      provide: USER_REPOSITORY,
-      useClass: TypeOrmUserRepository,
-    },
-    {
-      provide: ORGANIZATION_REPOSITORY,
-      useClass: TypeOrmOrganizationRepository,
-    },
-    {
-      provide: INVITATION_TOKEN_REPOSITORY,
-      useClass: TypeOrmInvitationTokenRepository,
-    },
-  ],
-  exports: [AuthService, JwtStrategy, PassportModule],
-})
-export class AuthModule {}

apps/backend/src/application/auth/auth.service.ts

@@ -1,330 +0,0 @@
-import {
-  Injectable,
-  UnauthorizedException,
-  ConflictException,
-  Logger,
-  Inject,
-  BadRequestException,
-} from '@nestjs/common';
-import { JwtService } from '@nestjs/jwt';
-import { ConfigService } from '@nestjs/config';
-import * as argon2 from 'argon2';
-import { UserRepository, USER_REPOSITORY } from '@domain/ports/out/user.repository';
-import { User, UserRole } from '@domain/entities/user.entity';
-import {
-  OrganizationRepository,
-  ORGANIZATION_REPOSITORY,
-} from '@domain/ports/out/organization.repository';
-import { Organization } from '@domain/entities/organization.entity';
-import { v4 as uuidv4 } from 'uuid';
-import { RegisterOrganizationDto } from '../dto/auth-login.dto';
-import { SubscriptionService } from '../services/subscription.service';
-
-export interface JwtPayload {
-  sub: string; // user ID
-  email: string;
-  role: string;
-  organizationId: string;
-  type: 'access' | 'refresh';
-}
-
-@Injectable()
-export class AuthService {
-  private readonly logger = new Logger(AuthService.name);
-
-  constructor(
-    @Inject(USER_REPOSITORY)
-    private readonly userRepository: UserRepository,
-    @Inject(ORGANIZATION_REPOSITORY)
-    private readonly organizationRepository: OrganizationRepository,
-    private readonly jwtService: JwtService,
-    private readonly configService: ConfigService,
-    private readonly subscriptionService: SubscriptionService,
-  ) {}
-
-  /**
-   * Register a new user
-   */
-  async register(
-    email: string,
-    password: string,
-    firstName: string,
-    lastName: string,
-    organizationId?: string,
-    organizationData?: RegisterOrganizationDto,
-    invitationRole?: string
-  ): Promise<{ accessToken: string; refreshToken: string; user: any }> {
-    this.logger.log(`Registering new user: ${email}`);
-
-    const existingUser = await this.userRepository.findByEmail(email);
-
-    if (existingUser) {
-      throw new ConflictException('User with this email already exists');
-    }
-
-    const passwordHash = await argon2.hash(password, {
-      type: argon2.argon2id,
-      memoryCost: 65536, // 64 MB
-      timeCost: 3,
-      parallelism: 4,
-    });
-
-    // Determine organization ID:
-    // 1. If organizationId is provided (invited user), use it
-    // 2. If organizationData is provided (new user), create a new organization
-    // 3. Otherwise, use default organization
-    const finalOrganizationId = await this.resolveOrganizationId(organizationId, organizationData);
-
-    // Determine role:
-    // - If invitation role is provided (invited user), use it
-    // - If organizationData is provided (new organization creator), make them MANAGER
-    // - Otherwise, default to USER
-    let userRole: UserRole;
-    if (invitationRole) {
-      userRole = invitationRole as UserRole;
-    } else if (organizationData) {
-      // User creating a new organization becomes MANAGER
-      userRole = UserRole.MANAGER;
-    } else {
-      // Default to USER for other cases
-      userRole = UserRole.USER;
-    }
-
-    const user = User.create({
-      id: uuidv4(),
-      organizationId: finalOrganizationId,
-      email,
-      passwordHash,
-      firstName,
-      lastName,
-      role: userRole,
-    });
-
-    const savedUser = await this.userRepository.save(user);
-
-    // Allocate a license for the new user
-    try {
-      await this.subscriptionService.allocateLicense(savedUser.id, finalOrganizationId);
-      this.logger.log(`License allocated for user: ${email}`);
-    } catch (error) {
-      this.logger.error(`Failed to allocate license for user ${email}:`, error);
-      // Note: We don't throw here because the user is already created.
-      // The license check should happen before invitation.
-    }
-
-    const tokens = await this.generateTokens(savedUser);
-
-    this.logger.log(`User registered successfully: ${email}`);
-
-    return {
-      ...tokens,
-      user: {
-        id: savedUser.id,
-        email: savedUser.email,
-        firstName: savedUser.firstName,
-        lastName: savedUser.lastName,
-        role: savedUser.role,
-        organizationId: savedUser.organizationId,
-      },
-    };
-  }
-
-  /**
-   * Login user with email and password
-   */
-  async login(
-    email: string,
-    password: string
-  ): Promise<{ accessToken: string; refreshToken: string; user: any }> {
-    this.logger.log(`Login attempt for: ${email}`);
-
-    const user = await this.userRepository.findByEmail(email);
-
-    if (!user) {
-      throw new UnauthorizedException('Invalid credentials');
-    }
-
-    if (!user.isActive) {
-      throw new UnauthorizedException('User account is inactive');
-    }
-
-    const isPasswordValid = await argon2.verify(user.passwordHash, password);
-
-    if (!isPasswordValid) {
-      throw new UnauthorizedException('Invalid credentials');
-    }
-
-    const tokens = await this.generateTokens(user);
-
-    this.logger.log(`User logged in successfully: ${email}`);
-
-    return {
-      ...tokens,
-      user: {
-        id: user.id,
-        email: user.email,
-        firstName: user.firstName,
-        lastName: user.lastName,
-        role: user.role,
-        organizationId: user.organizationId,
-      },
-    };
-  }
-
-  /**
-   * Refresh access token using refresh token
-   */
-  async refreshAccessToken(
-    refreshToken: string
-  ): Promise<{ accessToken: string; refreshToken: string }> {
-    try {
-      const payload = await this.jwtService.verifyAsync<JwtPayload>(refreshToken, {
-        secret: this.configService.get('JWT_SECRET'),
-      });
-
-      if (payload.type !== 'refresh') {
-        throw new UnauthorizedException('Invalid token type');
-      }
-
-      const user = await this.userRepository.findById(payload.sub);
-
-      if (!user || !user.isActive) {
-        throw new UnauthorizedException('User not found or inactive');
-      }
-
-      const tokens = await this.generateTokens(user);
-
-      this.logger.log(`Access token refreshed for user: ${user.email}`);
-
-      return tokens;
-    } catch (error: any) {
-      this.logger.error(`Token refresh failed: ${error?.message || 'Unknown error'}`);
-      throw new UnauthorizedException('Invalid or expired refresh token');
-    }
-  }
-
-  /**
-   * Validate user from JWT payload
-   */
-  async validateUser(payload: JwtPayload): Promise<User | null> {
-    const user = await this.userRepository.findById(payload.sub);
-
-    if (!user || !user.isActive) {
-      return null;
-    }
-
-    return user;
-  }
-
-  /**
-   * Generate access and refresh tokens
-   */
-  private async generateTokens(user: User): Promise<{ accessToken: string; refreshToken: string }> {
-    const accessPayload: JwtPayload = {
-      sub: user.id,
-      email: user.email,
-      role: user.role,
-      organizationId: user.organizationId,
-      type: 'access',
-    };
-
-    const refreshPayload: JwtPayload = {
-      sub: user.id,
-      email: user.email,
-      role: user.role,
-      organizationId: user.organizationId,
-      type: 'refresh',
-    };
-
-    const [accessToken, refreshToken] = await Promise.all([
-      this.jwtService.signAsync(accessPayload, {
-        expiresIn: this.configService.get('JWT_ACCESS_EXPIRATION', '15m'),
-      }),
-      this.jwtService.signAsync(refreshPayload, {
-        expiresIn: this.configService.get('JWT_REFRESH_EXPIRATION', '7d'),
-      }),
-    ]);
-
-    return { accessToken, refreshToken };
-  }
-
-  /**
-   * Resolve organization ID for registration
-   * 1. If organizationId is provided (invited user), validate and use it
-   * 2. If organizationData is provided (new user), create a new organization
-   * 3. Otherwise, throw an error (both are required)
-   */
-  private async resolveOrganizationId(
-    organizationId?: string,
-    organizationData?: RegisterOrganizationDto
-  ): Promise<string> {
-    // Case 1: Invited user - organizationId is provided
-    if (organizationId) {
-      this.logger.log(`Using existing organization for invited user: ${organizationId}`);
-
-      // Validate that the organization exists
-      const organization = await this.organizationRepository.findById(organizationId);
-
-      if (!organization) {
-        throw new BadRequestException('Invalid organization ID - organization does not exist');
-      }
-
-      if (!organization.isActive) {
-        throw new BadRequestException('Organization is not active');
-      }
-
-      return organizationId;
-    }
-
-    // Case 2: New user - create a new organization
-    if (organizationData) {
-      this.logger.log(`Creating new organization for user registration: ${organizationData.name}`);
-
-      // Check if organization name already exists
-      const existingOrg = await this.organizationRepository.findByName(organizationData.name);
-
-      if (existingOrg) {
-        throw new ConflictException('An organization with this name already exists');
-      }
-
-      // Check if SCAC code already exists (for carriers)
-      if (organizationData.scac) {
-        const existingScac = await this.organizationRepository.findBySCAC(organizationData.scac);
-
-        if (existingScac) {
-          throw new ConflictException('An organization with this SCAC code already exists');
-        }
-      }
-
-      // Create new organization
-      const newOrganization = Organization.create({
-        id: uuidv4(),
-        name: organizationData.name,
-        type: organizationData.type,
-        scac: organizationData.scac,
-        address: {
-          street: organizationData.street,
-          city: organizationData.city,
-          state: organizationData.state,
-          postalCode: organizationData.postalCode,
-          country: organizationData.country,
-        },
-        documents: [],
-        isActive: true,
-      });
-
-      const savedOrganization = await this.organizationRepository.save(newOrganization);
-
-      this.logger.log(
-        `New organization created: ${savedOrganization.id} - ${savedOrganization.name}`
-      );
-
-      return savedOrganization.id;
-    }
-
-    // Case 3: Neither provided - error
-    throw new BadRequestException(
-      'Either organizationId (for invited users) or organization data (for new users) must be provided'
-    );
-  }
-}

apps/backend/src/application/auth/jwt.strategy.ts

@@ -1,77 +0,0 @@
-import { Injectable, UnauthorizedException } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { PassportStrategy } from '@nestjs/passport';
-import { ExtractJwt, Strategy } from 'passport-jwt';
-import { AuthService } from './auth.service';
-
-/**
- * JWT Payload interface matching the token structure
- */
-export interface JwtPayload {
-  sub: string; // user ID
-  email: string;
-  role: string;
-  organizationId: string;
-  type: 'access' | 'refresh';
-  iat?: number; // issued at
-  exp?: number; // expiration
-}
-
-/**
- * JWT Strategy for Passport authentication
- *
- * This strategy:
- * - Extracts JWT from Authorization Bearer header
- * - Validates the token signature using the secret
- * - Validates the payload and retrieves the user
- * - Injects the user into the request object
- *
- * @see https://docs.nestjs.com/security/authentication#implementing-passport-jwt
- */
-@Injectable()
-export class JwtStrategy extends PassportStrategy(Strategy) {
-  constructor(
-    private readonly configService: ConfigService,
-    private readonly authService: AuthService
-  ) {
-    super({
-      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
-      ignoreExpiration: false,
-      secretOrKey: configService.get<string>('JWT_SECRET'),
-    });
-  }
-
-  /**
-   * Validate JWT payload and return user object
-   *
-   * This method is called automatically by Passport after the JWT is verified.
-   * If this method throws an error or returns null/undefined, authentication fails.
-   *
-   * @param payload - Decoded JWT payload
-   * @returns User object to be attached to request.user
-   * @throws UnauthorizedException if user is invalid or inactive
-   */
-  async validate(payload: JwtPayload) {
-    // Only accept access tokens (not refresh tokens)
-    if (payload.type !== 'access') {
-      throw new UnauthorizedException('Invalid token type');
-    }
-
-    // Validate user exists and is active
-    const user = await this.authService.validateUser(payload);
-
-    if (!user) {
-      throw new UnauthorizedException('User not found or inactive');
-    }
-
-    // This object will be attached to request.user
-    return {
-      id: user.id,
-      email: user.email,
-      role: user.role,
-      organizationId: user.organizationId,
-      firstName: user.firstName,
-      lastName: user.lastName,
-    };
-  }
-}

apps/backend/src/application/bookings/bookings.module.ts

@@ -1,79 +0,0 @@
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { BookingsController } from '../controllers/bookings.controller';
-
-// Import domain ports
-import { BOOKING_REPOSITORY } from '@domain/ports/out/booking.repository';
-import { RATE_QUOTE_REPOSITORY } from '@domain/ports/out/rate-quote.repository';
-import { USER_REPOSITORY } from '@domain/ports/out/user.repository';
-import { TypeOrmBookingRepository } from '../../infrastructure/persistence/typeorm/repositories/typeorm-booking.repository';
-import { TypeOrmRateQuoteRepository } from '../../infrastructure/persistence/typeorm/repositories/typeorm-rate-quote.repository';
-import { TypeOrmUserRepository } from '../../infrastructure/persistence/typeorm/repositories/typeorm-user.repository';
-
-// Import ORM entities
-import { BookingOrmEntity } from '../../infrastructure/persistence/typeorm/entities/booking.orm-entity';
-import { ContainerOrmEntity } from '../../infrastructure/persistence/typeorm/entities/container.orm-entity';
-import { RateQuoteOrmEntity } from '../../infrastructure/persistence/typeorm/entities/rate-quote.orm-entity';
-import { UserOrmEntity } from '../../infrastructure/persistence/typeorm/entities/user.orm-entity';
-
-// Import services and domain
-import { BookingService } from '@domain/services/booking.service';
-import { BookingAutomationService } from '../services/booking-automation.service';
-import { ExportService } from '../services/export.service';
-import { FuzzySearchService } from '../services/fuzzy-search.service';
-
-// Import infrastructure modules
-import { EmailModule } from '../../infrastructure/email/email.module';
-import { PdfModule } from '../../infrastructure/pdf/pdf.module';
-import { StorageModule } from '../../infrastructure/storage/storage.module';
-import { AuditModule } from '../audit/audit.module';
-import { NotificationsModule } from '../notifications/notifications.module';
-import { WebhooksModule } from '../webhooks/webhooks.module';
-
-/**
- * Bookings Module
- *
- * Handles booking management functionality:
- * - Create bookings from rate quotes
- * - View booking details
- * - List user/organization bookings
- * - Update booking status
- * - Post-booking automation (emails, PDFs)
- */
-@Module({
-  imports: [
-    TypeOrmModule.forFeature([
-      BookingOrmEntity,
-      ContainerOrmEntity,
-      RateQuoteOrmEntity,
-      UserOrmEntity,
-    ]),
-    EmailModule,
-    PdfModule,
-    StorageModule,
-    AuditModule,
-    NotificationsModule,
-    WebhooksModule,
-  ],
-  controllers: [BookingsController],
-  providers: [
-    BookingService,
-    BookingAutomationService,
-    ExportService,
-    FuzzySearchService,
-    {
-      provide: BOOKING_REPOSITORY,
-      useClass: TypeOrmBookingRepository,
-    },
-    {
-      provide: RATE_QUOTE_REPOSITORY,
-      useClass: TypeOrmRateQuoteRepository,
-    },
-    {
-      provide: USER_REPOSITORY,
-      useClass: TypeOrmUserRepository,
-    },
-  ],
-  exports: [BOOKING_REPOSITORY],
-})
-export class BookingsModule {}

apps/backend/src/application/controllers/admin.controller.ts

@@ -1,600 +0,0 @@
-import {
-  Controller,
-  Get,
-  Patch,
-  Delete,
-  Param,
-  Body,
-  HttpCode,
-  HttpStatus,
-  Logger,
-  UsePipes,
-  ValidationPipe,
-  NotFoundException,
-  BadRequestException,
-  ParseUUIDPipe,
-  UseGuards,
-  Inject,
-} from '@nestjs/common';
-import {
-  ApiTags,
-  ApiOperation,
-  ApiResponse,
-  ApiNotFoundResponse,
-  ApiParam,
-  ApiBearerAuth,
-} from '@nestjs/swagger';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { RolesGuard } from '../guards/roles.guard';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-import { Roles } from '../decorators/roles.decorator';
-
-// User imports
-import { UserRepository, USER_REPOSITORY } from '@domain/ports/out/user.repository';
-import { UserMapper } from '../mappers/user.mapper';
-import { UpdateUserDto, UserResponseDto, UserListResponseDto } from '../dto/user.dto';
-
-// Organization imports
-import {
-  OrganizationRepository,
-  ORGANIZATION_REPOSITORY,
-} from '@domain/ports/out/organization.repository';
-import { OrganizationMapper } from '../mappers/organization.mapper';
-import { OrganizationResponseDto, OrganizationListResponseDto } from '../dto/organization.dto';
-
-// CSV Booking imports
-import { TypeOrmCsvBookingRepository } from '@infrastructure/persistence/typeorm/repositories/csv-booking.repository';
-
-/**
- * Admin Controller
- *
- * Dedicated controller for admin-only endpoints that provide access to ALL data
- * in the database without organization filtering.
- *
- * All endpoints require ADMIN role.
- */
-@ApiTags('Admin')
-@Controller('admin')
-@UseGuards(JwtAuthGuard, RolesGuard)
-@Roles('admin')
-@ApiBearerAuth()
-export class AdminController {
-  private readonly logger = new Logger(AdminController.name);
-
-  constructor(
-    @Inject(USER_REPOSITORY) private readonly userRepository: UserRepository,
-    @Inject(ORGANIZATION_REPOSITORY)
-    private readonly organizationRepository: OrganizationRepository,
-    private readonly csvBookingRepository: TypeOrmCsvBookingRepository
-  ) {}
-
-  // ==================== USERS ENDPOINTS ====================
-
-  /**
-   * Get ALL users from database (admin only)
-   *
-   * Returns all users regardless of status (active/inactive) or organization
-   */
-  @Get('users')
-  @ApiOperation({
-    summary: 'Get all users (Admin only)',
-    description:
-      'Retrieve ALL users from the database without any filters. Includes active and inactive users from all organizations.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'All users retrieved successfully',
-    type: UserListResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin role',
-  })
-  async getAllUsers(@CurrentUser() user: UserPayload): Promise<UserListResponseDto> {
-    this.logger.log(`[ADMIN: ${user.email}] Fetching ALL users from database`);
-
-    let users = await this.userRepository.findAll();
-
-    // Security: Non-admin users (MANAGER and below) cannot see ADMIN users
-    if (user.role !== 'ADMIN') {
-      users = users.filter(u => u.role !== 'ADMIN');
-      this.logger.log(`[SECURITY] Non-admin user ${user.email} - filtered out ADMIN users`);
-    }
-
-    const userDtos = UserMapper.toDtoArray(users);
-
-    this.logger.log(`[ADMIN] Retrieved ${users.length} users from database`);
-
-    return {
-      users: userDtos,
-      total: users.length,
-      page: 1,
-      pageSize: users.length,
-      totalPages: 1,
-    };
-  }
-
-  /**
-   * Get user by ID (admin only)
-   */
-  @Get('users/:id')
-  @ApiOperation({
-    summary: 'Get user by ID (Admin only)',
-    description: 'Retrieve a specific user by ID',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'User ID (UUID)',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'User retrieved successfully',
-    type: UserResponseDto,
-  })
-  @ApiNotFoundResponse({
-    description: 'User not found',
-  })
-  async getUserById(
-    @Param('id', ParseUUIDPipe) id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<UserResponseDto> {
-    this.logger.log(`[ADMIN: ${user.email}] Fetching user: ${id}`);
-
-    const foundUser = await this.userRepository.findById(id);
-    if (!foundUser) {
-      throw new NotFoundException(`User ${id} not found`);
-    }
-
-    return UserMapper.toDto(foundUser);
-  }
-
-  /**
-   * Update user (admin only)
-   */
-  @Patch('users/:id')
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  @ApiOperation({
-    summary: 'Update user (Admin only)',
-    description: 'Update user details (any user, any organization)',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'User ID (UUID)',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'User updated successfully',
-    type: UserResponseDto,
-  })
-  @ApiNotFoundResponse({
-    description: 'User not found',
-  })
-  async updateUser(
-    @Param('id', ParseUUIDPipe) id: string,
-    @Body() dto: UpdateUserDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<UserResponseDto> {
-    this.logger.log(`[ADMIN: ${user.email}] Updating user: ${id}`);
-
-    const foundUser = await this.userRepository.findById(id);
-    if (!foundUser) {
-      throw new NotFoundException(`User ${id} not found`);
-    }
-
-    // Security: Prevent users from changing their own role
-    if (dto.role && id === user.id) {
-      this.logger.warn(`[SECURITY] User ${user.email} attempted to change their own role`);
-      throw new BadRequestException('You cannot change your own role');
-    }
-
-    // Apply updates
-    if (dto.firstName) {
-      foundUser.updateFirstName(dto.firstName);
-    }
-    if (dto.lastName) {
-      foundUser.updateLastName(dto.lastName);
-    }
-    if (dto.role) {
-      foundUser.updateRole(dto.role);
-    }
-    if (dto.isActive !== undefined) {
-      if (dto.isActive) {
-        foundUser.activate();
-      } else {
-        foundUser.deactivate();
-      }
-    }
-
-    const updatedUser = await this.userRepository.update(foundUser);
-    this.logger.log(`[ADMIN] User updated successfully: ${updatedUser.id}`);
-
-    return UserMapper.toDto(updatedUser);
-  }
-
-  /**
-   * Delete user (admin only)
-   */
-  @Delete('users/:id')
-  @HttpCode(HttpStatus.NO_CONTENT)
-  @ApiOperation({
-    summary: 'Delete user (Admin only)',
-    description: 'Permanently delete a user from the database',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'User ID (UUID)',
-  })
-  @ApiResponse({
-    status: HttpStatus.NO_CONTENT,
-    description: 'User deleted successfully',
-  })
-  @ApiNotFoundResponse({
-    description: 'User not found',
-  })
-  async deleteUser(
-    @Param('id', ParseUUIDPipe) id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<void> {
-    this.logger.log(`[ADMIN: ${user.email}] Deleting user: ${id}`);
-
-    const foundUser = await this.userRepository.findById(id);
-    if (!foundUser) {
-      throw new NotFoundException(`User ${id} not found`);
-    }
-
-    await this.userRepository.deleteById(id);
-    this.logger.log(`[ADMIN] User deleted successfully: ${id}`);
-  }
-
-  // ==================== ORGANIZATIONS ENDPOINTS ====================
-
-  /**
-   * Get ALL organizations from database (admin only)
-   *
-   * Returns all organizations regardless of status (active/inactive)
-   */
-  @Get('organizations')
-  @ApiOperation({
-    summary: 'Get all organizations (Admin only)',
-    description:
-      'Retrieve ALL organizations from the database without any filters. Includes active and inactive organizations.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'All organizations retrieved successfully',
-    type: OrganizationListResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin role',
-  })
-  async getAllOrganizations(
-    @CurrentUser() user: UserPayload
-  ): Promise<OrganizationListResponseDto> {
-    this.logger.log(`[ADMIN: ${user.email}] Fetching ALL organizations from database`);
-
-    const organizations = await this.organizationRepository.findAll();
-    const orgDtos = OrganizationMapper.toDtoArray(organizations);
-
-    this.logger.log(`[ADMIN] Retrieved ${organizations.length} organizations from database`);
-
-    return {
-      organizations: orgDtos,
-      total: organizations.length,
-      page: 1,
-      pageSize: organizations.length,
-      totalPages: 1,
-    };
-  }
-
-  /**
-   * Get organization by ID (admin only)
-   */
-  @Get('organizations/:id')
-  @ApiOperation({
-    summary: 'Get organization by ID (Admin only)',
-    description: 'Retrieve a specific organization by ID',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'Organization ID (UUID)',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Organization retrieved successfully',
-    type: OrganizationResponseDto,
-  })
-  @ApiNotFoundResponse({
-    description: 'Organization not found',
-  })
-  async getOrganizationById(
-    @Param('id', ParseUUIDPipe) id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<OrganizationResponseDto> {
-    this.logger.log(`[ADMIN: ${user.email}] Fetching organization: ${id}`);
-
-    const organization = await this.organizationRepository.findById(id);
-    if (!organization) {
-      throw new NotFoundException(`Organization ${id} not found`);
-    }
-
-    return OrganizationMapper.toDto(organization);
-  }
-
-  // ==================== CSV BOOKINGS ENDPOINTS ====================
-
-  /**
-   * Get ALL csv bookings from database (admin only)
-   *
-   * Returns all csv bookings from all organizations
-   */
-  @Get('bookings')
-  @ApiOperation({
-    summary: 'Get all CSV bookings (Admin only)',
-    description:
-      'Retrieve ALL CSV bookings from the database without any filters. Includes bookings from all organizations and all statuses.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'All CSV bookings retrieved successfully',
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin role',
-  })
-  async getAllBookings(@CurrentUser() user: UserPayload) {
-    this.logger.log(`[ADMIN: ${user.email}] Fetching ALL csv bookings from database`);
-
-    const csvBookings = await this.csvBookingRepository.findAll();
-    const bookingDtos = csvBookings.map(booking => this.csvBookingToDto(booking));
-
-    this.logger.log(`[ADMIN] Retrieved ${csvBookings.length} csv bookings from database`);
-
-    return {
-      bookings: bookingDtos,
-      total: csvBookings.length,
-      page: 1,
-      pageSize: csvBookings.length,
-      totalPages: csvBookings.length > 0 ? 1 : 0,
-    };
-  }
-
-  /**
-   * Get csv booking by ID (admin only)
-   */
-  @Get('bookings/:id')
-  @ApiOperation({
-    summary: 'Get CSV booking by ID (Admin only)',
-    description: 'Retrieve a specific CSV booking by ID',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'Booking ID (UUID)',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'CSV booking retrieved successfully',
-  })
-  @ApiNotFoundResponse({
-    description: 'CSV booking not found',
-  })
-  async getBookingById(@Param('id', ParseUUIDPipe) id: string, @CurrentUser() user: UserPayload) {
-    this.logger.log(`[ADMIN: ${user.email}] Fetching csv booking: ${id}`);
-
-    const csvBooking = await this.csvBookingRepository.findById(id);
-    if (!csvBooking) {
-      throw new NotFoundException(`CSV booking ${id} not found`);
-    }
-
-    return this.csvBookingToDto(csvBooking);
-  }
-
-  /**
-   * Update csv booking (admin only)
-   */
-  @Patch('bookings/:id')
-  @ApiOperation({
-    summary: 'Update CSV booking (Admin only)',
-    description: 'Update CSV booking status or details',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'Booking ID (UUID)',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'CSV booking updated successfully',
-  })
-  @ApiNotFoundResponse({
-    description: 'CSV booking not found',
-  })
-  async updateBooking(
-    @Param('id', ParseUUIDPipe) id: string,
-    @Body() updateDto: any,
-    @CurrentUser() user: UserPayload
-  ) {
-    this.logger.log(`[ADMIN: ${user.email}] Updating csv booking: ${id}`);
-
-    const csvBooking = await this.csvBookingRepository.findById(id);
-    if (!csvBooking) {
-      throw new NotFoundException(`CSV booking ${id} not found`);
-    }
-
-    // Apply updates to the domain entity
-    // Note: This is a simplified version. You may want to add proper domain methods
-    const updatedBooking = await this.csvBookingRepository.update(csvBooking);
-
-    this.logger.log(`[ADMIN] CSV booking updated successfully: ${id}`);
-    return this.csvBookingToDto(updatedBooking);
-  }
-
-  /**
-   * Delete csv booking (admin only)
-   */
-  @Delete('bookings/:id')
-  @HttpCode(HttpStatus.NO_CONTENT)
-  @ApiOperation({
-    summary: 'Delete CSV booking (Admin only)',
-    description: 'Permanently delete a CSV booking from the database',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'Booking ID (UUID)',
-  })
-  @ApiResponse({
-    status: HttpStatus.NO_CONTENT,
-    description: 'CSV booking deleted successfully',
-  })
-  @ApiNotFoundResponse({
-    description: 'CSV booking not found',
-  })
-  async deleteBooking(
-    @Param('id', ParseUUIDPipe) id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<void> {
-    this.logger.log(`[ADMIN: ${user.email}] Deleting csv booking: ${id}`);
-
-    const csvBooking = await this.csvBookingRepository.findById(id);
-    if (!csvBooking) {
-      throw new NotFoundException(`CSV booking ${id} not found`);
-    }
-
-    await this.csvBookingRepository.delete(id);
-    this.logger.log(`[ADMIN] CSV booking deleted successfully: ${id}`);
-  }
-
-  /**
-   * Helper method to convert CSV booking domain entity to DTO
-   */
-  private csvBookingToDto(booking: any) {
-    const primaryCurrency = booking.primaryCurrency as 'USD' | 'EUR';
-
-    return {
-      id: booking.id,
-      userId: booking.userId,
-      organizationId: booking.organizationId,
-      carrierName: booking.carrierName,
-      carrierEmail: booking.carrierEmail,
-      origin: booking.origin.getValue(),
-      destination: booking.destination.getValue(),
-      volumeCBM: booking.volumeCBM,
-      weightKG: booking.weightKG,
-      palletCount: booking.palletCount,
-      priceUSD: booking.priceUSD,
-      priceEUR: booking.priceEUR,
-      primaryCurrency: booking.primaryCurrency,
-      transitDays: booking.transitDays,
-      containerType: booking.containerType,
-      status: booking.status,
-      documents: booking.documents || [],
-      confirmationToken: booking.confirmationToken,
-      requestedAt: booking.requestedAt,
-      respondedAt: booking.respondedAt || null,
-      notes: booking.notes,
-      rejectionReason: booking.rejectionReason,
-      routeDescription: booking.getRouteDescription(),
-      isExpired: booking.isExpired(),
-      price: booking.getPriceInCurrency(primaryCurrency),
-    };
-  }
-
-  // ==================== DOCUMENTS ENDPOINTS ====================
-
-  /**
-   * Get ALL documents from all organizations (admin only)
-   *
-   * Returns documents grouped by organization
-   */
-  @Get('documents')
-  @ApiOperation({
-    summary: 'Get all documents (Admin only)',
-    description: 'Retrieve ALL documents from all organizations in the database.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'All documents retrieved successfully',
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin role',
-  })
-  async getAllDocuments(@CurrentUser() user: UserPayload): Promise<any> {
-    this.logger.log(`[ADMIN: ${user.email}] Fetching ALL documents from database`);
-
-    // Get all organizations
-    const organizations = await this.organizationRepository.findAll();
-
-    // Extract documents from all organizations
-    const allDocuments = organizations.flatMap(org =>
-      org.documents.map(doc => ({
-        ...doc,
-        organizationId: org.id,
-        organizationName: org.name,
-      }))
-    );
-
-    this.logger.log(
-      `[ADMIN] Retrieved ${allDocuments.length} documents from ${organizations.length} organizations`
-    );
-
-    return {
-      documents: allDocuments,
-      total: allDocuments.length,
-      organizationCount: organizations.length,
-    };
-  }
-
-  /**
-   * Get documents for a specific organization (admin only)
-   */
-  @Get('organizations/:id/documents')
-  @ApiOperation({
-    summary: 'Get organization documents (Admin only)',
-    description: 'Retrieve all documents for a specific organization',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'Organization ID (UUID)',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Organization documents retrieved successfully',
-  })
-  @ApiNotFoundResponse({
-    description: 'Organization not found',
-  })
-  async getOrganizationDocuments(
-    @Param('id', ParseUUIDPipe) id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<any> {
-    this.logger.log(`[ADMIN: ${user.email}] Fetching documents for organization: ${id}`);
-
-    const organization = await this.organizationRepository.findById(id);
-    if (!organization) {
-      throw new NotFoundException(`Organization ${id} not found`);
-    }
-
-    return {
-      organizationId: organization.id,
-      organizationName: organization.name,
-      documents: organization.documents,
-      total: organization.documents.length,
-    };
-  }
-}

apps/backend/src/application/controllers/admin/csv-rates.controller.ts

@@ -1,576 +0,0 @@
-import {
-  Controller,
-  Post,
-  Get,
-  Delete,
-  Param,
-  Body,
-  UseGuards,
-  UseInterceptors,
-  UploadedFile,
-  HttpCode,
-  HttpStatus,
-  Logger,
-  BadRequestException,
-} from '@nestjs/common';
-import { FileInterceptor } from '@nestjs/platform-express';
-import {
-  ApiTags,
-  ApiOperation,
-  ApiResponse,
-  ApiBearerAuth,
-  ApiConsumes,
-  ApiBody,
-} from '@nestjs/swagger';
-import { diskStorage } from 'multer';
-import { extname } from 'path';
-import { JwtAuthGuard } from '../../guards/jwt-auth.guard';
-import { RolesGuard } from '../../guards/roles.guard';
-import { Roles } from '../../decorators/roles.decorator';
-import { CurrentUser, UserPayload } from '../../decorators/current-user.decorator';
-import { CsvRateLoaderAdapter } from '@infrastructure/carriers/csv-loader/csv-rate-loader.adapter';
-import { CsvConverterService } from '@infrastructure/carriers/csv-loader/csv-converter.service';
-import { TypeOrmCsvRateConfigRepository } from '@infrastructure/persistence/typeorm/repositories/typeorm-csv-rate-config.repository';
-import {
-  CsvRateUploadDto,
-  CsvRateUploadResponseDto,
-  CsvRateConfigDto,
-  CsvFileValidationDto,
-} from '../../dto/csv-rate-upload.dto';
-import { CsvRateMapper } from '../../mappers/csv-rate.mapper';
-import { S3StorageAdapter } from '@infrastructure/storage/s3-storage.adapter';
-import { ConfigService } from '@nestjs/config';
-import * as fs from 'fs';
-import * as path from 'path';
-
-/**
- * Get CSV upload directory path (works in both dev and Docker)
- */
-function getCsvUploadPath(): string {
-  // In Docker, working directory is /app, so we use /app/src/...
-  // In local dev, process.cwd() points to the project root
-  const workDir = process.cwd();
-
-  // If we're in /app (Docker), use /app/src/infrastructure/...
-  if (workDir === '/app') {
-    return '/app/src/infrastructure/storage/csv-storage/rates';
-  }
-
-  // Otherwise (local dev), use relative path from project root
-  return path.join(workDir, 'apps/backend/src/infrastructure/storage/csv-storage/rates');
-}
-
-/**
- * CSV Rates Admin Controller
- *
- * ADMIN-ONLY endpoints for managing CSV rate files
- * Protected by JWT + Roles guard
- */
-@ApiTags('Admin - CSV Rates')
-@Controller('admin/csv-rates')
-@ApiBearerAuth()
-@UseGuards(JwtAuthGuard, RolesGuard)
-@Roles('ADMIN') // ⚠️ ONLY ADMIN can access these endpoints
-export class CsvRatesAdminController {
-  private readonly logger = new Logger(CsvRatesAdminController.name);
-  private readonly csvUploadPath: string;
-
-  constructor(
-    private readonly csvLoader: CsvRateLoaderAdapter,
-    private readonly csvConverter: CsvConverterService,
-    private readonly csvConfigRepository: TypeOrmCsvRateConfigRepository,
-    private readonly csvRateMapper: CsvRateMapper,
-    private readonly s3Storage: S3StorageAdapter,
-    private readonly configService: ConfigService
-  ) {
-    this.csvUploadPath = getCsvUploadPath();
-    this.logger.log(`📁 CSV upload path: ${this.csvUploadPath}`);
-  }
-
-  /**
-   * Upload CSV rate file (ADMIN only)
-   */
-  @Post('upload')
-  @HttpCode(HttpStatus.CREATED)
-  @UseInterceptors(
-    FileInterceptor('file', {
-      storage: diskStorage({
-        destination: getCsvUploadPath(),
-        filename: (req, file, cb) => {
-          // Use timestamp + random string to avoid conflicts
-          // We'll rename it later once we have the company name from req.body
-          const timestamp = Date.now();
-          const randomStr = Math.random().toString(36).substring(7);
-          const tempFilename = `temp-${timestamp}-${randomStr}.csv`;
-          cb(null, tempFilename);
-        },
-      }),
-      fileFilter: (req, file, cb) => {
-        // Only allow CSV files
-        if (extname(file.originalname).toLowerCase() !== '.csv') {
-          return cb(new BadRequestException('Only CSV files are allowed'), false);
-        }
-        cb(null, true);
-      },
-      limits: {
-        fileSize: 10 * 1024 * 1024, // 10MB max
-      },
-    })
-  )
-  @ApiConsumes('multipart/form-data')
-  @ApiOperation({
-    summary: 'Upload CSV rate file (ADMIN only)',
-    description:
-      'Upload a CSV file containing shipping rates for a carrier company. File must be valid CSV format with required columns. Maximum file size: 10MB.',
-  })
-  @ApiBody({
-    schema: {
-      type: 'object',
-      required: ['companyName', 'companyEmail', 'file'],
-      properties: {
-        companyName: {
-          type: 'string',
-          description: 'Carrier company name',
-          example: 'SSC Consolidation',
-        },
-        companyEmail: {
-          type: 'string',
-          format: 'email',
-          description: 'Email address for booking requests',
-          example: 'bookings@sscconsolidation.com',
-        },
-        file: {
-          type: 'string',
-          format: 'binary',
-          description: 'CSV file to upload',
-        },
-      },
-    },
-  })
-  @ApiResponse({
-    status: HttpStatus.CREATED,
-    description: 'CSV file uploaded and validated successfully',
-    type: CsvRateUploadResponseDto,
-  })
-  @ApiResponse({
-    status: 400,
-    description: 'Invalid file format or validation failed',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - Admin role required',
-  })
-  async uploadCsv(
-    @UploadedFile() file: Express.Multer.File,
-    @Body() dto: CsvRateUploadDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<CsvRateUploadResponseDto> {
-    this.logger.log(`[Admin: ${user.email}] Uploading CSV for company: ${dto.companyName}`);
-
-    if (!file) {
-      throw new BadRequestException('File is required');
-    }
-
-    try {
-      // Generate final filename based on company name
-      const sanitizedCompanyName = dto.companyName
-        .toLowerCase()
-        .replace(/\s+/g, '-')
-        .replace(/[^a-z0-9-]/g, '');
-      const finalFilename = `${sanitizedCompanyName}.csv`;
-
-      // Auto-convert CSV if needed (FOB FRET → Standard format)
-      const conversionResult = await this.csvConverter.autoConvert(file.path, dto.companyName);
-      const filePathToValidate = conversionResult.convertedPath;
-
-      if (conversionResult.wasConverted) {
-        this.logger.log(
-          `Converted ${conversionResult.rowsConverted} rows from FOB FRET format to standard format`
-        );
-      }
-
-      // Validate CSV file structure using the converted path
-      const validation = await this.csvLoader.validateCsvFile(filePathToValidate);
-
-      if (!validation.valid) {
-        this.logger.error(
-          `CSV validation failed for ${dto.companyName}: ${validation.errors.join(', ')}`
-        );
-        throw new BadRequestException({
-          message: 'CSV validation failed',
-          errors: validation.errors,
-        });
-      }
-
-      // Load rates to verify parsing using the converted path
-      // Pass company name from form to override CSV column value
-      const rates = await this.csvLoader.loadRatesFromCsv(
-        filePathToValidate,
-        dto.companyEmail,
-        dto.companyName
-      );
-      const ratesCount = rates.length;
-
-      this.logger.log(`Successfully parsed ${ratesCount} rates from ${file.filename}`);
-
-      // Rename file to final name (company-name.csv)
-      const finalPath = path.join(path.dirname(filePathToValidate), finalFilename);
-
-      // Delete old file if exists
-      if (fs.existsSync(finalPath)) {
-        fs.unlinkSync(finalPath);
-        this.logger.log(`Deleted old file: ${finalFilename}`);
-      }
-
-      // Rename temp file to final name
-      fs.renameSync(filePathToValidate, finalPath);
-      this.logger.log(`Renamed ${file.filename} to ${finalFilename}`);
-
-      // Upload CSV file to MinIO/S3
-      let minioObjectKey: string | null = null;
-      try {
-        const csvBuffer = fs.readFileSync(finalPath);
-        const bucket = this.configService.get<string>('AWS_S3_BUCKET', 'xpeditis-csv-rates');
-        const objectKey = `csv-rates/${finalFilename}`;
-
-        await this.s3Storage.upload({
-          bucket,
-          key: objectKey,
-          body: csvBuffer,
-          contentType: 'text/csv',
-          metadata: {
-            companyName: dto.companyName,
-            companyEmail: dto.companyEmail,
-            uploadedBy: user.email,
-            uploadedAt: new Date().toISOString(),
-          },
-        });
-
-        minioObjectKey = objectKey;
-        this.logger.log(`✅ CSV file uploaded to MinIO: ${bucket}/${objectKey}`);
-      } catch (error: any) {
-        this.logger.error(
-          `⚠️  Failed to upload CSV to MinIO (will continue with local storage): ${error.message}`
-        );
-        // Don't fail the entire operation if MinIO upload fails
-        // The file is still available locally
-      }
-
-      // Check if config exists for this company
-      const existingConfig = await this.csvConfigRepository.findByCompanyName(dto.companyName);
-
-      if (existingConfig) {
-        // Update existing configuration
-        await this.csvConfigRepository.update(existingConfig.id, {
-          csvFilePath: finalFilename,
-          uploadedAt: new Date(),
-          uploadedBy: user.id,
-          rowCount: ratesCount,
-          lastValidatedAt: new Date(),
-          metadata: {
-            ...existingConfig.metadata,
-            companyEmail: dto.companyEmail, // Store email in metadata
-            minioObjectKey, // Store MinIO object key
-            lastUpload: {
-              timestamp: new Date().toISOString(),
-              by: user.email,
-              ratesCount,
-            },
-          },
-        });
-
-        this.logger.log(`Updated CSV config for company: ${dto.companyName}`);
-      } else {
-        // Create new configuration
-        await this.csvConfigRepository.create({
-          companyName: dto.companyName,
-          csvFilePath: finalFilename,
-          type: 'CSV_ONLY',
-          hasApi: false,
-          apiConnector: null,
-          isActive: true,
-          uploadedAt: new Date(),
-          uploadedBy: user.id,
-          rowCount: ratesCount,
-          lastValidatedAt: new Date(),
-          metadata: {
-            uploadedBy: user.email,
-            description: `${dto.companyName} shipping rates`,
-            companyEmail: dto.companyEmail, // Store email in metadata
-            minioObjectKey, // Store MinIO object key
-          },
-        });
-
-        this.logger.log(`Created new CSV config for company: ${dto.companyName}`);
-      }
-
-      return {
-        success: true,
-        ratesCount,
-        csvFilePath: finalFilename,
-        companyName: dto.companyName,
-        uploadedAt: new Date(),
-      };
-    } catch (error: any) {
-      this.logger.error(`CSV upload failed: ${error?.message || 'Unknown error'}`, error?.stack);
-      throw error;
-    }
-  }
-
-  /**
-   * Get all CSV rate configurations
-   */
-  @Get('config')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'Get all CSV rate configurations (ADMIN only)',
-    description: 'Returns list of all CSV rate configurations with upload details.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'List of CSV rate configurations',
-    type: [CsvRateConfigDto],
-  })
-  async getAllConfigs(): Promise<CsvRateConfigDto[]> {
-    this.logger.log('Fetching all CSV rate configs (admin)');
-
-    const configs = await this.csvConfigRepository.findAll();
-    return this.csvRateMapper.mapConfigEntitiesToDtos(configs);
-  }
-
-  /**
-   * Get configuration for specific company
-   */
-  @Get('config/:companyName')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'Get CSV configuration for specific company (ADMIN only)',
-    description: 'Returns CSV rate configuration details for a specific carrier.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'CSV rate configuration',
-    type: CsvRateConfigDto,
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'Company configuration not found',
-  })
-  async getConfigByCompany(@Param('companyName') companyName: string): Promise<CsvRateConfigDto> {
-    this.logger.log(`Fetching CSV config for company: ${companyName}`);
-
-    const config = await this.csvConfigRepository.findByCompanyName(companyName);
-
-    if (!config) {
-      throw new BadRequestException(`No CSV configuration found for company: ${companyName}`);
-    }
-
-    return this.csvRateMapper.mapConfigEntityToDto(config);
-  }
-
-  /**
-   * Validate CSV file
-   */
-  @Post('validate/:companyName')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'Validate CSV file for company (ADMIN only)',
-    description:
-      'Validates the CSV file structure and data for a specific company without uploading.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Validation result',
-    type: CsvFileValidationDto,
-  })
-  async validateCsvFile(@Param('companyName') companyName: string): Promise<CsvFileValidationDto> {
-    this.logger.log(`Validating CSV file for company: ${companyName}`);
-
-    const config = await this.csvConfigRepository.findByCompanyName(companyName);
-
-    if (!config) {
-      throw new BadRequestException(`No CSV configuration found for company: ${companyName}`);
-    }
-
-    const result = await this.csvLoader.validateCsvFile(config.csvFilePath);
-
-    // Update validation timestamp
-    if (result.valid && result.rowCount) {
-      await this.csvConfigRepository.updateValidationInfo(companyName, result.rowCount, result);
-    }
-
-    return result;
-  }
-
-  /**
-   * Delete CSV rate configuration
-   */
-  @Delete('config/:companyName')
-  @HttpCode(HttpStatus.NO_CONTENT)
-  @ApiOperation({
-    summary: 'Delete CSV rate configuration (ADMIN only)',
-    description:
-      'Deletes the CSV rate configuration for a company. Note: This does not delete the actual CSV file.',
-  })
-  @ApiResponse({
-    status: HttpStatus.NO_CONTENT,
-    description: 'Configuration deleted successfully',
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'Company configuration not found',
-  })
-  async deleteConfig(
-    @Param('companyName') companyName: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<void> {
-    this.logger.warn(`[Admin: ${user.email}] Deleting CSV config for company: ${companyName}`);
-
-    await this.csvConfigRepository.delete(companyName);
-
-    this.logger.log(`Deleted CSV config for company: ${companyName}`);
-  }
-
-  /**
-   * List all CSV files (Frontend compatibility endpoint)
-   * Maps to GET /files for compatibility with frontend API client
-   */
-  @Get('files')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'List all CSV files (ADMIN only)',
-    description:
-      'Returns list of all uploaded CSV files with metadata. Alias for /config endpoint.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'List of CSV files',
-    schema: {
-      type: 'object',
-      properties: {
-        files: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              filename: { type: 'string', example: 'ssc-consolidation.csv' },
-              size: { type: 'number', example: 2048 },
-              uploadedAt: { type: 'string', format: 'date-time' },
-              rowCount: { type: 'number', example: 150 },
-            },
-          },
-        },
-      },
-    },
-  })
-  async listFiles(): Promise<{ files: any[] }> {
-    this.logger.log('Fetching all CSV files (frontend compatibility)');
-
-    const configs = await this.csvConfigRepository.findAll();
-
-    // Map configs to file info format expected by frontend
-    const files = configs.map(config => {
-      const filePath = path.join(
-        process.cwd(),
-        'apps/backend/src/infrastructure/storage/csv-storage/rates',
-        config.csvFilePath
-      );
-
-      let fileSize = 0;
-      try {
-        const stats = fs.statSync(filePath);
-        fileSize = stats.size;
-      } catch (error) {
-        this.logger.warn(`Could not get file size for ${config.csvFilePath}`);
-      }
-
-      return {
-        filename: config.csvFilePath,
-        size: fileSize,
-        uploadedAt: config.uploadedAt.toISOString(),
-        rowCount: config.rowCount,
-      };
-    });
-
-    return { files };
-  }
-
-  /**
-   * Delete CSV file (Frontend compatibility endpoint)
-   * Maps to DELETE /files/:filename
-   */
-  @Delete('files/:filename')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'Delete CSV file by filename (ADMIN only)',
-    description: 'Deletes a CSV file and its configuration from the system.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'File deleted successfully',
-    schema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean', example: true },
-        message: { type: 'string', example: 'File deleted successfully' },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'File not found',
-  })
-  async deleteFile(
-    @Param('filename') filename: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<{ success: boolean; message: string }> {
-    this.logger.warn(`[Admin: ${user.email}] Deleting CSV file: ${filename}`);
-
-    // Find config by file path
-    const configs = await this.csvConfigRepository.findAll();
-    const config = configs.find(c => c.csvFilePath === filename);
-
-    if (!config) {
-      throw new BadRequestException(`No configuration found for file: ${filename}`);
-    }
-
-    // Delete the file from filesystem
-    const filePath = path.join(
-      process.cwd(),
-      'apps/backend/src/infrastructure/storage/csv-storage/rates',
-      filename
-    );
-
-    try {
-      if (fs.existsSync(filePath)) {
-        fs.unlinkSync(filePath);
-        this.logger.log(`Deleted file: ${filePath}`);
-      }
-    } catch (error: any) {
-      this.logger.error(`Failed to delete file ${filePath}: ${error.message}`);
-    }
-
-    // Delete from MinIO/S3 if it exists there
-    const minioObjectKey = config.metadata?.minioObjectKey as string | undefined;
-    if (minioObjectKey) {
-      try {
-        const bucket = this.configService.get<string>('AWS_S3_BUCKET', 'xpeditis-csv-rates');
-        await this.s3Storage.delete({ bucket, key: minioObjectKey });
-        this.logger.log(`✅ Deleted file from MinIO: ${bucket}/${minioObjectKey}`);
-      } catch (error: any) {
-        this.logger.error(`⚠️  Failed to delete file from MinIO: ${error.message}`);
-        // Don't fail the operation if MinIO deletion fails
-      }
-    }
-
-    // Delete the configuration
-    await this.csvConfigRepository.delete(config.companyName);
-
-    this.logger.log(`Deleted CSV config and file for: ${config.companyName}`);
-
-    return {
-      success: true,
-      message: `File ${filename} deleted successfully`,
-    };
-  }
-}

apps/backend/src/application/controllers/audit.controller.ts

@@ -1,228 +0,0 @@
-/**
- * Audit Log Controller
- *
- * Provides endpoints for querying audit logs
- */
-
-import {
-  Controller,
-  Get,
-  Param,
-  Query,
-  UseGuards,
-  ParseIntPipe,
-  DefaultValuePipe,
-} from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiResponse, ApiBearerAuth, ApiQuery } from '@nestjs/swagger';
-import { AuditService } from '../services/audit.service';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { RolesGuard } from '../guards/roles.guard';
-import { Roles } from '../decorators/roles.decorator';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-import { AuditLog, AuditAction, AuditStatus } from '@domain/entities/audit-log.entity';
-
-class AuditLogResponseDto {
-  id: string;
-  action: string;
-  status: string;
-  userId: string;
-  userEmail: string;
-  organizationId: string;
-  resourceType?: string;
-  resourceId?: string;
-  resourceName?: string;
-  metadata?: Record<string, any>;
-  ipAddress?: string;
-  userAgent?: string;
-  errorMessage?: string;
-  timestamp: string;
-}
-
-class _AuditLogQueryDto {
-  userId?: string;
-  action?: AuditAction[];
-  status?: AuditStatus[];
-  resourceType?: string;
-  resourceId?: string;
-  startDate?: string;
-  endDate?: string;
-  page?: number;
-  limit?: number;
-}
-
-@ApiTags('Audit Logs')
-@ApiBearerAuth()
-@Controller('audit-logs')
-@UseGuards(JwtAuthGuard, RolesGuard)
-export class AuditController {
-  constructor(private readonly auditService: AuditService) {}
-
-  /**
-   * Get audit logs with filters
-   * Only admins and managers can view audit logs
-   */
-  @Get()
-  @Roles('admin', 'manager')
-  @ApiOperation({ summary: 'Get audit logs with filters' })
-  @ApiResponse({ status: 200, description: 'Audit logs retrieved successfully' })
-  @ApiQuery({ name: 'userId', required: false, description: 'Filter by user ID' })
-  @ApiQuery({
-    name: 'action',
-    required: false,
-    description: 'Filter by action (comma-separated)',
-    isArray: true,
-  })
-  @ApiQuery({
-    name: 'status',
-    required: false,
-    description: 'Filter by status (comma-separated)',
-    isArray: true,
-  })
-  @ApiQuery({ name: 'resourceType', required: false, description: 'Filter by resource type' })
-  @ApiQuery({ name: 'resourceId', required: false, description: 'Filter by resource ID' })
-  @ApiQuery({ name: 'startDate', required: false, description: 'Filter by start date (ISO 8601)' })
-  @ApiQuery({ name: 'endDate', required: false, description: 'Filter by end date (ISO 8601)' })
-  @ApiQuery({ name: 'page', required: false, description: 'Page number (default: 1)' })
-  @ApiQuery({ name: 'limit', required: false, description: 'Items per page (default: 50)' })
-  async getAuditLogs(
-    @CurrentUser() user: UserPayload,
-    @Query('userId') userId?: string,
-    @Query('action') action?: string,
-    @Query('status') status?: string,
-    @Query('resourceType') resourceType?: string,
-    @Query('resourceId') resourceId?: string,
-    @Query('startDate') startDate?: string,
-    @Query('endDate') endDate?: string,
-    @Query('page', new DefaultValuePipe(1), ParseIntPipe) page?: number,
-    @Query('limit', new DefaultValuePipe(50), ParseIntPipe) limit?: number
-  ): Promise<{ logs: AuditLogResponseDto[]; total: number; page: number; pageSize: number }> {
-    page = page || 1;
-    limit = limit || 50;
-    const filters: any = {
-      organizationId: user.organizationId,
-      userId,
-      action: action ? action.split(',') : undefined,
-      status: status ? status.split(',') : undefined,
-      resourceType,
-      resourceId,
-      startDate: startDate ? new Date(startDate) : undefined,
-      endDate: endDate ? new Date(endDate) : undefined,
-      offset: (page - 1) * limit,
-      limit,
-    };
-
-    const { logs, total } = await this.auditService.getAuditLogs(filters);
-
-    return {
-      logs: logs.map(log => this.mapToDto(log)),
-      total,
-      page,
-      pageSize: limit,
-    };
-  }
-
-  /**
-   * Get specific audit log by ID
-   */
-  @Get(':id')
-  @Roles('admin', 'manager')
-  @ApiOperation({ summary: 'Get audit log by ID' })
-  @ApiResponse({ status: 200, description: 'Audit log retrieved successfully' })
-  @ApiResponse({ status: 404, description: 'Audit log not found' })
-  async getAuditLogById(
-    @Param('id') id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<AuditLogResponseDto> {
-    const log = await this.auditService.getAuditLogs({
-      organizationId: user.organizationId,
-      limit: 1,
-    });
-
-    if (!log.logs.length) {
-      throw new Error('Audit log not found');
-    }
-
-    return this.mapToDto(log.logs[0]);
-  }
-
-  /**
-   * Get audit trail for a specific resource
-   */
-  @Get('resource/:type/:id')
-  @Roles('admin', 'manager', 'user')
-  @ApiOperation({ summary: 'Get audit trail for a specific resource' })
-  @ApiResponse({ status: 200, description: 'Audit trail retrieved successfully' })
-  async getResourceAuditTrail(
-    @Param('type') resourceType: string,
-    @Param('id') resourceId: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<AuditLogResponseDto[]> {
-    const logs = await this.auditService.getResourceAuditTrail(resourceType, resourceId);
-
-    // Filter by organization for security
-    const filteredLogs = logs.filter(log => log.organizationId === user.organizationId);
-
-    return filteredLogs.map(log => this.mapToDto(log));
-  }
-
-  /**
-   * Get recent activity for current organization
-   */
-  @Get('organization/activity')
-  @Roles('admin', 'manager')
-  @ApiOperation({ summary: 'Get recent organization activity' })
-  @ApiResponse({ status: 200, description: 'Organization activity retrieved successfully' })
-  @ApiQuery({ name: 'limit', required: false, description: 'Number of recent logs (default: 50)' })
-  async getOrganizationActivity(
-    @CurrentUser() user: UserPayload,
-    @Query('limit', new DefaultValuePipe(50), ParseIntPipe) limit?: number
-  ): Promise<AuditLogResponseDto[]> {
-    limit = limit || 50;
-    const logs = await this.auditService.getOrganizationActivity(user.organizationId, limit);
-    return logs.map(log => this.mapToDto(log));
-  }
-
-  /**
-   * Get user activity history
-   */
-  @Get('user/:userId/activity')
-  @Roles('admin', 'manager')
-  @ApiOperation({ summary: 'Get user activity history' })
-  @ApiResponse({ status: 200, description: 'User activity retrieved successfully' })
-  @ApiQuery({ name: 'limit', required: false, description: 'Number of recent logs (default: 50)' })
-  async getUserActivity(
-    @CurrentUser() user: UserPayload,
-    @Param('userId') userId: string,
-    @Query('limit', new DefaultValuePipe(50), ParseIntPipe) limit?: number
-  ): Promise<AuditLogResponseDto[]> {
-    limit = limit || 50;
-    const logs = await this.auditService.getUserActivity(userId, limit);
-
-    // Filter by organization for security
-    const filteredLogs = logs.filter(log => log.organizationId === user.organizationId);
-
-    return filteredLogs.map(log => this.mapToDto(log));
-  }
-
-  /**
-   * Map domain entity to DTO
-   */
-  private mapToDto(log: AuditLog): AuditLogResponseDto {
-    return {
-      id: log.id,
-      action: log.action,
-      status: log.status,
-      userId: log.userId,
-      userEmail: log.userEmail,
-      organizationId: log.organizationId,
-      resourceType: log.resourceType,
-      resourceId: log.resourceId,
-      resourceName: log.resourceName,
-      metadata: log.metadata,
-      ipAddress: log.ipAddress,
-      userAgent: log.userAgent,
-      errorMessage: log.errorMessage,
-      timestamp: log.timestamp.toISOString(),
-    };
-  }
-}

apps/backend/src/application/controllers/auth.controller.ts

@@ -1,259 +0,0 @@
-import {
-  Controller,
-  Post,
-  Body,
-  HttpCode,
-  HttpStatus,
-  UseGuards,
-  Get,
-  Inject,
-  NotFoundException,
-} from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiResponse, ApiBearerAuth } from '@nestjs/swagger';
-import { AuthService } from '../auth/auth.service';
-import { LoginDto, RegisterDto, AuthResponseDto, RefreshTokenDto } from '../dto/auth-login.dto';
-import { Public } from '../decorators/public.decorator';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { UserRepository, USER_REPOSITORY } from '@domain/ports/out/user.repository';
-import { UserMapper } from '../mappers/user.mapper';
-import { InvitationService } from '../services/invitation.service';
-
-/**
- * Authentication Controller
- *
- * Handles user authentication endpoints:
- * - POST /auth/register - User registration
- * - POST /auth/login - User login
- * - POST /auth/refresh - Token refresh
- * - POST /auth/logout - User logout (placeholder)
- * - GET /auth/me - Get current user profile
- */
-@ApiTags('Authentication')
-@Controller('auth')
-export class AuthController {
-  constructor(
-    private readonly authService: AuthService,
-    @Inject(USER_REPOSITORY) private readonly userRepository: UserRepository,
-    private readonly invitationService: InvitationService
-  ) {}
-
-  /**
-   * Register a new user
-   *
-   * Creates a new user account and returns access + refresh tokens.
-   *
-   * @param dto - Registration data (email, password, firstName, lastName, organizationId)
-   * @returns Access token, refresh token, and user info
-   */
-  @Public()
-  @Post('register')
-  @HttpCode(HttpStatus.CREATED)
-  @ApiOperation({
-    summary: 'Register new user',
-    description: 'Create a new user account with email and password. Returns JWT tokens.',
-  })
-  @ApiResponse({
-    status: 201,
-    description: 'User successfully registered',
-    type: AuthResponseDto,
-  })
-  @ApiResponse({
-    status: 409,
-    description: 'User with this email already exists',
-  })
-  @ApiResponse({
-    status: 400,
-    description: 'Validation error (invalid email, weak password, etc.)',
-  })
-  async register(@Body() dto: RegisterDto): Promise<AuthResponseDto> {
-    // If invitation token is provided, verify and use it
-    let invitationOrganizationId: string | undefined;
-    let invitationRole: string | undefined;
-
-    if (dto.invitationToken) {
-      const invitation = await this.invitationService.verifyInvitation(dto.invitationToken);
-
-      // Verify email matches invitation
-      if (invitation.email.toLowerCase() !== dto.email.toLowerCase()) {
-        throw new NotFoundException('Invitation email does not match registration email');
-      }
-
-      invitationOrganizationId = invitation.organizationId;
-      invitationRole = invitation.role;
-
-      // Override firstName/lastName from invitation if not provided
-      dto.firstName = dto.firstName || invitation.firstName;
-      dto.lastName = dto.lastName || invitation.lastName;
-    }
-
-    const result = await this.authService.register(
-      dto.email,
-      dto.password,
-      dto.firstName,
-      dto.lastName,
-      invitationOrganizationId || dto.organizationId,
-      dto.organization,
-      invitationRole
-    );
-
-    // Mark invitation as used if provided
-    if (dto.invitationToken) {
-      await this.invitationService.markInvitationAsUsed(dto.invitationToken);
-    }
-
-    return {
-      accessToken: result.accessToken,
-      refreshToken: result.refreshToken,
-      user: result.user,
-    };
-  }
-
-  /**
-   * Login with email and password
-   *
-   * Authenticates a user and returns access + refresh tokens.
-   *
-   * @param dto - Login credentials (email, password)
-   * @returns Access token, refresh token, and user info
-   */
-  @Public()
-  @Post('login')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'User login',
-    description: 'Authenticate with email and password. Returns JWT tokens.',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Login successful',
-    type: AuthResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Invalid credentials or inactive account',
-  })
-  async login(@Body() dto: LoginDto): Promise<AuthResponseDto> {
-    const result = await this.authService.login(dto.email, dto.password);
-
-    return {
-      accessToken: result.accessToken,
-      refreshToken: result.refreshToken,
-      user: result.user,
-    };
-  }
-
-  /**
-   * Refresh access token
-   *
-   * Obtains a new access token using a valid refresh token.
-   *
-   * @param dto - Refresh token
-   * @returns New access token
-   */
-  @Public()
-  @Post('refresh')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'Refresh access token',
-    description:
-      'Get a new access token using a valid refresh token. Refresh tokens are long-lived (7 days).',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Token refreshed successfully',
-    schema: {
-      properties: {
-        accessToken: { type: 'string', example: 'eyJhbGciOiJIUzI1NiIs...' },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Invalid or expired refresh token',
-  })
-  async refresh(@Body() dto: RefreshTokenDto): Promise<{ accessToken: string }> {
-    const result = await this.authService.refreshAccessToken(dto.refreshToken);
-
-    return { accessToken: result.accessToken };
-  }
-
-  /**
-   * Logout (placeholder)
-   *
-   * Currently a no-op endpoint. With JWT, logout is typically handled client-side
-   * by removing tokens. For more security, implement token blacklisting with Redis.
-   *
-   * @returns Success message
-   */
-  @UseGuards(JwtAuthGuard)
-  @Post('logout')
-  @HttpCode(HttpStatus.OK)
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Logout',
-    description: 'Logout the current user. Currently handled client-side by removing tokens.',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Logout successful',
-    schema: {
-      properties: {
-        message: { type: 'string', example: 'Logout successful' },
-      },
-    },
-  })
-  async logout(): Promise<{ message: string }> {
-    // TODO: Implement token blacklisting with Redis for more security
-    // For now, logout is handled client-side by removing tokens
-    return { message: 'Logout successful' };
-  }
-
-  /**
-   * Get current user profile
-   *
-   * Returns the profile of the currently authenticated user with complete details.
-   *
-   * @param user - Current user from JWT token
-   * @returns User profile with firstName, lastName, etc.
-   */
-  @UseGuards(JwtAuthGuard)
-  @Get('me')
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Get current user profile',
-    description: 'Returns the complete profile of the authenticated user.',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'User profile retrieved successfully',
-    schema: {
-      properties: {
-        id: { type: 'string', format: 'uuid' },
-        email: { type: 'string', format: 'email' },
-        firstName: { type: 'string' },
-        lastName: { type: 'string' },
-        role: { type: 'string', enum: ['ADMIN', 'MANAGER', 'USER', 'VIEWER'] },
-        organizationId: { type: 'string', format: 'uuid' },
-        isActive: { type: 'boolean' },
-        createdAt: { type: 'string', format: 'date-time' },
-        updatedAt: { type: 'string', format: 'date-time' },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - invalid or missing token',
-  })
-  async getProfile(@CurrentUser() user: UserPayload) {
-    // Fetch complete user details from database
-    const fullUser = await this.userRepository.findById(user.id);
-
-    if (!fullUser) {
-      throw new NotFoundException('User not found');
-    }
-
-    // Return complete user data with firstName and lastName
-    return UserMapper.toDto(fullUser);
-  }
-}

apps/backend/src/application/controllers/bookings.controller.ts

@@ -1,704 +0,0 @@
-import {
-  Controller,
-  Get,
-  Post,
-  Param,
-  Body,
-  Query,
-  HttpCode,
-  HttpStatus,
-  Logger,
-  UsePipes,
-  ValidationPipe,
-  NotFoundException,
-  ParseUUIDPipe,
-  ParseIntPipe,
-  DefaultValuePipe,
-  UseGuards,
-  Res,
-  StreamableFile,
-  Inject,
-} from '@nestjs/common';
-import {
-  ApiTags,
-  ApiOperation,
-  ApiResponse,
-  ApiBadRequestResponse,
-  ApiNotFoundResponse,
-  ApiInternalServerErrorResponse,
-  ApiQuery,
-  ApiParam,
-  ApiBearerAuth,
-  ApiProduces,
-} from '@nestjs/swagger';
-import { Response } from 'express';
-import { CreateBookingRequestDto, BookingResponseDto, BookingListResponseDto } from '../dto';
-import { BookingFilterDto } from '../dto/booking-filter.dto';
-import { BookingExportDto } from '../dto/booking-export.dto';
-import { BookingMapper } from '../mappers';
-import { BookingService } from '@domain/services/booking.service';
-import { BookingRepository, BOOKING_REPOSITORY } from '@domain/ports/out/booking.repository';
-import {
-  RateQuoteRepository,
-  RATE_QUOTE_REPOSITORY,
-} from '@domain/ports/out/rate-quote.repository';
-import { BookingNumber } from '@domain/value-objects/booking-number.vo';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-import { ExportService } from '../services/export.service';
-import { FuzzySearchService } from '../services/fuzzy-search.service';
-import { AuditService } from '../services/audit.service';
-import { AuditAction } from '@domain/entities/audit-log.entity';
-import { NotificationService } from '../services/notification.service';
-import { NotificationsGateway } from '../gateways/notifications.gateway';
-import { WebhookService } from '../services/webhook.service';
-import { WebhookEvent } from '@domain/entities/webhook.entity';
-
-@ApiTags('Bookings')
-@Controller('bookings')
-@UseGuards(JwtAuthGuard)
-@ApiBearerAuth()
-export class BookingsController {
-  private readonly logger = new Logger(BookingsController.name);
-
-  constructor(
-    private readonly bookingService: BookingService,
-    @Inject(BOOKING_REPOSITORY) private readonly bookingRepository: BookingRepository,
-    @Inject(RATE_QUOTE_REPOSITORY) private readonly rateQuoteRepository: RateQuoteRepository,
-    private readonly exportService: ExportService,
-    private readonly fuzzySearchService: FuzzySearchService,
-    private readonly auditService: AuditService,
-    private readonly notificationService: NotificationService,
-    private readonly notificationsGateway: NotificationsGateway,
-    private readonly webhookService: WebhookService
-  ) {}
-
-  @Post()
-  @HttpCode(HttpStatus.CREATED)
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  @ApiOperation({
-    summary: 'Create a new booking',
-    description:
-      'Create a new booking based on a rate quote. The booking will be in "draft" status initially. Requires authentication.',
-  })
-  @ApiResponse({
-    status: HttpStatus.CREATED,
-    description: 'Booking created successfully',
-    type: BookingResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiBadRequestResponse({
-    description: 'Invalid request parameters',
-  })
-  @ApiNotFoundResponse({
-    description: 'Rate quote not found',
-  })
-  @ApiInternalServerErrorResponse({
-    description: 'Internal server error',
-  })
-  async createBooking(
-    @Body() dto: CreateBookingRequestDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<BookingResponseDto> {
-    this.logger.log(`[User: ${user.email}] Creating booking for rate quote: ${dto.rateQuoteId}`);
-
-    try {
-      // Convert DTO to domain input, using authenticated user's data
-      const input = {
-        ...BookingMapper.toCreateBookingInput(dto),
-        userId: user.id,
-        organizationId: user.organizationId,
-      };
-
-      // Create booking via domain service
-      const booking = await this.bookingService.createBooking(input);
-
-      // Fetch rate quote for response
-      const rateQuote = await this.rateQuoteRepository.findById(dto.rateQuoteId);
-      if (!rateQuote) {
-        throw new NotFoundException(`Rate quote ${dto.rateQuoteId} not found`);
-      }
-
-      // Convert to DTO
-      const response = BookingMapper.toDto(booking, rateQuote);
-
-      this.logger.log(
-        `Booking created successfully: ${booking.bookingNumber.value} (${booking.id})`
-      );
-
-      // Audit log: Booking created
-      await this.auditService.logSuccess(
-        AuditAction.BOOKING_CREATED,
-        user.id,
-        user.email,
-        user.organizationId,
-        {
-          resourceType: 'booking',
-          resourceId: booking.id,
-          resourceName: booking.bookingNumber.value,
-          metadata: {
-            rateQuoteId: dto.rateQuoteId,
-            status: booking.status.value,
-            carrier: rateQuote.carrierName,
-          },
-        }
-      );
-
-      // Send real-time notification
-      try {
-        const notification = await this.notificationService.notifyBookingCreated(
-          user.id,
-          user.organizationId,
-          booking.bookingNumber.value,
-          booking.id
-        );
-        await this.notificationsGateway.sendNotificationToUser(user.id, notification);
-      } catch (error: any) {
-        // Don't fail the booking creation if notification fails
-        this.logger.error(`Failed to send notification: ${error?.message}`);
-      }
-
-      // Trigger webhooks
-      try {
-        await this.webhookService.triggerWebhooks(
-          WebhookEvent.BOOKING_CREATED,
-          user.organizationId,
-          {
-            bookingId: booking.id,
-            bookingNumber: booking.bookingNumber.value,
-            status: booking.status.value,
-            shipper: booking.shipper,
-            consignee: booking.consignee,
-            carrier: rateQuote.carrierName,
-            origin: rateQuote.origin,
-            destination: rateQuote.destination,
-            etd: rateQuote.etd?.toISOString(),
-            eta: rateQuote.eta?.toISOString(),
-            createdAt: booking.createdAt.toISOString(),
-          }
-        );
-      } catch (error: any) {
-        // Don't fail the booking creation if webhook fails
-        this.logger.error(`Failed to trigger webhooks: ${error?.message}`);
-      }
-
-      return response;
-    } catch (error: any) {
-      this.logger.error(
-        `Booking creation failed: ${error?.message || 'Unknown error'}`,
-        error?.stack
-      );
-
-      // Audit log: Booking creation failed
-      await this.auditService.logFailure(
-        AuditAction.BOOKING_CREATED,
-        user.id,
-        user.email,
-        user.organizationId,
-        error?.message || 'Unknown error',
-        {
-          resourceType: 'booking',
-          metadata: {
-            rateQuoteId: dto.rateQuoteId,
-          },
-        }
-      );
-
-      throw error;
-    }
-  }
-
-  @Get(':id')
-  @ApiOperation({
-    summary: 'Get booking by ID',
-    description: 'Retrieve detailed information about a specific booking. Requires authentication.',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'Booking ID (UUID)',
-    example: '550e8400-e29b-41d4-a716-446655440000',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Booking details retrieved successfully',
-    type: BookingResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiNotFoundResponse({
-    description: 'Booking not found',
-  })
-  async getBooking(
-    @Param('id', ParseUUIDPipe) id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<BookingResponseDto> {
-    this.logger.log(`[User: ${user.email}] Fetching booking: ${id}`);
-
-    const booking = await this.bookingRepository.findById(id);
-    if (!booking) {
-      throw new NotFoundException(`Booking ${id} not found`);
-    }
-
-    // Verify booking belongs to user's organization
-    if (booking.organizationId !== user.organizationId) {
-      throw new NotFoundException(`Booking ${id} not found`);
-    }
-
-    // Fetch rate quote
-    const rateQuote = await this.rateQuoteRepository.findById(booking.rateQuoteId);
-    if (!rateQuote) {
-      throw new NotFoundException(`Rate quote ${booking.rateQuoteId} not found`);
-    }
-
-    return BookingMapper.toDto(booking, rateQuote);
-  }
-
-  @Get('number/:bookingNumber')
-  @ApiOperation({
-    summary: 'Get booking by booking number',
-    description:
-      'Retrieve detailed information about a specific booking using its booking number. Requires authentication.',
-  })
-  @ApiParam({
-    name: 'bookingNumber',
-    description: 'Booking number',
-    example: 'WCM-2025-ABC123',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Booking details retrieved successfully',
-    type: BookingResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiNotFoundResponse({
-    description: 'Booking not found',
-  })
-  async getBookingByNumber(
-    @Param('bookingNumber') bookingNumber: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<BookingResponseDto> {
-    this.logger.log(`[User: ${user.email}] Fetching booking by number: ${bookingNumber}`);
-
-    const bookingNumberVo = BookingNumber.fromString(bookingNumber);
-    const booking = await this.bookingRepository.findByBookingNumber(bookingNumberVo);
-
-    if (!booking) {
-      throw new NotFoundException(`Booking ${bookingNumber} not found`);
-    }
-
-    // Verify booking belongs to user's organization
-    if (booking.organizationId !== user.organizationId) {
-      throw new NotFoundException(`Booking ${bookingNumber} not found`);
-    }
-
-    // Fetch rate quote
-    const rateQuote = await this.rateQuoteRepository.findById(booking.rateQuoteId);
-    if (!rateQuote) {
-      throw new NotFoundException(`Rate quote ${booking.rateQuoteId} not found`);
-    }
-
-    return BookingMapper.toDto(booking, rateQuote);
-  }
-
-  @Get()
-  @ApiOperation({
-    summary: 'List bookings',
-    description:
-      "Retrieve a paginated list of bookings for the authenticated user's organization. Requires authentication.",
-  })
-  @ApiQuery({
-    name: 'page',
-    required: false,
-    description: 'Page number (1-based)',
-    example: 1,
-  })
-  @ApiQuery({
-    name: 'pageSize',
-    required: false,
-    description: 'Number of items per page',
-    example: 20,
-  })
-  @ApiQuery({
-    name: 'status',
-    required: false,
-    description: 'Filter by booking status',
-    enum: ['draft', 'pending_confirmation', 'confirmed', 'in_transit', 'delivered', 'cancelled'],
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Bookings list retrieved successfully',
-    type: BookingListResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  async listBookings(
-    @Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number,
-    @Query('pageSize', new DefaultValuePipe(20), ParseIntPipe) pageSize: number,
-    @Query('status') status: string | undefined,
-    @CurrentUser() user: UserPayload
-  ): Promise<BookingListResponseDto> {
-    this.logger.log(
-      `[User: ${user.email}] Listing bookings: page=${page}, pageSize=${pageSize}, status=${status}`
-    );
-
-    // ADMIN: Fetch ALL bookings from database
-    // Others: Fetch only bookings from their organization
-    let bookings: any[];
-    if (user.role === 'ADMIN') {
-      this.logger.log(`[ADMIN] Fetching ALL bookings from database`);
-      bookings = await this.bookingRepository.findAll();
-    } else {
-      this.logger.log(`[User] Fetching bookings from organization: ${user.organizationId}`);
-      bookings = await this.bookingRepository.findByOrganization(user.organizationId);
-    }
-
-    // Filter by status if provided
-    const filteredBookings = status
-      ? bookings.filter((b: any) => b.status.value === status)
-      : bookings;
-
-    // Paginate
-    const startIndex = (page - 1) * pageSize;
-    const endIndex = startIndex + pageSize;
-    const paginatedBookings = filteredBookings.slice(startIndex, endIndex);
-
-    // Fetch rate quotes for all bookings (filter out those with missing rate quotes)
-    const bookingsWithQuotesRaw = await Promise.all(
-      paginatedBookings.map(async (booking: any) => {
-        const rateQuote = await this.rateQuoteRepository.findById(booking.rateQuoteId);
-        return { booking, rateQuote };
-      })
-    );
-
-    // Filter out bookings with missing rate quotes to avoid null pointer errors
-    const bookingsWithQuotes = bookingsWithQuotesRaw.filter(
-      (item): item is { booking: any; rateQuote: NonNullable<typeof item.rateQuote> } =>
-        item.rateQuote !== null && item.rateQuote !== undefined
-    );
-
-    // Convert to DTOs
-    const bookingDtos = BookingMapper.toListItemDtoArray(bookingsWithQuotes);
-
-    const totalPages = Math.ceil(filteredBookings.length / pageSize);
-
-    return {
-      bookings: bookingDtos,
-      total: filteredBookings.length,
-      page,
-      pageSize,
-      totalPages,
-    };
-  }
-
-  @Get('search/fuzzy')
-  @ApiOperation({
-    summary: 'Fuzzy search bookings',
-    description:
-      'Search bookings using fuzzy matching. Tolerant to typos and partial matches. Searches across booking number, shipper, and consignee names.',
-  })
-  @ApiQuery({
-    name: 'q',
-    required: true,
-    description: 'Search query (minimum 2 characters)',
-    example: 'WCM-2025',
-  })
-  @ApiQuery({
-    name: 'limit',
-    required: false,
-    description: 'Maximum number of results',
-    example: 20,
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Search results retrieved successfully',
-    type: [BookingResponseDto],
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  async fuzzySearch(
-    @Query('q') searchTerm: string,
-    @Query('limit', new DefaultValuePipe(20), ParseIntPipe) limit: number,
-    @CurrentUser() user: UserPayload
-  ): Promise<BookingResponseDto[]> {
-    this.logger.log(`[User: ${user.email}] Fuzzy search: "${searchTerm}"`);
-
-    if (!searchTerm || searchTerm.length < 2) {
-      return [];
-    }
-
-    // Perform fuzzy search
-    const bookingOrms = await this.fuzzySearchService.search(
-      searchTerm,
-      user.organizationId,
-      limit
-    );
-
-    // Map ORM entities to domain and fetch rate quotes
-    const bookingsWithQuotesRaw = await Promise.all(
-      bookingOrms.map(async bookingOrm => {
-        const booking = await this.bookingRepository.findById(bookingOrm.id);
-        const rateQuote = await this.rateQuoteRepository.findById(bookingOrm.rateQuoteId);
-        return { booking, rateQuote };
-      })
-    );
-
-    // Filter out bookings or rate quotes that are null
-    const bookingsWithQuotes = bookingsWithQuotesRaw.filter(
-      (item): item is { booking: NonNullable<typeof item.booking>; rateQuote: NonNullable<typeof item.rateQuote> } =>
-        item.booking !== null && item.booking !== undefined &&
-        item.rateQuote !== null && item.rateQuote !== undefined
-    );
-
-    // Convert to DTOs
-    const bookingDtos = bookingsWithQuotes.map(({ booking, rateQuote }) =>
-      BookingMapper.toDto(booking, rateQuote)
-    );
-
-    this.logger.log(`Fuzzy search returned ${bookingDtos.length} results`);
-
-    return bookingDtos;
-  }
-
-  @Get('advanced/search')
-  @ApiOperation({
-    summary: 'Advanced booking search with filtering',
-    description:
-      'Search bookings with advanced filtering options including status, date ranges, carrier, ports, shipper/consignee. Supports sorting and pagination.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Filtered bookings retrieved successfully',
-    type: BookingListResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  async advancedSearch(
-    @Query(new ValidationPipe({ transform: true })) filter: BookingFilterDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<BookingListResponseDto> {
-    this.logger.log(
-      `[User: ${user.email}] Advanced search with filters: ${JSON.stringify(filter)}`
-    );
-
-    // Fetch all bookings for organization
-    let bookings = await this.bookingRepository.findByOrganization(user.organizationId);
-
-    // Apply filters
-    bookings = this.applyFilters(bookings, filter);
-
-    // Sort bookings (use defaults if not provided)
-    const sortBy = filter.sortBy || 'createdAt';
-    const sortOrder = filter.sortOrder || 'desc';
-    bookings = this.sortBookings(bookings, sortBy, sortOrder);
-
-    // Total count before pagination
-    const total = bookings.length;
-
-    // Paginate
-    const startIndex = ((filter.page || 1) - 1) * (filter.pageSize || 20);
-    const endIndex = startIndex + (filter.pageSize || 20);
-    const paginatedBookings = bookings.slice(startIndex, endIndex);
-
-    // Fetch rate quotes (filter out those with missing rate quotes)
-    const bookingsWithQuotesRaw = await Promise.all(
-      paginatedBookings.map(async booking => {
-        const rateQuote = await this.rateQuoteRepository.findById(booking.rateQuoteId);
-        return { booking, rateQuote };
-      })
-    );
-
-    // Filter out bookings with missing rate quotes to avoid null pointer errors
-    const bookingsWithQuotes = bookingsWithQuotesRaw.filter(
-      (item): item is { booking: any; rateQuote: NonNullable<typeof item.rateQuote> } =>
-        item.rateQuote !== null && item.rateQuote !== undefined
-    );
-
-    // Convert to DTOs
-    const bookingDtos = BookingMapper.toListItemDtoArray(bookingsWithQuotes);
-
-    const totalPages = Math.ceil(total / (filter.pageSize || 20));
-
-    return {
-      bookings: bookingDtos,
-      total,
-      page: filter.page || 1,
-      pageSize: filter.pageSize || 20,
-      totalPages,
-    };
-  }
-
-  @Post('export')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'Export bookings to CSV/Excel/JSON',
-    description:
-      'Export bookings with optional filtering. Supports CSV, Excel (xlsx), and JSON formats.',
-  })
-  @ApiProduces(
-    'text/csv',
-    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-    'application/json'
-  )
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Export file generated successfully',
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  async exportBookings(
-    @Body(new ValidationPipe({ transform: true })) exportDto: BookingExportDto,
-    @Query(new ValidationPipe({ transform: true })) filter: BookingFilterDto,
-    @CurrentUser() user: UserPayload,
-    @Res({ passthrough: true }) res: Response
-  ): Promise<StreamableFile> {
-    this.logger.log(`[User: ${user.email}] Exporting bookings to ${exportDto.format}`);
-
-    let bookings: any[];
-
-    // If specific booking IDs provided, use those
-    if (exportDto.bookingIds && exportDto.bookingIds.length > 0) {
-      bookings = await Promise.all(
-        exportDto.bookingIds.map(id => this.bookingRepository.findById(id))
-      );
-      bookings = bookings.filter(b => b !== null && b.organizationId === user.organizationId);
-    } else {
-      // Otherwise, use filter criteria
-      bookings = await this.bookingRepository.findByOrganization(user.organizationId);
-      bookings = this.applyFilters(bookings, filter);
-    }
-
-    // Fetch rate quotes (filter out those with missing rate quotes)
-    const bookingsWithQuotesRaw = await Promise.all(
-      bookings.map(async booking => {
-        const rateQuote = await this.rateQuoteRepository.findById(booking.rateQuoteId);
-        return { booking, rateQuote };
-      })
-    );
-
-    // Filter out bookings with missing rate quotes to avoid null pointer errors
-    const bookingsWithQuotes = bookingsWithQuotesRaw.filter(
-      (item): item is { booking: any; rateQuote: NonNullable<typeof item.rateQuote> } =>
-        item.rateQuote !== null && item.rateQuote !== undefined
-    );
-
-    // Generate export file
-    const exportResult = await this.exportService.exportBookings(
-      bookingsWithQuotes,
-      exportDto.format,
-      exportDto.fields
-    );
-
-    // Set response headers
-    res.set({
-      'Content-Type': exportResult.contentType,
-      'Content-Disposition': `attachment; filename="${exportResult.filename}"`,
-    });
-
-    // Audit log: Data exported
-    await this.auditService.logSuccess(
-      AuditAction.DATA_EXPORTED,
-      user.id,
-      user.email,
-      user.organizationId,
-      {
-        resourceType: 'booking',
-        metadata: {
-          format: exportDto.format,
-          bookingCount: bookings.length,
-          fields: exportDto.fields?.join(', ') || 'all',
-          filename: exportResult.filename,
-        },
-      }
-    );
-
-    return new StreamableFile(exportResult.buffer);
-  }
-
-  /**
-   * Apply filters to bookings array
-   */
-  private applyFilters(bookings: any[], filter: BookingFilterDto): any[] {
-    let filtered = bookings;
-
-    // Filter by status
-    if (filter.status && filter.status.length > 0) {
-      filtered = filtered.filter(b => filter.status!.includes(b.status.value));
-    }
-
-    // Filter by search (booking number partial match)
-    if (filter.search) {
-      const searchLower = filter.search.toLowerCase();
-      filtered = filtered.filter(b => b.bookingNumber.value.toLowerCase().includes(searchLower));
-    }
-
-    // Filter by shipper
-    if (filter.shipper) {
-      const shipperLower = filter.shipper.toLowerCase();
-      filtered = filtered.filter(b => b.shipper.name.toLowerCase().includes(shipperLower));
-    }
-
-    // Filter by consignee
-    if (filter.consignee) {
-      const consigneeLower = filter.consignee.toLowerCase();
-      filtered = filtered.filter(b => b.consignee.name.toLowerCase().includes(consigneeLower));
-    }
-
-    // Filter by creation date range
-    if (filter.createdFrom) {
-      const fromDate = new Date(filter.createdFrom);
-      filtered = filtered.filter(b => b.createdAt >= fromDate);
-    }
-    if (filter.createdTo) {
-      const toDate = new Date(filter.createdTo);
-      filtered = filtered.filter(b => b.createdAt <= toDate);
-    }
-
-    return filtered;
-  }
-
-  /**
-   * Sort bookings array
-   */
-  private sortBookings(bookings: any[], sortBy: string, sortOrder: string): any[] {
-    return [...bookings].sort((a, b) => {
-      let aValue: any;
-      let bValue: any;
-
-      switch (sortBy) {
-        case 'bookingNumber':
-          aValue = a.bookingNumber.value;
-          bValue = b.bookingNumber.value;
-          break;
-        case 'status':
-          aValue = a.status.value;
-          bValue = b.status.value;
-          break;
-        case 'createdAt':
-        default:
-          aValue = a.createdAt;
-          bValue = b.createdAt;
-          break;
-      }
-
-      if (aValue < bValue) return sortOrder === 'asc' ? -1 : 1;
-      if (aValue > bValue) return sortOrder === 'asc' ? 1 : -1;
-      return 0;
-    });
-  }
-}

apps/backend/src/application/controllers/csv-booking-actions.controller.ts

@@ -1,91 +0,0 @@
-import { Controller, Get, Param, Query } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiResponse, ApiParam, ApiQuery } from '@nestjs/swagger';
-import { Public } from '../decorators/public.decorator';
-import { CsvBookingService } from '../services/csv-booking.service';
-
-/**
- * CSV Booking Actions Controller (Public Routes)
- *
- * Handles public accept/reject actions from carrier emails
- * Separated from main controller to avoid routing conflicts
- */
-@ApiTags('CSV Booking Actions')
-@Controller('csv-booking-actions')
-export class CsvBookingActionsController {
-  constructor(private readonly csvBookingService: CsvBookingService) {}
-
-  /**
-   * Accept a booking request (PUBLIC - token-based)
-   *
-   * GET /api/v1/csv-booking-actions/accept/:token
-   */
-  @Public()
-  @Get('accept/:token')
-  @ApiOperation({
-    summary: 'Accept booking request (public)',
-    description:
-      'Public endpoint for carriers to accept a booking via email link. Updates booking status and notifies the user.',
-  })
-  @ApiParam({ name: 'token', description: 'Booking confirmation token (UUID)' })
-  @ApiResponse({
-    status: 200,
-    description: 'Booking accepted successfully.',
-  })
-  @ApiResponse({ status: 404, description: 'Booking not found or invalid token' })
-  @ApiResponse({
-    status: 400,
-    description: 'Booking cannot be accepted (invalid status or expired)',
-  })
-  async acceptBooking(@Param('token') token: string) {
-    // Accept the booking
-    const booking = await this.csvBookingService.acceptBooking(token);
-
-    // Return simple success response
-    return {
-      success: true,
-      bookingId: booking.id,
-      action: 'accepted',
-    };
-  }
-
-  /**
-   * Reject a booking request (PUBLIC - token-based)
-   *
-   * GET /api/v1/csv-booking-actions/reject/:token
-   */
-  @Public()
-  @Get('reject/:token')
-  @ApiOperation({
-    summary: 'Reject booking request (public)',
-    description:
-      'Public endpoint for carriers to reject a booking via email link. Updates booking status and notifies the user.',
-  })
-  @ApiParam({ name: 'token', description: 'Booking confirmation token (UUID)' })
-  @ApiQuery({
-    name: 'reason',
-    required: false,
-    description: 'Rejection reason',
-    example: 'No capacity available',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Booking rejected successfully.',
-  })
-  @ApiResponse({ status: 404, description: 'Booking not found or invalid token' })
-  @ApiResponse({
-    status: 400,
-    description: 'Booking cannot be rejected (invalid status or expired)',
-  })
-  async rejectBooking(@Param('token') token: string, @Query('reason') reason: string) {
-    // Reject the booking
-    const booking = await this.csvBookingService.rejectBooking(token, reason);
-
-    // Return simple success response
-    return {
-      success: true,
-      bookingId: booking.id,
-      action: 'rejected',
-      reason: reason || null,
-    };
-  }
-}

apps/backend/src/application/controllers/csv-bookings.controller.ts

@@ -1,568 +0,0 @@
-import {
-  Controller,
-  Post,
-  Get,
-  Patch,
-  Delete,
-  Body,
-  Param,
-  Query,
-  UseGuards,
-  UseInterceptors,
-  UploadedFiles,
-  Request,
-  BadRequestException,
-  ParseIntPipe,
-  DefaultValuePipe,
-} from '@nestjs/common';
-import { FilesInterceptor } from '@nestjs/platform-express';
-import {
-  ApiTags,
-  ApiOperation,
-  ApiResponse,
-  ApiConsumes,
-  ApiBody,
-  ApiBearerAuth,
-  ApiQuery,
-  ApiParam,
-} from '@nestjs/swagger';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { Public } from '../decorators/public.decorator';
-import { CsvBookingService } from '../services/csv-booking.service';
-import {
-  CreateCsvBookingDto,
-  CsvBookingResponseDto,
-  CsvBookingListResponseDto,
-  CsvBookingStatsDto,
-} from '../dto/csv-booking.dto';
-
-/**
- * CSV Bookings Controller
- *
- * Handles HTTP requests for CSV-based booking requests
- *
- * IMPORTANT: Route order matters in NestJS!
- * Static routes MUST come BEFORE parameterized routes.
- * Otherwise, `:id` will capture "stats", "organization", etc.
- */
-@ApiTags('CSV Bookings')
-@Controller('csv-bookings')
-export class CsvBookingsController {
-  constructor(private readonly csvBookingService: CsvBookingService) {}
-
-  // ============================================================================
-  // STATIC ROUTES (must come FIRST)
-  // ============================================================================
-
-  /**
-   * Create a new CSV booking request
-   *
-   * POST /api/v1/csv-bookings
-   */
-  @Post()
-  @UseGuards(JwtAuthGuard)
-  @ApiBearerAuth()
-  @UseInterceptors(FilesInterceptor('documents', 10))
-  @ApiConsumes('multipart/form-data')
-  @ApiOperation({
-    summary: 'Create a new CSV booking request',
-    description:
-      'Creates a new booking request from CSV rate selection. Uploads documents, sends email to carrier, and creates a notification for the user.',
-  })
-  @ApiBody({
-    schema: {
-      type: 'object',
-      required: [
-        'carrierName',
-        'carrierEmail',
-        'origin',
-        'destination',
-        'volumeCBM',
-        'weightKG',
-        'palletCount',
-        'priceUSD',
-        'priceEUR',
-        'primaryCurrency',
-        'transitDays',
-        'containerType',
-      ],
-      properties: {
-        carrierName: { type: 'string', example: 'SSC Consolidation' },
-        carrierEmail: { type: 'string', format: 'email', example: 'bookings@sscconsolidation.com' },
-        origin: { type: 'string', example: 'NLRTM' },
-        destination: { type: 'string', example: 'USNYC' },
-        volumeCBM: { type: 'number', example: 25.5 },
-        weightKG: { type: 'number', example: 3500 },
-        palletCount: { type: 'number', example: 10 },
-        priceUSD: { type: 'number', example: 1850.5 },
-        priceEUR: { type: 'number', example: 1665.45 },
-        primaryCurrency: { type: 'string', enum: ['USD', 'EUR'], example: 'USD' },
-        transitDays: { type: 'number', example: 28 },
-        containerType: { type: 'string', example: 'LCL' },
-        notes: { type: 'string', example: 'Handle with care' },
-        documents: {
-          type: 'array',
-          items: { type: 'string', format: 'binary' },
-          description: 'Shipping documents (Bill of Lading, Packing List, Invoice, etc.)',
-        },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 201,
-    description: 'Booking created successfully',
-    type: CsvBookingResponseDto,
-  })
-  @ApiResponse({ status: 400, description: 'Invalid request data or missing documents' })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
-  async createBooking(
-    @Body() dto: CreateCsvBookingDto,
-    @UploadedFiles() files: Express.Multer.File[],
-    @Request() req: any
-  ): Promise<CsvBookingResponseDto> {
-    // Debug: Log request details
-    console.log('=== CSV Booking Request Debug ===');
-    console.log('req.user:', req.user);
-    console.log('req.body:', req.body);
-    console.log('dto:', dto);
-    console.log('files:', files?.length);
-    console.log('================================');
-
-    if (!files || files.length === 0) {
-      throw new BadRequestException('At least one document is required');
-    }
-
-    // Validate user authentication
-    if (!req.user || !req.user.id) {
-      throw new BadRequestException('User authentication failed - no user info in request');
-    }
-
-    if (!req.user.organizationId) {
-      throw new BadRequestException('Organization ID is required');
-    }
-
-    const userId = req.user.id;
-    const organizationId = req.user.organizationId;
-
-    // Convert string values to numbers (multipart/form-data sends everything as strings)
-    const sanitizedDto: CreateCsvBookingDto = {
-      ...dto,
-      volumeCBM: typeof dto.volumeCBM === 'string' ? parseFloat(dto.volumeCBM) : dto.volumeCBM,
-      weightKG: typeof dto.weightKG === 'string' ? parseFloat(dto.weightKG) : dto.weightKG,
-      palletCount:
-        typeof dto.palletCount === 'string' ? parseInt(dto.palletCount, 10) : dto.palletCount,
-      priceUSD: typeof dto.priceUSD === 'string' ? parseFloat(dto.priceUSD) : dto.priceUSD,
-      priceEUR: typeof dto.priceEUR === 'string' ? parseFloat(dto.priceEUR) : dto.priceEUR,
-      transitDays:
-        typeof dto.transitDays === 'string' ? parseInt(dto.transitDays, 10) : dto.transitDays,
-    };
-
-    return await this.csvBookingService.createBooking(sanitizedDto, files, userId, organizationId);
-  }
-
-  /**
-   * Get current user's bookings (paginated)
-   *
-   * GET /api/v1/csv-bookings
-   */
-  @Get()
-  @UseGuards(JwtAuthGuard)
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Get user bookings',
-    description: 'Retrieve all bookings for the authenticated user with pagination.',
-  })
-  @ApiQuery({ name: 'page', required: false, type: Number, example: 1 })
-  @ApiQuery({ name: 'limit', required: false, type: Number, example: 10 })
-  @ApiResponse({
-    status: 200,
-    description: 'Bookings retrieved successfully',
-    type: CsvBookingListResponseDto,
-  })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
-  async getUserBookings(
-    @Request() req: any,
-    @Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number,
-    @Query('limit', new DefaultValuePipe(10), ParseIntPipe) limit: number
-  ): Promise<CsvBookingListResponseDto> {
-    const userId = req.user.id;
-    return await this.csvBookingService.getUserBookings(userId, page, limit);
-  }
-
-  /**
-   * Get booking statistics for user
-   *
-   * GET /api/v1/csv-bookings/stats/me
-   */
-  @Get('stats/me')
-  @UseGuards(JwtAuthGuard)
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Get user booking statistics',
-    description:
-      'Get aggregated statistics for the authenticated user (pending, accepted, rejected, cancelled).',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Statistics retrieved successfully',
-    type: CsvBookingStatsDto,
-  })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
-  async getUserStats(@Request() req: any): Promise<CsvBookingStatsDto> {
-    const userId = req.user.id;
-    return await this.csvBookingService.getUserStats(userId);
-  }
-
-  /**
-   * Get organization booking statistics
-   *
-   * GET /api/v1/csv-bookings/stats/organization
-   */
-  @Get('stats/organization')
-  @UseGuards(JwtAuthGuard)
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Get organization booking statistics',
-    description: "Get aggregated statistics for the user's organization. For managers/admins.",
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Statistics retrieved successfully',
-    type: CsvBookingStatsDto,
-  })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
-  async getOrganizationStats(@Request() req: any): Promise<CsvBookingStatsDto> {
-    const organizationId = req.user.organizationId;
-    return await this.csvBookingService.getOrganizationStats(organizationId);
-  }
-
-  /**
-   * Get organization bookings (for managers/admins)
-   *
-   * GET /api/v1/csv-bookings/organization/all
-   */
-  @Get('organization/all')
-  @UseGuards(JwtAuthGuard)
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Get organization bookings',
-    description:
-      "Retrieve all bookings for the user's organization with pagination. For managers/admins.",
-  })
-  @ApiQuery({ name: 'page', required: false, type: Number, example: 1 })
-  @ApiQuery({ name: 'limit', required: false, type: Number, example: 10 })
-  @ApiResponse({
-    status: 200,
-    description: 'Organization bookings retrieved successfully',
-    type: CsvBookingListResponseDto,
-  })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
-  async getOrganizationBookings(
-    @Request() req: any,
-    @Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number,
-    @Query('limit', new DefaultValuePipe(10), ParseIntPipe) limit: number
-  ): Promise<CsvBookingListResponseDto> {
-    const organizationId = req.user.organizationId;
-    return await this.csvBookingService.getOrganizationBookings(organizationId, page, limit);
-  }
-
-  /**
-   * Accept a booking request (PUBLIC - token-based)
-   *
-   * GET /api/v1/csv-bookings/accept/:token
-   */
-  @Public()
-  @Get('accept/:token')
-  @ApiOperation({
-    summary: 'Accept booking request (public)',
-    description:
-      'Public endpoint for carriers to accept a booking via email link. Updates booking status and notifies the user.',
-  })
-  @ApiParam({ name: 'token', description: 'Booking confirmation token (UUID)' })
-  @ApiResponse({
-    status: 200,
-    description: 'Booking accepted successfully.',
-  })
-  @ApiResponse({ status: 404, description: 'Booking not found or invalid token' })
-  @ApiResponse({
-    status: 400,
-    description: 'Booking cannot be accepted (invalid status or expired)',
-  })
-  async acceptBooking(@Param('token') token: string) {
-    // Accept the booking
-    const booking = await this.csvBookingService.acceptBooking(token);
-
-    // Return simple success response
-    return {
-      success: true,
-      bookingId: booking.id,
-      action: 'accepted',
-    };
-  }
-
-  /**
-   * Reject a booking request (PUBLIC - token-based)
-   *
-   * GET /api/v1/csv-bookings/reject/:token
-   */
-  @Public()
-  @Get('reject/:token')
-  @ApiOperation({
-    summary: 'Reject booking request (public)',
-    description:
-      'Public endpoint for carriers to reject a booking via email link. Updates booking status and notifies the user.',
-  })
-  @ApiParam({ name: 'token', description: 'Booking confirmation token (UUID)' })
-  @ApiQuery({
-    name: 'reason',
-    required: false,
-    description: 'Rejection reason',
-    example: 'No capacity available',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Booking rejected successfully.',
-  })
-  @ApiResponse({ status: 404, description: 'Booking not found or invalid token' })
-  @ApiResponse({
-    status: 400,
-    description: 'Booking cannot be rejected (invalid status or expired)',
-  })
-  async rejectBooking(@Param('token') token: string, @Query('reason') reason: string) {
-    // Reject the booking
-    const booking = await this.csvBookingService.rejectBooking(token, reason);
-
-    // Return simple success response
-    return {
-      success: true,
-      bookingId: booking.id,
-      action: 'rejected',
-      reason: reason || null,
-    };
-  }
-
-  // ============================================================================
-  // PARAMETERIZED ROUTES (must come LAST)
-  // ============================================================================
-
-  /**
-   * Get a booking by ID
-   *
-   * GET /api/v1/csv-bookings/:id
-   *
-   * IMPORTANT: This route MUST be after all static GET routes
-   * Otherwise it will capture "stats", "organization", etc.
-   */
-  @Get(':id')
-  @UseGuards(JwtAuthGuard)
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Get booking by ID',
-    description: 'Retrieve a specific CSV booking by its ID. Only accessible by the booking owner.',
-  })
-  @ApiParam({ name: 'id', description: 'Booking ID (UUID)' })
-  @ApiResponse({
-    status: 200,
-    description: 'Booking retrieved successfully',
-    type: CsvBookingResponseDto,
-  })
-  @ApiResponse({ status: 404, description: 'Booking not found' })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
-  async getBooking(@Param('id') id: string, @Request() req: any): Promise<CsvBookingResponseDto> {
-    const userId = req.user.id;
-    const carrierId = req.user.carrierId; // May be undefined if not a carrier
-    return await this.csvBookingService.getBookingById(id, userId, carrierId);
-  }
-
-  /**
-   * Cancel a booking (user action)
-   *
-   * PATCH /api/v1/csv-bookings/:id/cancel
-   */
-  @Patch(':id/cancel')
-  @UseGuards(JwtAuthGuard)
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Cancel booking',
-    description: 'Cancel a pending booking. Only accessible by the booking owner.',
-  })
-  @ApiParam({ name: 'id', description: 'Booking ID (UUID)' })
-  @ApiResponse({
-    status: 200,
-    description: 'Booking cancelled successfully',
-    type: CsvBookingResponseDto,
-  })
-  @ApiResponse({ status: 404, description: 'Booking not found' })
-  @ApiResponse({ status: 400, description: 'Booking cannot be cancelled (already accepted)' })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
-  async cancelBooking(
-    @Param('id') id: string,
-    @Request() req: any
-  ): Promise<CsvBookingResponseDto> {
-    const userId = req.user.id;
-    return await this.csvBookingService.cancelBooking(id, userId);
-  }
-
-  /**
-   * Add documents to an existing booking
-   *
-   * POST /api/v1/csv-bookings/:id/documents
-   */
-  @Post(':id/documents')
-  @UseGuards(JwtAuthGuard)
-  @ApiBearerAuth()
-  @UseInterceptors(FilesInterceptor('documents', 10))
-  @ApiConsumes('multipart/form-data')
-  @ApiOperation({
-    summary: 'Add documents to an existing booking',
-    description:
-      'Upload additional documents to a pending booking. Only the booking owner can add documents.',
-  })
-  @ApiParam({ name: 'id', description: 'Booking ID (UUID)' })
-  @ApiBody({
-    schema: {
-      type: 'object',
-      properties: {
-        documents: {
-          type: 'array',
-          items: { type: 'string', format: 'binary' },
-          description: 'Documents to add (max 10 files)',
-        },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Documents added successfully',
-    schema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean', example: true },
-        message: { type: 'string', example: 'Documents added successfully' },
-        documentsAdded: { type: 'number', example: 2 },
-      },
-    },
-  })
-  @ApiResponse({ status: 400, description: 'Invalid request or booking cannot be modified' })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
-  @ApiResponse({ status: 404, description: 'Booking not found' })
-  async addDocuments(
-    @Param('id') id: string,
-    @UploadedFiles() files: Express.Multer.File[],
-    @Request() req: any
-  ) {
-    if (!files || files.length === 0) {
-      throw new BadRequestException('At least one document is required');
-    }
-
-    const userId = req.user.id;
-    return await this.csvBookingService.addDocuments(id, files, userId);
-  }
-
-  /**
-   * Replace a document in a booking
-   *
-   * PUT /api/v1/csv-bookings/:bookingId/documents/:documentId
-   */
-  @Patch(':bookingId/documents/:documentId')
-  @UseGuards(JwtAuthGuard)
-  @ApiBearerAuth()
-  @UseInterceptors(FilesInterceptor('document', 1))
-  @ApiConsumes('multipart/form-data')
-  @ApiOperation({
-    summary: 'Replace a document in a booking',
-    description:
-      'Replace an existing document with a new one. Only the booking owner can replace documents.',
-  })
-  @ApiParam({ name: 'bookingId', description: 'Booking ID (UUID)' })
-  @ApiParam({ name: 'documentId', description: 'Document ID (UUID) to replace' })
-  @ApiBody({
-    schema: {
-      type: 'object',
-      properties: {
-        document: {
-          type: 'string',
-          format: 'binary',
-          description: 'New document file to replace the existing one',
-        },
-      },
-    },
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Document replaced successfully',
-    schema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean', example: true },
-        message: { type: 'string', example: 'Document replaced successfully' },
-        newDocument: {
-          type: 'object',
-          properties: {
-            id: { type: 'string' },
-            type: { type: 'string' },
-            fileName: { type: 'string' },
-            filePath: { type: 'string' },
-            mimeType: { type: 'string' },
-            size: { type: 'number' },
-            uploadedAt: { type: 'string', format: 'date-time' },
-          },
-        },
-      },
-    },
-  })
-  @ApiResponse({ status: 400, description: 'Invalid request - missing file' })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
-  @ApiResponse({ status: 404, description: 'Booking or document not found' })
-  async replaceDocument(
-    @Param('bookingId') bookingId: string,
-    @Param('documentId') documentId: string,
-    @UploadedFiles() files: Express.Multer.File[],
-    @Request() req: any
-  ) {
-    if (!files || files.length === 0) {
-      throw new BadRequestException('A document file is required');
-    }
-
-    const userId = req.user.id;
-    return await this.csvBookingService.replaceDocument(bookingId, documentId, files[0], userId);
-  }
-
-  /**
-   * Delete a document from a booking
-   *
-   * DELETE /api/v1/csv-bookings/:bookingId/documents/:documentId
-   */
-  @Delete(':bookingId/documents/:documentId')
-  @UseGuards(JwtAuthGuard)
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Delete a document from a booking',
-    description:
-      'Remove a document from a pending booking. Only the booking owner can delete documents.',
-  })
-  @ApiParam({ name: 'bookingId', description: 'Booking ID (UUID)' })
-  @ApiParam({ name: 'documentId', description: 'Document ID (UUID)' })
-  @ApiResponse({
-    status: 200,
-    description: 'Document deleted successfully',
-    schema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean', example: true },
-        message: { type: 'string', example: 'Document deleted successfully' },
-      },
-    },
-  })
-  @ApiResponse({ status: 400, description: 'Booking cannot be modified (not pending)' })
-  @ApiResponse({ status: 401, description: 'Unauthorized' })
-  @ApiResponse({ status: 404, description: 'Booking or document not found' })
-  async deleteDocument(
-    @Param('bookingId') bookingId: string,
-    @Param('documentId') documentId: string,
-    @Request() req: any
-  ) {
-    const userId = req.user.id;
-    return await this.csvBookingService.deleteDocument(bookingId, documentId, userId);
-  }
-}

apps/backend/src/application/controllers/gdpr.controller.ts

@@ -1,195 +0,0 @@
-/**
- * GDPR Controller
- *
- * Endpoints for GDPR compliance (data export, deletion, consent)
- */
-
-import {
-  Controller,
-  Get,
-  Post,
-  Delete,
-  Body,
-  UseGuards,
-  HttpCode,
-  HttpStatus,
-  Res,
-  Req,
-} from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth, ApiResponse } from '@nestjs/swagger';
-import { Response, Request } from 'express';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { CurrentUser } from '../decorators/current-user.decorator';
-import { UserPayload } from '../decorators/current-user.decorator';
-import { GDPRService } from '../services/gdpr.service';
-import {
-  UpdateConsentDto,
-  ConsentResponseDto,
-  WithdrawConsentDto,
-  ConsentSuccessDto,
-} from '../dto/consent.dto';
-
-@ApiTags('GDPR')
-@Controller('gdpr')
-@UseGuards(JwtAuthGuard)
-@ApiBearerAuth()
-export class GDPRController {
-  constructor(private readonly gdprService: GDPRService) {}
-
-  /**
-   * Export user data (GDPR Right to Data Portability)
-   */
-  @Get('export')
-  @ApiOperation({
-    summary: 'Export all user data',
-    description: 'Export all personal data in JSON format (GDPR Article 20)',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Data export successful',
-  })
-  async exportData(@CurrentUser() user: UserPayload, @Res() res: Response): Promise<void> {
-    const exportData = await this.gdprService.exportUserData(user.id);
-
-    // Set headers for file download
-    res.setHeader('Content-Type', 'application/json');
-    res.setHeader(
-      'Content-Disposition',
-      `attachment; filename="xpeditis-data-export-${user.id}-${Date.now()}.json"`
-    );
-
-    res.json(exportData);
-  }
-
-  /**
-   * Export user data as CSV
-   */
-  @Get('export/csv')
-  @ApiOperation({
-    summary: 'Export user data as CSV',
-    description: 'Export personal data in CSV format for easy viewing',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'CSV export successful',
-  })
-  async exportDataCSV(@CurrentUser() user: UserPayload, @Res() res: Response): Promise<void> {
-    const exportData = await this.gdprService.exportUserData(user.id);
-
-    // Convert to CSV (simplified version)
-    let csv = 'Category,Field,Value\n';
-
-    // User data
-    Object.entries(exportData.userData).forEach(([key, value]) => {
-      csv += `User Data,${key},"${value}"\n`;
-    });
-
-    // Cookie consent data
-    if (exportData.cookieConsent) {
-      Object.entries(exportData.cookieConsent).forEach(([key, value]) => {
-        csv += `Cookie Consent,${key},"${value}"\n`;
-      });
-    }
-
-    // Set headers
-    res.setHeader('Content-Type', 'text/csv');
-    res.setHeader(
-      'Content-Disposition',
-      `attachment; filename="xpeditis-data-export-${user.id}-${Date.now()}.csv"`
-    );
-
-    res.send(csv);
-  }
-
-  /**
-   * Delete user data (GDPR Right to Erasure)
-   */
-  @Delete('delete-account')
-  @HttpCode(HttpStatus.NO_CONTENT)
-  @ApiOperation({
-    summary: 'Delete user account and data',
-    description: 'Permanently delete or anonymize user data (GDPR Article 17)',
-  })
-  @ApiResponse({
-    status: 204,
-    description: 'Account deletion initiated',
-  })
-  async deleteAccount(
-    @CurrentUser() user: UserPayload,
-    @Body() body: { reason?: string; confirmEmail: string }
-  ): Promise<void> {
-    // Verify email confirmation (security measure)
-    if (body.confirmEmail !== user.email) {
-      throw new Error('Email confirmation does not match');
-    }
-
-    await this.gdprService.deleteUserData(user.id, body.reason);
-  }
-
-  /**
-   * Record consent
-   */
-  @Post('consent')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'Record user consent',
-    description: 'Record consent for cookies (GDPR Article 7)',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Consent recorded',
-    type: ConsentResponseDto,
-  })
-  async recordConsent(
-    @CurrentUser() user: UserPayload,
-    @Body() body: UpdateConsentDto,
-    @Req() req: Request
-  ): Promise<ConsentResponseDto> {
-    // Add IP and user agent from request if not provided
-    const consentData: UpdateConsentDto = {
-      ...body,
-      ipAddress: body.ipAddress || req.ip || req.socket.remoteAddress,
-      userAgent: body.userAgent || req.headers['user-agent'],
-    };
-
-    return this.gdprService.recordConsent(user.id, consentData);
-  }
-
-  /**
-   * Withdraw consent
-   */
-  @Post('consent/withdraw')
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'Withdraw consent',
-    description: 'Withdraw consent for functional, analytics, or marketing (GDPR Article 7.3)',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Consent withdrawn',
-    type: ConsentResponseDto,
-  })
-  async withdrawConsent(
-    @CurrentUser() user: UserPayload,
-    @Body() body: WithdrawConsentDto
-  ): Promise<ConsentResponseDto> {
-    return this.gdprService.withdrawConsent(user.id, body.consentType);
-  }
-
-  /**
-   * Get consent status
-   */
-  @Get('consent')
-  @ApiOperation({
-    summary: 'Get current consent status',
-    description: 'Retrieve current consent preferences',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Consent status retrieved',
-    type: ConsentResponseDto,
-  })
-  async getConsentStatus(@CurrentUser() user: UserPayload): Promise<ConsentResponseDto | null> {
-    return this.gdprService.getConsentStatus(user.id);
-  }
-}

apps/backend/src/application/controllers/index.ts

@@ -1,2 +1 @@
-export * from './rates.controller';
-export * from './bookings.controller';
+export * from './health.controller';

apps/backend/src/application/controllers/invitations.controller.ts

@@ -1,180 +0,0 @@
-import {
-  Controller,
-  Post,
-  Get,
-  Body,
-  UseGuards,
-  HttpCode,
-  HttpStatus,
-  Logger,
-  Param,
-} from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiResponse, ApiBearerAuth, ApiParam } from '@nestjs/swagger';
-import { InvitationService } from '../services/invitation.service';
-import { CreateInvitationDto, InvitationResponseDto } from '../dto/invitation.dto';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { RolesGuard } from '../guards/roles.guard';
-import { Roles } from '../decorators/roles.decorator';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-import { Public } from '../decorators/public.decorator';
-import { UserRole } from '@domain/entities/user.entity';
-
-/**
- * Invitations Controller
- *
- * Handles user invitation endpoints:
- * - POST /invitations - Create invitation (admin/manager)
- * - GET /invitations/verify/:token - Verify invitation (public)
- * - GET /invitations - List organization invitations (admin/manager)
- */
-@ApiTags('Invitations')
-@Controller('invitations')
-export class InvitationsController {
-  private readonly logger = new Logger(InvitationsController.name);
-
-  constructor(private readonly invitationService: InvitationService) {}
-
-  /**
-   * Create invitation and send email
-   */
-  @Post()
-  @HttpCode(HttpStatus.CREATED)
-  @UseGuards(JwtAuthGuard, RolesGuard)
-  @Roles('admin', 'manager')
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Create invitation',
-    description: 'Send an invitation email to a new user. Admin/manager only.',
-  })
-  @ApiResponse({
-    status: 201,
-    description: 'Invitation created successfully',
-    type: InvitationResponseDto,
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin or manager role',
-  })
-  @ApiResponse({
-    status: 409,
-    description: 'Conflict - user or active invitation already exists',
-  })
-  async createInvitation(
-    @Body() dto: CreateInvitationDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<InvitationResponseDto> {
-    this.logger.log(`[User: ${user.email}] Creating invitation for: ${dto.email}`);
-
-    const invitation = await this.invitationService.createInvitation(
-      dto.email,
-      dto.firstName,
-      dto.lastName,
-      dto.role as unknown as UserRole,
-      user.organizationId,
-      user.id
-    );
-
-    return {
-      id: invitation.id,
-      token: invitation.token,
-      email: invitation.email,
-      firstName: invitation.firstName,
-      lastName: invitation.lastName,
-      role: invitation.role,
-      organizationId: invitation.organizationId,
-      expiresAt: invitation.expiresAt,
-      isUsed: invitation.isUsed,
-      usedAt: invitation.usedAt,
-      createdAt: invitation.createdAt,
-    };
-  }
-
-  /**
-   * Verify invitation token
-   */
-  @Get('verify/:token')
-  @Public()
-  @ApiOperation({
-    summary: 'Verify invitation token',
-    description: 'Check if an invitation token is valid and not expired. Public endpoint.',
-  })
-  @ApiParam({
-    name: 'token',
-    description: 'Invitation token',
-    example: 'abc123def456',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Invitation is valid',
-    type: InvitationResponseDto,
-  })
-  @ApiResponse({
-    status: 404,
-    description: 'Invitation not found',
-  })
-  @ApiResponse({
-    status: 400,
-    description: 'Invitation expired or already used',
-  })
-  async verifyInvitation(@Param('token') token: string): Promise<InvitationResponseDto> {
-    this.logger.log(`Verifying invitation token: ${token}`);
-
-    const invitation = await this.invitationService.verifyInvitation(token);
-
-    return {
-      id: invitation.id,
-      token: invitation.token,
-      email: invitation.email,
-      firstName: invitation.firstName,
-      lastName: invitation.lastName,
-      role: invitation.role,
-      organizationId: invitation.organizationId,
-      expiresAt: invitation.expiresAt,
-      isUsed: invitation.isUsed,
-      usedAt: invitation.usedAt,
-      createdAt: invitation.createdAt,
-    };
-  }
-
-  /**
-   * List organization invitations
-   */
-  @Get()
-  @UseGuards(JwtAuthGuard, RolesGuard)
-  @Roles('admin', 'manager')
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'List invitations',
-    description: 'Get all invitations for the current organization. Admin/manager only.',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Invitations retrieved successfully',
-    type: [InvitationResponseDto],
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin or manager role',
-  })
-  async listInvitations(@CurrentUser() user: UserPayload): Promise<InvitationResponseDto[]> {
-    this.logger.log(`[User: ${user.email}] Listing invitations for organization`);
-
-    const invitations = await this.invitationService.getOrganizationInvitations(
-      user.organizationId
-    );
-
-    return invitations.map(invitation => ({
-      id: invitation.id,
-      token: invitation.token,
-      email: invitation.email,
-      firstName: invitation.firstName,
-      lastName: invitation.lastName,
-      role: invitation.role,
-      organizationId: invitation.organizationId,
-      expiresAt: invitation.expiresAt,
-      isUsed: invitation.isUsed,
-      usedAt: invitation.usedAt,
-      createdAt: invitation.createdAt,
-    }));
-  }
-}

apps/backend/src/application/controllers/notifications.controller.ts

@@ -1,207 +0,0 @@
-/**
- * Notifications Controller
- *
- * REST API endpoints for managing notifications
- */
-
-import {
-  Controller,
-  Get,
-  Post,
-  Patch,
-  Delete,
-  Param,
-  Query,
-  UseGuards,
-  ParseIntPipe,
-  DefaultValuePipe,
-  NotFoundException,
-} from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiResponse, ApiBearerAuth, ApiQuery } from '@nestjs/swagger';
-import { NotificationService } from '../services/notification.service';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-import { Notification } from '@domain/entities/notification.entity';
-
-class NotificationResponseDto {
-  id: string;
-  type: string;
-  priority: string;
-  title: string;
-  message: string;
-  metadata?: Record<string, any>;
-  read: boolean;
-  readAt?: string;
-  actionUrl?: string;
-  createdAt: string;
-}
-
-@ApiTags('Notifications')
-@ApiBearerAuth()
-@Controller('notifications')
-@UseGuards(JwtAuthGuard)
-export class NotificationsController {
-  constructor(private readonly notificationService: NotificationService) {}
-
-  /**
-   * Get user's notifications
-   */
-  @Get()
-  @ApiOperation({ summary: 'Get user notifications' })
-  @ApiResponse({ status: 200, description: 'Notifications retrieved successfully' })
-  @ApiQuery({ name: 'read', required: false, description: 'Filter by read status' })
-  @ApiQuery({ name: 'page', required: false, description: 'Page number (default: 1)' })
-  @ApiQuery({ name: 'limit', required: false, description: 'Items per page (default: 20)' })
-  async getNotifications(
-    @CurrentUser() user: UserPayload,
-    @Query('read') read?: string,
-    @Query('page', new DefaultValuePipe(1), ParseIntPipe) page?: number,
-    @Query('limit', new DefaultValuePipe(20), ParseIntPipe) limit?: number
-  ): Promise<{
-    notifications: NotificationResponseDto[];
-    total: number;
-    page: number;
-    pageSize: number;
-  }> {
-    page = page || 1;
-    limit = limit || 20;
-
-    const filters: any = {
-      userId: user.id,
-      read: read !== undefined ? read === 'true' : undefined,
-      offset: (page - 1) * limit,
-      limit,
-    };
-
-    const { notifications, total } = await this.notificationService.getNotifications(filters);
-
-    return {
-      notifications: notifications.map(n => this.mapToDto(n)),
-      total,
-      page,
-      pageSize: limit,
-    };
-  }
-
-  /**
-   * Get unread notifications
-   */
-  @Get('unread')
-  @ApiOperation({ summary: 'Get unread notifications' })
-  @ApiResponse({ status: 200, description: 'Unread notifications retrieved successfully' })
-  @ApiQuery({
-    name: 'limit',
-    required: false,
-    description: 'Number of notifications (default: 50)',
-  })
-  async getUnreadNotifications(
-    @CurrentUser() user: UserPayload,
-    @Query('limit', new DefaultValuePipe(50), ParseIntPipe) limit?: number
-  ): Promise<NotificationResponseDto[]> {
-    limit = limit || 50;
-    const notifications = await this.notificationService.getUnreadNotifications(user.id, limit);
-    return notifications.map(n => this.mapToDto(n));
-  }
-
-  /**
-   * Get unread count
-   */
-  @Get('unread/count')
-  @ApiOperation({ summary: 'Get unread notifications count' })
-  @ApiResponse({ status: 200, description: 'Unread count retrieved successfully' })
-  async getUnreadCount(@CurrentUser() user: UserPayload): Promise<{ count: number }> {
-    const count = await this.notificationService.getUnreadCount(user.id);
-    return { count };
-  }
-
-  /**
-   * Get notification by ID
-   */
-  @Get(':id')
-  @ApiOperation({ summary: 'Get notification by ID' })
-  @ApiResponse({ status: 200, description: 'Notification retrieved successfully' })
-  @ApiResponse({ status: 404, description: 'Notification not found' })
-  async getNotificationById(
-    @CurrentUser() user: UserPayload,
-    @Param('id') id: string
-  ): Promise<NotificationResponseDto> {
-    const notification = await this.notificationService.getNotificationById(id);
-
-    if (!notification || notification.userId !== user.id) {
-      throw new NotFoundException('Notification not found');
-    }
-
-    return this.mapToDto(notification);
-  }
-
-  /**
-   * Mark notification as read
-   */
-  @Patch(':id/read')
-  @ApiOperation({ summary: 'Mark notification as read' })
-  @ApiResponse({ status: 200, description: 'Notification marked as read' })
-  @ApiResponse({ status: 404, description: 'Notification not found' })
-  async markAsRead(
-    @CurrentUser() user: UserPayload,
-    @Param('id') id: string
-  ): Promise<{ success: boolean }> {
-    const notification = await this.notificationService.getNotificationById(id);
-
-    if (!notification || notification.userId !== user.id) {
-      throw new NotFoundException('Notification not found');
-    }
-
-    await this.notificationService.markAsRead(id);
-    return { success: true };
-  }
-
-  /**
-   * Mark all notifications as read
-   */
-  @Post('read-all')
-  @ApiOperation({ summary: 'Mark all notifications as read' })
-  @ApiResponse({ status: 200, description: 'All notifications marked as read' })
-  async markAllAsRead(@CurrentUser() user: UserPayload): Promise<{ success: boolean }> {
-    await this.notificationService.markAllAsRead(user.id);
-    return { success: true };
-  }
-
-  /**
-   * Delete notification
-   */
-  @Delete(':id')
-  @ApiOperation({ summary: 'Delete notification' })
-  @ApiResponse({ status: 200, description: 'Notification deleted' })
-  @ApiResponse({ status: 404, description: 'Notification not found' })
-  async deleteNotification(
-    @CurrentUser() user: UserPayload,
-    @Param('id') id: string
-  ): Promise<{ success: boolean }> {
-    const notification = await this.notificationService.getNotificationById(id);
-
-    if (!notification || notification.userId !== user.id) {
-      throw new NotFoundException('Notification not found');
-    }
-
-    await this.notificationService.deleteNotification(id);
-    return { success: true };
-  }
-
-  /**
-   * Map notification entity to DTO
-   */
-  private mapToDto(notification: Notification): NotificationResponseDto {
-    return {
-      id: notification.id,
-      type: notification.type,
-      priority: notification.priority,
-      title: notification.title,
-      message: notification.message,
-      metadata: notification.metadata,
-      read: notification.read,
-      readAt: notification.readAt?.toISOString(),
-      actionUrl: notification.actionUrl,
-      createdAt: notification.createdAt.toISOString(),
-    };
-  }
-}

apps/backend/src/application/controllers/organizations.controller.ts

@@ -1,373 +0,0 @@
-import {
-  Controller,
-  Get,
-  Post,
-  Patch,
-  Param,
-  Body,
-  Query,
-  HttpCode,
-  HttpStatus,
-  Logger,
-  UsePipes,
-  ValidationPipe,
-  NotFoundException,
-  ParseUUIDPipe,
-  ParseIntPipe,
-  DefaultValuePipe,
-  UseGuards,
-  ForbiddenException,
-  Inject,
-} from '@nestjs/common';
-import {
-  ApiTags,
-  ApiOperation,
-  ApiResponse,
-  ApiBadRequestResponse,
-  ApiNotFoundResponse,
-  ApiQuery,
-  ApiParam,
-  ApiBearerAuth,
-} from '@nestjs/swagger';
-import {
-  CreateOrganizationDto,
-  UpdateOrganizationDto,
-  OrganizationResponseDto,
-  OrganizationListResponseDto,
-} from '../dto/organization.dto';
-import { OrganizationMapper } from '../mappers/organization.mapper';
-import {
-  OrganizationRepository,
-  ORGANIZATION_REPOSITORY,
-} from '@domain/ports/out/organization.repository';
-import { Organization, OrganizationType } from '@domain/entities/organization.entity';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { RolesGuard } from '../guards/roles.guard';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-import { Roles } from '../decorators/roles.decorator';
-import { v4 as uuidv4 } from 'uuid';
-
-/**
- * Organizations Controller
- *
- * Manages organization CRUD operations:
- * - Create organization (admin only)
- * - Get organization details
- * - Update organization (admin/manager)
- * - List organizations
- */
-@ApiTags('Organizations')
-@Controller('organizations')
-@UseGuards(JwtAuthGuard, RolesGuard)
-@ApiBearerAuth()
-export class OrganizationsController {
-  private readonly logger = new Logger(OrganizationsController.name);
-
-  constructor(
-    @Inject(ORGANIZATION_REPOSITORY) private readonly organizationRepository: OrganizationRepository
-  ) {}
-
-  /**
-   * Create a new organization
-   *
-   * Admin-only endpoint to create a new organization.
-   */
-  @Post()
-  @HttpCode(HttpStatus.CREATED)
-  @Roles('admin')
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  @ApiOperation({
-    summary: 'Create new organization',
-    description: 'Create a new organization (freight forwarder, carrier, or shipper). Admin-only.',
-  })
-  @ApiResponse({
-    status: HttpStatus.CREATED,
-    description: 'Organization created successfully',
-    type: OrganizationResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin role',
-  })
-  @ApiBadRequestResponse({
-    description: 'Invalid request parameters',
-  })
-  async createOrganization(
-    @Body() dto: CreateOrganizationDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<OrganizationResponseDto> {
-    this.logger.log(`[Admin: ${user.email}] Creating organization: ${dto.name} (${dto.type})`);
-
-    try {
-      // Check for duplicate name
-      const existingByName = await this.organizationRepository.findByName(dto.name);
-      if (existingByName) {
-        throw new ForbiddenException(`Organization with name "${dto.name}" already exists`);
-      }
-
-      // Check for duplicate SCAC if provided
-      if (dto.scac) {
-        const existingBySCAC = await this.organizationRepository.findBySCAC(dto.scac);
-        if (existingBySCAC) {
-          throw new ForbiddenException(`Organization with SCAC "${dto.scac}" already exists`);
-        }
-      }
-
-      // Create organization entity
-      const organization = Organization.create({
-        id: uuidv4(),
-        name: dto.name,
-        type: dto.type,
-        scac: dto.scac,
-        address: OrganizationMapper.mapDtoToAddress(dto.address),
-        logoUrl: dto.logoUrl,
-        documents: [],
-        isActive: true,
-      });
-
-      // Save to database
-      const savedOrg = await this.organizationRepository.save(organization);
-
-      this.logger.log(`Organization created successfully: ${savedOrg.name} (${savedOrg.id})`);
-
-      return OrganizationMapper.toDto(savedOrg);
-    } catch (error: any) {
-      this.logger.error(
-        `Organization creation failed: ${error?.message || 'Unknown error'}`,
-        error?.stack
-      );
-      throw error;
-    }
-  }
-
-  /**
-   * Get organization by ID
-   *
-   * Retrieve details of a specific organization.
-   * Users can only view their own organization unless they are admins.
-   */
-  @Get(':id')
-  @ApiOperation({
-    summary: 'Get organization by ID',
-    description:
-      'Retrieve organization details. Users can view their own organization, admins can view any.',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'Organization ID (UUID)',
-    example: '550e8400-e29b-41d4-a716-446655440000',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Organization details retrieved successfully',
-    type: OrganizationResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiNotFoundResponse({
-    description: 'Organization not found',
-  })
-  async getOrganization(
-    @Param('id', ParseUUIDPipe) id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<OrganizationResponseDto> {
-    this.logger.log(`[User: ${user.email}] Fetching organization: ${id}`);
-
-    const organization = await this.organizationRepository.findById(id);
-    if (!organization) {
-      throw new NotFoundException(`Organization ${id} not found`);
-    }
-
-    // Authorization: Users can only view their own organization (unless admin)
-    if (user.role !== 'ADMIN' && organization.id !== user.organizationId) {
-      throw new ForbiddenException('You can only view your own organization');
-    }
-
-    return OrganizationMapper.toDto(organization);
-  }
-
-  /**
-   * Update organization
-   *
-   * Update organization details (name, address, logo, status).
-   * Requires admin or manager role.
-   */
-  @Patch(':id')
-  @Roles('admin', 'manager')
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  @ApiOperation({
-    summary: 'Update organization',
-    description:
-      'Update organization details (name, address, logo, status). Requires admin or manager role.',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'Organization ID (UUID)',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Organization updated successfully',
-    type: OrganizationResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin or manager role',
-  })
-  @ApiNotFoundResponse({
-    description: 'Organization not found',
-  })
-  async updateOrganization(
-    @Param('id', ParseUUIDPipe) id: string,
-    @Body() dto: UpdateOrganizationDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<OrganizationResponseDto> {
-    this.logger.log(`[User: ${user.email}] Updating organization: ${id}`);
-
-    const organization = await this.organizationRepository.findById(id);
-    if (!organization) {
-      throw new NotFoundException(`Organization ${id} not found`);
-    }
-
-    // Authorization: Managers can only update their own organization
-    if (user.role === 'manager' && organization.id !== user.organizationId) {
-      throw new ForbiddenException('You can only update your own organization');
-    }
-
-    // Update fields
-    if (dto.name) {
-      organization.updateName(dto.name);
-    }
-
-    if (dto.siren) {
-      organization.updateSiren(dto.siren);
-    }
-
-    if (dto.eori) {
-      organization.updateEori(dto.eori);
-    }
-
-    if (dto.contact_phone) {
-      organization.updateContactPhone(dto.contact_phone);
-    }
-
-    if (dto.contact_email) {
-      organization.updateContactEmail(dto.contact_email);
-    }
-
-    if (dto.address) {
-      organization.updateAddress(OrganizationMapper.mapDtoToAddress(dto.address));
-    }
-
-    if (dto.logoUrl !== undefined) {
-      organization.updateLogoUrl(dto.logoUrl);
-    }
-
-    if (dto.isActive !== undefined) {
-      if (dto.isActive) {
-        organization.activate();
-      } else {
-        organization.deactivate();
-      }
-    }
-
-    // Save updated organization
-    const updatedOrg = await this.organizationRepository.save(organization);
-
-    this.logger.log(`Organization updated successfully: ${updatedOrg.id}`);
-
-    return OrganizationMapper.toDto(updatedOrg);
-  }
-
-  /**
-   * List organizations
-   *
-   * Retrieve a paginated list of organizations.
-   * Admins can see all, others see only their own.
-   */
-  @Get()
-  @ApiOperation({
-    summary: 'List organizations',
-    description:
-      'Retrieve a paginated list of organizations. Admins see all, others see only their own.',
-  })
-  @ApiQuery({
-    name: 'page',
-    required: false,
-    description: 'Page number (1-based)',
-    example: 1,
-  })
-  @ApiQuery({
-    name: 'pageSize',
-    required: false,
-    description: 'Number of items per page',
-    example: 20,
-  })
-  @ApiQuery({
-    name: 'type',
-    required: false,
-    description: 'Filter by organization type',
-    enum: OrganizationType,
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Organizations list retrieved successfully',
-    type: OrganizationListResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  async listOrganizations(
-    @Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number,
-    @Query('pageSize', new DefaultValuePipe(20), ParseIntPipe) pageSize: number,
-    @Query('type') type: OrganizationType | undefined,
-    @CurrentUser() user: UserPayload
-  ): Promise<OrganizationListResponseDto> {
-    this.logger.log(
-      `[User: ${user.email}] Listing organizations: page=${page}, pageSize=${pageSize}, type=${type}`
-    );
-
-    // Fetch organizations
-    let organizations: Organization[];
-
-    if (user.role === 'ADMIN') {
-      // Admins can see all organizations
-      organizations = await this.organizationRepository.findAll();
-    } else {
-      // Others see only their own organization
-      const userOrg = await this.organizationRepository.findById(user.organizationId);
-      organizations = userOrg ? [userOrg] : [];
-    }
-
-    // Filter by type if provided
-    const filteredOrgs = type ? organizations.filter(org => org.type === type) : organizations;
-
-    // Paginate
-    const startIndex = (page - 1) * pageSize;
-    const endIndex = startIndex + pageSize;
-    const paginatedOrgs = filteredOrgs.slice(startIndex, endIndex);
-
-    // Convert to DTOs
-    const orgDtos = OrganizationMapper.toDtoArray(paginatedOrgs);
-
-    const totalPages = Math.ceil(filteredOrgs.length / pageSize);
-
-    return {
-      organizations: orgDtos,
-      total: filteredOrgs.length,
-      page,
-      pageSize,
-      totalPages,
-    };
-  }
-}

apps/backend/src/application/controllers/ports.controller.ts

@@ -1,98 +0,0 @@
-import {
-  Controller,
-  Get,
-  Query,
-  HttpCode,
-  HttpStatus,
-  Logger,
-  UsePipes,
-  ValidationPipe,
-  UseGuards,
-} from '@nestjs/common';
-import {
-  ApiTags,
-  ApiOperation,
-  ApiResponse,
-  ApiBadRequestResponse,
-  ApiInternalServerErrorResponse,
-  ApiBearerAuth,
-} from '@nestjs/swagger';
-import { PortSearchRequestDto, PortSearchResponseDto } from '../dto/port.dto';
-import { PortMapper } from '../mappers/port.mapper';
-import { PortSearchService } from '@domain/services/port-search.service';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-
-@ApiTags('Ports')
-@Controller('ports')
-@ApiBearerAuth()
-export class PortsController {
-  private readonly logger = new Logger(PortsController.name);
-
-  constructor(private readonly portSearchService: PortSearchService) {}
-
-  @Get('search')
-  @UseGuards(JwtAuthGuard)
-  @HttpCode(HttpStatus.OK)
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  @ApiOperation({
-    summary: 'Search ports (autocomplete)',
-    description:
-      'Search for maritime ports by name, city, or UN/LOCODE code. Returns up to 50 results ordered by relevance. Requires authentication.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Port search completed successfully',
-    type: PortSearchResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiBadRequestResponse({
-    description: 'Invalid request parameters',
-    schema: {
-      example: {
-        statusCode: 400,
-        message: ['query must be a string'],
-        error: 'Bad Request',
-      },
-    },
-  })
-  @ApiInternalServerErrorResponse({
-    description: 'Internal server error',
-  })
-  async searchPorts(
-    @Query() dto: PortSearchRequestDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<PortSearchResponseDto> {
-    const startTime = Date.now();
-    this.logger.log(
-      `[User: ${user.email}] Searching ports: query="${dto.query}", limit=${dto.limit || 10}, country=${dto.countryFilter || 'all'}`
-    );
-
-    try {
-      // Call domain service
-      const result = await this.portSearchService.search({
-        query: dto.query,
-        limit: dto.limit,
-        countryFilter: dto.countryFilter,
-      });
-
-      const duration = Date.now() - startTime;
-      this.logger.log(
-        `[User: ${user.email}] Port search completed: ${result.totalMatches} results in ${duration}ms`
-      );
-
-      // Map to response DTO
-      return PortMapper.toSearchResponseDto(result.ports, result.totalMatches);
-    } catch (error: any) {
-      const duration = Date.now() - startTime;
-      this.logger.error(
-        `[User: ${user.email}] Port search failed after ${duration}ms: ${error?.message || 'Unknown error'}`,
-        error?.stack
-      );
-      throw error;
-    }
-  }
-}

apps/backend/src/application/controllers/rates.controller.ts

@@ -1,346 +0,0 @@
-import {
-  Controller,
-  Post,
-  Get,
-  Body,
-  HttpCode,
-  HttpStatus,
-  Logger,
-  UsePipes,
-  ValidationPipe,
-  UseGuards,
-} from '@nestjs/common';
-import {
-  ApiTags,
-  ApiOperation,
-  ApiResponse,
-  ApiBadRequestResponse,
-  ApiInternalServerErrorResponse,
-  ApiBearerAuth,
-} from '@nestjs/swagger';
-import { RateSearchRequestDto, RateSearchResponseDto } from '../dto';
-import { RateQuoteMapper } from '../mappers';
-import { RateSearchService } from '@domain/services/rate-search.service';
-import { CsvRateSearchService } from '@domain/services/csv-rate-search.service';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-import { CsvRateSearchDto, CsvRateSearchResponseDto } from '../dto/csv-rate-search.dto';
-import { AvailableCompaniesDto, FilterOptionsDto } from '../dto/csv-rate-upload.dto';
-import { CsvRateMapper } from '../mappers/csv-rate.mapper';
-
-@ApiTags('Rates')
-@Controller('rates')
-@ApiBearerAuth()
-export class RatesController {
-  private readonly logger = new Logger(RatesController.name);
-
-  constructor(
-    private readonly rateSearchService: RateSearchService,
-    private readonly csvRateSearchService: CsvRateSearchService,
-    private readonly csvRateMapper: CsvRateMapper
-  ) {}
-
-  @Post('search')
-  @UseGuards(JwtAuthGuard)
-  @HttpCode(HttpStatus.OK)
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  @ApiOperation({
-    summary: 'Search shipping rates',
-    description:
-      'Search for available shipping rates from multiple carriers. Results are cached for 15 minutes. Requires authentication.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Rate search completed successfully',
-    type: RateSearchResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiBadRequestResponse({
-    description: 'Invalid request parameters',
-    schema: {
-      example: {
-        statusCode: 400,
-        message: ['Origin must be a valid 5-character UN/LOCODE (e.g., NLRTM)'],
-        error: 'Bad Request',
-      },
-    },
-  })
-  @ApiInternalServerErrorResponse({
-    description: 'Internal server error',
-  })
-  async searchRates(
-    @Body() dto: RateSearchRequestDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<RateSearchResponseDto> {
-    const startTime = Date.now();
-    this.logger.log(
-      `[User: ${user.email}] Searching rates: ${dto.origin} → ${dto.destination}, ${dto.containerType}`
-    );
-
-    try {
-      // Convert DTO to domain input
-      const searchInput = {
-        origin: dto.origin,
-        destination: dto.destination,
-        containerType: dto.containerType,
-        mode: dto.mode,
-        departureDate: new Date(dto.departureDate),
-        quantity: dto.quantity,
-        weight: dto.weight,
-        volume: dto.volume,
-        isHazmat: dto.isHazmat,
-        imoClass: dto.imoClass,
-      };
-
-      // Execute search
-      const result = await this.rateSearchService.execute(searchInput);
-
-      // Convert domain entities to DTOs
-      const quoteDtos = RateQuoteMapper.toDtoArray(result.quotes);
-
-      const responseTimeMs = Date.now() - startTime;
-      this.logger.log(`Rate search completed: ${quoteDtos.length} quotes, ${responseTimeMs}ms`);
-
-      return {
-        quotes: quoteDtos,
-        count: quoteDtos.length,
-        origin: dto.origin,
-        destination: dto.destination,
-        departureDate: dto.departureDate,
-        containerType: dto.containerType,
-        mode: dto.mode,
-        fromCache: false, // TODO: Implement cache detection
-        responseTimeMs,
-      };
-    } catch (error: any) {
-      this.logger.error(`Rate search failed: ${error?.message || 'Unknown error'}`, error?.stack);
-      throw error;
-    }
-  }
-
-  /**
-   * Search CSV-based rates with advanced filters
-   */
-  @Post('search-csv')
-  @UseGuards(JwtAuthGuard)
-  @HttpCode(HttpStatus.OK)
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  @ApiOperation({
-    summary: 'Search CSV-based rates with advanced filters',
-    description:
-      'Search for rates from CSV-loaded carriers (SSC, ECU, TCC, NVO) with advanced filtering options including volume, weight, pallets, price range, transit time, and more.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'CSV rate search completed successfully',
-    type: CsvRateSearchResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiBadRequestResponse({
-    description: 'Invalid request parameters',
-  })
-  async searchCsvRates(
-    @Body() dto: CsvRateSearchDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<CsvRateSearchResponseDto> {
-    const startTime = Date.now();
-    this.logger.log(
-      `[User: ${user.email}] Searching CSV rates: ${dto.origin} → ${dto.destination}, ${dto.volumeCBM} CBM, ${dto.weightKG} kg`
-    );
-
-    try {
-      // Map DTO to domain input
-      const searchInput = {
-        origin: dto.origin,
-        destination: dto.destination,
-        volumeCBM: dto.volumeCBM,
-        weightKG: dto.weightKG,
-        palletCount: dto.palletCount ?? 0,
-        containerType: dto.containerType,
-        filters: this.csvRateMapper.mapFiltersDtoToDomain(dto.filters),
-
-        // Service requirements for detailed pricing
-        hasDangerousGoods: dto.hasDangerousGoods ?? false,
-        requiresSpecialHandling: dto.requiresSpecialHandling ?? false,
-        requiresTailgate: dto.requiresTailgate ?? false,
-        requiresStraps: dto.requiresStraps ?? false,
-        requiresThermalCover: dto.requiresThermalCover ?? false,
-        hasRegulatedProducts: dto.hasRegulatedProducts ?? false,
-        requiresAppointment: dto.requiresAppointment ?? false,
-      };
-
-      // Execute CSV rate search
-      const result = await this.csvRateSearchService.execute(searchInput);
-
-      // Map domain output to response DTO
-      const response = this.csvRateMapper.mapSearchOutputToResponseDto(result);
-
-      const responseTimeMs = Date.now() - startTime;
-      this.logger.log(
-        `CSV rate search completed: ${response.totalResults} results, ${responseTimeMs}ms`
-      );
-
-      return response;
-    } catch (error: any) {
-      this.logger.error(
-        `CSV rate search failed: ${error?.message || 'Unknown error'}`,
-        error?.stack
-      );
-      throw error;
-    }
-  }
-
-  /**
-   * Search CSV-based rates with service level offers (RAPID, STANDARD, ECONOMIC)
-   */
-  @Post('search-csv-offers')
-  @UseGuards(JwtAuthGuard)
-  @HttpCode(HttpStatus.OK)
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  @ApiOperation({
-    summary: 'Search CSV-based rates with service level offers',
-    description:
-      'Search for rates from CSV-loaded carriers and generate 3 service level offers for each matching rate: RAPID (20% more expensive, 30% faster), STANDARD (base price and transit), ECONOMIC (15% cheaper, 50% slower). Results are sorted by price (cheapest first).',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'CSV rate search with offers completed successfully',
-    type: CsvRateSearchResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiBadRequestResponse({
-    description: 'Invalid request parameters',
-  })
-  async searchCsvRatesWithOffers(
-    @Body() dto: CsvRateSearchDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<CsvRateSearchResponseDto> {
-    const startTime = Date.now();
-    this.logger.log(
-      `[User: ${user.email}] Searching CSV rates with offers: ${dto.origin} → ${dto.destination}, ${dto.volumeCBM} CBM, ${dto.weightKG} kg`
-    );
-
-    try {
-      // Map DTO to domain input
-      const searchInput = {
-        origin: dto.origin,
-        destination: dto.destination,
-        volumeCBM: dto.volumeCBM,
-        weightKG: dto.weightKG,
-        palletCount: dto.palletCount ?? 0,
-        containerType: dto.containerType,
-        filters: this.csvRateMapper.mapFiltersDtoToDomain(dto.filters),
-
-        // Service requirements for detailed pricing
-        hasDangerousGoods: dto.hasDangerousGoods ?? false,
-        requiresSpecialHandling: dto.requiresSpecialHandling ?? false,
-        requiresTailgate: dto.requiresTailgate ?? false,
-        requiresStraps: dto.requiresStraps ?? false,
-        requiresThermalCover: dto.requiresThermalCover ?? false,
-        hasRegulatedProducts: dto.hasRegulatedProducts ?? false,
-        requiresAppointment: dto.requiresAppointment ?? false,
-      };
-
-      // Execute CSV rate search WITH OFFERS GENERATION
-      const result = await this.csvRateSearchService.executeWithOffers(searchInput);
-
-      // Map domain output to response DTO
-      const response = this.csvRateMapper.mapSearchOutputToResponseDto(result);
-
-      const responseTimeMs = Date.now() - startTime;
-      this.logger.log(
-        `CSV rate search with offers completed: ${response.totalResults} results (including 3 offers per rate), ${responseTimeMs}ms`
-      );
-
-      return response;
-    } catch (error: any) {
-      this.logger.error(
-        `CSV rate search with offers failed: ${error?.message || 'Unknown error'}`,
-        error?.stack
-      );
-      throw error;
-    }
-  }
-
-  /**
-   * Get available companies
-   */
-  @Get('companies')
-  @UseGuards(JwtAuthGuard)
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'Get available carrier companies',
-    description: 'Returns list of all available carrier companies in the CSV rate system.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'List of available companies',
-    type: AvailableCompaniesDto,
-  })
-  async getCompanies(): Promise<AvailableCompaniesDto> {
-    this.logger.log('Fetching available companies');
-
-    try {
-      const companies = await this.csvRateSearchService.getAvailableCompanies();
-
-      return {
-        companies,
-        total: companies.length,
-      };
-    } catch (error: any) {
-      this.logger.error(
-        `Failed to fetch companies: ${error?.message || 'Unknown error'}`,
-        error?.stack
-      );
-      throw error;
-    }
-  }
-
-  /**
-   * Get filter options
-   */
-  @Get('filters/options')
-  @UseGuards(JwtAuthGuard)
-  @HttpCode(HttpStatus.OK)
-  @ApiOperation({
-    summary: 'Get available filter options',
-    description:
-      'Returns available options for all filters (companies, container types, currencies).',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Available filter options',
-    type: FilterOptionsDto,
-  })
-  async getFilterOptions(): Promise<FilterOptionsDto> {
-    this.logger.log('Fetching filter options');
-
-    try {
-      const [companies, containerTypes] = await Promise.all([
-        this.csvRateSearchService.getAvailableCompanies(),
-        this.csvRateSearchService.getAvailableContainerTypes(),
-      ]);
-
-      return {
-        companies,
-        containerTypes,
-        currencies: ['USD', 'EUR'],
-      };
-    } catch (error: any) {
-      this.logger.error(
-        `Failed to fetch filter options: ${error?.message || 'Unknown error'}`,
-        error?.stack
-      );
-      throw error;
-    }
-  }
-}

apps/backend/src/application/controllers/subscriptions.controller.ts

@@ -1,266 +0,0 @@
-/**
- * Subscriptions Controller
- *
- * Handles subscription management endpoints:
- * - GET /subscriptions - Get subscription overview
- * - GET /subscriptions/plans - Get all available plans
- * - GET /subscriptions/can-invite - Check if can invite users
- * - POST /subscriptions/checkout - Create Stripe checkout session
- * - POST /subscriptions/portal - Create Stripe portal session
- * - POST /subscriptions/webhook - Handle Stripe webhooks
- */
-
-import {
-  Controller,
-  Get,
-  Post,
-  Body,
-  UseGuards,
-  HttpCode,
-  HttpStatus,
-  Logger,
-  Headers,
-  RawBodyRequest,
-  Req,
-} from '@nestjs/common';
-import {
-  ApiTags,
-  ApiOperation,
-  ApiResponse,
-  ApiBearerAuth,
-  ApiExcludeEndpoint,
-} from '@nestjs/swagger';
-import { Request } from 'express';
-import { SubscriptionService } from '../services/subscription.service';
-import {
-  CreateCheckoutSessionDto,
-  CreatePortalSessionDto,
-  SyncSubscriptionDto,
-  SubscriptionOverviewResponseDto,
-  CanInviteResponseDto,
-  CheckoutSessionResponseDto,
-  PortalSessionResponseDto,
-  AllPlansResponseDto,
-} from '../dto/subscription.dto';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { RolesGuard } from '../guards/roles.guard';
-import { Roles } from '../decorators/roles.decorator';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-import { Public } from '../decorators/public.decorator';
-
-@ApiTags('Subscriptions')
-@Controller('subscriptions')
-export class SubscriptionsController {
-  private readonly logger = new Logger(SubscriptionsController.name);
-
-  constructor(private readonly subscriptionService: SubscriptionService) {}
-
-  /**
-   * Get subscription overview for current organization
-   */
-  @Get()
-  @UseGuards(JwtAuthGuard, RolesGuard)
-  @Roles('admin', 'manager')
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Get subscription overview',
-    description:
-      'Get the subscription details including licenses for the current organization. Admin/manager only.',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Subscription overview retrieved successfully',
-    type: SubscriptionOverviewResponseDto,
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin or manager role',
-  })
-  async getSubscriptionOverview(
-    @CurrentUser() user: UserPayload,
-  ): Promise<SubscriptionOverviewResponseDto> {
-    this.logger.log(`[User: ${user.email}] Getting subscription overview`);
-    return this.subscriptionService.getSubscriptionOverview(user.organizationId);
-  }
-
-  /**
-   * Get all available plans
-   */
-  @Get('plans')
-  @UseGuards(JwtAuthGuard)
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Get all plans',
-    description: 'Get details of all available subscription plans.',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Plans retrieved successfully',
-    type: AllPlansResponseDto,
-  })
-  getAllPlans(): AllPlansResponseDto {
-    this.logger.log('Getting all subscription plans');
-    return this.subscriptionService.getAllPlans();
-  }
-
-  /**
-   * Check if organization can invite more users
-   */
-  @Get('can-invite')
-  @UseGuards(JwtAuthGuard, RolesGuard)
-  @Roles('admin', 'manager')
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Check license availability',
-    description:
-      'Check if the organization can invite more users based on license availability. Admin/manager only.',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'License availability check result',
-    type: CanInviteResponseDto,
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin or manager role',
-  })
-  async canInvite(@CurrentUser() user: UserPayload): Promise<CanInviteResponseDto> {
-    this.logger.log(`[User: ${user.email}] Checking license availability`);
-    return this.subscriptionService.canInviteUser(user.organizationId);
-  }
-
-  /**
-   * Create Stripe Checkout session for subscription upgrade
-   */
-  @Post('checkout')
-  @HttpCode(HttpStatus.OK)
-  @UseGuards(JwtAuthGuard, RolesGuard)
-  @Roles('admin', 'manager')
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Create checkout session',
-    description:
-      'Create a Stripe Checkout session for upgrading subscription. Admin/Manager only.',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Checkout session created successfully',
-    type: CheckoutSessionResponseDto,
-  })
-  @ApiResponse({
-    status: 400,
-    description: 'Bad request - invalid plan or already subscribed',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin or manager role',
-  })
-  async createCheckoutSession(
-    @Body() dto: CreateCheckoutSessionDto,
-    @CurrentUser() user: UserPayload,
-  ): Promise<CheckoutSessionResponseDto> {
-    this.logger.log(`[User: ${user.email}] Creating checkout session for plan: ${dto.plan}`);
-    return this.subscriptionService.createCheckoutSession(
-      user.organizationId,
-      user.id,
-      dto,
-    );
-  }
-
-  /**
-   * Create Stripe Customer Portal session
-   */
-  @Post('portal')
-  @HttpCode(HttpStatus.OK)
-  @UseGuards(JwtAuthGuard, RolesGuard)
-  @Roles('admin', 'manager')
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Create portal session',
-    description:
-      'Create a Stripe Customer Portal session for subscription management. Admin/Manager only.',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Portal session created successfully',
-    type: PortalSessionResponseDto,
-  })
-  @ApiResponse({
-    status: 400,
-    description: 'Bad request - no Stripe customer found',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin or manager role',
-  })
-  async createPortalSession(
-    @Body() dto: CreatePortalSessionDto,
-    @CurrentUser() user: UserPayload,
-  ): Promise<PortalSessionResponseDto> {
-    this.logger.log(`[User: ${user.email}] Creating portal session`);
-    return this.subscriptionService.createPortalSession(user.organizationId, dto);
-  }
-
-  /**
-   * Sync subscription from Stripe
-   * Useful when webhooks are not available (e.g., local development)
-   */
-  @Post('sync')
-  @HttpCode(HttpStatus.OK)
-  @UseGuards(JwtAuthGuard, RolesGuard)
-  @Roles('admin', 'manager')
-  @ApiBearerAuth()
-  @ApiOperation({
-    summary: 'Sync subscription from Stripe',
-    description:
-      'Manually sync subscription data from Stripe. Useful when webhooks are not working (local dev). Pass sessionId after checkout to sync new subscription. Admin/Manager only.',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'Subscription synced successfully',
-    type: SubscriptionOverviewResponseDto,
-  })
-  @ApiResponse({
-    status: 400,
-    description: 'Bad request - no Stripe subscription found',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin or manager role',
-  })
-  async syncFromStripe(
-    @Body() dto: SyncSubscriptionDto,
-    @CurrentUser() user: UserPayload,
-  ): Promise<SubscriptionOverviewResponseDto> {
-    this.logger.log(
-      `[User: ${user.email}] Syncing subscription from Stripe${dto.sessionId ? ` (sessionId: ${dto.sessionId})` : ''}`,
-    );
-    return this.subscriptionService.syncFromStripe(user.organizationId, dto.sessionId);
-  }
-
-  /**
-   * Handle Stripe webhook events
-   */
-  @Post('webhook')
-  @Public()
-  @HttpCode(HttpStatus.OK)
-  @ApiExcludeEndpoint()
-  async handleWebhook(
-    @Headers('stripe-signature') signature: string,
-    @Req() req: RawBodyRequest<Request>,
-  ): Promise<{ received: boolean }> {
-    const rawBody = req.rawBody;
-    if (!rawBody) {
-      this.logger.error('No raw body found in request');
-      return { received: false };
-    }
-
-    try {
-      await this.subscriptionService.handleStripeWebhook(rawBody, signature);
-      return { received: true };
-    } catch (error) {
-      this.logger.error('Webhook processing failed', error);
-      return { received: false };
-    }
-  }
-}

apps/backend/src/application/controllers/users.controller.ts

@@ -1,503 +0,0 @@
-import {
-  Controller,
-  Get,
-  Post,
-  Patch,
-  Delete,
-  Param,
-  Body,
-  Query,
-  HttpCode,
-  HttpStatus,
-  Logger,
-  UsePipes,
-  ValidationPipe,
-  NotFoundException,
-  BadRequestException,
-  ParseUUIDPipe,
-  ParseIntPipe,
-  DefaultValuePipe,
-  UseGuards,
-  ForbiddenException,
-  ConflictException,
-  Inject,
-} from '@nestjs/common';
-import {
-  ApiTags,
-  ApiOperation,
-  ApiResponse,
-  ApiBadRequestResponse,
-  ApiNotFoundResponse,
-  ApiQuery,
-  ApiParam,
-  ApiBearerAuth,
-} from '@nestjs/swagger';
-import {
-  CreateUserDto,
-  UpdateUserDto,
-  UpdatePasswordDto,
-  UserResponseDto,
-  UserListResponseDto,
-} from '../dto/user.dto';
-import { UserMapper } from '../mappers/user.mapper';
-import { UserRepository, USER_REPOSITORY } from '@domain/ports/out/user.repository';
-import { User, UserRole as DomainUserRole } from '@domain/entities/user.entity';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { RolesGuard } from '../guards/roles.guard';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-import { Roles } from '../decorators/roles.decorator';
-import { v4 as uuidv4 } from 'uuid';
-import * as argon2 from 'argon2';
-import * as crypto from 'crypto';
-import { SubscriptionService } from '../services/subscription.service';
-
-/**
- * Users Controller
- *
- * Manages user CRUD operations:
- * - Create user / Invite user (admin/manager)
- * - Get user details
- * - Update user (admin/manager)
- * - Delete/deactivate user (admin)
- * - List users in organization
- * - Update own password
- */
-@ApiTags('Users')
-@Controller('users')
-@UseGuards(JwtAuthGuard, RolesGuard)
-@ApiBearerAuth()
-export class UsersController {
-  private readonly logger = new Logger(UsersController.name);
-
-  constructor(
-    @Inject(USER_REPOSITORY) private readonly userRepository: UserRepository,
-    private readonly subscriptionService: SubscriptionService,
-  ) {}
-
-  /**
-   * Create/Invite a new user
-   *
-   * Admin can create users in any organization.
-   * Manager can only create users in their own organization.
-   */
-  @Post()
-  @HttpCode(HttpStatus.CREATED)
-  @Roles('admin', 'manager')
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  @ApiOperation({
-    summary: 'Create/Invite new user',
-    description:
-      'Create a new user account. Admin can create in any org, manager only in their own.',
-  })
-  @ApiResponse({
-    status: HttpStatus.CREATED,
-    description: 'User created successfully',
-    type: UserResponseDto,
-  })
-  @ApiResponse({
-    status: 401,
-    description: 'Unauthorized - missing or invalid token',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin or manager role',
-  })
-  @ApiBadRequestResponse({
-    description: 'Invalid request parameters',
-  })
-  async createUser(
-    @Body() dto: CreateUserDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<UserResponseDto> {
-    this.logger.log(`[User: ${user.email}] Creating user: ${dto.email} (${dto.role})`);
-
-    // Authorization: Only ADMIN can assign ADMIN role
-    if (dto.role === 'ADMIN' && user.role !== 'ADMIN') {
-      throw new ForbiddenException('Only platform administrators can create users with ADMIN role');
-    }
-
-    // Authorization: Managers can only create users in their own organization
-    if (user.role === 'MANAGER' && dto.organizationId !== user.organizationId) {
-      throw new ForbiddenException('You can only create users in your own organization');
-    }
-
-    // Check if user already exists
-    const existingUser = await this.userRepository.findByEmail(dto.email);
-    if (existingUser) {
-      throw new ConflictException('User with this email already exists');
-    }
-
-    // Generate temporary password if not provided
-    const tempPassword = dto.password || this.generateTemporaryPassword();
-
-    // Hash password with Argon2id
-    const passwordHash = await argon2.hash(tempPassword, {
-      type: argon2.argon2id,
-      memoryCost: 65536, // 64 MB
-      timeCost: 3,
-      parallelism: 4,
-    });
-
-    // Map DTO role to Domain role
-    const domainRole = dto.role as unknown as DomainUserRole;
-
-    // Create user entity
-    const newUser = User.create({
-      id: uuidv4(),
-      organizationId: dto.organizationId,
-      email: dto.email,
-      passwordHash,
-      firstName: dto.firstName,
-      lastName: dto.lastName,
-      role: domainRole,
-    });
-
-    // Save to database
-    const savedUser = await this.userRepository.save(newUser);
-
-    this.logger.log(`User created successfully: ${savedUser.id}`);
-
-    // TODO: Send invitation email with temporary password
-    this.logger.warn(
-      `TODO: Send invitation email to ${dto.email} with temp password: ${tempPassword}`
-    );
-
-    return UserMapper.toDto(savedUser);
-  }
-
-  /**
-   * Get user by ID
-   */
-  @Get(':id')
-  @Roles('admin', 'manager')
-  @ApiOperation({
-    summary: 'Get user by ID',
-    description: 'Retrieve user details. Only ADMIN and MANAGER can access this endpoint.',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'User ID (UUID)',
-    example: '550e8400-e29b-41d4-a716-446655440000',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'User details retrieved successfully',
-    type: UserResponseDto,
-  })
-  @ApiNotFoundResponse({
-    description: 'User not found',
-  })
-  async getUser(
-    @Param('id', ParseUUIDPipe) id: string,
-    @CurrentUser() currentUser: UserPayload
-  ): Promise<UserResponseDto> {
-    this.logger.log(`[User: ${currentUser.email}] Fetching user: ${id}`);
-
-    const user = await this.userRepository.findById(id);
-    if (!user) {
-      throw new NotFoundException(`User ${id} not found`);
-    }
-
-    // Authorization: Can only view users in same organization (unless admin)
-    if (currentUser.role !== 'ADMIN' && user.organizationId !== currentUser.organizationId) {
-      throw new ForbiddenException('You can only view users in your organization');
-    }
-
-    return UserMapper.toDto(user);
-  }
-
-  /**
-   * Update user
-   */
-  @Patch(':id')
-  @Roles('admin', 'manager')
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  @ApiOperation({
-    summary: 'Update user',
-    description: 'Update user details (name, role, status). Admin/manager only.',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'User ID (UUID)',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'User updated successfully',
-    type: UserResponseDto,
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin or manager role',
-  })
-  @ApiNotFoundResponse({
-    description: 'User not found',
-  })
-  async updateUser(
-    @Param('id', ParseUUIDPipe) id: string,
-    @Body() dto: UpdateUserDto,
-    @CurrentUser() currentUser: UserPayload
-  ): Promise<UserResponseDto> {
-    this.logger.log(`[User: ${currentUser.email}] Updating user: ${id}`);
-
-    const user = await this.userRepository.findById(id);
-    if (!user) {
-      throw new NotFoundException(`User ${id} not found`);
-    }
-
-    // Security: Prevent users from changing their own role
-    if (dto.role && id === currentUser.id) {
-      this.logger.warn(`[SECURITY] User ${currentUser.email} attempted to change their own role`);
-      throw new BadRequestException('You cannot change your own role');
-    }
-
-    // Authorization: Only ADMIN can assign ADMIN role
-    if (dto.role === 'ADMIN' && currentUser.role !== 'ADMIN') {
-      throw new ForbiddenException('Only platform administrators can assign ADMIN role');
-    }
-
-    // Authorization: Managers can only update users in their own organization
-    if (currentUser.role === 'MANAGER' && user.organizationId !== currentUser.organizationId) {
-      throw new ForbiddenException('You can only update users in your own organization');
-    }
-
-    // Update fields
-    if (dto.firstName) {
-      user.updateFirstName(dto.firstName);
-    }
-
-    if (dto.lastName) {
-      user.updateLastName(dto.lastName);
-    }
-
-    if (dto.role) {
-      const domainRole = dto.role as unknown as DomainUserRole;
-      user.updateRole(domainRole);
-    }
-
-    if (dto.isActive !== undefined) {
-      if (dto.isActive) {
-        user.activate();
-        // Reallocate license if reactivating user
-        try {
-          await this.subscriptionService.allocateLicense(id, user.organizationId);
-          this.logger.log(`License reallocated for reactivated user: ${id}`);
-        } catch (error) {
-          this.logger.error(`Failed to reallocate license for user ${id}:`, error);
-          throw new ForbiddenException(
-            'Cannot reactivate user: no licenses available. Please upgrade your subscription.',
-          );
-        }
-      } else {
-        user.deactivate();
-        // Revoke license when deactivating user
-        await this.subscriptionService.revokeLicense(id);
-        this.logger.log(`License revoked for deactivated user: ${id}`);
-      }
-    }
-
-    // Save updated user
-    const updatedUser = await this.userRepository.save(user);
-
-    this.logger.log(`User updated successfully: ${updatedUser.id}`);
-
-    return UserMapper.toDto(updatedUser);
-  }
-
-  /**
-   * Delete/deactivate user
-   */
-  @Delete(':id')
-  @Roles('admin')
-  @ApiOperation({
-    summary: 'Delete user',
-    description: 'Deactivate a user account. Admin only.',
-  })
-  @ApiParam({
-    name: 'id',
-    description: 'User ID (UUID)',
-  })
-  @ApiResponse({
-    status: HttpStatus.NO_CONTENT,
-    description: 'User deactivated successfully',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Forbidden - requires admin role',
-  })
-  @ApiNotFoundResponse({
-    description: 'User not found',
-  })
-  async deleteUser(
-    @Param('id', ParseUUIDPipe) id: string,
-    @CurrentUser() currentUser: UserPayload
-  ): Promise<void> {
-    this.logger.log(`[Admin: ${currentUser.email}] Deleting user: ${id}`);
-
-    const user = await this.userRepository.findById(id);
-    if (!user) {
-      throw new NotFoundException(`User ${id} not found`);
-    }
-
-    // Revoke license before deleting user
-    await this.subscriptionService.revokeLicense(id);
-    this.logger.log(`License revoked for user being deleted: ${id}`);
-
-    // Permanently delete user from database
-    await this.userRepository.deleteById(id);
-
-    this.logger.log(`User deleted successfully: ${id}`);
-  }
-
-  /**
-   * List users in organization
-   */
-  @Get()
-  @Roles('admin', 'manager')
-  @ApiOperation({
-    summary: 'List users',
-    description:
-      'Retrieve a paginated list of users in your organization. Only ADMIN and MANAGER can access this endpoint.',
-  })
-  @ApiQuery({
-    name: 'page',
-    required: false,
-    description: 'Page number (1-based)',
-    example: 1,
-  })
-  @ApiQuery({
-    name: 'pageSize',
-    required: false,
-    description: 'Number of items per page',
-    example: 20,
-  })
-  @ApiQuery({
-    name: 'role',
-    required: false,
-    description: 'Filter by role',
-    enum: ['admin', 'manager', 'user', 'viewer'],
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Users list retrieved successfully',
-    type: UserListResponseDto,
-  })
-  async listUsers(
-    @Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number,
-    @Query('pageSize', new DefaultValuePipe(20), ParseIntPipe) pageSize: number,
-    @Query('role') role: string | undefined,
-    @CurrentUser() currentUser: UserPayload
-  ): Promise<UserListResponseDto> {
-    this.logger.log(
-      `[User: ${currentUser.email}] Listing users: page=${page}, pageSize=${pageSize}, role=${role}`
-    );
-
-    // Fetch users from current user's organization
-    this.logger.log(
-      `[User: ${currentUser.email}] Fetching users from organization: ${currentUser.organizationId}`
-    );
-    let users = await this.userRepository.findByOrganization(currentUser.organizationId);
-
-    // Security: Non-admin users cannot see ADMIN users
-    if (currentUser.role !== 'ADMIN') {
-      users = users.filter(u => u.role !== DomainUserRole.ADMIN);
-      this.logger.log(`[SECURITY] Non-admin user ${currentUser.email} - filtered out ADMIN users`);
-    } else {
-      this.logger.log(
-        `[ADMIN] User ${currentUser.email} can see all users including ADMINs in their organization`
-      );
-    }
-
-    // Filter by role if provided
-    const filteredUsers = role ? users.filter(u => u.role === role) : users;
-
-    // Paginate
-    const startIndex = (page - 1) * pageSize;
-    const endIndex = startIndex + pageSize;
-    const paginatedUsers = filteredUsers.slice(startIndex, endIndex);
-
-    // Convert to DTOs
-    const userDtos = UserMapper.toDtoArray(paginatedUsers);
-
-    const totalPages = Math.ceil(filteredUsers.length / pageSize);
-
-    return {
-      users: userDtos,
-      total: filteredUsers.length,
-      page,
-      pageSize,
-      totalPages,
-    };
-  }
-
-  /**
-   * Update own password
-   */
-  @Patch('me/password')
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  @ApiOperation({
-    summary: 'Update own password',
-    description: 'Update your own password. Requires current password.',
-  })
-  @ApiResponse({
-    status: HttpStatus.OK,
-    description: 'Password updated successfully',
-    schema: {
-      properties: {
-        message: { type: 'string', example: 'Password updated successfully' },
-      },
-    },
-  })
-  @ApiBadRequestResponse({
-    description: 'Invalid current password',
-  })
-  async updatePassword(
-    @Body() dto: UpdatePasswordDto,
-    @CurrentUser() currentUser: UserPayload
-  ): Promise<{ message: string }> {
-    this.logger.log(`[User: ${currentUser.email}] Updating password`);
-
-    const user = await this.userRepository.findById(currentUser.id);
-    if (!user) {
-      throw new NotFoundException('User not found');
-    }
-
-    // Verify current password
-    const isPasswordValid = await argon2.verify(user.passwordHash, dto.currentPassword);
-
-    if (!isPasswordValid) {
-      throw new ForbiddenException('Current password is incorrect');
-    }
-
-    // Hash new password
-    const newPasswordHash = await argon2.hash(dto.newPassword, {
-      type: argon2.argon2id,
-      memoryCost: 65536,
-      timeCost: 3,
-      parallelism: 4,
-    });
-
-    // Update password
-    user.updatePassword(newPasswordHash);
-    await this.userRepository.save(user);
-
-    this.logger.log(`Password updated successfully for user: ${user.id}`);
-
-    return { message: 'Password updated successfully' };
-  }
-
-  /**
-   * Generate a secure temporary password
-   */
-  private generateTemporaryPassword(): string {
-    const length = 16;
-    const charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*';
-    let password = '';
-
-    const randomBytes = crypto.randomBytes(length);
-    for (let i = 0; i < length; i++) {
-      password += charset[randomBytes[i] % charset.length];
-    }
-
-    return password;
-  }
-}

apps/backend/src/application/controllers/webhooks.controller.ts

@@ -1,251 +0,0 @@
-/**
- * Webhooks Controller
- *
- * REST API endpoints for managing webhooks
- */
-
-import {
-  Controller,
-  Get,
-  Post,
-  Patch,
-  Delete,
-  Body,
-  Param,
-  UseGuards,
-  NotFoundException,
-  ForbiddenException,
-} from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiResponse, ApiBearerAuth } from '@nestjs/swagger';
-import { WebhookService, CreateWebhookInput } from '../services/webhook.service';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-import { RolesGuard } from '../guards/roles.guard';
-import { Roles } from '../decorators/roles.decorator';
-import { CurrentUser, UserPayload } from '../decorators/current-user.decorator';
-import { Webhook, WebhookEvent } from '@domain/entities/webhook.entity';
-
-class CreateWebhookDto {
-  url: string;
-  events: WebhookEvent[];
-  description?: string;
-  headers?: Record<string, string>;
-}
-
-class UpdateWebhookDto {
-  url?: string;
-  events?: WebhookEvent[];
-  description?: string;
-  headers?: Record<string, string>;
-}
-
-class WebhookResponseDto {
-  id: string;
-  url: string;
-  events: WebhookEvent[];
-  status: string;
-  description?: string;
-  headers?: Record<string, string>;
-  retryCount: number;
-  lastTriggeredAt?: string;
-  failureCount: number;
-  createdAt: string;
-  updatedAt: string;
-}
-
-@ApiTags('Webhooks')
-@ApiBearerAuth()
-@Controller('webhooks')
-@UseGuards(JwtAuthGuard, RolesGuard)
-export class WebhooksController {
-  constructor(private readonly webhookService: WebhookService) {}
-
-  /**
-   * Create a new webhook
-   * Only admins and managers can create webhooks
-   */
-  @Post()
-  @Roles('admin', 'manager')
-  @ApiOperation({ summary: 'Create a new webhook' })
-  @ApiResponse({ status: 201, description: 'Webhook created successfully' })
-  async createWebhook(
-    @Body() dto: CreateWebhookDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<WebhookResponseDto> {
-    const input: CreateWebhookInput = {
-      organizationId: user.organizationId,
-      url: dto.url,
-      events: dto.events,
-      description: dto.description,
-      headers: dto.headers,
-    };
-
-    const webhook = await this.webhookService.createWebhook(input);
-    return this.mapToDto(webhook);
-  }
-
-  /**
-   * Get all webhooks for organization
-   */
-  @Get()
-  @Roles('admin', 'manager')
-  @ApiOperation({ summary: 'Get all webhooks for organization' })
-  @ApiResponse({ status: 200, description: 'Webhooks retrieved successfully' })
-  async getWebhooks(@CurrentUser() user: UserPayload): Promise<WebhookResponseDto[]> {
-    const webhooks = await this.webhookService.getWebhooksByOrganization(user.organizationId);
-    return webhooks.map(w => this.mapToDto(w));
-  }
-
-  /**
-   * Get webhook by ID
-   */
-  @Get(':id')
-  @Roles('admin', 'manager')
-  @ApiOperation({ summary: 'Get webhook by ID' })
-  @ApiResponse({ status: 200, description: 'Webhook retrieved successfully' })
-  @ApiResponse({ status: 404, description: 'Webhook not found' })
-  async getWebhookById(
-    @Param('id') id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<WebhookResponseDto> {
-    const webhook = await this.webhookService.getWebhookById(id);
-
-    if (!webhook) {
-      throw new NotFoundException('Webhook not found');
-    }
-
-    // Verify webhook belongs to user's organization
-    if (webhook.organizationId !== user.organizationId) {
-      throw new ForbiddenException('Access denied');
-    }
-
-    return this.mapToDto(webhook);
-  }
-
-  /**
-   * Update webhook
-   */
-  @Patch(':id')
-  @Roles('admin', 'manager')
-  @ApiOperation({ summary: 'Update webhook' })
-  @ApiResponse({ status: 200, description: 'Webhook updated successfully' })
-  @ApiResponse({ status: 404, description: 'Webhook not found' })
-  async updateWebhook(
-    @Param('id') id: string,
-    @Body() dto: UpdateWebhookDto,
-    @CurrentUser() user: UserPayload
-  ): Promise<WebhookResponseDto> {
-    const webhook = await this.webhookService.getWebhookById(id);
-
-    if (!webhook) {
-      throw new NotFoundException('Webhook not found');
-    }
-
-    // Verify webhook belongs to user's organization
-    if (webhook.organizationId !== user.organizationId) {
-      throw new ForbiddenException('Access denied');
-    }
-
-    const updatedWebhook = await this.webhookService.updateWebhook(id, dto);
-    return this.mapToDto(updatedWebhook);
-  }
-
-  /**
-   * Activate webhook
-   */
-  @Post(':id/activate')
-  @Roles('admin', 'manager')
-  @ApiOperation({ summary: 'Activate webhook' })
-  @ApiResponse({ status: 200, description: 'Webhook activated successfully' })
-  @ApiResponse({ status: 404, description: 'Webhook not found' })
-  async activateWebhook(
-    @Param('id') id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<{ success: boolean }> {
-    const webhook = await this.webhookService.getWebhookById(id);
-
-    if (!webhook) {
-      throw new NotFoundException('Webhook not found');
-    }
-
-    // Verify webhook belongs to user's organization
-    if (webhook.organizationId !== user.organizationId) {
-      throw new ForbiddenException('Access denied');
-    }
-
-    await this.webhookService.activateWebhook(id);
-    return { success: true };
-  }
-
-  /**
-   * Deactivate webhook
-   */
-  @Post(':id/deactivate')
-  @Roles('admin', 'manager')
-  @ApiOperation({ summary: 'Deactivate webhook' })
-  @ApiResponse({ status: 200, description: 'Webhook deactivated successfully' })
-  @ApiResponse({ status: 404, description: 'Webhook not found' })
-  async deactivateWebhook(
-    @Param('id') id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<{ success: boolean }> {
-    const webhook = await this.webhookService.getWebhookById(id);
-
-    if (!webhook) {
-      throw new NotFoundException('Webhook not found');
-    }
-
-    // Verify webhook belongs to user's organization
-    if (webhook.organizationId !== user.organizationId) {
-      throw new ForbiddenException('Access denied');
-    }
-
-    await this.webhookService.deactivateWebhook(id);
-    return { success: true };
-  }
-
-  /**
-   * Delete webhook
-   */
-  @Delete(':id')
-  @Roles('admin', 'manager')
-  @ApiOperation({ summary: 'Delete webhook' })
-  @ApiResponse({ status: 200, description: 'Webhook deleted successfully' })
-  @ApiResponse({ status: 404, description: 'Webhook not found' })
-  async deleteWebhook(
-    @Param('id') id: string,
-    @CurrentUser() user: UserPayload
-  ): Promise<{ success: boolean }> {
-    const webhook = await this.webhookService.getWebhookById(id);
-
-    if (!webhook) {
-      throw new NotFoundException('Webhook not found');
-    }
-
-    // Verify webhook belongs to user's organization
-    if (webhook.organizationId !== user.organizationId) {
-      throw new ForbiddenException('Access denied');
-    }
-
-    await this.webhookService.deleteWebhook(id);
-    return { success: true };
-  }
-
-  /**
-   * Map webhook entity to DTO (without exposing secret)
-   */
-  private mapToDto(webhook: Webhook): WebhookResponseDto {
-    return {
-      id: webhook.id,
-      url: webhook.url,
-      events: webhook.events,
-      status: webhook.status,
-      description: webhook.description,
-      headers: webhook.headers,
-      retryCount: webhook.retryCount,
-      lastTriggeredAt: webhook.lastTriggeredAt?.toISOString(),
-      failureCount: webhook.failureCount,
-      createdAt: webhook.createdAt.toISOString(),
-      updatedAt: webhook.updatedAt.toISOString(),
-    };
-  }
-}

apps/backend/src/application/csv-bookings.module.ts

@@ -1,28 +0,0 @@
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { CsvBookingsController } from './controllers/csv-bookings.controller';
-import { CsvBookingActionsController } from './controllers/csv-booking-actions.controller';
-import { CsvBookingService } from './services/csv-booking.service';
-import { CsvBookingOrmEntity } from '../infrastructure/persistence/typeorm/entities/csv-booking.orm-entity';
-import { TypeOrmCsvBookingRepository } from '../infrastructure/persistence/typeorm/repositories/csv-booking.repository';
-import { NotificationsModule } from './notifications/notifications.module';
-import { EmailModule } from '../infrastructure/email/email.module';
-import { StorageModule } from '../infrastructure/storage/storage.module';
-
-/**
- * CSV Bookings Module
- *
- * Handles CSV-based booking workflow with carrier email confirmations
- */
-@Module({
-  imports: [
-    TypeOrmModule.forFeature([CsvBookingOrmEntity]),
-    NotificationsModule,
-    EmailModule,
-    StorageModule,
-  ],
-  controllers: [CsvBookingsController, CsvBookingActionsController],
-  providers: [CsvBookingService, TypeOrmCsvBookingRepository],
-  exports: [CsvBookingService, TypeOrmCsvBookingRepository],
-})
-export class CsvBookingsModule {}

apps/backend/src/application/dashboard/dashboard.controller.ts

@@ -1,75 +0,0 @@
-/**
- * Dashboard Controller
- *
- * Provides dashboard analytics and KPI endpoints
- */
-
-import { Controller, Get, UseGuards, Request } from '@nestjs/common';
-import { AnalyticsService } from '../services/analytics.service';
-import { JwtAuthGuard } from '../guards/jwt-auth.guard';
-
-@Controller('dashboard')
-@UseGuards(JwtAuthGuard)
-export class DashboardController {
-  constructor(private readonly analyticsService: AnalyticsService) {}
-
-  /**
-   * Get dashboard KPIs
-   * GET /api/v1/dashboard/kpis
-   */
-  @Get('kpis')
-  async getKPIs(@Request() req: any) {
-    const organizationId = req.user.organizationId;
-    return this.analyticsService.calculateKPIs(organizationId);
-  }
-
-  /**
-   * Get bookings chart data (6 months)
-   * GET /api/v1/dashboard/bookings-chart
-   */
-  @Get('bookings-chart')
-  async getBookingsChart(@Request() req: any) {
-    const organizationId = req.user.organizationId;
-    return this.analyticsService.getBookingsChartData(organizationId);
-  }
-
-  /**
-   * Get top 5 trade lanes
-   * GET /api/v1/dashboard/top-trade-lanes
-   */
-  @Get('top-trade-lanes')
-  async getTopTradeLanes(@Request() req: any) {
-    const organizationId = req.user.organizationId;
-    return this.analyticsService.getTopTradeLanes(organizationId);
-  }
-
-  /**
-   * Get dashboard alerts
-   * GET /api/v1/dashboard/alerts
-   */
-  @Get('alerts')
-  async getAlerts(@Request() req: any) {
-    const organizationId = req.user.organizationId;
-    return this.analyticsService.getAlerts(organizationId);
-  }
-
-  /**
-   * Get CSV Booking KPIs
-   * GET /api/v1/dashboard/csv-booking-kpis
-   */
-  @Get('csv-booking-kpis')
-  async getCsvBookingKPIs(@Request() req: any) {
-    const organizationId = req.user.organizationId;
-    return this.analyticsService.getCsvBookingKPIs(organizationId);
-  }
-
-  /**
-   * Get Top Carriers
-   * GET /api/v1/dashboard/top-carriers
-   */
-  @Get('top-carriers')
-  async getTopCarriers(@Request() req: any) {
-    const organizationId = req.user.organizationId;
-    return this.analyticsService.getTopCarriers(organizationId, 5);
-  }
-}

apps/backend/src/application/dashboard/dashboard.module.ts

@@ -1,18 +0,0 @@
-/**
- * Dashboard Module
- */
-
-import { Module } from '@nestjs/common';
-import { DashboardController } from './dashboard.controller';
-import { AnalyticsService } from '../services/analytics.service';
-import { BookingsModule } from '../bookings/bookings.module';
-import { RatesModule } from '../rates/rates.module';
-import { CsvBookingsModule } from '../csv-bookings.module';
-
-@Module({
-  imports: [BookingsModule, RatesModule, CsvBookingsModule],
-  controllers: [DashboardController],
-  providers: [AnalyticsService],
-  exports: [AnalyticsService],
-})
-export class DashboardModule {}

apps/backend/src/application/decorators/current-user.decorator.ts

@@ -1,42 +0,0 @@
-import { createParamDecorator, ExecutionContext } from '@nestjs/common';
-
-/**
- * User payload interface extracted from JWT
- */
-export interface UserPayload {
-  id: string;
-  email: string;
-  role: string;
-  organizationId: string;
-  firstName: string;
-  lastName: string;
-}
-
-/**
- * CurrentUser Decorator
- *
- * Extracts the authenticated user from the request object.
- * Must be used with JwtAuthGuard.
- *
- * Usage:
- * @UseGuards(JwtAuthGuard)
- * @Get('me')
- * getProfile(@CurrentUser() user: UserPayload) {
- *   return user;
- * }
- *
- * You can also extract a specific property:
- * @Get('my-bookings')
- * getMyBookings(@CurrentUser('id') userId: string) {
- *   return this.bookingService.findByUserId(userId);
- * }
- */
-export const CurrentUser = createParamDecorator(
-  (data: keyof UserPayload | undefined, ctx: ExecutionContext) => {
-    const request = ctx.switchToHttp().getRequest();
-    const user = request.user;
-
-    // If a specific property is requested, return only that property
-    return data ? user?.[data] : user;
-  }
-);

apps/backend/src/application/decorators/index.ts

@@ -1,3 +0,0 @@
-export * from './current-user.decorator';
-export * from './public.decorator';
-export * from './roles.decorator';

apps/backend/src/application/decorators/public.decorator.ts

@@ -1,16 +0,0 @@
-import { SetMetadata } from '@nestjs/common';
-
-/**
- * Public Decorator
- *
- * Marks a route as public, bypassing JWT authentication.
- * Use this for routes that should be accessible without a token.
- *
- * Usage:
- * @Public()
- * @Post('login')
- * login(@Body() dto: LoginDto) {
- *   return this.authService.login(dto.email, dto.password);
- * }
- */
-export const Public = () => SetMetadata('isPublic', true);

apps/backend/src/application/decorators/roles.decorator.ts

@@ -1,23 +0,0 @@
-import { SetMetadata } from '@nestjs/common';
-
-/**
- * Roles Decorator
- *
- * Specifies which roles are allowed to access a route.
- * Must be used with both JwtAuthGuard and RolesGuard.
- *
- * Available roles:
- * - 'admin': Full system access
- * - 'manager': Manage bookings and users within organization
- * - 'user': Create and view bookings
- * - 'viewer': Read-only access
- *
- * Usage:
- * @UseGuards(JwtAuthGuard, RolesGuard)
- * @Roles('admin', 'manager')
- * @Delete('bookings/:id')
- * deleteBooking(@Param('id') id: string) {
- *   return this.bookingService.delete(id);
- * }
- */
-export const Roles = (...roles: string[]) => SetMetadata('roles', roles);

apps/backend/src/application/dto/auth-login.dto.ts

@@ -1,218 +0,0 @@
-import {
-  IsEmail,
-  IsString,
-  MinLength,
-  IsOptional,
-  ValidateNested,
-  IsEnum,
-  MaxLength,
-  Matches,
-} from 'class-validator';
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { Type } from 'class-transformer';
-import { OrganizationType } from '@domain/entities/organization.entity';
-
-export class LoginDto {
-  @ApiProperty({
-    example: 'john.doe@acme.com',
-    description: 'Email address',
-  })
-  @IsEmail({}, { message: 'Invalid email format' })
-  email: string;
-
-  @ApiProperty({
-    example: 'SecurePassword123!',
-    description: 'Password (minimum 12 characters)',
-    minLength: 12,
-  })
-  @IsString()
-  @MinLength(12, { message: 'Password must be at least 12 characters' })
-  password: string;
-}
-
-/**
- * Organization data for registration (nested in RegisterDto)
- */
-export class RegisterOrganizationDto {
-  @ApiProperty({
-    example: 'Acme Freight Forwarding',
-    description: 'Organization name',
-    minLength: 2,
-    maxLength: 200,
-  })
-  @IsString()
-  @MinLength(2)
-  @MaxLength(200)
-  name: string;
-
-  @ApiProperty({
-    example: OrganizationType.FREIGHT_FORWARDER,
-    description: 'Organization type',
-    enum: OrganizationType,
-  })
-  @IsEnum(OrganizationType)
-  type: OrganizationType;
-
-  @ApiProperty({
-    example: '123 Main Street',
-    description: 'Street address',
-  })
-  @IsString()
-  street: string;
-
-  @ApiProperty({
-    example: 'Rotterdam',
-    description: 'City',
-  })
-  @IsString()
-  city: string;
-
-  @ApiPropertyOptional({
-    example: 'South Holland',
-    description: 'State or province',
-  })
-  @IsString()
-  @IsOptional()
-  state?: string;
-
-  @ApiProperty({
-    example: '3000 AB',
-    description: 'Postal code',
-  })
-  @IsString()
-  postalCode: string;
-
-  @ApiProperty({
-    example: 'NL',
-    description: 'Country code (ISO 3166-1 alpha-2)',
-    minLength: 2,
-    maxLength: 2,
-  })
-  @IsString()
-  @MinLength(2)
-  @MaxLength(2)
-  @Matches(/^[A-Z]{2}$/, { message: 'Country must be a 2-letter ISO code (e.g., NL, US, CN)' })
-  country: string;
-
-  @ApiPropertyOptional({
-    example: 'MAEU',
-    description: 'Standard Carrier Alpha Code (4 uppercase letters, required for carriers only)',
-    minLength: 4,
-    maxLength: 4,
-  })
-  @IsString()
-  @IsOptional()
-  @MinLength(4)
-  @MaxLength(4)
-  @Matches(/^[A-Z]{4}$/, { message: 'SCAC must be 4 uppercase letters' })
-  scac?: string;
-}
-
-export class RegisterDto {
-  @ApiProperty({
-    example: 'john.doe@acme.com',
-    description: 'Email address',
-  })
-  @IsEmail({}, { message: 'Invalid email format' })
-  email: string;
-
-  @ApiProperty({
-    example: 'SecurePassword123!',
-    description: 'Password (minimum 12 characters)',
-    minLength: 12,
-  })
-  @IsString()
-  @MinLength(12, { message: 'Password must be at least 12 characters' })
-  password: string;
-
-  @ApiPropertyOptional({
-    example: 'John',
-    description: 'First name (optional if using invitation token)',
-  })
-  @IsString()
-  @IsOptional()
-  @MinLength(2, { message: 'First name must be at least 2 characters' })
-  firstName: string;
-
-  @ApiPropertyOptional({
-    example: 'Doe',
-    description: 'Last name (optional if using invitation token)',
-  })
-  @IsString()
-  @IsOptional()
-  @MinLength(2, { message: 'Last name must be at least 2 characters' })
-  lastName: string;
-
-  @ApiPropertyOptional({
-    example: 'abc123def456',
-    description: 'Invitation token (for invited users)',
-    required: false,
-  })
-  @IsString()
-  @IsOptional()
-  invitationToken?: string;
-
-  @ApiPropertyOptional({
-    example: '550e8400-e29b-41d4-a716-446655440000',
-    description:
-      'Organization ID (optional - for invited users). If not provided, organization data must be provided.',
-    required: false,
-  })
-  @IsString()
-  @IsOptional()
-  organizationId?: string;
-
-  @ApiPropertyOptional({
-    description:
-      'Organization data (required if organizationId and invitationToken are not provided)',
-    type: RegisterOrganizationDto,
-    required: false,
-  })
-  @ValidateNested()
-  @Type(() => RegisterOrganizationDto)
-  @IsOptional()
-  organization?: RegisterOrganizationDto;
-}
-
-export class AuthResponseDto {
-  @ApiProperty({
-    example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
-    description: 'JWT access token (valid 15 minutes)',
-  })
-  accessToken: string;
-
-  @ApiProperty({
-    example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
-    description: 'JWT refresh token (valid 7 days)',
-  })
-  refreshToken: string;
-
-  @ApiProperty({
-    example: {
-      id: '550e8400-e29b-41d4-a716-446655440000',
-      email: 'john.doe@acme.com',
-      firstName: 'John',
-      lastName: 'Doe',
-      role: 'user',
-      organizationId: '550e8400-e29b-41d4-a716-446655440001',
-    },
-    description: 'User information',
-  })
-  user: {
-    id: string;
-    email: string;
-    firstName: string;
-    lastName: string;
-    role: string;
-    organizationId: string;
-  };
-}
-
-export class RefreshTokenDto {
-  @ApiProperty({
-    example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
-    description: 'Refresh token',
-  })
-  @IsString()
-  refreshToken: string;
-}

apps/backend/src/application/dto/booking-export.dto.ts

@@ -1,68 +0,0 @@
-/**
- * Booking Export DTO
- *
- * Defines export format options
- */
-
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { IsEnum, IsOptional, IsArray, IsString } from 'class-validator';
-
-export enum ExportFormat {
-  CSV = 'csv',
-  EXCEL = 'excel',
-  JSON = 'json',
-}
-
-export enum ExportField {
-  BOOKING_NUMBER = 'bookingNumber',
-  STATUS = 'status',
-  CREATED_AT = 'createdAt',
-  CARRIER = 'carrier',
-  ORIGIN = 'origin',
-  DESTINATION = 'destination',
-  ETD = 'etd',
-  ETA = 'eta',
-  SHIPPER = 'shipper',
-  CONSIGNEE = 'consignee',
-  CONTAINER_TYPE = 'containerType',
-  CONTAINER_COUNT = 'containerCount',
-  TOTAL_TEUS = 'totalTEUs',
-  PRICE = 'price',
-}
-
-export class BookingExportDto {
-  @ApiProperty({
-    description: 'Export format',
-    enum: ExportFormat,
-    example: ExportFormat.CSV,
-  })
-  @IsEnum(ExportFormat)
-  format: ExportFormat;
-
-  @ApiPropertyOptional({
-    description: 'Fields to include in export (if omitted, all fields included)',
-    enum: ExportField,
-    isArray: true,
-    example: [
-      ExportField.BOOKING_NUMBER,
-      ExportField.STATUS,
-      ExportField.CARRIER,
-      ExportField.ORIGIN,
-      ExportField.DESTINATION,
-    ],
-  })
-  @IsOptional()
-  @IsArray()
-  @IsEnum(ExportField, { each: true })
-  fields?: ExportField[];
-
-  @ApiPropertyOptional({
-    description: 'Booking IDs to export (if omitted, exports filtered bookings)',
-    isArray: true,
-    example: ['550e8400-e29b-41d4-a716-446655440000'],
-  })
-  @IsOptional()
-  @IsArray()
-  @IsString({ each: true })
-  bookingIds?: string[];
-}

apps/backend/src/application/dto/booking-filter.dto.ts

@@ -1,175 +0,0 @@
-/**
- * Advanced Booking Filter DTO
- *
- * Supports comprehensive filtering for booking searches
- */
-
-import { ApiPropertyOptional } from '@nestjs/swagger';
-import {
-  IsOptional,
-  IsString,
-  IsArray,
-  IsDateString,
-  IsEnum,
-  IsInt,
-  Min,
-  Max,
-} from 'class-validator';
-import { Type } from 'class-transformer';
-
-export enum BookingStatusFilter {
-  DRAFT = 'draft',
-  PENDING_CONFIRMATION = 'pending_confirmation',
-  CONFIRMED = 'confirmed',
-  IN_TRANSIT = 'in_transit',
-  DELIVERED = 'delivered',
-  CANCELLED = 'cancelled',
-}
-
-export enum BookingSortField {
-  CREATED_AT = 'createdAt',
-  BOOKING_NUMBER = 'bookingNumber',
-  STATUS = 'status',
-  ETD = 'etd',
-  ETA = 'eta',
-}
-
-export enum SortOrder {
-  ASC = 'asc',
-  DESC = 'desc',
-}
-
-export class BookingFilterDto {
-  @ApiPropertyOptional({
-    description: 'Page number (1-based)',
-    example: 1,
-    minimum: 1,
-  })
-  @IsOptional()
-  @IsInt()
-  @Min(1)
-  @Type(() => Number)
-  page?: number = 1;
-
-  @ApiPropertyOptional({
-    description: 'Number of items per page',
-    example: 20,
-    minimum: 1,
-    maximum: 100,
-  })
-  @IsOptional()
-  @IsInt()
-  @Min(1)
-  @Max(100)
-  @Type(() => Number)
-  pageSize?: number = 20;
-
-  @ApiPropertyOptional({
-    description: 'Filter by booking status (multiple)',
-    enum: BookingStatusFilter,
-    isArray: true,
-    example: ['confirmed', 'in_transit'],
-  })
-  @IsOptional()
-  @IsArray()
-  @IsEnum(BookingStatusFilter, { each: true })
-  status?: BookingStatusFilter[];
-
-  @ApiPropertyOptional({
-    description: 'Search by booking number (partial match)',
-    example: 'WCM-2025',
-  })
-  @IsOptional()
-  @IsString()
-  search?: string;
-
-  @ApiPropertyOptional({
-    description: 'Filter by carrier name or code',
-    example: 'Maersk',
-  })
-  @IsOptional()
-  @IsString()
-  carrier?: string;
-
-  @ApiPropertyOptional({
-    description: 'Filter by origin port code',
-    example: 'NLRTM',
-  })
-  @IsOptional()
-  @IsString()
-  originPort?: string;
-
-  @ApiPropertyOptional({
-    description: 'Filter by destination port code',
-    example: 'CNSHA',
-  })
-  @IsOptional()
-  @IsString()
-  destinationPort?: string;
-
-  @ApiPropertyOptional({
-    description: 'Filter by shipper name (partial match)',
-    example: 'Acme Corp',
-  })
-  @IsOptional()
-  @IsString()
-  shipper?: string;
-
-  @ApiPropertyOptional({
-    description: 'Filter by consignee name (partial match)',
-    example: 'XYZ Ltd',
-  })
-  @IsOptional()
-  @IsString()
-  consignee?: string;
-
-  @ApiPropertyOptional({
-    description: 'Filter by creation date from (ISO 8601)',
-    example: '2025-01-01T00:00:00.000Z',
-  })
-  @IsOptional()
-  @IsDateString()
-  createdFrom?: string;
-
-  @ApiPropertyOptional({
-    description: 'Filter by creation date to (ISO 8601)',
-    example: '2025-12-31T23:59:59.999Z',
-  })
-  @IsOptional()
-  @IsDateString()
-  createdTo?: string;
-
-  @ApiPropertyOptional({
-    description: 'Filter by ETD from (ISO 8601)',
-    example: '2025-06-01T00:00:00.000Z',
-  })
-  @IsOptional()
-  @IsDateString()
-  etdFrom?: string;
-
-  @ApiPropertyOptional({
-    description: 'Filter by ETD to (ISO 8601)',
-    example: '2025-06-30T23:59:59.999Z',
-  })
-  @IsOptional()
-  @IsDateString()
-  etdTo?: string;
-
-  @ApiPropertyOptional({
-    description: 'Sort field',
-    enum: BookingSortField,
-    example: BookingSortField.CREATED_AT,
-  })
-  @IsOptional()
-  @IsEnum(BookingSortField)
-  sortBy?: BookingSortField = BookingSortField.CREATED_AT;
-
-  @ApiPropertyOptional({
-    description: 'Sort order',
-    enum: SortOrder,
-    example: SortOrder.DESC,
-  })
-  @IsOptional()
-  @IsEnum(SortOrder)
-  sortOrder?: SortOrder = SortOrder.DESC;
-}

apps/backend/src/application/dto/booking-response.dto.ts

@@ -1,184 +0,0 @@
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { PortDto, PricingDto } from './rate-search-response.dto';
-
-export class BookingAddressDto {
-  @ApiProperty({ example: '123 Main Street' })
-  street: string;
-
-  @ApiProperty({ example: 'Rotterdam' })
-  city: string;
-
-  @ApiProperty({ example: '3000 AB' })
-  postalCode: string;
-
-  @ApiProperty({ example: 'NL' })
-  country: string;
-}
-
-export class BookingPartyDto {
-  @ApiProperty({ example: 'Acme Corporation' })
-  name: string;
-
-  @ApiProperty({ type: BookingAddressDto })
-  address: BookingAddressDto;
-
-  @ApiProperty({ example: 'John Doe' })
-  contactName: string;
-
-  @ApiProperty({ example: 'john.doe@acme.com' })
-  contactEmail: string;
-
-  @ApiProperty({ example: '+31612345678' })
-  contactPhone: string;
-}
-
-export class BookingContainerDto {
-  @ApiProperty({ example: '550e8400-e29b-41d4-a716-446655440000' })
-  id: string;
-
-  @ApiProperty({ example: '40HC' })
-  type: string;
-
-  @ApiPropertyOptional({ example: 'ABCU1234567' })
-  containerNumber?: string;
-
-  @ApiPropertyOptional({ example: 22000 })
-  vgm?: number;
-
-  @ApiPropertyOptional({ example: -18 })
-  temperature?: number;
-
-  @ApiPropertyOptional({ example: 'SEAL123456' })
-  sealNumber?: string;
-}
-
-export class BookingRateQuoteDto {
-  @ApiProperty({ example: '550e8400-e29b-41d4-a716-446655440000' })
-  id: string;
-
-  @ApiProperty({ example: 'Maersk Line' })
-  carrierName: string;
-
-  @ApiProperty({ example: 'MAERSK' })
-  carrierCode: string;
-
-  @ApiProperty({ type: PortDto })
-  origin: PortDto;
-
-  @ApiProperty({ type: PortDto })
-  destination: PortDto;
-
-  @ApiProperty({ type: PricingDto })
-  pricing: PricingDto;
-
-  @ApiProperty({ example: '40HC' })
-  containerType: string;
-
-  @ApiProperty({ example: 'FCL' })
-  mode: string;
-
-  @ApiProperty({ example: '2025-02-15T10:00:00Z' })
-  etd: string;
-
-  @ApiProperty({ example: '2025-03-17T14:00:00Z' })
-  eta: string;
-
-  @ApiProperty({ example: 30 })
-  transitDays: number;
-}
-
-export class BookingResponseDto {
-  @ApiProperty({ example: '550e8400-e29b-41d4-a716-446655440000' })
-  id: string;
-
-  @ApiProperty({ example: 'WCM-2025-ABC123', description: 'Unique booking number' })
-  bookingNumber: string;
-
-  @ApiProperty({
-    example: 'draft',
-    enum: ['draft', 'pending_confirmation', 'confirmed', 'in_transit', 'delivered', 'cancelled'],
-  })
-  status: string;
-
-  @ApiProperty({ type: BookingPartyDto })
-  shipper: BookingPartyDto;
-
-  @ApiProperty({ type: BookingPartyDto })
-  consignee: BookingPartyDto;
-
-  @ApiProperty({ example: 'Electronics and consumer goods' })
-  cargoDescription: string;
-
-  @ApiProperty({ type: [BookingContainerDto] })
-  containers: BookingContainerDto[];
-
-  @ApiPropertyOptional({ example: 'Please handle with care. Delivery before 5 PM.' })
-  specialInstructions?: string;
-
-  @ApiProperty({ type: BookingRateQuoteDto, description: 'Associated rate quote details' })
-  rateQuote: BookingRateQuoteDto;
-
-  @ApiProperty({ example: '2025-02-15T10:00:00Z' })
-  createdAt: string;
-
-  @ApiProperty({ example: '2025-02-15T10:00:00Z' })
-  updatedAt: string;
-}
-
-export class BookingListItemDto {
-  @ApiProperty({ example: '550e8400-e29b-41d4-a716-446655440000' })
-  id: string;
-
-  @ApiProperty({ example: 'WCM-2025-ABC123' })
-  bookingNumber: string;
-
-  @ApiProperty({ example: 'draft' })
-  status: string;
-
-  @ApiProperty({ example: 'Acme Corporation' })
-  shipperName: string;
-
-  @ApiProperty({ example: 'Shanghai Imports Ltd' })
-  consigneeName: string;
-
-  @ApiProperty({ example: 'NLRTM' })
-  originPort: string;
-
-  @ApiProperty({ example: 'CNSHA' })
-  destinationPort: string;
-
-  @ApiProperty({ example: 'Maersk Line' })
-  carrierName: string;
-
-  @ApiProperty({ example: '2025-02-15T10:00:00Z' })
-  etd: string;
-
-  @ApiProperty({ example: '2025-03-17T14:00:00Z' })
-  eta: string;
-
-  @ApiProperty({ example: 1700.0 })
-  totalAmount: number;
-
-  @ApiProperty({ example: 'USD' })
-  currency: string;
-
-  @ApiProperty({ example: '2025-02-15T10:00:00Z' })
-  createdAt: string;
-}
-
-export class BookingListResponseDto {
-  @ApiProperty({ type: [BookingListItemDto] })
-  bookings: BookingListItemDto[];
-
-  @ApiProperty({ example: 25, description: 'Total number of bookings' })
-  total: number;
-
-  @ApiProperty({ example: 1, description: 'Current page number' })
-  page: number;
-
-  @ApiProperty({ example: 20, description: 'Items per page' })
-  pageSize: number;
-
-  @ApiProperty({ example: 2, description: 'Total number of pages' })
-  totalPages: number;
-}

apps/backend/src/application/dto/consent.dto.ts

@@ -1,139 +0,0 @@
-/**
- * Cookie Consent DTOs
- * GDPR compliant consent management
- */
-
-import { IsBoolean, IsOptional, IsString, IsEnum, IsDateString, IsIP } from 'class-validator';
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-
-/**
- * Request DTO for recording/updating cookie consent
- */
-export class UpdateConsentDto {
-  @ApiProperty({
-    example: true,
-    description: 'Essential cookies consent (always true, required for functionality)',
-    default: true,
-  })
-  @IsBoolean()
-  essential: boolean;
-
-  @ApiProperty({
-    example: false,
-    description: 'Functional cookies consent (preferences, language, etc.)',
-    default: false,
-  })
-  @IsBoolean()
-  functional: boolean;
-
-  @ApiProperty({
-    example: false,
-    description: 'Analytics cookies consent (Google Analytics, Sentry, etc.)',
-    default: false,
-  })
-  @IsBoolean()
-  analytics: boolean;
-
-  @ApiProperty({
-    example: false,
-    description: 'Marketing cookies consent (ads, tracking, remarketing)',
-    default: false,
-  })
-  @IsBoolean()
-  marketing: boolean;
-
-  @ApiPropertyOptional({
-    example: '192.168.1.1',
-    description: 'IP address at time of consent (for GDPR audit trail)',
-  })
-  @IsOptional()
-  @IsString()
-  ipAddress?: string;
-
-  @ApiPropertyOptional({
-    example: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
-    description: 'User agent at time of consent',
-  })
-  @IsOptional()
-  @IsString()
-  userAgent?: string;
-}
-
-/**
- * Response DTO for consent status
- */
-export class ConsentResponseDto {
-  @ApiProperty({
-    example: '550e8400-e29b-41d4-a716-446655440000',
-    description: 'User ID',
-  })
-  userId: string;
-
-  @ApiProperty({
-    example: true,
-    description: 'Essential cookies consent (always true)',
-  })
-  essential: boolean;
-
-  @ApiProperty({
-    example: false,
-    description: 'Functional cookies consent',
-  })
-  functional: boolean;
-
-  @ApiProperty({
-    example: false,
-    description: 'Analytics cookies consent',
-  })
-  analytics: boolean;
-
-  @ApiProperty({
-    example: false,
-    description: 'Marketing cookies consent',
-  })
-  marketing: boolean;
-
-  @ApiProperty({
-    example: '2025-01-27T10:30:00.000Z',
-    description: 'Date when consent was recorded',
-  })
-  consentDate: Date;
-
-  @ApiProperty({
-    example: '2025-01-27T10:30:00.000Z',
-    description: 'Last update timestamp',
-  })
-  updatedAt: Date;
-}
-
-/**
- * Request DTO for withdrawing specific consent
- */
-export class WithdrawConsentDto {
-  @ApiProperty({
-    example: 'marketing',
-    description: 'Type of consent to withdraw',
-    enum: ['functional', 'analytics', 'marketing'],
-  })
-  @IsEnum(['functional', 'analytics', 'marketing'], {
-    message: 'Consent type must be functional, analytics, or marketing',
-  })
-  consentType: 'functional' | 'analytics' | 'marketing';
-}
-
-/**
- * Success response DTO
- */
-export class ConsentSuccessDto {
-  @ApiProperty({
-    example: true,
-    description: 'Operation success status',
-  })
-  success: boolean;
-
-  @ApiProperty({
-    example: 'Consent preferences saved successfully',
-    description: 'Response message',
-  })
-  message: string;
-}

apps/backend/src/application/dto/create-booking-request.dto.ts

@@ -1,135 +0,0 @@
-import {
-  IsString,
-  IsUUID,
-  IsOptional,
-  ValidateNested,
-  IsArray,
-  IsEmail,
-  Matches,
-  MinLength,
-} from 'class-validator';
-import { Type } from 'class-transformer';
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-
-export class AddressDto {
-  @ApiProperty({ example: '123 Main Street' })
-  @IsString()
-  @MinLength(5, { message: 'Street must be at least 5 characters' })
-  street: string;
-
-  @ApiProperty({ example: 'Rotterdam' })
-  @IsString()
-  @MinLength(2, { message: 'City must be at least 2 characters' })
-  city: string;
-
-  @ApiProperty({ example: '3000 AB' })
-  @IsString()
-  postalCode: string;
-
-  @ApiProperty({ example: 'NL', description: 'ISO 3166-1 alpha-2 country code' })
-  @IsString()
-  @Matches(/^[A-Z]{2}$/, { message: 'Country must be a valid 2-letter ISO country code' })
-  country: string;
-}
-
-export class PartyDto {
-  @ApiProperty({ example: 'Acme Corporation' })
-  @IsString()
-  @MinLength(2, { message: 'Name must be at least 2 characters' })
-  name: string;
-
-  @ApiProperty({ type: AddressDto })
-  @ValidateNested()
-  @Type(() => AddressDto)
-  address: AddressDto;
-
-  @ApiProperty({ example: 'John Doe' })
-  @IsString()
-  @MinLength(2, { message: 'Contact name must be at least 2 characters' })
-  contactName: string;
-
-  @ApiProperty({ example: 'john.doe@acme.com' })
-  @IsEmail({}, { message: 'Contact email must be a valid email address' })
-  contactEmail: string;
-
-  @ApiProperty({ example: '+31612345678' })
-  @IsString()
-  @Matches(/^\+?[1-9]\d{1,14}$/, {
-    message: 'Contact phone must be a valid international phone number',
-  })
-  contactPhone: string;
-}
-
-export class ContainerDto {
-  @ApiProperty({ example: '40HC', description: 'Container type' })
-  @IsString()
-  type: string;
-
-  @ApiPropertyOptional({ example: 'ABCU1234567', description: 'Container number (11 characters)' })
-  @IsOptional()
-  @IsString()
-  @Matches(/^[A-Z]{4}\d{7}$/, {
-    message: 'Container number must be 4 letters followed by 7 digits',
-  })
-  containerNumber?: string;
-
-  @ApiPropertyOptional({ example: 22000, description: 'Verified Gross Mass in kg' })
-  @IsOptional()
-  vgm?: number;
-
-  @ApiPropertyOptional({
-    example: -18,
-    description: 'Temperature in Celsius (for reefer containers)',
-  })
-  @IsOptional()
-  temperature?: number;
-
-  @ApiPropertyOptional({ example: 'SEAL123456', description: 'Seal number' })
-  @IsOptional()
-  @IsString()
-  sealNumber?: string;
-}
-
-export class CreateBookingRequestDto {
-  @ApiProperty({
-    example: '550e8400-e29b-41d4-a716-446655440000',
-    description: 'Rate quote ID from previous search',
-  })
-  @IsUUID(4, { message: 'Rate quote ID must be a valid UUID' })
-  rateQuoteId: string;
-
-  @ApiProperty({ type: PartyDto, description: 'Shipper details' })
-  @ValidateNested()
-  @Type(() => PartyDto)
-  shipper: PartyDto;
-
-  @ApiProperty({ type: PartyDto, description: 'Consignee details' })
-  @ValidateNested()
-  @Type(() => PartyDto)
-  consignee: PartyDto;
-
-  @ApiProperty({
-    example: 'Electronics and consumer goods',
-    description: 'Cargo description',
-  })
-  @IsString()
-  @MinLength(10, { message: 'Cargo description must be at least 10 characters' })
-  cargoDescription: string;
-
-  @ApiProperty({
-    type: [ContainerDto],
-    description: 'Container details (can be empty for initial booking)',
-  })
-  @IsArray()
-  @ValidateNested({ each: true })
-  @Type(() => ContainerDto)
-  containers: ContainerDto[];
-
-  @ApiPropertyOptional({
-    example: 'Please handle with care. Delivery before 5 PM.',
-    description: 'Special instructions for the carrier',
-  })
-  @IsOptional()
-  @IsString()
-  specialInstructions?: string;
-}

apps/backend/src/application/dto/csv-booking.dto.ts

@@ -1,440 +0,0 @@
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import {
-  IsString,
-  IsEmail,
-  IsNumber,
-  Min,
-  IsOptional,
-  IsEnum,
-  MinLength,
-  MaxLength,
-} from 'class-validator';
-
-/**
- * Create CSV Booking DTO
- *
- * Request body for creating a new CSV-based booking request
- * This is sent by the user after selecting a rate from CSV search results
- */
-export class CreateCsvBookingDto {
-  @ApiProperty({
-    description: 'Carrier/Company name',
-    example: 'SSC Consolidation',
-  })
-  @IsString()
-  @MinLength(2)
-  @MaxLength(200)
-  carrierName: string;
-
-  @ApiProperty({
-    description: 'Carrier email address for booking request',
-    example: 'bookings@sscconsolidation.com',
-  })
-  @IsEmail()
-  carrierEmail: string;
-
-  @ApiProperty({
-    description: 'Origin port code (UN/LOCODE)',
-    example: 'NLRTM',
-  })
-  @IsString()
-  @MinLength(5)
-  @MaxLength(5)
-  origin: string;
-
-  @ApiProperty({
-    description: 'Destination port code (UN/LOCODE)',
-    example: 'USNYC',
-  })
-  @IsString()
-  @MinLength(5)
-  @MaxLength(5)
-  destination: string;
-
-  @ApiProperty({
-    description: 'Volume in cubic meters (CBM)',
-    example: 25.5,
-    minimum: 0.01,
-  })
-  @IsNumber()
-  @Min(0.01)
-  volumeCBM: number;
-
-  @ApiProperty({
-    description: 'Weight in kilograms',
-    example: 3500,
-    minimum: 1,
-  })
-  @IsNumber()
-  @Min(1)
-  weightKG: number;
-
-  @ApiProperty({
-    description: 'Number of pallets',
-    example: 10,
-    minimum: 0,
-  })
-  @IsNumber()
-  @Min(0)
-  palletCount: number;
-
-  @ApiProperty({
-    description: 'Price in USD',
-    example: 1850.5,
-    minimum: 0,
-  })
-  @IsNumber()
-  @Min(0)
-  priceUSD: number;
-
-  @ApiProperty({
-    description: 'Price in EUR',
-    example: 1665.45,
-    minimum: 0,
-  })
-  @IsNumber()
-  @Min(0)
-  priceEUR: number;
-
-  @ApiProperty({
-    description: 'Primary currency',
-    enum: ['USD', 'EUR'],
-    example: 'USD',
-  })
-  @IsEnum(['USD', 'EUR'])
-  primaryCurrency: string;
-
-  @ApiProperty({
-    description: 'Transit time in days',
-    example: 28,
-    minimum: 1,
-  })
-  @IsNumber()
-  @Min(1)
-  transitDays: number;
-
-  @ApiProperty({
-    description: 'Container type',
-    example: 'LCL',
-  })
-  @IsString()
-  @MinLength(2)
-  @MaxLength(50)
-  containerType: string;
-
-  @ApiPropertyOptional({
-    description: 'Additional notes or requirements',
-    example: 'Please handle with care - fragile goods',
-  })
-  @IsOptional()
-  @IsString()
-  @MaxLength(1000)
-  notes?: string;
-
-  // Documents will be handled via file upload interceptor
-  // Not included in DTO validation but processed separately
-}
-
-/**
- * Document DTO for response
- */
-export class CsvBookingDocumentDto {
-  @ApiProperty({
-    description: 'Document unique ID',
-    example: '123e4567-e89b-12d3-a456-426614174000',
-  })
-  id: string;
-
-  @ApiProperty({
-    description: 'Document type',
-    enum: [
-      'BILL_OF_LADING',
-      'PACKING_LIST',
-      'COMMERCIAL_INVOICE',
-      'CERTIFICATE_OF_ORIGIN',
-      'OTHER',
-    ],
-    example: 'BILL_OF_LADING',
-  })
-  type: string;
-
-  @ApiProperty({
-    description: 'Original file name',
-    example: 'bill-of-lading.pdf',
-  })
-  fileName: string;
-
-  @ApiProperty({
-    description: 'File storage path or URL',
-    example: '/uploads/documents/123e4567-e89b-12d3-a456-426614174000.pdf',
-  })
-  filePath: string;
-
-  @ApiProperty({
-    description: 'File MIME type',
-    example: 'application/pdf',
-  })
-  mimeType: string;
-
-  @ApiProperty({
-    description: 'File size in bytes',
-    example: 245678,
-  })
-  size: number;
-
-  @ApiProperty({
-    description: 'Upload timestamp',
-    example: '2025-10-23T14:30:00Z',
-  })
-  uploadedAt: Date;
-}
-
-/**
- * CSV Booking Response DTO
- *
- * Response when creating or retrieving a CSV booking
- */
-export class CsvBookingResponseDto {
-  @ApiProperty({
-    description: 'Booking unique ID',
-    example: '123e4567-e89b-12d3-a456-426614174000',
-  })
-  id: string;
-
-  @ApiProperty({
-    description: 'User ID who created the booking',
-    example: '987fcdeb-51a2-43e8-9c6d-8b9a1c2d3e4f',
-  })
-  userId: string;
-
-  @ApiProperty({
-    description: 'Organization ID',
-    example: 'a1234567-0000-4000-8000-000000000001',
-  })
-  organizationId: string;
-
-  @ApiProperty({
-    description: 'Carrier/Company name',
-    example: 'SSC Consolidation',
-  })
-  carrierName: string;
-
-  @ApiProperty({
-    description: 'Carrier email address',
-    example: 'bookings@sscconsolidation.com',
-  })
-  carrierEmail: string;
-
-  @ApiProperty({
-    description: 'Origin port code',
-    example: 'NLRTM',
-  })
-  origin: string;
-
-  @ApiProperty({
-    description: 'Destination port code',
-    example: 'USNYC',
-  })
-  destination: string;
-
-  @ApiProperty({
-    description: 'Volume in CBM',
-    example: 25.5,
-  })
-  volumeCBM: number;
-
-  @ApiProperty({
-    description: 'Weight in KG',
-    example: 3500,
-  })
-  weightKG: number;
-
-  @ApiProperty({
-    description: 'Number of pallets',
-    example: 10,
-  })
-  palletCount: number;
-
-  @ApiProperty({
-    description: 'Price in USD',
-    example: 1850.5,
-  })
-  priceUSD: number;
-
-  @ApiProperty({
-    description: 'Price in EUR',
-    example: 1665.45,
-  })
-  priceEUR: number;
-
-  @ApiProperty({
-    description: 'Primary currency',
-    enum: ['USD', 'EUR'],
-    example: 'USD',
-  })
-  primaryCurrency: string;
-
-  @ApiProperty({
-    description: 'Transit time in days',
-    example: 28,
-  })
-  transitDays: number;
-
-  @ApiProperty({
-    description: 'Container type',
-    example: 'LCL',
-  })
-  containerType: string;
-
-  @ApiProperty({
-    description: 'Booking status',
-    enum: ['PENDING', 'ACCEPTED', 'REJECTED', 'CANCELLED'],
-    example: 'PENDING',
-  })
-  status: string;
-
-  @ApiProperty({
-    description: 'Uploaded documents',
-    type: [CsvBookingDocumentDto],
-  })
-  documents: CsvBookingDocumentDto[];
-
-  @ApiProperty({
-    description: 'Confirmation token for accept/reject actions',
-    example: 'abc123-def456-ghi789',
-  })
-  confirmationToken: string;
-
-  @ApiProperty({
-    description: 'Booking request timestamp',
-    example: '2025-10-23T14:30:00Z',
-  })
-  requestedAt: Date;
-
-  @ApiProperty({
-    description: 'Response timestamp (when accepted/rejected)',
-    example: '2025-10-24T09:15:00Z',
-    nullable: true,
-  })
-  respondedAt: Date | null;
-
-  @ApiPropertyOptional({
-    description: 'Additional notes',
-    example: 'Please handle with care',
-  })
-  notes?: string;
-
-  @ApiPropertyOptional({
-    description: 'Rejection reason (if rejected)',
-    example: 'No capacity available for requested dates',
-  })
-  rejectionReason?: string;
-
-  @ApiProperty({
-    description: 'Route description (origin → destination)',
-    example: 'NLRTM → USNYC',
-  })
-  routeDescription: string;
-
-  @ApiProperty({
-    description: 'Whether the booking is expired (7+ days pending)',
-    example: false,
-  })
-  isExpired: boolean;
-
-  @ApiProperty({
-    description: 'Price in the primary currency',
-    example: 1850.5,
-  })
-  price: number;
-}
-
-/**
- * Update CSV Booking Status DTO
- *
- * Request body for accepting/rejecting a booking
- */
-export class UpdateCsvBookingStatusDto {
-  @ApiPropertyOptional({
-    description: 'Rejection reason (required when rejecting)',
-    example: 'No capacity available',
-  })
-  @IsOptional()
-  @IsString()
-  @MaxLength(500)
-  rejectionReason?: string;
-}
-
-/**
- * CSV Booking List Response DTO
- *
- * Paginated list of bookings
- */
-export class CsvBookingListResponseDto {
-  @ApiProperty({
-    description: 'Array of bookings',
-    type: [CsvBookingResponseDto],
-  })
-  bookings: CsvBookingResponseDto[];
-
-  @ApiProperty({
-    description: 'Total number of bookings',
-    example: 42,
-  })
-  total: number;
-
-  @ApiProperty({
-    description: 'Current page number',
-    example: 1,
-  })
-  page: number;
-
-  @ApiProperty({
-    description: 'Number of items per page',
-    example: 10,
-  })
-  limit: number;
-
-  @ApiProperty({
-    description: 'Total number of pages',
-    example: 5,
-  })
-  totalPages: number;
-}
-
-/**
- * CSV Booking Statistics DTO
- *
- * Statistics for user's or organization's bookings
- */
-export class CsvBookingStatsDto {
-  @ApiProperty({
-    description: 'Number of pending bookings',
-    example: 5,
-  })
-  pending: number;
-
-  @ApiProperty({
-    description: 'Number of accepted bookings',
-    example: 12,
-  })
-  accepted: number;
-
-  @ApiProperty({
-    description: 'Number of rejected bookings',
-    example: 2,
-  })
-  rejected: number;
-
-  @ApiProperty({
-    description: 'Number of cancelled bookings',
-    example: 1,
-  })
-  cancelled: number;
-
-  @ApiProperty({
-    description: 'Total number of bookings',
-    example: 20,
-  })
-  total: number;
-}

apps/backend/src/application/dto/csv-rate-search.dto.ts

@@ -1,394 +0,0 @@
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import {
-  IsNotEmpty,
-  IsString,
-  IsNumber,
-  Min,
-  IsOptional,
-  ValidateNested,
-  IsBoolean,
-} from 'class-validator';
-import { Type } from 'class-transformer';
-import { RateSearchFiltersDto } from './rate-search-filters.dto';
-
-/**
- * CSV Rate Search Request DTO
- *
- * Request body for searching rates in CSV-based system
- * Includes basic search parameters + optional advanced filters
- */
-export class CsvRateSearchDto {
-  @ApiProperty({
-    description: 'Origin port code (UN/LOCODE format)',
-    example: 'NLRTM',
-    pattern: '^[A-Z]{2}[A-Z0-9]{3}$',
-  })
-  @IsNotEmpty()
-  @IsString()
-  origin: string;
-
-  @ApiProperty({
-    description: 'Destination port code (UN/LOCODE format)',
-    example: 'USNYC',
-    pattern: '^[A-Z]{2}[A-Z0-9]{3}$',
-  })
-  @IsNotEmpty()
-  @IsString()
-  destination: string;
-
-  @ApiProperty({
-    description: 'Volume in cubic meters (CBM)',
-    minimum: 0.01,
-    example: 25.5,
-  })
-  @IsNotEmpty()
-  @IsNumber()
-  @Min(0.01)
-  volumeCBM: number;
-
-  @ApiProperty({
-    description: 'Weight in kilograms',
-    minimum: 1,
-    example: 3500,
-  })
-  @IsNotEmpty()
-  @IsNumber()
-  @Min(1)
-  weightKG: number;
-
-  @ApiPropertyOptional({
-    description: 'Number of pallets (0 if no pallets)',
-    minimum: 0,
-    example: 10,
-    default: 0,
-  })
-  @IsOptional()
-  @IsNumber()
-  @Min(0)
-  palletCount?: number;
-
-  @ApiPropertyOptional({
-    description: 'Container type filter (e.g., LCL, 20DRY, 40HC)',
-    example: 'LCL',
-  })
-  @IsOptional()
-  @IsString()
-  containerType?: string;
-
-  @ApiPropertyOptional({
-    description: 'Advanced filters for narrowing results',
-    type: RateSearchFiltersDto,
-  })
-  @IsOptional()
-  @ValidateNested()
-  @Type(() => RateSearchFiltersDto)
-  filters?: RateSearchFiltersDto;
-
-  // Service requirements for detailed price calculation
-  @ApiPropertyOptional({
-    description: 'Cargo contains dangerous goods (DG)',
-    example: true,
-    default: false,
-  })
-  @IsOptional()
-  @IsBoolean()
-  hasDangerousGoods?: boolean;
-
-  @ApiPropertyOptional({
-    description: 'Requires special handling',
-    example: true,
-    default: false,
-  })
-  @IsOptional()
-  @IsBoolean()
-  requiresSpecialHandling?: boolean;
-
-  @ApiPropertyOptional({
-    description: 'Requires tailgate lift',
-    example: false,
-    default: false,
-  })
-  @IsOptional()
-  @IsBoolean()
-  requiresTailgate?: boolean;
-
-  @ApiPropertyOptional({
-    description: 'Requires securing straps',
-    example: true,
-    default: false,
-  })
-  @IsOptional()
-  @IsBoolean()
-  requiresStraps?: boolean;
-
-  @ApiPropertyOptional({
-    description: 'Requires thermal protection cover',
-    example: false,
-    default: false,
-  })
-  @IsOptional()
-  @IsBoolean()
-  requiresThermalCover?: boolean;
-
-  @ApiPropertyOptional({
-    description: 'Contains regulated products requiring special documentation',
-    example: false,
-    default: false,
-  })
-  @IsOptional()
-  @IsBoolean()
-  hasRegulatedProducts?: boolean;
-
-  @ApiPropertyOptional({
-    description: 'Requires delivery appointment',
-    example: true,
-    default: false,
-  })
-  @IsOptional()
-  @IsBoolean()
-  requiresAppointment?: boolean;
-}
-
-/**
- * CSV Rate Search Response DTO
- *
- * Response containing matching rates with calculated prices
- */
-export class CsvRateSearchResponseDto {
-  @ApiProperty({
-    description: 'Array of matching rate results',
-    type: [Object], // Will be replaced with RateResultDto
-  })
-  results: CsvRateResultDto[];
-
-  @ApiProperty({
-    description: 'Total number of results found',
-    example: 15,
-  })
-  totalResults: number;
-
-  @ApiProperty({
-    description: 'CSV files that were searched',
-    type: [String],
-    example: ['ssc-consolidation.csv', 'ecu-worldwide.csv'],
-  })
-  searchedFiles: string[];
-
-  @ApiProperty({
-    description: 'Timestamp when search was executed',
-    example: '2025-10-23T10:30:00Z',
-  })
-  searchedAt: Date;
-
-  @ApiProperty({
-    description: 'Filters that were applied to the search',
-    type: RateSearchFiltersDto,
-  })
-  appliedFilters: RateSearchFiltersDto;
-}
-
-/**
- * Surcharge Item DTO
- */
-export class SurchargeItemDto {
-  @ApiProperty({
-    description: 'Surcharge code',
-    example: 'DG_FEE',
-  })
-  code: string;
-
-  @ApiProperty({
-    description: 'Surcharge description',
-    example: 'Dangerous goods fee',
-  })
-  description: string;
-
-  @ApiProperty({
-    description: 'Surcharge amount in currency',
-    example: 65.0,
-  })
-  amount: number;
-
-  @ApiProperty({
-    description: 'Type of surcharge calculation',
-    enum: ['FIXED', 'PER_UNIT', 'PERCENTAGE'],
-    example: 'FIXED',
-  })
-  type: 'FIXED' | 'PER_UNIT' | 'PERCENTAGE';
-}
-
-/**
- * Price Breakdown DTO
- */
-export class PriceBreakdownDto {
-  @ApiProperty({
-    description: 'Base price before any charges',
-    example: 0,
-  })
-  basePrice: number;
-
-  @ApiProperty({
-    description: 'Charge based on volume (CBM)',
-    example: 150.0,
-  })
-  volumeCharge: number;
-
-  @ApiProperty({
-    description: 'Charge based on weight (KG)',
-    example: 25.0,
-  })
-  weightCharge: number;
-
-  @ApiProperty({
-    description: 'Charge for pallets',
-    example: 125.0,
-  })
-  palletCharge: number;
-
-  @ApiProperty({
-    description: 'List of all surcharges',
-    type: [SurchargeItemDto],
-  })
-  surcharges: SurchargeItemDto[];
-
-  @ApiProperty({
-    description: 'Total of all surcharges',
-    example: 242.0,
-  })
-  totalSurcharges: number;
-
-  @ApiProperty({
-    description: 'Total price including all charges',
-    example: 542.0,
-  })
-  totalPrice: number;
-
-  @ApiProperty({
-    description: 'Currency of the pricing',
-    enum: ['USD', 'EUR'],
-    example: 'USD',
-  })
-  currency: string;
-}
-
-/**
- * Single CSV Rate Result DTO
- */
-export class CsvRateResultDto {
-  @ApiProperty({
-    description: 'Company name',
-    example: 'SSC Consolidation',
-  })
-  companyName: string;
-
-  @ApiProperty({
-    description: 'Company email for booking requests',
-    example: 'bookings@sscconsolidation.com',
-  })
-  companyEmail: string;
-
-  @ApiProperty({
-    description: 'Origin port code',
-    example: 'NLRTM',
-  })
-  origin: string;
-
-  @ApiProperty({
-    description: 'Destination port code',
-    example: 'USNYC',
-  })
-  destination: string;
-
-  @ApiProperty({
-    description: 'Container type',
-    example: 'LCL',
-  })
-  containerType: string;
-
-  @ApiProperty({
-    description: 'Calculated price in USD',
-    example: 1850.5,
-  })
-  priceUSD: number;
-
-  @ApiProperty({
-    description: 'Calculated price in EUR',
-    example: 1665.45,
-  })
-  priceEUR: number;
-
-  @ApiProperty({
-    description: 'Primary currency of the rate',
-    enum: ['USD', 'EUR'],
-    example: 'USD',
-  })
-  primaryCurrency: string;
-
-  @ApiProperty({
-    description: 'Detailed price breakdown with all charges',
-    type: PriceBreakdownDto,
-  })
-  priceBreakdown: PriceBreakdownDto;
-
-  @ApiProperty({
-    description: 'Whether this rate has separate surcharges',
-    example: true,
-  })
-  hasSurcharges: boolean;
-
-  @ApiProperty({
-    description: 'Details of surcharges if any',
-    example: 'BAF+CAF included',
-    nullable: true,
-  })
-  surchargeDetails: string | null;
-
-  @ApiProperty({
-    description: 'Transit time in days',
-    example: 28,
-  })
-  transitDays: number;
-
-  @ApiProperty({
-    description: 'Rate validity end date',
-    example: '2025-12-31',
-  })
-  validUntil: string;
-
-  @ApiProperty({
-    description: 'Source of the rate',
-    enum: ['CSV', 'API'],
-    example: 'CSV',
-  })
-  source: 'CSV' | 'API';
-
-  @ApiProperty({
-    description: 'Match score (0-100) indicating how well this rate matches the search',
-    minimum: 0,
-    maximum: 100,
-    example: 95,
-  })
-  matchScore: number;
-
-  @ApiPropertyOptional({
-    description: 'Service level (only present when using search-csv-offers endpoint)',
-    enum: ['RAPID', 'STANDARD', 'ECONOMIC'],
-    example: 'RAPID',
-  })
-  serviceLevel?: string;
-
-  @ApiPropertyOptional({
-    description: 'Original price before service level adjustment',
-    example: { usd: 1500.0, eur: 1350.0 },
-  })
-  originalPrice?: {
-    usd: number;
-    eur: number;
-  };
-
-  @ApiPropertyOptional({
-    description: 'Original transit days before service level adjustment',
-    example: 20,
-  })
-  originalTransitDays?: number;
-}

apps/backend/src/application/dto/csv-rate-upload.dto.ts

@@ -1,211 +0,0 @@
-import { ApiProperty } from '@nestjs/swagger';
-import { IsNotEmpty, IsString, MaxLength, IsEmail } from 'class-validator';
-
-/**
- * CSV Rate Upload DTO
- *
- * Request DTO for uploading CSV rate files (ADMIN only)
- */
-export class CsvRateUploadDto {
-  @ApiProperty({
-    description: 'Name of the carrier company',
-    example: 'SSC Consolidation',
-    maxLength: 255,
-  })
-  @IsNotEmpty()
-  @IsString()
-  @MaxLength(255)
-  companyName: string;
-
-  @ApiProperty({
-    description: 'Email address of the carrier company for booking requests',
-    example: 'bookings@sscconsolidation.com',
-    maxLength: 255,
-  })
-  @IsNotEmpty()
-  @IsEmail()
-  @MaxLength(255)
-  companyEmail: string;
-
-  @ApiProperty({
-    description: 'CSV file containing shipping rates',
-    type: 'string',
-    format: 'binary',
-  })
-  file: any; // Will be handled by multer
-}
-
-/**
- * CSV Rate Upload Response DTO
- */
-export class CsvRateUploadResponseDto {
-  @ApiProperty({
-    description: 'Upload success status',
-    example: true,
-  })
-  success: boolean;
-
-  @ApiProperty({
-    description: 'Number of rate rows parsed from CSV',
-    example: 25,
-  })
-  ratesCount: number;
-
-  @ApiProperty({
-    description: 'Path where CSV file was saved',
-    example: 'ssc-consolidation.csv',
-  })
-  csvFilePath: string;
-
-  @ApiProperty({
-    description: 'Company name for which rates were uploaded',
-    example: 'SSC Consolidation',
-  })
-  companyName: string;
-
-  @ApiProperty({
-    description: 'Upload timestamp',
-    example: '2025-10-23T10:30:00Z',
-  })
-  uploadedAt: Date;
-}
-
-/**
- * CSV Rate Config Response DTO
- *
- * Configuration entry for a company's CSV rates
- */
-export class CsvRateConfigDto {
-  @ApiProperty({
-    description: 'Configuration ID',
-    example: '123e4567-e89b-12d3-a456-426614174000',
-  })
-  id: string;
-
-  @ApiProperty({
-    description: 'Company name',
-    example: 'SSC Consolidation',
-  })
-  companyName: string;
-
-  @ApiProperty({
-    description: 'CSV file path',
-    example: 'ssc-consolidation.csv',
-  })
-  csvFilePath: string;
-
-  @ApiProperty({
-    description: 'Integration type',
-    enum: ['CSV_ONLY', 'CSV_AND_API'],
-    example: 'CSV_ONLY',
-  })
-  type: 'CSV_ONLY' | 'CSV_AND_API';
-
-  @ApiProperty({
-    description: 'Whether company has API connector',
-    example: false,
-  })
-  hasApi: boolean;
-
-  @ApiProperty({
-    description: 'API connector name if hasApi is true',
-    example: null,
-    nullable: true,
-  })
-  apiConnector: string | null;
-
-  @ApiProperty({
-    description: 'Whether configuration is active',
-    example: true,
-  })
-  isActive: boolean;
-
-  @ApiProperty({
-    description: 'When CSV was last uploaded',
-    example: '2025-10-23T10:30:00Z',
-  })
-  uploadedAt: Date;
-
-  @ApiProperty({
-    description: 'Number of rate rows in CSV',
-    example: 25,
-    nullable: true,
-  })
-  rowCount: number | null;
-
-  @ApiProperty({
-    description: 'Additional metadata',
-    example: { description: 'LCL rates for Europe to US', coverage: 'Global' },
-    nullable: true,
-  })
-  metadata: Record<string, any> | null;
-}
-
-/**
- * CSV File Validation Result DTO
- */
-export class CsvFileValidationDto {
-  @ApiProperty({
-    description: 'Whether CSV file is valid',
-    example: true,
-  })
-  valid: boolean;
-
-  @ApiProperty({
-    description: 'Validation errors if any',
-    type: [String],
-    example: [],
-  })
-  errors: string[];
-
-  @ApiProperty({
-    description: 'Number of rows in CSV file',
-    example: 25,
-    required: false,
-  })
-  rowCount?: number;
-}
-
-/**
- * Available Companies Response DTO
- */
-export class AvailableCompaniesDto {
-  @ApiProperty({
-    description: 'List of available company names',
-    type: [String],
-    example: ['SSC Consolidation', 'ECU Worldwide', 'TCC Logistics', 'NVO Consolidation'],
-  })
-  companies: string[];
-
-  @ApiProperty({
-    description: 'Total number of companies',
-    example: 4,
-  })
-  total: number;
-}
-
-/**
- * Filter Options Response DTO
- */
-export class FilterOptionsDto {
-  @ApiProperty({
-    description: 'Available company names',
-    type: [String],
-    example: ['SSC Consolidation', 'ECU Worldwide', 'TCC Logistics', 'NVO Consolidation'],
-  })
-  companies: string[];
-
-  @ApiProperty({
-    description: 'Available container types',
-    type: [String],
-    example: ['LCL', '20DRY', '40HC', '40DRY'],
-  })
-  containerTypes: string[];
-
-  @ApiProperty({
-    description: 'Supported currencies',
-    type: [String],
-    example: ['USD', 'EUR'],
-  })
-  currencies: string[];
-}

apps/backend/src/application/dto/index.ts

@@ -1,12 +0,0 @@
-// Rate Search DTOs
-export * from './rate-search-request.dto';
-export * from './rate-search-response.dto';
-
-// Booking DTOs
-export * from './create-booking-request.dto';
-export * from './booking-response.dto';
-export * from './booking-filter.dto';
-export * from './booking-export.dto';
-
-// Port DTOs
-export * from './port.dto';

apps/backend/src/application/dto/invitation.dto.ts

@@ -1,159 +0,0 @@
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { IsEmail, IsString, MinLength, IsEnum, IsOptional } from 'class-validator';
-
-export enum InvitationRole {
-  MANAGER = 'MANAGER',
-  USER = 'USER',
-  VIEWER = 'VIEWER',
-}
-
-/**
- * Create Invitation DTO
- */
-export class CreateInvitationDto {
-  @ApiProperty({
-    example: 'jane.doe@acme.com',
-    description: 'Email address of the person to invite',
-  })
-  @IsEmail({}, { message: 'Invalid email format' })
-  email: string;
-
-  @ApiProperty({
-    example: 'Jane',
-    description: 'First name',
-    minLength: 2,
-  })
-  @IsString()
-  @MinLength(2, { message: 'First name must be at least 2 characters' })
-  firstName: string;
-
-  @ApiProperty({
-    example: 'Doe',
-    description: 'Last name',
-    minLength: 2,
-  })
-  @IsString()
-  @MinLength(2, { message: 'Last name must be at least 2 characters' })
-  lastName: string;
-
-  @ApiProperty({
-    example: InvitationRole.USER,
-    description: 'Role to assign to the invited user',
-    enum: InvitationRole,
-  })
-  @IsEnum(InvitationRole)
-  role: InvitationRole;
-}
-
-/**
- * Invitation Response DTO
- */
-export class InvitationResponseDto {
-  @ApiProperty({
-    example: '550e8400-e29b-41d4-a716-446655440000',
-    description: 'Invitation ID',
-  })
-  id: string;
-
-  @ApiProperty({
-    example: 'abc123def456',
-    description: 'Invitation token',
-  })
-  token: string;
-
-  @ApiProperty({
-    example: 'jane.doe@acme.com',
-    description: 'Email address',
-  })
-  email: string;
-
-  @ApiProperty({
-    example: 'Jane',
-    description: 'First name',
-  })
-  firstName: string;
-
-  @ApiProperty({
-    example: 'Doe',
-    description: 'Last name',
-  })
-  lastName: string;
-
-  @ApiProperty({
-    example: InvitationRole.USER,
-    description: 'Role',
-    enum: InvitationRole,
-  })
-  role: string;
-
-  @ApiProperty({
-    example: '550e8400-e29b-41d4-a716-446655440000',
-    description: 'Organization ID',
-  })
-  organizationId: string;
-
-  @ApiProperty({
-    example: '2025-12-01T00:00:00Z',
-    description: 'Expiration date',
-  })
-  expiresAt: Date;
-
-  @ApiProperty({
-    example: false,
-    description: 'Whether the invitation has been used',
-  })
-  isUsed: boolean;
-
-  @ApiPropertyOptional({
-    example: '2025-11-24T10:00:00Z',
-    description: 'Date when invitation was used',
-  })
-  usedAt?: Date;
-
-  @ApiProperty({
-    example: '2025-11-20T10:00:00Z',
-    description: 'Creation date',
-  })
-  createdAt: Date;
-}
-
-/**
- * Verify Invitation DTO
- */
-export class VerifyInvitationDto {
-  @ApiProperty({
-    example: 'abc123def456',
-    description: 'Invitation token',
-  })
-  @IsString()
-  token: string;
-}
-
-/**
- * Accept Invitation DTO (for registration)
- */
-export class AcceptInvitationDto {
-  @ApiProperty({
-    example: 'abc123def456',
-    description: 'Invitation token',
-  })
-  @IsString()
-  token: string;
-
-  @ApiProperty({
-    example: 'SecurePassword123!',
-    description: 'Password (minimum 12 characters)',
-    minLength: 12,
-  })
-  @IsString()
-  @MinLength(12, { message: 'Password must be at least 12 characters' })
-  password: string;
-
-  @ApiPropertyOptional({
-    example: '+33612345678',
-    description: 'Phone number (optional)',
-  })
-  @IsString()
-  @IsOptional()
-  phoneNumber?: string;
-}

apps/backend/src/application/dto/organization.dto.ts

@@ -1,399 +0,0 @@
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import {
-  IsString,
-  IsEnum,
-  IsNotEmpty,
-  MinLength,
-  MaxLength,
-  IsOptional,
-  IsUrl,
-  IsBoolean,
-  ValidateNested,
-  Matches,
-  IsUUID,
-} from 'class-validator';
-import { Type } from 'class-transformer';
-import { OrganizationType } from '@domain/entities/organization.entity';
-
-/**
- * Address DTO
- */
-export class AddressDto {
-  @ApiProperty({
-    example: '123 Main Street',
-    description: 'Street address',
-  })
-  @IsString()
-  @IsNotEmpty()
-  street: string;
-
-  @ApiProperty({
-    example: 'Rotterdam',
-    description: 'City',
-  })
-  @IsString()
-  @IsNotEmpty()
-  city: string;
-
-  @ApiPropertyOptional({
-    example: 'South Holland',
-    description: 'State or province',
-  })
-  @IsString()
-  @IsOptional()
-  state?: string;
-
-  @ApiProperty({
-    example: '3000 AB',
-    description: 'Postal code',
-  })
-  @IsString()
-  @IsNotEmpty()
-  postalCode: string;
-
-  @ApiProperty({
-    example: 'NL',
-    description: 'Country code (ISO 3166-1 alpha-2)',
-    minLength: 2,
-    maxLength: 2,
-  })
-  @IsString()
-  @MinLength(2)
-  @MaxLength(2)
-  @Matches(/^[A-Z]{2}$/, { message: 'Country must be a 2-letter ISO code (e.g., NL, US, CN)' })
-  country: string;
-}
-
-/**
- * Create Organization DTO
- */
-export class CreateOrganizationDto {
-  @ApiProperty({
-    example: 'Acme Freight Forwarding',
-    description: 'Organization name',
-    minLength: 2,
-    maxLength: 200,
-  })
-  @IsString()
-  @IsNotEmpty()
-  @MinLength(2)
-  @MaxLength(200)
-  name: string;
-
-  @ApiProperty({
-    example: OrganizationType.FREIGHT_FORWARDER,
-    description: 'Organization type',
-    enum: OrganizationType,
-  })
-  @IsEnum(OrganizationType)
-  type: OrganizationType;
-
-  @ApiPropertyOptional({
-    example: 'MAEU',
-    description: 'Standard Carrier Alpha Code (4 uppercase letters, required for carriers only)',
-    minLength: 4,
-    maxLength: 4,
-  })
-  @IsString()
-  @IsOptional()
-  @MinLength(4)
-  @MaxLength(4)
-  @Matches(/^[A-Z]{4}$/, { message: 'SCAC must be 4 uppercase letters (e.g., MAEU, MSCU)' })
-  scac?: string;
-
-  @ApiPropertyOptional({
-    example: '123456789',
-    description: 'French SIREN number (9 digits)',
-    minLength: 9,
-    maxLength: 9,
-  })
-  @IsString()
-  @IsOptional()
-  @MinLength(9)
-  @MaxLength(9)
-  @Matches(/^[0-9]{9}$/, { message: 'SIREN must be 9 digits' })
-  siren?: string;
-
-  @ApiPropertyOptional({
-    example: 'FR123456789',
-    description: 'EU EORI number',
-  })
-  @IsString()
-  @IsOptional()
-  eori?: string;
-
-  @ApiPropertyOptional({
-    example: '+33 6 80 18 28 12',
-    description: 'Contact phone number',
-  })
-  @IsString()
-  @IsOptional()
-  contact_phone?: string;
-
-  @ApiPropertyOptional({
-    example: 'contact@xpeditis.com',
-    description: 'Contact email address',
-  })
-  @IsString()
-  @IsOptional()
-  contact_email?: string;
-
-  @ApiProperty({
-    description: 'Organization address',
-    type: AddressDto,
-  })
-  @ValidateNested()
-  @Type(() => AddressDto)
-  address: AddressDto;
-
-  @ApiPropertyOptional({
-    example: 'https://example.com/logo.png',
-    description: 'Logo URL',
-  })
-  @IsUrl()
-  @IsOptional()
-  logoUrl?: string;
-}
-
-/**
- * Update Organization DTO
- */
-export class UpdateOrganizationDto {
-  @ApiPropertyOptional({
-    example: 'Acme Freight Forwarding Inc.',
-    description: 'Organization name',
-    minLength: 2,
-    maxLength: 200,
-  })
-  @IsString()
-  @IsOptional()
-  @MinLength(2)
-  @MaxLength(200)
-  name?: string;
-
-  @ApiPropertyOptional({
-    example: '123456789',
-    description: 'French SIREN number (9 digits)',
-    minLength: 9,
-    maxLength: 9,
-  })
-  @IsString()
-  @IsOptional()
-  @MinLength(9)
-  @MaxLength(9)
-  @Matches(/^[0-9]{9}$/, { message: 'SIREN must be 9 digits' })
-  siren?: string;
-
-  @ApiPropertyOptional({
-    example: 'FR123456789',
-    description: 'EU EORI number',
-  })
-  @IsString()
-  @IsOptional()
-  eori?: string;
-
-  @ApiPropertyOptional({
-    example: '+33 6 80 18 28 12',
-    description: 'Contact phone number',
-  })
-  @IsString()
-  @IsOptional()
-  contact_phone?: string;
-
-  @ApiPropertyOptional({
-    example: 'contact@xpeditis.com',
-    description: 'Contact email address',
-  })
-  @IsString()
-  @IsOptional()
-  contact_email?: string;
-
-  @ApiPropertyOptional({
-    description: 'Organization address',
-    type: AddressDto,
-  })
-  @ValidateNested()
-  @Type(() => AddressDto)
-  @IsOptional()
-  address?: AddressDto;
-
-  @ApiPropertyOptional({
-    example: 'https://example.com/logo.png',
-    description: 'Logo URL',
-  })
-  @IsUrl()
-  @IsOptional()
-  logoUrl?: string;
-
-  @ApiPropertyOptional({
-    example: true,
-    description: 'Active status',
-  })
-  @IsBoolean()
-  @IsOptional()
-  isActive?: boolean;
-}
-
-/**
- * Organization Document DTO
- */
-export class OrganizationDocumentDto {
-  @ApiProperty({
-    example: '550e8400-e29b-41d4-a716-446655440000',
-    description: 'Document ID',
-  })
-  @IsUUID()
-  id: string;
-
-  @ApiProperty({
-    example: 'business_license',
-    description: 'Document type',
-  })
-  @IsString()
-  type: string;
-
-  @ApiProperty({
-    example: 'Business License 2025',
-    description: 'Document name',
-  })
-  @IsString()
-  name: string;
-
-  @ApiProperty({
-    example: 'https://s3.amazonaws.com/xpeditis/documents/doc123.pdf',
-    description: 'Document URL',
-  })
-  @IsUrl()
-  url: string;
-
-  @ApiProperty({
-    example: '2025-01-15T10:00:00Z',
-    description: 'Upload timestamp',
-  })
-  uploadedAt: Date;
-}
-
-/**
- * Organization Response DTO
- */
-export class OrganizationResponseDto {
-  @ApiProperty({
-    example: '550e8400-e29b-41d4-a716-446655440000',
-    description: 'Organization ID',
-  })
-  id: string;
-
-  @ApiProperty({
-    example: 'Acme Freight Forwarding',
-    description: 'Organization name',
-  })
-  name: string;
-
-  @ApiProperty({
-    example: OrganizationType.FREIGHT_FORWARDER,
-    description: 'Organization type',
-    enum: OrganizationType,
-  })
-  type: OrganizationType;
-
-  @ApiPropertyOptional({
-    example: 'MAEU',
-    description: 'Standard Carrier Alpha Code (carriers only)',
-  })
-  scac?: string;
-
-  @ApiPropertyOptional({
-    example: '123456789',
-    description: 'French SIREN number (9 digits)',
-  })
-  siren?: string;
-
-  @ApiPropertyOptional({
-    example: 'FR123456789',
-    description: 'EU EORI number',
-  })
-  eori?: string;
-
-  @ApiPropertyOptional({
-    example: '+33 6 80 18 28 12',
-    description: 'Contact phone number',
-  })
-  contact_phone?: string;
-
-  @ApiPropertyOptional({
-    example: 'contact@xpeditis.com',
-    description: 'Contact email address',
-  })
-  contact_email?: string;
-
-  @ApiProperty({
-    description: 'Organization address',
-    type: AddressDto,
-  })
-  address: AddressDto;
-
-  @ApiPropertyOptional({
-    example: 'https://example.com/logo.png',
-    description: 'Logo URL',
-  })
-  logoUrl?: string;
-
-  @ApiProperty({
-    description: 'Organization documents',
-    type: [OrganizationDocumentDto],
-  })
-  documents: OrganizationDocumentDto[];
-
-  @ApiProperty({
-    example: true,
-    description: 'Active status',
-  })
-  isActive: boolean;
-
-  @ApiProperty({
-    example: '2025-01-01T00:00:00Z',
-    description: 'Creation timestamp',
-  })
-  createdAt: Date;
-
-  @ApiProperty({
-    example: '2025-01-15T10:00:00Z',
-    description: 'Last update timestamp',
-  })
-  updatedAt: Date;
-}
-
-/**
- * Organization List Response DTO
- */
-export class OrganizationListResponseDto {
-  @ApiProperty({
-    description: 'List of organizations',
-    type: [OrganizationResponseDto],
-  })
-  organizations: OrganizationResponseDto[];
-
-  @ApiProperty({
-    example: 25,
-    description: 'Total number of organizations',
-  })
-  total: number;
-
-  @ApiProperty({
-    example: 1,
-    description: 'Current page number',
-  })
-  page: number;
-
-  @ApiProperty({
-    example: 20,
-    description: 'Page size',
-  })
-  pageSize: number;
-
-  @ApiProperty({
-    example: 2,
-    description: 'Total number of pages',
-  })
-  totalPages: number;
-}