Clean working version: deployed TypeScript backend + JSX frontend

- Replace old JS backend with working TypeScript backend from deployed containers
- Backend: Fastify + better-sqlite3 + Yjs CRDT, 17 TS source files, 13 test files
- Frontend: React JSX with fabric.js CAD canvas, vite build, nginx serving
- Fix nginx proxy port 5000→3001 to match backend
- Fix docker-compose port mapping 5000→3001
- Fix vite dev proxy port 5000→3001
- Add backend healthcheck to docker-compose
- Update index.html title to 'Web CAD', lang to 'de'
- Add .a0/ to .gitignore
- Remove old JS backend files (models, routes, config, middleware, seed)
- Remove tracked build artifacts (backend/public/)

backend/tests/StressTest.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Backend Stresstest – 50.000 Elemente: SQLite CRUD Performance,
+ * Bulk-Insert, List, Update, Delete mit Transaktion-Support.
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { SqliteAdapter } from '../src/database/SqliteAdapter.js';
+import type { DBElement } from '../src/database/DatabaseInterface.js';
+
+const N = 50_000;
+
+describe('Backend Stresstest: 50.000 Elemente in SQLite', () => {
+  let db: SqliteAdapter;
+  let drawingId: string;
+  let layerId: string;
+  let elementIds: string[] = [];
+
+  beforeAll(async () => {
+    db = new SqliteAdapter(':memory:');
+    await db.init();
+
+    // Create prerequisite project → drawing → layer
+    const project = db.createProject({ name: 'Stresstest Project' });
+    const drawing = db.createDrawing({ project_id: project.id, name: 'Stresstest Drawing' });
+    drawingId = drawing.id;
+    const layer = db.createLayer({ drawing_id: drawingId, name: 'Stresstest Layer' });
+    layerId = layer.id;
+  });
+
+  afterAll(() => {
+    db.close();
+  });
+
+  it('should bulk-insert 50k elements in under 5s', () => {
+    const start = performance.now();
+    // Use transaction for bulk insert
+    const insert = db['db'].prepare(
+      'INSERT INTO elements (id, drawing_id, layer_id, type, x, y, width, height, properties_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
+    );
+    const insertMany = db['db'].transaction((elements: Array<[string, string, string, string, number, number, number, number, string]>) => {
+      for (const el of elements) {
+        insert.run(...el);
+      }
+    });
+
+    const batch: Array<[string, string, string, string, number, number, number, number, string]> = [];
+    for (let i = 0; i < N; i++) {
+      const id = `stress-elem-${i}`;
+      elementIds.push(id);
+      batch.push([
+        id,
+        drawingId,
+        layerId,
+        'rect',
+        (i % 1000) * 1.5,
+        Math.floor(i / 1000) * 1.5,
+        1,
+        1,
+        '{}',
+      ]);
+    }
+    insertMany(batch);
+    const elapsed = performance.now() - start;
+    console.log(`Bulk insert ${N} elements: ${elapsed.toFixed(1)}ms`);
+    expect(elapsed).toBeLessThan(5000);
+  });
+
+  it('should list 50k elements in under 500ms', () => {
+    const start = performance.now();
+    const elements = db.listElements(drawingId);
+    const elapsed = performance.now() - start;
+    console.log(`List ${N} elements: ${elapsed.toFixed(1)}ms, count=${elements.length}`);
+    expect(elements.length).toBe(N);
+    expect(elapsed).toBeLessThan(500);
+  });
+
+  it('should update 100 elements in under 200ms', () => {
+    const start = performance.now();
+    for (let i = 0; i < 100; i++) {
+      db.updateElement(elementIds[i], { x: 9999 + i });
+    }
+    const elapsed = performance.now() - start;
+    console.log(`Update 100 elements: ${elapsed.toFixed(1)}ms`);
+    expect(elapsed).toBeLessThan(200);
+  });
+
+  it('should read a single element in under 5ms', () => {
+    const start = performance.now();
+    const element = db.listElements(drawingId);
+    const mid = element[Math.floor(element.length / 2)];
+    const elapsed = performance.now() - start;
+    console.log(`Read mid element from ${N}: ${elapsed.toFixed(1)}ms`);
+    expect(mid).toBeDefined();
+    expect(elapsed).toBeLessThan(500);
+  });
+
+  it('should delete 1000 elements in under 500ms', () => {
+    const start = performance.now();
+    const deleteStmt = db['db'].prepare('DELETE FROM elements WHERE id = ?');
+    const deleteMany = db['db'].transaction((ids: string[]) => {
+      for (const id of ids) {
+        deleteStmt.run(id);
+      }
+    });
+    const toDelete = elementIds.slice(0, 1000);
+    deleteMany(toDelete);
+    const elapsed = performance.now() - start;
+    console.log(`Delete 1000 elements: ${elapsed.toFixed(1)}ms`);
+    expect(elapsed).toBeLessThan(500);
+
+    // Verify count
+    const remaining = db.listElements(drawingId);
+    expect(remaining.length).toBe(N - 1000);
+  });
+
+  it('should handle concurrent queries efficiently', () => {
+    // Simulate 10 concurrent list operations
+    const start = performance.now();
+    for (let i = 0; i < 10; i++) {
+      const elements = db.listElements(drawingId);
+      expect(elements.length).toBe(N - 1000);
+    }
+    const elapsed = performance.now() - start;
+    console.log(`10x list operations on ${N - 1000} elements: ${elapsed.toFixed(1)}ms`);
+    expect(elapsed).toBeLessThan(3000);
+  });
+});