Cloudflare
Multi-Tenant Trilogy

// Loader Worker — routes tenant requests to their sandboxed Worker
import { Router } from "itty-router";

interface Env {
  TENANT_WORKERS: DynamicNamespace;
  TENANT_REGISTRY: KVNamespace;
}

const router = Router();

router.get("/api/tenants/:tenantId/*", async (req, env: Env) => {
  const { tenantId } = req.params;
  const config = await env.TENANT_REGISTRY.get(tenantId, "json");

  // Resolve the tenant's dynamic worker binding
  const worker = env.TENANT_WORKERS.get(tenantId);
  if (!worker) return new Response("Tenant not found", { status: 404 });

  // Dispatch — full subrequest isolation
  return worker.fetch(req.original);
});

export default { fetch: router.handle };

// Durable Object Facet — per-tenant stateful runtime
import { DurableObject } from "cloudflare:workers";

interface Env {
  TENANT_FACET: DurableObjectNamespace<TenantFacet>;
}

export class TenantFacet extends DurableObject {
  private sql: SqlStorage;

  constructor(ctx: DurableObjectState, env: Env) {
    super(ctx, env);
    this.sql = ctx.storage.sql;

    // Idempotent schema init
    this.sql.exec(`
      CREATE TABLE IF NOT EXISTS tenant_store (
        key TEXT PRIMARY KEY,
        value TEXT,
        created_at TEXT DEFAULT (datetime('now'))
      )
    `);
  }

  async query(sql: string, params?: unknown[]) {
    const result = this.sql.exec(sql, params);
    return result.toArray();
  }

  async set(key: string, value: unknown) {
    this.sql.exec(
      "INSERT OR REPLACE INTO tenant_store (key, value) VALUES (?, ?)",
      [key, JSON.stringify(value)],
    );
  }

  async get(key: string) {
    const row = this.sql.exec(
      "SELECT value FROM tenant_store WHERE key = ?", [key]
    ).one();
    return row ? JSON.parse(row.value as string) : null;
  }
}

// Dynamic Workflow — durable multi-step execution
import { WorkflowEntrypoint } from "cloudflare:workers";

interface Env {
  TENANT_WORKFLOW: WorkflowBinding;
}

interface Params {
  tenantId: string;
  customerLogic: string; // user-defined step function
  payload: Record<string, unknown>;
}

export class TenantWorkflow extends WorkflowEntrypoint<
  Env, Params
> {
  async run(event: WorkflowEvent<Params>, step: WorkflowStep) {
    const { tenantId, customerLogic, payload } = event.payload;

    // Step 1 — Validate (durable checkpoint)
    const validated = await step.do("validate", async () => {
      return validatePayload(payload);
    });

    // Step 2 — Execute customer-defined logic
    const processed = await step.do("process", async () => {
      const fn = new Function("data", customerLogic);
      return fn(validated);
    });

    // Step 3 — Downstream effects with retries
    const result = await step.do("webhook", async () => {
      return fetch(processed.webhookUrl, {
        method: "POST", body: JSON.stringify(processed.data),
      });
    }, { retries: { limit: 3, delay: "5 seconds" } });

    return result;
  }
}