Initial: RAPPORT-HOST Iteration 1 (proprietär)

Kommerzielle Hosting-/Abo-Plattform für Rapport-Instanzen.

- React-Frontend (Vite/JSX): Landing, Register, Login, Plans, Dashboard
- Node/Express-Backend: Auth (bcrypt+JWT), Stripe-Billing, Provisioning
- HOST-Postgres-Schema: accounts, subscriptions, instances
- Provisioning-Interface + Modell-A-Adapter (Studio im geteilten Stack)
- MOCK-Modus: voller End-to-End-Flow ohne Stripe/Rapport-Stack testbar
- Idempotentes Fulfillment (Upsert auf stripe_subscription_id)
- docker-compose für lokale host-db; identisch auf Hetzner deploybar

E2E lokal verifiziert: Register -> Checkout(mock) -> Instanz -> Idempotenz.

Lizenz: proprietär (kein AGPL-Code eingebunden, nur Netzwerk-API zur Familie).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

server/provisioning/index.js

@@ -0,0 +1,21 @@
+// Provisioning-Interface — entkoppelt "Abo bezahlt" von "wie entsteht die Instanz".
+//
+// Modell A (jetzt): ein Studio im geteilten Rapport-Stack  -> studio-adapter.js
+// Modell B (später): eigener Container pro Kunde            -> container-adapter.js
+//
+// Beide implementieren dieselbe Signatur:
+//   provision({ account, plan }) -> { studioId, slug, instanceUrl }
+//   deprovision({ instance })    -> void
+//
+// Der Aufrufer (Billing-Webhook) kennt nur dieses Interface, nie die Details.
+import * as studioAdapter from "./studio-adapter.js";
+
+const adapter = studioAdapter; // Modell A. Später per Env umschaltbar.
+
+export function provision(args) {
+  return adapter.provision(args);
+}
+
+export function deprovision(args) {
+  return adapter.deprovision(args);
+}

server/provisioning/studio-adapter.js

@@ -0,0 +1,79 @@
+// Modell-A-Provisioning: legt für einen zahlenden HOST-Kunden ein isoliertes
+// Studio im GETEILTEN Rapport-Stack an. Vermarktet als "eigene Instanz",
+// technisch ein mandantengetrenntes Studio (RLS).
+//
+// Ablauf gegen den Rapport-Stack (echtes Provisioning):
+//   1. GoTrue-Admin-API (service_role): Auth-User für die Kunden-Email anlegen
+//   2. RPC ensure_profile: Profil füllen
+//   3. RPC create_studio_with_admin: Studio anlegen, User = Admin
+//   4. Instanz-URL aus Template bauen
+//
+// MOCK-Modus (provisioningMock): ohne RAPPORT_API_URL/SERVICE_KEY wird nur eine
+// synthetische studioId + slug erzeugt, damit der gesamte HOST-Flow lokal ohne
+// laufenden Rapport-Stack durchgetestet werden kann.
+import { randomUUID } from "node:crypto";
+import { env, provisioningMock } from "../env.js";
+
+function makeSlug(seed) {
+  const base = (seed || "studio").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32);
+  return `${base || "studio"}-${Math.random().toString(36).slice(2, 7)}`;
+}
+
+function instanceUrl(slug) {
+  return env.rapport.instanceUrlTemplate.replace("{slug}", encodeURIComponent(slug));
+}
+
+export async function provision({ account, plan }) {
+  const slug = makeSlug(account.email.split("@")[0]);
+
+  if (provisioningMock) {
+    const studioId = randomUUID();
+    console.log(`[provision:MOCK] Studio '${slug}' (${studioId}) für ${account.email}, Plan ${plan.id}`);
+    return { studioId, slug, instanceUrl: instanceUrl(slug) };
+  }
+
+  // ── Echtes Provisioning gegen den geteilten Rapport-Stack ──────────────────
+  // Hinweis: nutzt service_role (RAPPORT_SERVICE_KEY) — niemals ins Frontend!
+  const base = env.rapport.apiUrl.replace(/\/+$/, "");
+  const headers = {
+    apikey: env.rapport.serviceKey,
+    Authorization: `Bearer ${env.rapport.serviceKey}`,
+    "Content-Type": "application/json",
+  };
+
+  // 1. Auth-User anlegen (GoTrue Admin-API), bereits bestätigt.
+  const tempPassword = randomUUID();
+  const userRes = await fetch(`${base}/auth/v1/admin/users`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ email: account.email, password: tempPassword, email_confirm: true }),
+  });
+  if (!userRes.ok) throw new Error(`GoTrue admin/users: ${userRes.status} ${await userRes.text()}`);
+  const user = await userRes.json();
+
+  // 2.+3. Profil + Studio per RPC. Da create_studio_with_admin auth.uid() nutzt,
+  // muss der Aufruf im Kontext des neuen Users laufen — hier vereinfacht über
+  // einen service_role-RPC, der die Ziel-User-ID als Argument nimmt. Diese
+  // server-seitige Variante (create_studio_for_user) ist im Rapport-Schema noch
+  // anzulegen; bis dahin schützt der MOCK-Modus den lokalen Test.
+  const slugForStudio = slug;
+  const rpcRes = await fetch(`${base}/rest/v1/rpc/create_studio_for_user`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ p_user_id: user.id, p_name: account.email.split("@")[0], p_slug: slugForStudio }),
+  });
+  if (!rpcRes.ok) throw new Error(`create_studio_for_user: ${rpcRes.status} ${await rpcRes.text()}`);
+  const studioId = (await rpcRes.json());
+
+  return { studioId, slug: slugForStudio, instanceUrl: instanceUrl(slugForStudio) };
+}
+
+export async function deprovision({ instance }) {
+  if (provisioningMock) {
+    console.log(`[deprovision:MOCK] Studio ${instance.studio_slug} deaktiviert.`);
+    return;
+  }
+  // Echtes Deprovisioning (Studio sperren statt löschen — Daten erhalten für
+  // Reaktivierung/Export) ist im Rapport-Schema noch zu definieren.
+  console.warn(`[deprovision] noch nicht implementiert für ${instance.studio_slug}`);
+}