@cosmicdrift/kumiko-bundled-features 0.3.0 → 0.4.1

package/src/config/index.ts

@@ -1,3 +1,8 @@
+import type { DbConnection, EncryptionProvider } from "@cosmicdrift/kumiko-framework/db";
+import { seedConfigValues } from "@cosmicdrift/kumiko-framework/db";
+import type { Registry } from "@cosmicdrift/kumiko-framework/engine";
+import { configValueEntity, configValuesTable } from "./table";
+
 export {
   CONFIG_FEATURE,
   ConfigErrors,
@@ -13,3 +18,15 @@ export {
 export type { AppConfigOverrides, ConfigResolver } from "./resolver";
 export { createConfigResolver, validateAppOverrides } from "./resolver";
 export { configValuesTable } from "./table";
+
+// Boot helper for runDevApp / runProdApp: pulls every ConfigSeedDef from
+// the registry and writes the matching system/tenant/user rows via the
+// event-store executor. Idempotent across boots — see config-seeding.md.
+export function seedAllConfigValues(
+  registry: Registry,
+  db: DbConnection,
+  encryption?: EncryptionProvider,
+): Promise<{ created: number; skipped: number }> {
+  const seeds = registry.getAllConfigSeeds();
+  return seedConfigValues(seeds, configValuesTable, configValueEntity, registry, db, encryption);
+}

package/src/config/resolver.ts

@@ -5,14 +5,17 @@ import {
   type TenantDb,
 } from "@cosmicdrift/kumiko-framework/db";
 import type {
+  ConfigCascade,
+  ConfigCascadeLevel,
   ConfigKeyDefinition,
   ConfigResolver,
+  ConfigStoredRowWithSource,
   ConfigValueSource,
   ConfigValueWithSource,
 } from "@cosmicdrift/kumiko-framework/engine";
 import { SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
 import { assertUnreachable, parseJsonOrThrow } from "@cosmicdrift/kumiko-framework/utils";
-import { and, eq, isNull, or } from "drizzle-orm";
+import { and, eq, inArray, isNull, or } from "drizzle-orm";
 import { configValuesTable } from "./table";
 
 type ConfigRow = {
@@ -66,6 +69,148 @@ export type ConfigResolverOptions = {
   appOverrides?: AppConfigOverrides;
 };
 
+// Shared cascade-builder. Single-key path passes a `findRow`-bound row
+// fetcher (one SQL per lookup); batch path passes a closure over
+// pre-loaded rows. The builder itself is unaware of which.
+async function buildCascade(
+  qualifiedKey: string,
+  keyDef: ConfigKeyDefinition,
+  tenantId: string,
+  userId: string,
+  db: DbConnection | TenantDb,
+  fetchRow: (
+    tenantId: string,
+    userId: string | null,
+  ) => Promise<ConfigRow | null> | ConfigRow | null,
+  appOverrides: AppConfigOverrides | undefined,
+  encryption: EncryptionProvider | undefined,
+): Promise<ConfigCascade> {
+  type Lookup = {
+    tenantId: string;
+    userId: string | null;
+    source: ConfigValueSource;
+    label: string;
+  };
+  const lookups: Lookup[] = [];
+
+  switch (keyDef.scope) {
+    case "user":
+      lookups.push({ tenantId, userId, source: "user-row", label: "User" });
+      lookups.push({ tenantId, userId: null, source: "tenant-row", label: "Tenant" });
+      break;
+    case "tenant":
+      lookups.push({ tenantId, userId: null, source: "tenant-row", label: "Tenant" });
+      lookups.push({
+        tenantId: SYSTEM_TENANT_ID,
+        userId: null,
+        source: "system-row",
+        label: "System",
+      });
+      break;
+    case "system":
+      lookups.push({
+        tenantId: SYSTEM_TENANT_ID,
+        userId: null,
+        source: "system-row",
+        label: "System",
+      });
+      break;
+    default:
+      assertUnreachable(keyDef.scope, "config scope");
+  }
+
+  const levels: ConfigCascadeLevel[] = [];
+  let activeIndex = -1;
+
+  for (const lookup of lookups) {
+    const row = await fetchRow(lookup.tenantId, lookup.userId);
+    if (row?.value !== null && row?.value !== undefined) {
+      let raw = row.value;
+      if (keyDef.encrypted && encryption) {
+        raw = encryption.decrypt(raw);
+      }
+      if (activeIndex === -1) activeIndex = levels.length;
+      levels.push({
+        label: lookup.label,
+        value: deserializeValue(raw, keyDef.type),
+        source: lookup.source,
+        isActive: false,
+        hasValue: true,
+      });
+    } else {
+      levels.push({
+        label: lookup.label,
+        value: undefined,
+        source: lookup.source,
+        isActive: false,
+        hasValue: false,
+      });
+    }
+  }
+
+  const overrideValue = appOverrides?.get(qualifiedKey);
+  const hasOverride = overrideValue !== undefined;
+  if (activeIndex === -1 && hasOverride) activeIndex = levels.length;
+  levels.push({
+    label: "App-Override",
+    value: overrideValue,
+    source: "app-override",
+    isActive: false,
+    hasValue: hasOverride,
+  });
+
+  if (keyDef.computed) {
+    const value = await keyDef.computed({ tenantId, userId, db });
+    if (activeIndex === -1) activeIndex = levels.length;
+    levels.push({
+      label: "Computed",
+      value,
+      source: "computed",
+      isActive: false,
+      hasValue: true,
+    });
+  } else {
+    levels.push({
+      label: "Computed",
+      value: undefined,
+      source: "computed",
+      isActive: false,
+      hasValue: false,
+    });
+  }
+
+  if (keyDef.default !== undefined) {
+    if (activeIndex === -1) activeIndex = levels.length;
+    levels.push({
+      label: "Default",
+      value: keyDef.default,
+      source: "default",
+      isActive: false,
+      hasValue: true,
+    });
+  } else {
+    if (activeIndex === -1) activeIndex = levels.length;
+    levels.push({
+      label: "Default",
+      value: undefined,
+      source: "missing",
+      isActive: false,
+      hasValue: false,
+    });
+  }
+
+  const active = activeIndex >= 0 ? levels[activeIndex] : undefined;
+  if (active !== undefined) {
+    levels[activeIndex] = { ...active, isActive: true };
+  }
+
+  return {
+    value: active?.value,
+    source: active?.source ?? "missing",
+    levels,
+  };
+}
+
 export function createConfigResolver(options: ConfigResolverOptions = {}): ConfigResolver {
   const { encryption, appOverrides } = options;
   async function findRow(
@@ -193,6 +338,133 @@ export function createConfigResolver(options: ConfigResolverOptions = {}): Confi
 
       return result;
     },
+
+    async getAllWithSource(tenantId, userId, db) {
+      // Load ALL potentially relevant rows (user + tenant + system)
+      const rows = await db
+        .select()
+        .from(configValuesTable)
+        .where(
+          or(
+            and(eq(configValuesTable.tenantId, SYSTEM_TENANT_ID), isNull(configValuesTable.userId)),
+            and(eq(configValuesTable.tenantId, tenantId), isNull(configValuesTable.userId)),
+            and(eq(configValuesTable.tenantId, tenantId), eq(configValuesTable.userId, userId)),
+          ),
+        );
+
+      const result = new Map<string, ConfigStoredRowWithSource>();
+
+      // Group rows by key so we can determine the winner and its source
+      const groups = new Map<string, ConfigRow[]>();
+      for (const row of rows) {
+        const r = row as ConfigRow; // @cast-boundary db-row
+        const g = groups.get(r.key) ?? [];
+        g.push(r);
+        groups.set(r.key, g);
+      }
+
+      for (const [key, keyRows] of groups) {
+        const specificityOf = (candidate: ConfigRow) =>
+          (candidate.userId !== null ? 2 : 0) + (candidate.tenantId !== SYSTEM_TENANT_ID ? 1 : 0);
+
+        const first = keyRows[0];
+        if (!first) continue;
+        let winner: ConfigRow = first;
+        for (const r of keyRows) {
+          if (specificityOf(r) > specificityOf(winner)) {
+            winner = r;
+          }
+        }
+
+        let source: ConfigValueSource;
+        if (winner.userId !== null) {
+          source = "user-row";
+        } else if (winner.tenantId !== SYSTEM_TENANT_ID) {
+          source = "tenant-row";
+        } else {
+          source = "system-row";
+        }
+
+        result.set(key, { ...winner, source });
+      }
+
+      return result;
+    },
+
+    async getCascade(qualifiedKey, keyDef, tenantId, userId, db): Promise<ConfigCascade> {
+      // Single-key path uses findRow per cascade step. The batch path
+      // bulk-loads all rows up-front; both build identical levels arrays.
+      return buildCascade(
+        qualifiedKey,
+        keyDef,
+        tenantId,
+        userId,
+        db,
+        (tid, uid) => findRow(qualifiedKey, tid, uid, db),
+        appOverrides,
+        encryption,
+      );
+    },
+
+    async getCascadeBatch(
+      keys,
+      keyDefs,
+      tenantId,
+      userId,
+      db,
+    ): Promise<ReadonlyMap<string, ConfigCascade>> {
+      if (keys.length === 0) return new Map();
+
+      // One SQL query for all keys + every scope (user-row,
+      // tenant-row, system-row). The cascade-builder then matches
+      // per-key from this preloaded set instead of querying again.
+      const rows = await db
+        .select()
+        .from(configValuesTable)
+        .where(
+          and(
+            inArray(configValuesTable.key, [...keys]),
+            or(
+              and(
+                eq(configValuesTable.tenantId, SYSTEM_TENANT_ID),
+                isNull(configValuesTable.userId),
+              ),
+              and(eq(configValuesTable.tenantId, tenantId), isNull(configValuesTable.userId)),
+              and(eq(configValuesTable.tenantId, tenantId), eq(configValuesTable.userId, userId)),
+            ),
+          ),
+        );
+
+      const grouped = new Map<string, ConfigRow[]>();
+      for (const row of rows) {
+        const r = row as ConfigRow; // @cast-boundary db-row
+        const g = grouped.get(r.key) ?? [];
+        g.push(r);
+        grouped.set(r.key, g);
+      }
+
+      const result = new Map<string, ConfigCascade>();
+      for (const key of keys) {
+        const keyDef = keyDefs.get(key);
+        if (!keyDef) continue;
+
+        const keyRows = grouped.get(key) ?? [];
+        const cascade = await buildCascade(
+          key,
+          keyDef,
+          tenantId,
+          userId,
+          db,
+          (tid, uid) =>
+            keyRows.find((r) => r.tenantId === tid && (r.userId ?? null) === uid) ?? null,
+          appOverrides,
+          encryption,
+        );
+        result.set(key, cascade);
+      }
+
+      return result;
+    },
   };
 }
 

package/src/delivery/__tests__/delivery.integration.ts

@@ -27,8 +27,10 @@ import { createChannelPushFeature } from "../../channel-push/feature";
 import { createInMemoryPushTransport } from "../../channel-push/types";
 import { createConfigFeature } from "../../config/feature";
 import { configValuesTable } from "../../config/table";
+import { createRendererFoundationFeature } from "../../renderer-foundation/feature";
 import { createRendererSimpleFeature } from "../../renderer-simple/feature";
 import { simpleRenderer } from "../../renderer-simple/simple-renderer";
+import { createTemplateResolverFeature } from "../../template-resolver/feature";
 import { TenantQueries } from "../../tenant/constants";
 import { createTenantFeature } from "../../tenant/feature";
 import { tenantMembershipsTable } from "../../tenant/membership-table";
@@ -241,6 +243,8 @@ const ticketFeature = defineFeature("tickets", (r) => {
 
 const configFeature = createConfigFeature();
 const tenantFeature = createTenantFeature();
+const templateResolverFeature = createTemplateResolverFeature();
+const rendererFoundationFeature = createRendererFoundationFeature();
 const deliveryFeature = createDeliveryFeature();
 const channelInAppFeature = createChannelInAppFeature();
 const rendererSimpleFeature = createRendererSimpleFeature();
@@ -256,6 +260,8 @@ const channelPushFeature = createChannelPushFeature({
 const features = [
   configFeature,
   tenantFeature,
+  templateResolverFeature,
+  rendererFoundationFeature,
   deliveryFeature,
   channelInAppFeature,
   rendererSimpleFeature,

package/src/delivery/delivery-service.ts

@@ -18,7 +18,6 @@ import type {
   DeliveryChannel,
   DeliveryLogEntry,
   DeliveryService,
-  NotificationRenderer,
 } from "./types";
 
 export type RateLimitConfig = {
@@ -56,17 +55,10 @@ export function collectChannels(registry: Registry): DeliveryChannel[] {
   });
 }
 
-// Build renderer map from registry extension usages
-export function collectRenderers(registry: Registry): Map<string, NotificationRenderer> {
-  const usages = registry.getExtensionUsages("notificationRenderer");
-  const map = new Map<string, NotificationRenderer>();
-  for (const usage of usages) {
-    // @cast-boundary engine-payload — extension-usage carries unknown options
-    const opts = usage.options as { render: NotificationRenderer["render"] };
-    map.set(usage.entityName, { name: usage.entityName, render: opts.render });
-  }
-  return map;
-}
+// `collectRenderers` entfernt 2026-05-19: notificationRenderer-Extension-Point
+// wurde nie konsumiert (channel-email nimmt renderer als Konstruktor-Option,
+// nicht aus Extension-Usages). Multi-Kind-Plugin-Pool lebt jetzt im
+// `renderer-foundation`-Bundle via `collectRendererPlugins`.
 
 export function createDeliveryService(options: DeliveryServiceOptions): DeliveryService {
   const {

package/src/delivery/feature.ts

@@ -48,13 +48,15 @@ export function createDeliveryFeature(): FeatureDefinition {
       },
     });
 
-    // Extension points: channels and renderers register as features
+    // Extension point: delivery-channels (email/in-app/push). Renderer-
+    // Extension-Point lebt jetzt im `renderer-foundation`-Bundle als
+    // `renderer` (Multi-Kind-Plugin-Contract). delivery hostet keinen
+    // eigenen mehr — channel-email nimmt renderer als direkte
+    // Konstruktor-Option (siehe email-channel.ts), nicht via Extension-
+    // Usage. Migration 2026-05-19.
     r.extendsRegistrar("deliveryChannel", {
       onRegister: () => {},
     });
-    r.extendsRegistrar("notificationRenderer", {
-      onRegister: () => {},
-    });
 
     const handlers = {
       setPreference: r.writeHandler(setPreferenceWrite),

package/src/delivery/index.ts

@@ -8,7 +8,6 @@ export {
 } from "./constants";
 export {
   collectChannels,
-  collectRenderers,
   createDeliveryService,
   type DeliveryServiceOptions,
   type KillSwitchResolver,

package/src/legal-pages/web/client-plugin.ts

@@ -20,17 +20,57 @@ import type { TreeChildrenSubscribe, TreeNode } from "@cosmicdrift/kumiko-framew
 import type { ClientFeatureDefinition } from "@cosmicdrift/kumiko-renderer-web";
 import { LEGAL_OPTIONAL_BLOCKS, LEGAL_REQUIRED_BLOCKS } from "../constants";
 
-const treeProvider: TreeChildrenSubscribe = (_ctx) => (emit) => {
-  const allBlocks = [...LEGAL_REQUIRED_BLOCKS, ...LEGAL_OPTIONAL_BLOCKS];
-  const nodes: readonly TreeNode[] = allBlocks.map((b) => ({
-    label: `${b.slug} (${b.lang})`,
-    target: {
-      featureId: "text-content",
-      action: "edit",
-      args: { slug: b.slug, lang: b.lang },
+const treeProvider: TreeChildrenSubscribe = () => (emit) => {
+  // V.1.5d Slug-first Verschachtelung (Variante C):
+  //   📁 Legal
+  //     📁 imprint
+  //       de
+  //       en
+  //     📁 privacy
+  //       de
+  //       en
+  //
+  // Slug ist der Übersetzungs-Anker — User pflegt DE+EN-Versionen
+  // desselben Inhalts zusammen statt nach Sprache zu gruppieren.
+  // Sub-Items sind reine Sprach-Leaves; Label = Sprache, target zeigt
+  // auf text-content:edit mit slug+lang.
+
+  // Group all blocks by slug, collect set of langs per slug.
+  const bySlug = new Map<string, string[]>();
+  for (const b of [...LEGAL_REQUIRED_BLOCKS, ...LEGAL_OPTIONAL_BLOCKS]) {
+    const langs = bySlug.get(b.slug) ?? [];
+    if (!langs.includes(b.lang)) langs.push(b.lang);
+    bySlug.set(b.slug, langs);
+  }
+
+  const slugFolders: TreeNode[] = [];
+  for (const slug of [...bySlug.keys()].sort()) {
+    const langs = bySlug.get(slug);
+    if (langs === undefined) continue;
+    const langLeaves: TreeNode[] = langs.sort().map((lang) => ({
+      label: lang,
+      target: {
+        featureId: "text-content",
+        action: "edit",
+        args: { slug, lang },
+      },
+    }));
+    slugFolders.push({
+      label: slug,
+      icon: "folder",
+      state: "filled",
+      children: langLeaves,
+    });
+  }
+
+  emit([
+    {
+      label: "Legal",
+      icon: "folder",
+      state: "filled",
+      children: slugFolders,
     },
-  }));
-  emit(nodes);
+  ]);
   return () => {};
 };
 

package/src/renderer-foundation/README.md

@@ -0,0 +1,86 @@
+# renderer-foundation
+
+Plugin-Foundation für Renderer (Notification, HTML-Mail, PDF, Image). Plugins (`renderer-simple`, `renderer-mail-html`, `renderer-puppeteer-client`) registrieren sich via `r.useExtension("renderer", "<name>", { kinds, render })`.
+
+**Plan-Doc:** [`kumiko-platform/docs/plans/features/renderer-foundation.md`](../../../../../../kumiko-platform/docs/plans/features/renderer-foundation.md)
+
+## Mount
+
+```typescript
+import {
+  collectRendererPlugins,
+  createRendererFoundationApi,
+  createRendererFoundationFeature,
+} from "@cosmicdrift/kumiko-bundled-features/renderer-foundation";
+
+const features = [
+  createTemplateResolverFeature(),
+  createRendererFoundationFeature(),
+  createRendererSimpleFeature(),   // Plugin
+  createRendererMailHtmlFeature(), // Plugin (enterprise)
+  // weitere Plugins...
+];
+
+const app = createKumikoApp({
+  features,
+  extraContext: ({ registry }) => ({
+    rendererFoundation: createRendererFoundationApi(
+      collectRendererPlugins(registry),
+    ),
+  }),
+});
+```
+
+## Konsumtion
+
+```typescript
+import { requireRendererFoundation } from "@cosmicdrift/kumiko-bundled-features/renderer-foundation";
+
+async function sendMail(ctx, tenantId) {
+  const foundation = requireRendererFoundation(ctx, "sendMail");
+  const renderer = foundation.createRendererForTenant({ tenantId, kind: "mail-html" });
+  const result = await renderer.render(
+    {
+      kind: "mail-html",
+      payload: { content: "Hello {{name}}", contentFormat: "markdown", variables: { name: "Frau Schmidt" } },
+    },
+    { db: ctx.db, registry: ctx.registry, tenantId },
+  );
+  // result.html, result.text
+}
+```
+
+Plugins ohne Service-Deps (`renderer-simple`) ignorieren den zweiten `ctx`-Parameter.
+
+## Plugin-Auswahl-Reihenfolge
+
+1. Tenant-Override (Config-Key `rendererPluginByKind`, z.B. `{ "mail-html": "mail-html" }`)
+2. `DEFAULT_PLUGIN_BY_KIND` aus constants
+3. Erstes Plugin im Pool das das kind bedient
+4. `RendererError("no_plugin_for_kind")` wenn nichts passt
+
+## Eigenes Plugin schreiben
+
+```typescript
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+
+export const myRendererFeature = defineFeature("renderer-myown", (r) => {
+  r.requires("renderer-foundation");
+  r.useExtension("renderer", "myown", {
+    kinds: ["document-pdf"],
+    // ctx ist optional — nur nehmen wenn Service-Access nötig
+    render: async (req, ctx) => {
+      // ctx.db, ctx.registry, ctx.tenantId verfügbar
+      // eigene PDF-Logik
+      return { kind: "document-pdf", pdfBytes: ..., pageCount: 1, sizeBytes: ... };
+    },
+  });
+});
+```
+
+## Out-of-Scope
+
+- Template-Storage (kommt aus `template-resolver`)
+- Resource-URL-Substitution (Caller-Verantwortung: signed-URL vs. data-URI je nach kind)
+- Template-Authoring-UI — `designer`-Bundle (geplant)
+- Mail-Versand — `delivery` + `mail-transport-smtp`