Skip to content

🏗️ G100 Architecture

Multi-Tenancy with Self-Sufficient Instances

🎯 Architecture Principles

1. Option B: Self-Sufficient Instances

┌─────────────────────────────────────────────────────────────────┐
│                    SHARED CORE MODULES                          │
│              (NPM Packages / Shared Library)                    │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────────┐   │
│  │   AUTH   │ │ CONTRACT │ │ PAYMENT  │ │ DOCUMENT GEN     │   │
│  │  Module  │ │  Module  │ │  Module  │ │ (Adobe/PDF)      │   │
│  └──────────┘ └──────────┘ └──────────┘ └──────────────────┘   │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────────┐   │
│  │   CRM    │ │ BOOKING  │ │   NFT    │ │    i18n          │   │
│  │ Module   │ │  Module  │ │  Module  │ │   Module         │   │
│  └──────────┘ └──────────┘ └──────────┘ └──────────────────┘   │
└─────────────────────────────────────────────────────────────────┘
                              │
              ┌───────────────┼───────────────┐
              │               │               │
              ▼               ▼               ▼
    ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
    │  FLO Instance   │ │ MORELO Instance │ │ Future Instance │
    ├─────────────────┤ ├─────────────────┤ ├─────────────────┤
    │ • Own DB        │ │ • Own DB        │ │ • Own DB        │
    │ • Own Frontend  │ │ • Own Frontend  │ │ • Own Frontend  │
    │ • Own Domain    │ │ • Own Domain    │ │ • Own Domain    │
    │                 │ │                 │ │                 │
    │ 🔌 API Client   │ │ 🔌 API Client   │ │ 🔌 API Client   │
    │ (Optional)      │ │ (Optional)      │ │ (Optional)      │
    └─────────────────┘ └─────────────────┘ └─────────────────┘
              │               │               │
              └───────────────┼───────────────┘
                              ▼
                ┌─────────────────────────────┐
                │  UNIFIED CONTRACT API       │
                │  (Optional Central Hub)     │
                └─────────────────────────────┘

2. Why Self-Sufficient?

Benefit Description
Independence Jede Instance kann offline arbeiten
Scalability Kein Single Point of Failure
Flexibility Eigene Tech-Stack Entscheidungen
Performance Keine API-Latenz für lokale Operationen
Privacy Daten bleiben in Instance (GDPR)

3. Shared vs Local

// SHARED (NPM Package)
import { createContract } from '@contractplattform/core';

// LOCAL (Instance-specific)
const contract = await createContract({
  type: 'kfz_kaufvertrag',
  instance: 'morelo',
  ...
});

// Wird lokal in Instance-DB gespeichert
await db.contracts.insert(contract);

// Optional: Sync to Master API
if (config.syncToMaster) {
  await api.contracts.sync(contract);
}

🗄️ Database Strategy

Option: Separate D1 per Instance

┌─────────────────────────────────────────────────────────┐
│                  Cloudflare D1                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │
│  │   flo-db     │  │  morelo-db   │  │ bavaria-db   │  │
│  ├──────────────┤  ├──────────────┤  ├──────────────┤  │
│  │ users        │  │ users        │  │ users        │  │
│  │ contracts    │  │ contracts    │  │ contracts    │  │
│  │ memberships  │  │ vehicles     │  │ yachts       │  │
│  │ properties   │  │ dealers      │  │ marinas      │  │
│  └──────────────┘  └──────────────┘  └──────────────┘  │
└─────────────────────────────────────────────────────────┘

Advantages:

  • ✅ Complete data isolation
  • ✅ Instance-specific schema
  • ✅ Independent scaling
  • ✅ GDPR compliance easier

Disadvantages:

  • ⚠️ Cross-instance queries harder
  • ⚠️ Data duplication (users)

Alternative: Shared Users + Separate Assets

-- SHARED: master-db
CREATE TABLE users (
  id TEXT PRIMARY KEY,
  email TEXT UNIQUE,
  name TEXT,
  instance_id TEXT  -- 'flo', 'morelo', 'bavaria'
);

-- INSTANCE: morelo-db
CREATE TABLE vehicles (
  id TEXT PRIMARY KEY,
  user_id TEXT,     -- Reference to master-db
  vin TEXT,
  model TEXT,
  ...
);

📦 NPM Package Structure

@contractplattform/
├── core/              # Shared Logic
│   ├── contracts/
│   ├── auth/
│   └── types/
│
├── ui/                # Shared UI Components
│   ├── ContractForm/
│   ├── SignatureField/
│   └── DocumentViewer/
│
├── integrations/      # External APIs
│   ├── stripe/
│   ├── adobe/
│   ├── salesforce/
│   └── ms-graph/
│
└── cli/               # Instance Generator
    └── create-instance

Usage in Instance

{
  "name": "morelo-dealer-suite",
  "dependencies": {
    "@contractplattform/core": "^1.0.0",
    "@contractplattform/ui": "^1.0.0",
    "@contractplattform/integrations": "^1.0.0"
  }
}

🔌 API Connection (Optional)

Instances können optional mit Master API verbinden:

Scenario 1: Full Independence

// FLO Instance - Komplett eigenständig
const contract = await db.contracts.create({
  type: 'membership',
  ...
});

// Keine API-Verbindung nötig

Scenario 2: Sync to Master

// MORELO Instance - Sync für Analytics
const contract = await db.contracts.create({
  type: 'kfz_kaufvertrag',
  ...
});

// Optional: Push to Master für Cross-Instance Analytics
if (config.features.centralAnalytics) {
  await api.contracts.sync({
    instance_id: 'morelo',
    contract: contract,
  });
}

Scenario 3: Shared Services

// Bavaria Instance - Nutzt Shared Document Generation
const contract = await db.contracts.create({
  type: 'yacht_kaufvertrag',
  ...
});

// Document Generation via Master API (Adobe Express)
const pdf = await api.documents.generate({
  contract_id: contract.id,
  template: 'yacht_kaufvertrag_de',
  instance_id: 'bavaria',
});

🌐 Tech Stack per Instance

FLO

Frontend:  SwiftUI (iOS Native)
Backend:   TBD (Node.js / Cloudflare Workers?)
Database:  D1 / PostgreSQL
Auth:      Firebase Auth / Custom
Payments:  Stripe
Booking:   MS Bookings

MORELO

Frontend:  SvelteKit (PWA)
Backend:   Hono (Cloudflare Workers)
Database:  Cloudflare D1
Auth:      JWT (Custom)
Payments:  Stripe + Leasing APIs
CRM:       Salesforce
Hardware:  ESP32 (MQTT)

ContractPlattform

Frontend:  SvelteKit
Backend:   SvelteKit API Routes
Database:  Prisma + PostgreSQL / D1
Auth:      MS Graph OAuth
Payments:  Stripe
CRM:       Custom

Future (Bavaria, Porsche, etc.)

Template:  Copy from MORELO
Adjust:    Asset Type, Vocabulary, Integrations
Deploy:    Independent Cloudflare Workers

🔐 Authentication Strategy

Per-Instance Auth

FLO:     Firebase Auth (Social Login)
MORELO:  JWT (Dealer Login)
Contract: MS Graph OAuth (Office 365)

Shared User Pool (Optional)

// Master Auth Service (Optional)
POST /api/v1/auth/login
{
  "email": "max@example.com",
  "password": "...",
  "instance_id": "morelo"
}

Response:
{
  "token": "eyJhbGc...",
  "user": {
    "id": "usr_123",
    "email": "max@example.com",
    "instances": ["morelo", "bavaria"]  // Multi-Instance Access
  }
}

📊 Data Flow Example

MORELO: Fahrzeugkauf End-to-End

sequenceDiagram
    participant Kunde
    participant Frontend
    participant Backend
    participant D1 Database
    participant Salesforce
    participant Adobe
    participant Blockchain

    Kunde->>Frontend: Konfiguriert Fahrzeug
    Frontend->>Backend: POST /konfigurator
    Backend->>D1 Database: Save Configuration

    Kunde->>Frontend: Erstellt Angebot
    Frontend->>Backend: POST /contracts
    Backend->>D1 Database: Create Contract (Draft)
    Backend->>Adobe: Generate PDF
    Adobe-->>Backend: PDF URL
    Backend->>D1 Database: Update Contract
    Backend-->>Frontend: Contract + PDF

    Kunde->>Frontend: Unterschreibt
    Frontend->>Backend: POST /contracts/{id}/sign
    Backend->>D1 Database: Update Status (Signed)
    Backend->>Salesforce: Create Opportunity
    Salesforce-->>Backend: Opportunity ID
    Backend->>D1 Database: Link to Salesforce

    Note over Backend: Bei Fahrzeug-Auslieferung
    Backend->>Blockchain: Mint NFT
    Blockchain-->>Backend: Token ID
    Backend->>D1 Database: Update Contract (NFT)
    Backend-->>Frontend: Contract Complete

🚀 Deployment Strategy

Per Instance

# wrangler.toml (MORELO)
name = "morelo-dealer-suite"
main = "src/index.ts"
compatibility_date = "2024-01-01"

[[d1_databases]]
binding = "DB"
database_name = "morelo-db"
database_id = "xxx"

[vars]
INSTANCE_ID = "morelo"
API_URL = "https://api.contractplattform.dev"  # Optional

# wrangler.toml (FLO)
name = "flo-backend"
main = "src/index.ts"

[[d1_databases]]
binding = "DB"
database_name = "flo-db"
database_id = "yyy"

[vars]
INSTANCE_ID = "flo"
API_URL = "https://api.contractplattform.dev"  # Optional

Domains

morelo.contractplattform.dev    → MORELO Instance
flo.contractplattform.dev       → FLO Instance
bavaria.contractplattform.dev   → Bavaria Instance
api.contractplattform.dev       → Master API (Optional)

🔄 Migration Path

Phase 1: Independent Instances (NOW)

  • ✅ MORELO läuft eigenständig
  • ✅ FLO läuft eigenständig
  • ✅ ContractPlattform läuft eigenständig
  • ❌ Keine Verbindung untereinander

Phase 2: Shared Modules (Q2 2026)

  • 🔄 Extract common code to NPM packages
  • 🔄 Refactor Instances to use @contractplattform/core
  • ✅ Instances bleiben eigenständig

Phase 3: Optional API (Q3 2026)

  • 🔌 Deploy Master API
  • 🔌 Instances können optional syncen
  • ✅ Weiterhin full independence

Phase 4: Cross-Instance Features (Q4 2026)

  • 🌐 User can have accounts in multiple instances
  • 📊 Shared Analytics Dashboard
  • 🔔 Cross-Instance Notifications

Next: i18n & Vocabulary →