changed static paths to relative api paths so useable without cors

.github/workflows/docker.yml

@@ -1,10 +1,10 @@
 name: CI/CD Pipeline
 
 on:
+  workflow_dispatch:
   push:
-    branches: [ main, master, development ]
+    branches: [ "development", "main", "staging" ]
-  pull_request:
+    tags: [ "v*.*.*" ]
-    branches: [ main, master, development ]
 
 env:
   REGISTRY: ghcr.io
@@ -110,8 +110,9 @@ jobs:
     if: github.event_name == 'push'
     
     permissions:
-      contents: read
+      contents: write
       packages: write
+      id-token: write
 
     steps:
       - name: Checkout code
@@ -163,7 +164,7 @@ jobs:
 
       - name: Display pushed images
         run: |
-          echo "✅ Docker images pushed successfully!"
+          echo "Docker images pushed successfully!"
-          echo "📦 Image: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}"
+          echo "- Image: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}"
-          echo "🏷️  Tags: ${{ steps.meta.outputs.tags }}"
+          echo "- Tags: ${{ steps.meta.outputs.tags }}"
-          echo "🚀 New version: ${{ needs.set-tag.outputs.tag_name }}"
+          echo "- New version: ${{ needs.set-tag.outputs.tag_name }}"

Dockerfile

@@ -5,7 +5,7 @@ WORKDIR /app/backend
 
 # Install Python + OR-Tools
 RUN apt-get update && apt-get install -y python3 python3-pip build-essential \
- && pip install --no-cache-dir ortools
+  && pip install --no-cache-dir ortools
 
 # Create symlink so python3 is callable as python
 RUN ln -sf /usr/bin/python3 /usr/bin/python
@@ -23,13 +23,12 @@ COPY backend/src/ ./src/
 # Build backend
 RUN npm run build
 
+# Copy database files manually
+RUN cp -r src/database/ dist/database/
 
 # Verify Python and OR-Tools installation
 RUN python -c "from ortools.sat.python import cp_model; print('OR-Tools installed successfully')"
 
-#RUN python3 -c "from ortools.sat.python import cp_model; print('OR-Tools installed successfully')"
-
-
 # Frontend build stage
 FROM node:20-bullseye AS frontend-builder
 
@@ -50,45 +49,42 @@ COPY frontend/public/ ./public/
 RUN npm run build
 
 # Production stage
-FROM node:20-alpine
+FROM node:20-bookworm
 
 WORKDIR /app
 
-# Install Python and OR-Tools for production
-#RUN apk add --no-cache \
-#    python \
-#    py3-pip \
-#    && pip3 install ortools
-
 # Install PM2 for process management
 RUN npm install -g pm2
 
+# Create data directory for SQLite database with proper permissions
+RUN mkdir -p /app/data
+
 # Copy backend built files
 COPY --from=backend-builder /app/backend/package*.json ./
 COPY --from=backend-builder /app/backend/dist/ ./dist/
 COPY --from=backend-builder /app/backend/node_modules/ ./node_modules/
-# COPY --from=backend-builder /app/backend/python-scripts/ ./python-scripts/
 
 # Copy frontend built files  
 COPY --from=frontend-builder /app/frontend/build/ ./frontend-build/
 
 # Copy PM2 configuration
-COPY ecosystem.config.js ./
+COPY ecosystem.config.cjs ./
 
-# Create a non-root user
+# Create a non-root user and group - DEBIAN STYLE
-RUN addgroup -g 1001 -S nodejs && \
+RUN groupadd -g 1001 nodejs && \
-    adduser -S schichtplan -u 1001 && \
+    useradd -m -u 1001 -s /bin/bash -g nodejs schichtplan && \
-    chown -R schichtplan:nodejs /app
+    chown -R schichtplan:nodejs /app && \
+    chmod 755 /app && \
+    chmod 775 /app/data
+
+# Set PM2 to use app directory instead of home directory
+ENV PM2_HOME=/app/.pm2
 
 USER schichtplan
 
-# Verify installations
+EXPOSE 3002
-#RUN python --version && \
-#    python -c "from ortools.sat.python import cp_model; print('OR-Tools verified')"
-
-EXPOSE 3000 3002
 
 HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
   CMD wget --no-verbose --tries=1 --spider http://localhost:3002/api/health || exit 1
 
-CMD ["pm2-runtime", "ecosystem.config.js"]
+CMD ["pm2-runtime", "ecosystem.config.cjs"]

backend/src/scripts/initializeDatabase.ts

@@ -8,7 +8,30 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 export async function initializeDatabase(): Promise<void> {
-  const schemaPath = path.join(__dirname, '../database/schema.sql');
+  const possiblePaths = [
+    path.join(__dirname, '../database/schema.sql'),
+    path.join(__dirname, '../../database/schema.sql'),
+    path.join(process.cwd(), 'database/schema.sql'),
+    path.join(process.cwd(), 'src/database/schema.sql'),
+    path.join(process.cwd(), 'dist/database/schema.sql')
+  ];
+
+  let schemaPath: string | null = null;
+
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) {
+      schemaPath = p;
+      break;
+    }
+  }
+
+  if (!schemaPath) {
+    throw new Error(
+      `❌ schema.sql not found in any of the tested paths:\n${possiblePaths.join('\n')}`
+    );
+  }
+
+  console.log(`✅ Using schema at: ${schemaPath}`);
   const schema = fs.readFileSync(schemaPath, 'utf8');
   
   try {

backend/src/server.ts

@@ -1,7 +1,9 @@
 // backend/src/server.ts
 import express from 'express';
-import cors from 'cors';
+import path from 'path';
+import { fileURLToPath } from 'url';
 import { initializeDatabase } from './scripts/initializeDatabase.js';
+import fs from 'fs';
 
 // Route imports
 import authRoutes from './routes/auth.js';
@@ -11,11 +13,13 @@ import setupRoutes from './routes/setup.js';
 import scheduledShifts from './routes/scheduledShifts.js';
 import schedulingRoutes from './routes/scheduling.js';
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const app = express();
 const PORT = 3002;
 
-// CORS und Middleware
+// Middleware
-app.use(cors());
 app.use(express.json());
 
 // API Routes
@@ -26,17 +30,6 @@ app.use('/api/shift-plans', shiftPlanRoutes);
 app.use('/api/scheduled-shifts', scheduledShifts);
 app.use('/api/scheduling', schedulingRoutes);
 
-// Error handling middleware should come after routes
-app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
-  console.error('Unhandled error:', err);
-  res.status(500).json({ error: 'Internal server error' });
-});
-
-// 404 handler for API routes
-app.use('/api/*', (req, res) => {
-  res.status(404).json({ error: 'API endpoint not found' });
-});
-
 // Health route
 app.get('/api/health', (req: any, res: any) => {
   res.json({ 
@@ -46,49 +39,82 @@ app.get('/api/health', (req: any, res: any) => {
   });
 });
 
-// Setup status route (additional endpoint for clarity)
+// 🆕 STATIC FILE SERVING FÜR FRONTEND
-app.get('/api/initial-setup', async (req: any, res: any) => {
+const frontendBuildPath = path.join(__dirname, '../frontend-build');
-  try {
+console.log('📁 Frontend build path:', frontendBuildPath);
-    const { db } = await import('./services/databaseService.js');
-    
-    const adminExists = await db.get<{ 'COUNT(*)': number }>(
-      'SELECT COUNT(*) FROM employees WHERE role = ?',
-      ['admin']
-    );
 
-    res.json({
+// Überprüfe ob das Verzeichnis existiert
-      needsInitialSetup: !adminExists || adminExists['COUNT(*)'] === 0
+if (fs.existsSync(frontendBuildPath)) {
-    });
+  console.log('✅ Frontend build directory exists');
-  } catch (error) {
+  const files = fs.readdirSync(frontendBuildPath);
-    console.error('Error checking initial setup:', error);
+  console.log('📄 Files in frontend-build:', files);
-    res.status(500).json({ error: 'Internal server error' });
+  
+  // Serviere statische Dateien
+  app.use(express.static(frontendBuildPath));
+  
+  console.log('✅ Static file serving configured');
+} else {
+  console.log('❌ Frontend build directory NOT FOUND:', frontendBuildPath);
+}
+
+app.get('/', (req, res) => {
+  const indexPath = path.join(frontendBuildPath, 'index.html');
+  console.log('📄 Serving index.html from:', indexPath);
+  
+  if (fs.existsSync(indexPath)) {
+    res.sendFile(indexPath);
+  } else {
+    console.error('❌ index.html not found at:', indexPath);
+    res.status(404).send('Frontend not found - index.html missing');
   }
 });
 
+app.get('*', (req, res) => {
+  // Ignoriere API Routes
+  if (req.path.startsWith('/api/')) {
+    return res.status(404).json({ error: 'API endpoint not found' });
+  }
+  
+  const indexPath = path.join(frontendBuildPath, 'index.html');
+  console.log('🔄 Client-side routing for:', req.path, '-> index.html');
+  
+  if (fs.existsSync(indexPath)) {
+    res.sendFile(indexPath);
+  } else {
+    console.error('❌ index.html not found for client-side routing');
+    res.status(404).json({ error: 'Frontend application not found' });
+  }
+});
+
+// Error handling middleware
+app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
+  console.error('Unhandled error:', err);
+  res.status(500).json({ error: 'Internal server error' });
+});
+
 // Initialize the application
 const initializeApp = async () => {
   try {
     // Initialize database with base schema
     await initializeDatabase();
-    //console.log('✅ Database initialized successfully');
     
     // Apply any pending migrations
     const { applyMigration } = await import('./scripts/applyMigration.js');
     await applyMigration();
-    //console.log('✅ Database migrations applied');
 
     // Start server only after successful initialization
     app.listen(PORT, () => {
-      console.log('🎉 BACKEND STARTED SUCCESSFULLY!');
+      console.log('🎉 APPLICATION STARTED SUCCESSFULLY!');
       console.log(`📍 Port: ${PORT}`);
-      console.log(`📍 Health: http://localhost:${PORT}/api/health`);
+      console.log(`📍 Frontend: http://localhost:${PORT}`);
+      console.log(`📍 API: http://localhost:${PORT}/api`);
       console.log('');
-      console.log(`🔧 Setup ready at: http://localhost:${PORT}/api/setup/status`);
+      console.log(`🔧 Setup: http://localhost:${PORT}/api/setup/status`);
       console.log('📝 Create your admin account on first launch');
     });
   } catch (error) {
     console.error('❌ Error during initialization:', error);
-    process.exit(1); // Exit if initialization fails
+    process.exit(1);
   }
 };
 

backend/src/services/databaseService.ts

@@ -1,10 +1,18 @@
 import sqlite3 from 'sqlite3';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import fs from 'fs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const dbPath = path.join(__dirname, '../../database/schichtplan.db');
+
+const dbPath = process.env.DB_PATH || '/app/data/schichtplan.db';
+
+// Stelle sicher, dass das Verzeichnis existiert
+const dbDir = path.dirname(dbPath);
+if (!fs.existsSync(dbDir)) {
+  fs.mkdirSync(dbDir, { recursive: true });
+}
 
 class Database {
   private db: sqlite3.Database;

ecosystem.config.cjs

@@ -0,0 +1,18 @@
+// ecosystem.config.cjs
+module.exports = {
+  apps: [
+    {
+      name: 'schichtplaner',
+      script: './dist/server.js',
+      instances: 1,
+      exec_mode: 'fork',
+      env: {
+        NODE_ENV: 'production',
+        PORT: 3002
+      },
+      error_file: './logs/app-err.log',
+      out_file: './logs/app-out.log',
+      time: true
+    }
+  ]
+};

ecosystem.config.js

@@ -1,30 +0,0 @@
-module.exports = {
-  apps: [
-    {
-      name: 'backend',
-      script: './dist/server.js',
-      instances: 1,
-      exec_mode: 'fork',
-      env: {
-        NODE_ENV: 'production',
-        PORT: 3002
-      },
-      error_file: './logs/backend-err.log',
-      out_file: './logs/backend-out.log',
-      time: true
-    },
-    {
-      name: 'frontend', 
-      script: 'npx',
-      args: 'serve -s frontend-build -l 3000',
-      instances: 1,
-      exec_mode: 'fork',
-      env: {
-        NODE_ENV: 'production'
-      },
-      error_file: './logs/frontend-err.log',
-      out_file: './logs/frontend-out.log', 
-      time: true
-    }
-  ]
-};

frontend/src/contexts/AuthContext.tsx

@@ -20,6 +20,7 @@ interface AuthContextType {
 }
 
 const AuthContext = createContext<AuthContextType | undefined>(undefined);
+const API_BASE_URL = process.env.REACT_APP_API_BASE_URL || '/api';
 
 interface AuthProviderProps {
   children: ReactNode;
@@ -48,7 +49,7 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children }) => {
   const checkSetupStatus = async (): Promise<void> => {
     try {
       console.log('🔍 Checking setup status...');
-      const response = await fetch('http://localhost:3002/api/setup/status');
+      const response = await fetch(`${API_BASE_URL}/setup/status`);
       if (!response.ok) {
         throw new Error('Setup status check failed');
       }
@@ -72,7 +73,7 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children }) => {
         return;
       }
 
-      const response = await fetch('http://localhost:3002/api/auth/me', {
+      const response = await fetch(`${API_BASE_URL}/auth/me`, {
         headers: {
           'Authorization': `Bearer ${token}`
         }
@@ -104,7 +105,7 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children }) => {
     try {
       console.log('🔐 Attempting login for:', credentials.email);
       
-      const response = await fetch('http://localhost:3002/api/auth/login', {
+      const response = await fetch(`${API_BASE_URL}/auth/login`, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',

frontend/src/services/authService.ts

@@ -1,6 +1,6 @@
 // frontend/src/services/authService.ts
 import { Employee } from '../models/Employee';
-const API_BASE = 'http://localhost:3002/api';
+const API_BASE = process.env.REACT_APP_API_BASE_URL || '/api';
 
 export interface LoginRequest {
   email: string;

frontend/src/services/employeeService.ts

@@ -1,7 +1,7 @@
 // frontend/src/services/employeeService.ts
 import { Employee, CreateEmployeeRequest, UpdateEmployeeRequest, EmployeeAvailability } from '../models/Employee';
 
-const API_BASE_URL = 'http://localhost:3002/api';
+const API_BASE_URL = '/api';
 
 const getAuthHeaders = () => {
   const token = localStorage.getItem('token');

frontend/src/services/shiftAssignmentService.ts

@@ -4,7 +4,7 @@ import { Employee, EmployeeAvailability } from '../models/Employee';
 import { authService } from './authService';
 import { AssignmentResult, ScheduleRequest } from '../models/scheduling';
 
-const API_BASE_URL = 'http://localhost:3002/api';
+const API_BASE_URL = '/api';