@r8s/eurooffice 0.2.0

package/__tests__/eurooffice.test.ts

@@ -0,0 +1,427 @@
+import { describe, it, expect } from 'vitest'
+import { render, jsx } from '@r8s/core'
+import { Namespace, OperatorContext, SecretContext, RoutingContext } from '@r8s/core/defaults'
+import { runGuardrails, noPlaintextSecrets, validateResource } from '@r8s/core'
+import { operators } from '@r8s/crds'
+import type { r8sElement } from '@r8s/core'
+
+// EuroOffice recipe tests:
+//   1. Operator declarations (deduped via OperatorContext)
+//   2. Rendering: defaults, all props, gateway/ingress adaptation, TCP probes
+//   3. Namespace inheritance from the Platform context
+//   4. Security: no plaintext credentials in rendered output
+import { EuroOffice } from '../src/index'
+
+const objectStorage = {
+  endpoint: 'https://s3.test',
+  bucket: 'docs-blobs',
+  credentialsSecret: 'docs-blobs-credentials',
+}
+
+const openbao = { backend: 'openbao', mount: 'kv', path: 'test' }
+
+/** Render EuroOffice inside a Platform-like secrets backend (OpenBao). */
+function renderEuroOffice(props: Record<string, unknown>): ReturnType<typeof render> {
+  return render(
+    jsx(SecretContext.Provider, {
+      value: { backend: 'openbao', mount: 'kv', path: 'test' },
+      children: jsx(EuroOffice, { objectStorage, ...props } as never),
+    })
+  )
+}
+
+/** Render EuroOffice wrapped only in an OperatorContext (no secrets backend). */
+function renderEuroOfficeWithContext(
+  operators_: any[],
+  props: Record<string, unknown>
+): r8sElement {
+  return jsx(OperatorContext.Provider, {
+    value: operators_,
+    children: jsx(EuroOffice, {
+      objectStorage,
+      secretsName: 'existing-secrets',
+      ...props,
+    } as never),
+  })
+}
+
+/** Render EuroOffice inside a Platform-like Namespace context (no explicit namespace prop). */
+function renderEuroOfficeInNamespace(
+  namespaceValue: string,
+  props: Record<string, unknown>
+): ReturnType<typeof render> {
+  return render(
+    jsx(Namespace.Provider, {
+      value: namespaceValue,
+      children: jsx(SecretContext.Provider, {
+        value: openbao as never,
+        children: jsx(EuroOffice, { objectStorage, ...props } as never),
+      }),
+    })
+  )
+}
+
+describe('operator declarations', () => {
+  it('declares the cnpg operator via the Database recipe', () => {
+    const result = renderEuroOffice({ host: 'docs.example.com' })
+    expect(result.operators.some((op) => op.name === 'cnpg')).toBe(true)
+  })
+
+  it('adds no app-level operators beyond cnpg (Endpoint owns routing operators)', () => {
+    const result = renderEuroOffice({ host: 'docs.example.com', conversions: true })
+    const names = result.operators.map((op) => op.name)
+    expect(names.filter((n) => n === 'cnpg')).toHaveLength(1)
+    expect(names).not.toContain('redis-operator')
+  })
+
+  it('deduplicates operators provided via context', () => {
+    const result = render(
+      renderEuroOfficeWithContext([operators['cnpg']()], { host: 'docs.example.com' })
+    )
+    const names = result.operators.map((op) => op.name)
+    expect(names.filter((n) => n === 'cnpg')).toHaveLength(1)
+  })
+
+  it('allows version overrides through context operators', () => {
+    const result = render(renderEuroOfficeWithContext([operators['cnpg']('1.24.0')], {}))
+    const cnpg = result.operators.filter((op) => op.name === 'cnpg')
+    expect(cnpg).toHaveLength(1)
+    expect(cnpg[0].version).toBe('1.24.0')
+  })
+})
+
+describe('rendering defaults', () => {
+  it('renders app deployment, service, database and endpoint', () => {
+    const result = renderEuroOffice({ host: 'docs.example.com' })
+    const kinds = result.resources.map((r) => r.kind)
+    expect(kinds).toContain('Deployment')
+    expect(kinds).toContain('Service')
+    expect(kinds).toContain('Ingress')
+    expect(kinds).toContain('Cluster')
+  })
+
+  it('adds LibreOffice conversion workers when conversions is set', () => {
+    const result = renderEuroOffice({
+      host: 'docs.example.com',
+      conversions: true,
+      conversionWorkers: 2,
+    })
+    const deployments = result.resources.filter((r) => r.kind === 'Deployment')
+    const soffice = deployments.find((d: any) => d.metadata.name === 'eurooffice-soffice') as any
+    expect(soffice).toBeDefined()
+    expect(soffice.spec.replicas).toBe(2)
+    expect(soffice.spec.template.spec.containers[0].command).toContain(
+      '--accept=socket,host=0.0.0.0,port=2002;urp;'
+    )
+    const services = result.resources.filter((r) => r.kind === 'Service')
+    expect(services.some((s: any) => s.metadata.name === 'eurooffice-soffice')).toBe(true)
+  })
+
+  it('probes the soffice workers on the UNO TCP socket (not HTTP)', () => {
+    const result = renderEuroOffice({ host: 'docs.example.com', conversions: true })
+    const soffice = result.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'eurooffice-soffice'
+    ) as any
+    const container = soffice.spec.template.spec.containers[0]
+    expect(container.livenessProbe.tcpSocket).toEqual({ port: 2002 })
+    expect(container.readinessProbe.tcpSocket).toEqual({ port: 2002 })
+    expect(container.readinessProbe.initialDelaySeconds).toBe(20)
+    expect(container.livenessProbe.httpGet).toBeUndefined()
+    expect(container.readinessProbe.httpGet).toBeUndefined()
+  })
+
+  it('does not render conversion workers by default', () => {
+    const result = renderEuroOffice({ host: 'docs.example.com' })
+    const deployments = result.resources
+      .filter((r) => r.kind === 'Deployment')
+      .map((d: any) => d.metadata.name)
+    expect(deployments).not.toContain('eurooffice-soffice')
+  })
+
+  it('defaults app replicas to 1 when websockets are enabled (no session affinity)', () => {
+    const result = renderEuroOffice({ host: 'docs.example.com' })
+    const app = result.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'eurooffice'
+    ) as any
+    expect(app.spec.replicas).toBe(1)
+  })
+
+  it('defaults app replicas to 2 when websockets are disabled', () => {
+    const result = renderEuroOffice({ host: 'docs.example.com', websockets: false })
+    const app = result.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'eurooffice'
+    ) as any
+    expect(app.spec.replicas).toBe(2)
+  })
+
+  it('renders explicit replicas with websockets enabled (caller opts into sticky sessions)', () => {
+    const result = renderEuroOffice({
+      host: 'docs.example.com',
+      websockets: true,
+      replicas: 3,
+    })
+    const app = result.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'eurooffice'
+    ) as any
+    expect(app.spec.replicas).toBe(3)
+  })
+
+  it('enables websockets by default and allows disabling them', () => {
+    const on = renderEuroOffice({ host: 'docs.example.com' })
+    const appOn = on.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'eurooffice'
+    ) as any
+    const envOn = appOn.spec.template.spec.containers[0].env
+    expect(envOn.find((e: any) => e.name === 'WEBSOCKETS_ENABLED').value).toBe('true')
+
+    const off = renderEuroOffice({ host: 'docs.example.com', websockets: false })
+    const appOff = off.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'eurooffice'
+    ) as any
+    const envOff = appOff.spec.template.spec.containers[0].env
+    expect(envOff.find((e: any) => e.name === 'WEBSOCKETS_ENABLED').value).toBe('false')
+  })
+
+  it('renders gateway resources when platform uses gateway routing', () => {
+    const result = render(
+      jsx(RoutingContext.Provider, {
+        value: { mode: 'gateway', gatewayClassName: 'eg' },
+        children: jsx(SecretContext.Provider, {
+          value: openbao as never,
+          children: jsx(EuroOffice, { objectStorage, host: 'docs.example.com' } as never),
+        }),
+      })
+    )
+    const kinds = result.resources.map((r) => r.kind)
+    expect(kinds).toContain('HTTPRoute')
+  })
+
+  it('renders a valid Ingress when platform uses ingress routing', () => {
+    const result = render(
+      jsx(RoutingContext.Provider, {
+        value: { mode: 'ingress' },
+        children: jsx(SecretContext.Provider, {
+          value: openbao as never,
+          children: jsx(EuroOffice, { objectStorage, host: 'docs.example.com' } as never),
+        }),
+      })
+    )
+    const ingress = result.resources.find((r) => r.kind === 'Ingress') as any
+    expect(ingress).toBeDefined()
+    expect(ingress.spec.rules[0].host).toBe('docs.example.com')
+  })
+
+  it('passes resource validation', () => {
+    const result = renderEuroOffice({ host: 'docs.example.com', conversions: true })
+    for (const resource of result.resources) {
+      expect(validateResource(resource)).toEqual([])
+    }
+  })
+})
+
+describe('namespace inheritance', () => {
+  it('inherits namespace from the Platform context when namespace prop is not set', () => {
+    const result = renderEuroOfficeInNamespace('docs', { host: 'docs.example.com' })
+    for (const kind of ['Deployment', 'Service', 'Cluster', 'Ingress']) {
+      const resource = result.resources.find((r: any) => r.kind === kind)
+      expect(resource).toBeDefined()
+      expect(resource.metadata.namespace).toBe('docs')
+    }
+  })
+
+  it('explicit namespace prop wins over the Platform context', () => {
+    const result = renderEuroOfficeInNamespace('docs', {
+      host: 'docs.example.com',
+      namespace: 'collab',
+    })
+    const app = result.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'eurooffice'
+    ) as any
+    expect(app.metadata.namespace).toBe('collab')
+  })
+
+  it('falls back to default when no Platform namespace is present', () => {
+    const result = renderEuroOffice({ host: 'docs.example.com' })
+    const app = result.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'eurooffice'
+    ) as any
+    expect(app.metadata.namespace).toBe('default')
+  })
+})
+
+describe('rendering with all props', () => {
+  it('accepts the full prop surface', () => {
+    const result = renderEuroOffice({
+      name: 'docs',
+      namespace: 'docs',
+      version: '1.2.0',
+      host: 'docs.example.com',
+      replicas: 3,
+      websockets: false,
+      smtp: { host: 'smtp.example.com', port: 465, from: 'no-reply@docs.example.com' },
+      conversions: true,
+      conversionWorkers: 4,
+      objectStorage: {
+        endpoint: 'https://s3.internal.example.com',
+        bucket: 'docs-blobs',
+        credentialsSecret: 'docs-blobs-credentials',
+        region: 'eu-north-1',
+      },
+      resources: {
+        requests: { memory: '1Gi', cpu: '500m' },
+        limits: { memory: '4Gi', cpu: '2000m' },
+      },
+      tls: { secretName: 'docs-tls', clusterIssuer: 'letsencrypt-prod' },
+    })
+    expect(result.resources.length).toBeGreaterThan(0)
+    const app = result.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'docs'
+    ) as any
+    expect(app.spec.template.spec.containers[0].image).toBe('ghcr.io/berget-ai/eurooffice:1.2.0')
+    expect(app.spec.replicas).toBe(3)
+    expect(app.spec.template.spec.containers[0].resources.limits.memory).toBe('4Gi')
+    const env = app.spec.template.spec.containers[0].env
+    expect(env.find((e: any) => e.name === 'WEBSOCKETS_ENABLED').value).toBe('false')
+    expect(env.find((e: any) => e.name === 'SMTP_HOST').value).toBe('smtp.example.com')
+    expect(env.find((e: any) => e.name === 'SMTP_PORT').value).toBe('465')
+    expect(env.find((e: any) => e.name === 'SMTP_FROM').value).toBe('no-reply@docs.example.com')
+    expect(env.find((e: any) => e.name === 'AWS_REGION').value).toBe('eu-north-1')
+    expect(env.find((e: any) => e.name === 'SOFFICE_HOST').value).toBe('docs-soffice')
+
+    const soffice = result.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'docs-soffice'
+    ) as any
+    expect(soffice.spec.template.spec.containers[0].image).toBe(
+      'ghcr.io/berget-ai/eurooffice:1.2.0'
+    )
+    expect(soffice.spec.replicas).toBe(4)
+  })
+})
+
+describe('secrets handling', () => {
+  it('accepts an explicit secretsName without a backend', () => {
+    expect(() =>
+      render(
+        jsx(EuroOffice, {
+          host: 'docs.example.com',
+          objectStorage,
+          secretsName: 'existing-secrets',
+        } as never)
+      )
+    ).not.toThrow()
+
+    const result = render(
+      jsx(EuroOffice, {
+        host: 'docs.example.com',
+        objectStorage,
+        secretsName: 'existing-secrets',
+      } as never)
+    )
+    const kinds = result.resources.map((r) => r.kind)
+    expect(kinds).not.toContain('OpenBaoStaticSecret')
+    const app = result.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'eurooffice'
+    ) as any
+    const env = app.spec.template.spec.containers[0].env
+    const appSecret = env.find((e: any) => e.name === 'APP_SECRET')
+    expect(appSecret.valueFrom.secretKeyRef.name).toBe('existing-secrets')
+    expect(appSecret.valueFrom.secretKeyRef.key).toBe('secretKey')
+  })
+
+  it('provisions the app secrets bundle through a secrets backend', () => {
+    const result = renderEuroOffice({ host: 'docs.example.com' })
+    const secretCr = result.resources.find((r) => r.kind === 'OpenBaoStaticSecret') as any
+    expect(secretCr).toBeDefined()
+    expect(secretCr.metadata.name).toBe('eurooffice-secrets')
+    expect(secretCr.spec.destination.name).toBe('eurooffice-secrets')
+    expect(secretCr.spec.path).toBe('test/eurooffice/secrets')
+  })
+
+  it('provisions the app secrets bundle through Vault', () => {
+    const result = render(
+      jsx(SecretContext.Provider, {
+        value: { backend: 'vault', mount: 'kv', path: 'apps' },
+        children: jsx(EuroOffice, { objectStorage, host: 'docs.example.com' } as never),
+      })
+    )
+    const kinds = result.resources.map((r) => r.kind)
+    expect(kinds).toContain('VaultStaticSecret')
+    const secretCr = result.resources.find((r) => r.kind === 'VaultStaticSecret') as any
+    expect(secretCr.spec.path).toBe('apps/eurooffice/secrets')
+  })
+
+  it('wires credentials via secretKeyRef (never plaintext env)', () => {
+    const result = renderEuroOffice({
+      host: 'docs.example.com',
+      smtp: { host: 'smtp.example.com' },
+    })
+    const app = result.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'eurooffice'
+    ) as any
+    const env = app.spec.template.spec.containers[0].env
+    const smtpPassword = env.find((e: any) => e.name === 'SMTP_PASSWORD')
+    const appSecret = env.find((e: any) => e.name === 'APP_SECRET')
+    const accessKey = env.find((e: any) => e.name === 'AWS_ACCESS_KEY_ID')
+    const secretAccessKey = env.find((e: any) => e.name === 'AWS_SECRET_ACCESS_KEY')
+    expect(smtpPassword.valueFrom.secretKeyRef.name).toBe('eurooffice-secrets')
+    expect(smtpPassword.valueFrom.secretKeyRef.key).toBe('smtpPassword')
+    expect(appSecret.valueFrom.secretKeyRef.name).toBe('eurooffice-secrets')
+    expect(appSecret.valueFrom.secretKeyRef.key).toBe('secretKey')
+    expect(accessKey.valueFrom.secretKeyRef.name).toBe('docs-blobs-credentials')
+    expect(accessKey.valueFrom.secretKeyRef.key).toBe('accessKey')
+    expect(secretAccessKey.valueFrom.secretKeyRef.name).toBe('docs-blobs-credentials')
+    expect(secretAccessKey.valueFrom.secretKeyRef.key).toBe('secretKey')
+    expect(smtpPassword.value).toBeUndefined()
+    expect(appSecret.value).toBeUndefined()
+    expect(accessKey.value).toBeUndefined()
+    expect(secretAccessKey.value).toBeUndefined()
+  })
+
+  it('auto-wires DATABASE_URL from the DatabaseContext (no manual connection string)', () => {
+    const result = renderEuroOffice({ host: 'docs.example.com' })
+    const app = result.resources.find(
+      (r: any) => r.kind === 'Deployment' && r.metadata.name === 'eurooffice'
+    ) as any
+    const env = app.spec.template.spec.containers[0].env
+    const databaseUrl = env.find((e: any) => e.name === 'DATABASE_URL')
+    expect(databaseUrl.value).toBe(
+      'postgresql://$(PGUSER):$(PGPASSWORD)@$(PGHOST):$(PGPORT)/$(PGDATABASE)'
+    )
+    const dbPassword = env.find((e: any) => e.name === 'PGPASSWORD')
+    expect(dbPassword.valueFrom.secretKeyRef.name).toBe('eurooffice-db-credentials')
+    expect(dbPassword.value).toBeUndefined()
+  })
+
+  it('renders no plaintext credentials anywhere', () => {
+    const result = renderEuroOffice({
+      host: 'docs.example.com',
+      smtp: { host: 'smtp.example.com', port: 587, from: 'no-reply@docs.example.com' },
+      conversions: true,
+      conversionWorkers: 2,
+    })
+    const { passed, errors } = runGuardrails(result.resources as any[], [noPlaintextSecrets])
+    if (!passed) {
+      console.error('Plaintext credential violations:', errors)
+    }
+    expect(passed).toBe(true)
+  })
+})
+
+describe('validation errors', () => {
+  it('throws when no secrets backend and no secrets name', () => {
+    expect(() =>
+      render(jsx(EuroOffice, { host: 'docs.example.com', objectStorage } as never))
+    ).toThrow(/application secrets/)
+  })
+
+  it('throws for unknown secrets backends', () => {
+    expect(() =>
+      render(
+        jsx(SecretContext.Provider, {
+          value: { backend: 'unknown' as never },
+          children: jsx(EuroOffice, { objectStorage, host: 'docs.example.com' } as never),
+        })
+      )
+    ).toThrow(/application secrets/)
+  })
+})

package/examples/basic.tsx

@@ -0,0 +1,17 @@
+import { Platform } from '@r8s/recipes'
+import { EuroOffice } from '@r8s/eurooffice'
+
+export default (
+  <Platform secrets={{ backend: 'openbao', mount: 'kv', path: 'apps' }}>
+    <EuroOffice
+      name="docs"
+      host="docs.example.com"
+      objectStorage={{
+        endpoint: 'https://s3.internal.example.com',
+        bucket: 'docs-blobs',
+        credentialsSecret: 'docs-blobs-credentials',
+      }}
+      smtp={{ host: 'smtp.example.com', port: 587, from: 'no-reply@${env:MAIL_DOMAIN}' }}
+    />
+  </Platform>
+)

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@r8s/eurooffice",
+  "version": "0.2.0",
+  "description": "EuroOffice collaborative document suite — Postgres persistence, S3 blob storage, LibreOffice conversions, SMTP delivery and websocket collaboration",
+  "license": "MIT",
+  "author": "Berget AI AB",
+  "homepage": "https://r8s.berget.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/berget-ai/r8s.git",
+    "directory": "packages/eurooffice"
+  },
+  "bugs": "https://github.com/berget-ai/r8s/issues",
+  "keywords": [
+    "eurooffice",
+    "libreoffice",
+    "documents",
+    "conversion"
+  ],
+  "r8s": {
+    "category": "Productivity & Documents"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc --build",
+    "test": "vitest run",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
+  },
+  "category": "Collaboration & Productivity",
+  "dependencies": {
+    "@r8s/core": "^0.2.0",
+    "@r8s/crds": "^0.2.0",
+    "@r8s/k8s-types": "^0.2.0",
+    "@r8s/recipes": "^0.2.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
+  }
+}

package/src/index.tsx

@@ -0,0 +1,324 @@
+import { jsx, Fragment, useContext } from '@r8s/core'
+import { Namespace, SecretContext } from '@r8s/core/defaults'
+import { Database, WebService, Endpoint } from '@r8s/recipes'
+import type { SecretRef } from '@r8s/recipes'
+
+export interface EuroOfficeProps {
+  /** Resource name (defaults to 'eurooffice') */
+  name?: string
+  /** Kubernetes namespace (defaults to 'default') */
+  namespace?: string
+  /** Container image tag (defaults to 'latest' — pin a version in production) */
+  version?: string
+  /** Public hostname for the document suite (required) */
+  host: string
+  /**
+   * Number of app replicas.
+   *
+   * With `websockets` enabled (the default) this defaults to **1**:
+   * websocket sessions are pinned to the pod that accepted the
+   * connection and the workload has no session affinity, so >1 replicas
+   * means collaborators on different pods stop seeing each other live.
+   * An explicitly set `replicas` is rendered as asked — pair it with a
+   * sticky-session (source-IP) ingress strategy for live co-editing.
+   * With `websockets: false` the default is 2 (the app is stateless —
+   * scale freely).
+   */
+  replicas?: number
+  /**
+   * Collaborative editing over websockets (default: true). Disable only
+   * for single-user or read-only deployments — document presence,
+   * cursor sharing and live co-editing all rely on websockets.
+   */
+  websockets?: boolean
+  /**
+   * S3-compatible object storage for document blobs and attachments
+   * (RustFS in the platform). Required — reference a bucket whose
+   * credentials live in a Secret provisioned by the secrets backend
+   * (keys: accessKey, secretKey) — never plaintext.
+   */
+  objectStorage: {
+    /** S3 endpoint URL, e.g. https://s3.internal.example.com */
+    endpoint: string
+    /** Bucket name for document blobs */
+    bucket: string
+    /** Name of the Secret holding accessKey / secretKey */
+    credentialsSecret: string
+    /** Region string for the S3 client (defaults to 'us-east-1') */
+    region?: string
+  }
+  /**
+   * Outgoing SMTP for invitations and notifications. The SMTP password is
+   * delivered via secretKeyRef from the `${name}-secrets` bundle
+   * (key: smtpPassword) — never plaintext.
+   */
+  smtp?: {
+    /** SMTP server hostname, e.g. smtp.example.com */
+    host: string
+    /** SMTP port (defaults to 587) */
+    port?: number
+    /** From address for outgoing mail, e.g. no-reply@example.com */
+    from?: string
+  }
+  /**
+   * LibreOffice headless document-conversion workers (same app image,
+   * which must include soffice). Adds a `${name}-soffice` Deployment +
+   * Service; the app reaches it at SOFFICE_HOST:SOFFICE_PORT. Workers
+   * serve the UNO socket (TCP), not HTTP — their probes probe the socket.
+   */
+  conversions?: boolean
+  /** LibreOffice conversion worker replicas (defaults to 1, only used with conversions) */
+  conversionWorkers?: number
+  /**
+   * Name of an existing Secret holding `secretKey` and `smtpPassword`.
+   * Required unless a secrets backend (openbao/vault) is configured on
+   * the surrounding Platform — the backend then provisions them.
+   * Plaintext values are not supported.
+   */
+  secretsName?: string
+  /** Requested app resources */
+  resources?: {
+    requests?: { cpu?: string; memory?: string }
+    limits?: { cpu?: string; memory?: string }
+  }
+  /** TLS configuration (defaults to letsencrypt-prod cluster issuer) */
+  tls?: {
+    secretName: string
+    clusterIssuer: string
+  }
+}
+
+/**
+ * EuroOffice — collaborative document suite.
+ *
+ * @title EuroOffice
+ * @category Productivity & Documents
+ *
+ * Composes:
+ * - CNPG Postgres cluster (documents, revisions, users; DATABASE_URL is
+ *   auto-wired from the DatabaseContext — no manual connection string)
+ * - EuroOffice Deployment + Service + Endpoint (websockets enabled by
+ *   default for live co-editing)
+ * - Required S3/RustFS object storage for document blobs
+ * - Optional LibreOffice headless conversion workers (same image; probed
+ *   on their UNO TCP socket)
+ * - Optional SMTP delivery; password via the `${name}-secrets` bundle
+ * - APP_SECRET (and SMTP_PASSWORD) provisioned through the Platform
+ *   secrets backend (openbao / vault), or referenced from an existing
+ *   Secret via `secretsName`
+ *
+ * The namespace is inherited from the surrounding `<Platform>` (via the
+ * Namespace context) unless set explicitly.
+ *
+ * Wrap the component in `<Platform secrets={{ backend: 'openbao' }}>` and
+ * the app secrets bundle is provisioned for you. Without a backend you
+ * must point `secretsName` at a pre-created Secret.
+ *
+ * @example
+ * import { Platform } from '@r8s/recipes'
+ * import { EuroOffice } from '@r8s/eurooffice'
+ *
+ * export default (
+ *   <Platform secrets={{ backend: 'openbao', mount: 'kv', path: 'apps' }}>
+ *     <EuroOffice
+ *       name="docs"
+ *       host="docs.example.com"
+ *       objectStorage={{
+ *         endpoint: 'https://s3.internal.example.com',
+ *         bucket: 'docs-blobs',
+ *         credentialsSecret: 'docs-blobs-credentials',
+ *       }}
+ *       smtp={{ host: 'smtp.example.com', port: 587, from: 'no-reply@${env:MAIL_DOMAIN}' }}
+ *     />
+ *   </Platform>
+ * )
+ */
+export function EuroOffice(props: EuroOfficeProps) {
+  const {
+    name = 'eurooffice',
+    namespace: namespaceProp,
+    version = 'latest',
+    host,
+    replicas: replicasProp,
+    websockets = true,
+    objectStorage,
+    smtp,
+    conversions = false,
+    conversionWorkers = 1,
+    secretsName,
+    resources = {
+      requests: { memory: '512Mi', cpu: '250m' },
+      limits: { memory: '2Gi', cpu: '1000m' },
+    },
+    tls = { secretName: `${name}-tls`, clusterIssuer: 'letsencrypt-prod' },
+  } = props
+
+  // Inherit namespace from <Platform> context if not explicitly set
+  const contextNamespace = useContext(Namespace)
+  const namespace =
+    namespaceProp ?? (contextNamespace !== 'default' ? contextNamespace : undefined) ?? 'default'
+
+  // Live co-editing runs over websockets pinned to a single pod (no session
+  // affinity) — default to 1 replica unless the caller explicitly scales.
+  const replicas = replicasProp ?? (websockets ? 1 : 2)
+
+  const secretProvider = useContext(SecretContext)
+  const resources_: ReturnType<typeof jsx>[] = []
+
+  const platformSecretsName = secretsName ?? `${name}-secrets`
+
+  // --- App secrets (APP_SECRET / SMTP_PASSWORD) -----------------------------
+  // The app secret signs sessions and collaborator tokens — never render
+  // it as plaintext. With a secrets backend the bundle is provisioned
+  // through the backend (keys: secretKey, smtpPassword); otherwise
+  // reference a pre-created Secret.
+  if (!secretsName) {
+    if (
+      !secretProvider ||
+      (secretProvider.backend !== 'vault' && secretProvider.backend !== 'openbao')
+    ) {
+      throw new Error(
+        `EuroOffice "${name}" requires application secrets (APP_SECRET, SMTP_PASSWORD).\n` +
+          `\n` +
+          `The app secret signs sessions and collaborator tokens — it must ` +
+          `not be rendered as plaintext.\n` +
+          `\n` +
+          `Fix: configure a secrets backend on the Platform:\n` +
+          `  <Platform secrets={{ backend: 'openbao', mount: 'kv', path: 'apps' }}>\n` +
+          `    <EuroOffice name="${name}" host="${host}" />\n` +
+          `  </Platform>\n` +
+          `\n` +
+          `Or reference a pre-created Secret (keys: secretKey, smtpPassword):\n` +
+          `  <EuroOffice name="${name}" host="${host}" secretsName="${name}-secrets" />`
+      )
+    }
+
+    const spec = {
+      ...(secretProvider.backend === 'vault'
+        ? { vaultAuthRef: secretProvider.authRef }
+        : { openbaoAuthRef: secretProvider.authRef }),
+      mount: secretProvider.mount,
+      type: 'kv-v2' as const,
+      path: `${secretProvider.path ?? name}/${name}/secrets`,
+      destination: { create: true, name: platformSecretsName },
+    }
+    resources_.push(
+      secretProvider.backend === 'vault'
+        ? jsx('VaultStaticSecret', {
+            apiVersion: 'secrets.hashicorp.com/v1beta1',
+            kind: 'VaultStaticSecret',
+            metadata: { name: `${name}-secrets`, namespace },
+            spec,
+          })
+        : jsx('OpenBaoStaticSecret', {
+            apiVersion: 'secrets.openbao.org/v1beta1',
+            kind: 'OpenBaoStaticSecret',
+            metadata: { name: `${name}-secrets`, namespace },
+            spec,
+          })
+    )
+  }
+
+  // --- Env wiring -------------------------------------------------------------
+  // Every credential is delivered via secretKeyRef — no plaintext in the
+  // manifest. DATABASE_URL is auto-wired by WebService from the
+  // DatabaseContext (PG* vars + $(VAR) template), so it is not declared here.
+  const env: Record<string, string> = {
+    PORT: '3000',
+    APP_URL: `https://${host}`,
+    WEBSOCKETS_ENABLED: websockets ? 'true' : 'false',
+    AWS_REGION: objectStorage.region ?? 'us-east-1',
+    AWS_S3_UPLOAD_BUCKET_URL: `${objectStorage.endpoint}/${objectStorage.bucket}`,
+    AWS_S3_UPLOAD_BUCKET_NAME: objectStorage.bucket,
+    AWS_S3_ENDPOINT: objectStorage.endpoint,
+    AWS_S3_FORCE_PATH_STYLE: 'true',
+    ...(smtp
+      ? {
+          SMTP_HOST: smtp.host,
+          SMTP_PORT: String(smtp.port ?? 587),
+          ...(smtp.from && { SMTP_FROM: smtp.from }),
+        }
+      : {}),
+    ...(conversions
+      ? {
+          SOFFICE_HOST: `${name}-soffice`,
+          SOFFICE_PORT: '2002',
+        }
+      : {}),
+  }
+
+  // Credentials delivered via secretKeyRef (runtime injection)
+  const secrets: Record<string, SecretRef | string> = {
+    APP_SECRET: { secret: platformSecretsName, key: 'secretKey' },
+    ...(smtp
+      ? { SMTP_PASSWORD: { secret: platformSecretsName, key: 'smtpPassword' as const } }
+      : {}),
+    AWS_ACCESS_KEY_ID: { secret: objectStorage.credentialsSecret, key: 'accessKey' },
+    AWS_SECRET_ACCESS_KEY: { secret: objectStorage.credentialsSecret, key: 'secretKey' },
+  }
+
+  // --- Database + app + conversions + endpoint --------------------------------
+  // Database wraps the app so credentials stay consistent with the r8s
+  // Database recipe (CNPG dedicated cluster provisions the secret) and
+  // WebService auto-wires DATABASE_URL from the DatabaseContext.
+  resources_.push(
+    jsx(Database, {
+      name,
+      namespace,
+      storage: '10Gi',
+      children: (
+        <WebService
+          name={name}
+          namespace={namespace}
+          image={`ghcr.io/berget-ai/eurooffice:${version}`}
+          port={3000}
+          replicas={replicas}
+          resources={resources}
+          env={env}
+          secrets={secrets}
+        />
+      ),
+    })
+  )
+
+  // LibreOffice headless conversion workers — same app image (must include
+  // soffice), listening for UNO socket connections. The workers know HTTP
+  // health endpoints no better than we do, so probe the UNO TCP socket
+  // directly (httpGet /health would crash-loop them).
+  if (conversions) {
+    resources_.push(
+      <WebService
+        name={`${name}-soffice`}
+        namespace={namespace}
+        image={`ghcr.io/berget-ai/eurooffice:${version}`}
+        port={2002}
+        replicas={conversionWorkers}
+        command={[
+          'soffice',
+          '--headless',
+          '--norestore',
+          '--accept=socket,host=0.0.0.0,port=2002;urp;',
+        ]}
+        env={{ SOFFICE_MODE: 'worker' }}
+        probes={{
+          liveness: { tcp: true, port: 2002 },
+          readiness: { tcp: true, port: 2002, initialDelaySeconds: 20 },
+        }}
+      />
+    )
+  }
+
+  // --- Endpoint — collaborative editing shares the app host -------------------
+  resources_.push(
+    <Endpoint
+      name={`${name}-endpoint`}
+      namespace={namespace}
+      host={host}
+      serviceName={name}
+      servicePort={3000}
+      tls={tls}
+    />
+  )
+
+  return jsx(Fragment, { children: resources_ })
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true
+  },
+  "include": ["src/**/*"],
+  "references": [
+    { "path": "../core" },
+    { "path": "../k8s-types" },
+    { "path": "../crds" },
+    { "path": "../recipes" }
+  ]
+}