Öffnungszeiten: Schalter, Collections und Felder

ZEITEN_ENABLED/ZEITEN_PILOT_EMAILS/ZEITEN_KEIN_NEUBAU als config.zeiten (neben config.termine),
zeitenSetup (30 € einmalig), Collection-IDs oeffnungszeiten und zeitenErinnerungen, Schema der beiden
Collections plus fünf neue portalFeatures-Felder, scripts/zeiten-setup.mjs (idempotent, --check),
schemaKeys kennt die neuen Collections und Felder.

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

test/support/schema.js

@@ -1,5 +1,6 @@
 import { readFileSync } from 'node:fs'
 import { TERMINE_COLLECTIONS } from '../../server/services/termine/schema.js'
+import { ZEITEN_COLLECTIONS, ZEITEN_FEATURE_ATTRIBUTES } from '../../server/services/zeiten/schema.js'
 import { FEATURE_CONSENT_ATTRIBUTES, PORTAL_FEATURE_ATTRIBUTES } from '../../scripts/feature-setup.mjs'
 
 // Setup-Skripte, die Collections in Appwrite anlegen (Blockformat: 'id', ... \n  ],)
@@ -9,12 +10,15 @@ const SETUP_SCRIPTS = ['setup-abo-collections.mjs', 'setup-finanzen.mjs']
  * Attribut-Schlüssel einer Collection, wie sie scripts/setup-abo-collections.mjs bzw.
  * scripts/setup-finanzen.mjs in Appwrite anlegen. Tests geben sie dem Appwrite-Nachbau als Schema:
  * Schreibt der Code ein Feld, das das Setup-Skript nicht anlegt, scheitert der Test wie Appwrite in
- * Produktion. Die Termine-Collections kommen aus server/services/termine/schema.js (scripts/termine-setup.mjs);
- * portalFeatures bekommt zusaetzlich die Attribute aus scripts/feature-setup.mjs (PORTAL_FEATURE_ATTRIBUTES);
+ * Produktion. Die Termine-Collections kommen aus server/services/termine/schema.js (scripts/termine-setup.mjs),
+ * die Zeiten-Collections aus server/services/zeiten/schema.js (scripts/zeiten-setup.mjs);
+ * portalFeatures bekommt zusaetzlich die Attribute aus scripts/feature-setup.mjs (PORTAL_FEATURE_ATTRIBUTES) und die
+ * Zeiten-Felder aus server/services/zeiten/schema.js (ZEITEN_FEATURE_ATTRIBUTES, angelegt von scripts/zeiten-setup.mjs);
  * featureConsents (Zustimmungsnachweis) steht ganz dort (FEATURE_CONSENT_ATTRIBUTES).
  */
 export function schemaKeys(collection) {
   if (Object.hasOwn(TERMINE_COLLECTIONS, collection)) return TERMINE_COLLECTIONS[collection].attributes.map((a) => a.key)
+  if (Object.hasOwn(ZEITEN_COLLECTIONS, collection)) return ZEITEN_COLLECTIONS[collection].attributes.map((a) => a.key)
   if (collection === 'featureConsents') return FEATURE_CONSENT_ATTRIBUTES.map((a) => a.key)
   for (const script of SETUP_SCRIPTS) {
     const src = readFileSync(new URL(`../../scripts/${script}`, import.meta.url), 'utf8')
@@ -22,7 +26,9 @@ export function schemaKeys(collection) {
     if (start < 0) continue
     const block = src.slice(start, src.indexOf('\n  ],', start))
     const keys = [...block.matchAll(/key: '(\w+)'/g)].map((m) => m[1])
-    return collection === 'portalFeatures' ? [...keys, ...PORTAL_FEATURE_ATTRIBUTES.map((a) => a.key)] : keys
+    return collection === 'portalFeatures'
+      ? [...keys, ...PORTAL_FEATURE_ATTRIBUTES.map((a) => a.key), ...ZEITEN_FEATURE_ATTRIBUTES.map((a) => a.key)]
+      : keys
   }
   throw new Error(`Collection ${collection} fehlt im Setup-Skript`)
 }

test/zeitenSchalter.test.js

@@ -0,0 +1,146 @@
+import { test, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { config } from '../server/config.js'
+import { zeitenAus, zeitenFuerKunde, zeitenModus } from '../server/services/zeiten/schalter.js'
+
+const ZEITEN_ENV = [
+  'ZEITEN_ENABLED',
+  'ZEITEN_PILOT_EMAILS',
+  'ZEITEN_KEIN_NEUBAU',
+  'APPWRITE_COLLECTION_OEFFNUNGSZEITEN',
+  'APPWRITE_COLLECTION_ZEITEN_ERINNERUNGEN',
+]
+
+let original
+beforeEach(() => {
+  original = { ...config.zeiten }
+})
+afterEach(() => {
+  Object.assign(config.zeiten, original)
+})
+
+/** Frische config.js-Instanz mit genau diesen Zeiten-Umgebungsvariablen (alle anderen entfernt). */
+let freshCounter = 0
+async function freshConfig(env = {}) {
+  const saved = Object.fromEntries(ZEITEN_ENV.map((key) => [key, process.env[key]]))
+  for (const key of ZEITEN_ENV) delete process.env[key]
+  Object.assign(process.env, env)
+  try {
+    freshCounter += 1
+    return (await import(`../server/config.js?zeiten-test=${freshCounter}`)).config
+  } finally {
+    for (const key of ZEITEN_ENV) {
+      if (saved[key] === undefined) delete process.env[key]
+      else process.env[key] = saved[key]
+    }
+  }
+}
+
+test('Vorgabe ist aus', async () => {
+  const fresh = await freshConfig()
+  assert.deepEqual(fresh.zeiten, { mode: 'off', pilotEmails: [], keinNeubau: ['emmas-schatzkiste'] })
+  // ZEITEN_ENABLED leer ⇒ aus; der Schalter liest config.zeiten bei jedem Aufruf
+  config.zeiten.mode = fresh.zeiten.mode
+  assert.equal(zeitenModus(), 'off')
+  assert.equal(zeitenAus(), true)
+  assert.equal(zeitenFuerKunde('kenso.gri@gmail.com'), false)
+})
+
+test('Konfiguration: leerer oder unbekannter Schalter ist off, Umgebungsvariablen werden bereinigt', async () => {
+  for (const value of ['', '  ', 'banane', 'true', '1']) {
+    assert.equal((await freshConfig({ ZEITEN_ENABLED: value })).zeiten.mode, 'off', `ZEITEN_ENABLED=${JSON.stringify(value)}`)
+  }
+  assert.equal((await freshConfig({ ZEITEN_ENABLED: ' ON ' })).zeiten.mode, 'on')
+  const fresh = await freshConfig({
+    ZEITEN_ENABLED: ' Pilot ',
+    ZEITEN_PILOT_EMAILS: ' Kenso.Gri@Gmail.com, ,justin@webklar.com ',
+  })
+  assert.equal(fresh.zeiten.mode, 'pilot')
+  assert.deepEqual(fresh.zeiten.pilotEmails, ['kenso.gri@gmail.com', 'justin@webklar.com'])
+})
+
+test('zeitenModus: leer und unbekannt sind off, pilot und on bleiben', () => {
+  for (const value of [undefined, null, '', 'banane', 'PILOT', 'true']) {
+    config.zeiten.mode = value
+    assert.equal(zeitenModus(), 'off', `mode=${JSON.stringify(value)}`)
+    assert.equal(zeitenAus(), true)
+  }
+  config.zeiten.mode = 'pilot'
+  assert.equal(zeitenModus(), 'pilot')
+  assert.equal(zeitenAus(), false)
+  config.zeiten.mode = 'on'
+  assert.equal(zeitenModus(), 'on')
+  assert.equal(zeitenAus(), false)
+})
+
+test('off sperrt alle, auch mit Stern in der Liste', () => {
+  config.zeiten.mode = 'off'
+  config.zeiten.pilotEmails = ['*', 'kenso.gri@gmail.com']
+  assert.equal(zeitenFuerKunde('kenso.gri@gmail.com'), false)
+  assert.equal(zeitenFuerKunde('jemand@example.com'), false)
+})
+
+test('pilot gilt nur für die Pilotliste', () => {
+  config.zeiten.mode = 'pilot'
+  config.zeiten.pilotEmails = ['a@b.de']
+  assert.equal(zeitenFuerKunde('A@b.de'), true)
+  assert.equal(zeitenFuerKunde(' a@b.de '), true)
+  assert.equal(zeitenFuerKunde('x@y.de'), false)
+  assert.equal(zeitenFuerKunde('a@b.de.evil.de'), false)
+  // Stern = alle, leere Liste = niemand, ohne Adresse = niemand
+  config.zeiten.pilotEmails = ['*']
+  assert.equal(zeitenFuerKunde('x@y.de'), true)
+  config.zeiten.pilotEmails = []
+  assert.equal(zeitenFuerKunde('a@b.de'), false)
+  config.zeiten.pilotEmails = ['a@b.de']
+  for (const email of [undefined, null, '', '   ']) assert.equal(zeitenFuerKunde(email), false)
+})
+
+test('on gilt für alle', () => {
+  config.zeiten.mode = 'on'
+  config.zeiten.pilotEmails = ['a@b.de']
+  assert.equal(zeitenFuerKunde('x@y.de'), true)
+  assert.equal(zeitenFuerKunde(undefined), true)
+})
+
+test('keinNeubau kommt aus ZEITEN_KEIN_NEUBAU, Vorgabe emmas-schatzkiste', async () => {
+  assert.deepEqual((await freshConfig()).zeiten.keinNeubau, ['emmas-schatzkiste'])
+  assert.deepEqual((await freshConfig({ ZEITEN_KEIN_NEUBAU: '' })).zeiten.keinNeubau, ['emmas-schatzkiste'])
+  assert.deepEqual(
+    (await freshConfig({ ZEITEN_KEIN_NEUBAU: ' Emmas-Schatzkiste, , Andere-Site ' })).zeiten.keinNeubau,
+    ['emmas-schatzkiste', 'andere-site'],
+  )
+})
+
+test('zeiten steht neben config.termine, nicht darin', async () => {
+  const fresh = await freshConfig()
+  assert.equal('keinNeubau' in fresh.termine, false)
+  assert.equal('zeiten' in fresh.termine, false)
+  assert.notEqual(fresh.zeiten, fresh.termine)
+})
+
+test('zeitenSetup: 3000 Cent einmalig', async () => {
+  const fresh = await freshConfig()
+  assert.deepEqual(fresh.zeitenSetup, {
+    key: 'zeitenSetup',
+    name: 'Öffnungszeiten live – Einrichtung',
+    amountCents: 3000,
+    lookupKey: 'webklar_zeiten_einrichtung_3000',
+    oneTime: true,
+    priceNickname: 'Öffnungszeiten-Einrichtung 30 €',
+  })
+  assert.equal(config.zeitenSetup.amountCents, 3000)
+  assert.equal(config.zeitenSetup.oneTime, true)
+  assert.equal(config.zeitenSetup.lookupKey, 'webklar_zeiten_einrichtung_3000')
+})
+
+test('Konfiguration: Collection-IDs der Zeiten-Collections', async () => {
+  const fresh = await freshConfig()
+  assert.equal(fresh.collections.oeffnungszeiten, 'oeffnungszeiten')
+  assert.equal(fresh.collections.zeitenErinnerungen, 'zeitenErinnerungen')
+  const anders = await freshConfig({
+    APPWRITE_COLLECTION_OEFFNUNGSZEITEN: 'zDaten',
+    APPWRITE_COLLECTION_ZEITEN_ERINNERUNGEN: 'zMerker',
+  })
+  assert.deepEqual([anders.collections.oeffnungszeiten, anders.collections.zeitenErinnerungen], ['zDaten', 'zMerker'])
+})

test/zeitenSetup.test.js

@@ -0,0 +1,262 @@
+import { test, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { startAppwriteMock } from './support/appwriteMock.js'
+import { startFakeStripe } from './support/fakeStripe.js'
+import { useTestEnv } from './support/testEnv.js'
+import { schemaKeys } from './support/schema.js'
+import { ZEITEN_COLLECTIONS, ZEITEN_DATETIMES, ZEITEN_FEATURE_ATTRIBUTES } from '../server/services/zeiten/schema.js'
+
+// Das Skript und die Konfiguration laden erst nach useTestEnv (Endpunkt des Nachbaus), daher dynamische Imports
+const aw = await startAppwriteMock({ schema: { oeffnungszeiten: schemaKeys('oeffnungszeiten') }, datetimes: ZEITEN_DATETIMES })
+const st = await startFakeStripe()
+useTestEnv({ appwriteUrl: aw.url, stripeUrl: st.url })
+const { config } = await import('../server/config.js')
+const { main } = await import('../scripts/zeiten-setup.mjs')
+const { createDocument, updateDocument, getDocument } = await import('../server/services/appwriteAdmin.js')
+after(() => Promise.all([aw.close(), st.close()]))
+
+const NAMES = ['oeffnungszeiten', 'zeitenErinnerungen']
+const FEATURE_KEYS = ['unlockedBy', 'aboEndeAt', 'einbau', 'behaltenSessionId', 'k24At']
+const keysOf = (name) => ZEITEN_COLLECTIONS[name].attributes.map((a) => a.key)
+
+/**
+ * Appwrite-Client mit Zustand (wie in termineSetup.test.js): Attribute gibt es nur in vorhandenen Collections,
+ * Indizes nur auf vorhandenen Attributen. `initial` = { collectionId: { attrs: [...], indexes: [...] } }.
+ * portalFeatures gibt es immer (legt setup-abo-collections.mjs an), mit den Feldern, die schon da sind.
+ */
+function fakeClient(initial = {}) {
+  const start = { portalFeatures: { attrs: ['customerId', 'projectId', 'featureKey', 'state'] }, ...initial }
+  const state = new Map(
+    Object.entries(start).map(([id, c]) => [id, { attrs: new Map((c.attrs || []).map((key) => [key, null])), indexes: new Set(c.indexes || []) }]),
+  )
+  const calls = { collections: [], attrs: [], indexes: [] }
+  const need = (id) => {
+    if (!state.has(id)) throw Object.assign(new Error(`Collection ${id} fehlt`), { status: 404 })
+    return state.get(id)
+  }
+  return {
+    state,
+    calls,
+    async collectionExists(id) {
+      return state.has(id)
+    },
+    async ensureCollection(id, name) {
+      if (state.has(id)) return false
+      state.set(id, { attrs: new Map(), indexes: new Set() })
+      calls.collections.push({ id, name })
+      return true
+    },
+    async listAttributes(id) {
+      return [...need(id).attrs.keys()].map((key) => ({ key }))
+    },
+    async createAttribute(id, attr) {
+      const collection = need(id)
+      if (collection.attrs.has(attr.key)) throw new Error(`Attribut ${id}.${attr.key} existiert schon`)
+      collection.attrs.set(attr.key, attr)
+      calls.attrs.push(`${id}.${attr.key}`)
+    },
+    async waitForAttribute(id, key) {
+      assert.ok(need(id).attrs.has(key), `wartet auf nie angelegtes Attribut ${id}.${key}`)
+    },
+    async listIndexes(id) {
+      return [...need(id).indexes].map((key) => ({ key }))
+    },
+    async createIndex(id, index) {
+      const collection = need(id)
+      for (const key of index.attributes) {
+        if (!collection.attrs.has(key)) throw new Error(`Index ${index.key}: Attribut ${key} fehlt in ${id}`)
+      }
+      collection.indexes.add(index.key)
+      calls.indexes.push(`${id}.${index.key}`)
+    },
+  }
+}
+
+const quiet = () => {}
+const featuresId = config.collections.portalFeatures
+const expectedAttrs = [
+  ...NAMES.flatMap((name) => keysOf(name).map((key) => `${config.collections[name]}.${key}`)),
+  ...FEATURE_KEYS.map((key) => `${featuresId}.${key}`),
+]
+const expectedIndexes = NAMES.flatMap((name) => ZEITEN_COLLECTIONS[name].indexes.map((i) => `${config.collections[name]}.${i.key}`))
+
+test('oeffnungszeiten hat die Felder aus Spec 2.1', () => {
+  assert.deepEqual(Object.keys(ZEITEN_COLLECTIONS), NAMES)
+  const keys = keysOf('oeffnungszeiten')
+  for (const key of ['customerId', 'projectId', 'featureId', 'version', 'daten', 'teamVersion', 'team', 'ersatzHash', 'updatedAt', 'updatedBy']) {
+    assert.ok(keys.includes(key), key)
+  }
+  assert.equal(keys.length, 10)
+
+  const byKey = Object.fromEntries(ZEITEN_COLLECTIONS.oeffnungszeiten.attributes.map((a) => [a.key, a]))
+  assert.deepEqual(byKey.daten, { key: 'daten', type: 'string', size: 40000, required: false })
+  assert.deepEqual(byKey.team, { key: 'team', type: 'string', size: 2000, required: false })
+  assert.deepEqual(byKey.ersatzHash, { key: 'ersatzHash', type: 'string', size: 64, required: false })
+  assert.deepEqual(byKey.updatedBy, { key: 'updatedBy', type: 'string', size: 64, required: false })
+  for (const key of ['customerId', 'projectId', 'featureId']) assert.deepEqual([byKey[key].type, byKey[key].size], ['string', 64], key)
+  for (const key of ['version', 'teamVersion']) assert.equal(byKey[key].type, 'integer', key)
+  assert.equal(byKey.updatedAt.type, 'datetime')
+  // Löschung beim Kunden-Löschen liest über customerId
+  assert.deepEqual(ZEITEN_COLLECTIONS.oeffnungszeiten.indexes, [{ key: 'idx_customer', type: 'key', attributes: ['customerId'] }])
+})
+
+test('daten fasst 32 KB JSON', () => {
+  const daten = ZEITEN_COLLECTIONS.oeffnungszeiten.attributes.find((a) => a.key === 'daten')
+  assert.ok(daten.size >= 40000, `daten.size ${daten.size}`)
+  // 32 KB Spielraum auch bei JSON-Maskierung von Umlauten und Anführungszeichen
+  assert.ok(daten.size >= 32 * 1024)
+})
+
+test('zeitenErinnerungen: featureId, datum, createdAt', () => {
+  assert.deepEqual(keysOf('zeitenErinnerungen'), ['featureId', 'datum', 'createdAt'])
+  const byKey = Object.fromEntries(ZEITEN_COLLECTIONS.zeitenErinnerungen.attributes.map((a) => [a.key, a]))
+  assert.deepEqual(byKey.featureId, { key: 'featureId', type: 'string', size: 64, required: false })
+  assert.deepEqual(byKey.datum, { key: 'datum', type: 'string', size: 10, required: false })
+  assert.deepEqual(byKey.createdAt, { key: 'createdAt', type: 'datetime', required: false })
+  assert.deepEqual(ZEITEN_COLLECTIONS.zeitenErinnerungen.indexes, [{ key: 'idx_datum', type: 'key', attributes: ['datum'] }])
+})
+
+test('portalFeatures bekommt unlockedBy(8), aboEndeAt, einbau(12), behaltenSessionId(128), k24At', () => {
+  assert.deepEqual(ZEITEN_FEATURE_ATTRIBUTES, [
+    { key: 'unlockedBy', type: 'string', size: 8, required: false },
+    { key: 'aboEndeAt', type: 'datetime', required: false },
+    { key: 'einbau', type: 'string', size: 12, required: false },
+    { key: 'behaltenSessionId', type: 'string', size: 128, required: false },
+    { key: 'k24At', type: 'datetime', required: false },
+  ])
+})
+
+test('Schema: jedes Attribut ist optional, hat eine gültige Form; Indizes nur auf vorhandenen Attributen', () => {
+  for (const name of NAMES) {
+    const { attributes, indexes } = ZEITEN_COLLECTIONS[name]
+    assert.equal(new Set(attributes.map((a) => a.key)).size, attributes.length, `${name}: doppelte Schlüssel`)
+    for (const attr of attributes) {
+      assert.match(attr.key, /^[A-Za-z][A-Za-z0-9]{0,35}$/, `${name}.${attr.key}`)
+      assert.equal(attr.required, false, `${name}.${attr.key}`)
+      assert.ok(['string', 'integer', 'boolean', 'datetime'].includes(attr.type), `${name}.${attr.key}: Typ ${attr.type}`)
+      if (attr.type === 'string') assert.ok(Number.isInteger(attr.size) && attr.size > 0, `${name}.${attr.key}: Größe`)
+      else assert.equal('size' in attr, false, `${name}.${attr.key}: Größe nur bei Text`)
+    }
+    for (const index of indexes) {
+      assert.equal(index.type, 'key')
+      assert.ok(index.attributes.every((key) => keysOf(name).includes(key)), `${name}.${index.key}`)
+    }
+  }
+  for (const attr of ZEITEN_FEATURE_ATTRIBUTES) {
+    assert.match(attr.key, /^[A-Za-z][A-Za-z0-9]{0,35}$/, attr.key)
+    assert.equal(attr.required, false, attr.key)
+    if (attr.type === 'string') assert.ok(Number.isInteger(attr.size) && attr.size > 0, `${attr.key}: Größe`)
+    else assert.equal('size' in attr, false, `${attr.key}: Größe nur bei Text`)
+  }
+})
+
+test('ZEITEN_DATETIMES nennt je Collection genau die datetime-Attribute', () => {
+  assert.deepEqual(ZEITEN_DATETIMES, { oeffnungszeiten: ['updatedAt'], zeitenErinnerungen: ['createdAt'] })
+})
+
+test('schemaKeys liefert die Zeiten-Collections und die neuen portalFeatures-Felder', () => {
+  assert.deepEqual(schemaKeys('oeffnungszeiten'), keysOf('oeffnungszeiten'))
+  assert.deepEqual(schemaKeys('zeitenErinnerungen'), ['featureId', 'datum', 'createdAt'])
+  const features = schemaKeys('portalFeatures')
+  for (const key of FEATURE_KEYS) assert.ok(features.includes(key), `portalFeatures.${key}`)
+  // bestehende Felder und Setup-Skripte bleiben
+  for (const key of ['disabledReason', 'aboEndeMailAt', 'zahlungMeldung', 'unlockedByPurchase']) assert.ok(features.includes(key), key)
+  assert.ok(schemaKeys('termineConfig').includes('einstellung'))
+  assert.ok(schemaKeys('subscriptions').length > 0)
+  assert.throws(() => schemaKeys('gibtEsNicht'), /fehlt im Setup-Skript/)
+})
+
+test('Rundreise: Öffnungszeiten anlegen, ändern und zurücklesen; unbekanntes Feld lehnt der Nachbau ab', async () => {
+  const collection = config.collections.oeffnungszeiten
+  const daten = JSON.stringify({ land: 'RP', plaene: [], feiertage: {}, ausnahmen: [], hinweise: [], kontakt: { an: false } })
+  const created = await createDocument(
+    collection,
+    { customerId: 'c1', projectId: 'p1', featureId: 'f1', version: 1, daten, teamVersion: 0, updatedAt: '2026-10-04T10:00:00.000Z', updatedBy: 'kunde' },
+    'f1',
+  )
+  assert.equal(created.$id, 'f1')
+  await updateDocument(collection, 'f1', { version: 2, updatedBy: 'team:s1', ersatzHash: 'abc' })
+  const doc = await getDocument(collection, 'f1')
+  assert.deepEqual([doc.version, doc.updatedBy, doc.ersatzHash, doc.daten], [2, 'team:s1', 'abc', daten])
+  await assert.rejects(() => createDocument(collection, { customerId: 'c1', fremd: 'x' }, 'f2'), /Unknown attribute/)
+})
+
+test('Konfiguration: Collection-IDs der Zeiten-Collections', () => {
+  assert.deepEqual(NAMES.map((name) => config.collections[name]), NAMES)
+})
+
+test('main legt auf leerer Datenbank 2 Collections, alle Attribute und Indizes an und ergänzt portalFeatures', async () => {
+  const client = fakeClient()
+  const result = await main({ client, log: quiet })
+  assert.deepEqual(client.calls.collections, NAMES.map((id) => ({ id, name: id })))
+  assert.deepEqual([...client.calls.attrs].sort(), [...expectedAttrs].sort())
+  assert.deepEqual([...client.calls.indexes].sort(), [...expectedIndexes].sort())
+  assert.ok(client.calls.indexes.includes('oeffnungszeiten.idx_customer'))
+  assert.ok(client.calls.indexes.includes('zeitenErinnerungen.idx_datum'))
+  assert.equal(result.missing.length, expectedAttrs.length)
+  assert.deepEqual(result.missingCollections, NAMES)
+  assert.equal(result.missingIndexes.length, expectedIndexes.length)
+  // portalFeatures wird nicht neu angelegt, bekommt aber genau die fünf Felder
+  assert.ok(!client.calls.collections.some((c) => c.id === featuresId))
+  assert.deepEqual(client.calls.attrs.filter((k) => k.startsWith(`${featuresId}.`)), FEATURE_KEYS.map((key) => `${featuresId}.${key}`))
+  const features = client.state.get(featuresId).attrs
+  assert.deepEqual(features.get('unlockedBy'), { key: 'unlockedBy', type: 'string', size: 8, required: false })
+  assert.deepEqual(features.get('k24At'), { key: 'k24At', type: 'datetime', required: false })
+})
+
+test('main: zweiter Lauf legt nichts mehr an', async () => {
+  const client = fakeClient()
+  await main({ client, log: quiet })
+  client.calls.collections.length = client.calls.attrs.length = client.calls.indexes.length = 0
+  const result = await main({ client, log: quiet })
+  assert.deepEqual(client.calls, { collections: [], attrs: [], indexes: [] })
+  assert.deepEqual(result, { missing: [], missingCollections: [], missingIndexes: [] })
+})
+
+test('main legt nur fehlende Attribute und Indizes einer vorhandenen Collection an', async () => {
+  const client = fakeClient({
+    zeitenErinnerungen: { attrs: ['featureId', 'datum'], indexes: [] },
+    portalFeatures: { attrs: ['customerId', 'unlockedBy', 'einbau'] },
+  })
+  await main({ client, log: quiet })
+  assert.ok(!client.calls.collections.some((c) => c.id === 'zeitenErinnerungen'))
+  assert.deepEqual(client.calls.attrs.filter((k) => k.startsWith('zeitenErinnerungen.')), ['zeitenErinnerungen.createdAt'])
+  assert.deepEqual(client.calls.indexes.filter((k) => k.startsWith('zeitenErinnerungen.')), ['zeitenErinnerungen.idx_datum'])
+  assert.deepEqual(
+    client.calls.attrs.filter((k) => k.startsWith(`${featuresId}.`)),
+    [`${featuresId}.aboEndeAt`, `${featuresId}.behaltenSessionId`, `${featuresId}.k24At`],
+  )
+  assert.equal(client.calls.collections.length, 1)
+})
+
+test('--check meldet fehlende Collections und Felder, ohne zu schreiben', async () => {
+  const client = fakeClient()
+  const lines = []
+  const result = await main({ check: true, client, log: (line) => lines.push(line) })
+  assert.deepEqual(client.calls, { collections: [], attrs: [], indexes: [] })
+  assert.equal(client.state.size, 1, 'nur portalFeatures, nichts angelegt')
+  assert.deepEqual([...client.state.get(featuresId).attrs.keys()], ['customerId', 'projectId', 'featureKey', 'state'])
+  assert.deepEqual(result.missingCollections, NAMES)
+  assert.equal(result.missing.length, expectedAttrs.length)
+  assert.equal(result.missingIndexes.length, expectedIndexes.length)
+  assert.ok(lines.some((line) => line.includes('oeffnungszeiten') && line.includes('FEHLT')))
+  assert.ok(lines.some((line) => line.includes(`${featuresId}.unlockedBy FEHLT`)), lines.join('\n'))
+  assert.ok(lines.some((line) => line.includes('Index oeffnungszeiten.idx_customer FEHLT')))
+})
+
+test('--check meldet bei vollständigem Stand nichts und ein einzelnes fehlendes portalFeatures-Feld genau dieses', async () => {
+  const client = fakeClient()
+  await main({ client, log: quiet })
+  assert.deepEqual(await main({ check: true, client, log: quiet }), { missing: [], missingCollections: [], missingIndexes: [] })
+  client.state.get(featuresId).attrs.delete('k24At')
+  const result = await main({ check: true, client, log: quiet })
+  assert.deepEqual(result.missing.map((a) => `${a.collection}.${a.key}`), [`${featuresId}.k24At`])
+  assert.deepEqual(result.missingCollections, [])
+})
+
+test('main: fehlt portalFeatures, bricht es mit klarer Meldung ab, ohne etwas anzulegen', async () => {
+  const client = fakeClient()
+  client.state.delete(featuresId)
+  await assert.rejects(() => main({ client, log: quiet }), /portalFeatures.*fehlt/)
+  assert.deepEqual(client.calls, { collections: [], attrs: [], indexes: [] })
+})