@cosmicdrift/kumiko-framework 0.146.3 → 0.147.0

package/src/engine/pattern-library/mixed-schemas.ts

@@ -0,0 +1,484 @@
+// Mixed pattern schemas (header form + opaque body source).
+
+import {
+  accessRuleField,
+  ENTITY_HOOK_TYPE_OPTIONS,
+  HOOK_TYPE_OPTIONS,
+  HTTP_METHOD_OPTIONS,
+} from "./shared-fields";
+import type { PatternFormSchema } from "./types";
+
+// --- Mixed patterns (header form + opaque body source) --------------------
+
+export const screenSchema: PatternFormSchema = {
+  kind: "screen",
+  label: { en: "Screen", de: "Bildschirm" },
+  summary: { en: "List / edit / detail / custom UI surface." },
+  category: "ui",
+  editability: "mixed",
+  fields: [
+    {
+      path: "definition.id",
+      label: { en: "ID", de: "ID" },
+      input: "text",
+      required: true,
+    },
+    {
+      path: "definition.type",
+      label: { en: "Type", de: "Typ" },
+      input: "select",
+      options: [
+        { value: "entityList", label: { en: "Entity list" } },
+        { value: "entityEdit", label: { en: "Entity edit" } },
+        { value: "actionForm", label: { en: "Action form" } },
+        { value: "custom", label: { en: "Custom" } },
+      ],
+      required: true,
+    },
+    {
+      path: "definition",
+      label: { en: "Definition", de: "Definition" },
+      hint: { en: "Full ScreenDefinition — closures show as code-blocks." },
+      input: "json-readonly",
+    },
+    {
+      path: "opaqueProps",
+      label: { en: "Closure paths", de: "Closure-Pfade" },
+      hint: { en: "JSON-paths whose values are inline closures." },
+      input: "json-readonly",
+      readOnly: true,
+    },
+  ],
+};
+
+export const writeHandlerSchema: PatternFormSchema = {
+  kind: "writeHandler",
+  label: { en: "Write handler", de: "Write-Handler" },
+  summary: { en: "Mutation endpoint with Zod schema + closure body." },
+  category: "behaviour",
+  editability: "mixed",
+  fields: [
+    {
+      path: "handlerName",
+      label: { en: "Name", de: "Name" },
+      input: "text",
+      required: true,
+      placeholder: "task:create",
+    },
+    {
+      path: "schemaSource",
+      label: { en: "Zod schema (source)", de: "Zod-Schema (Source)" },
+      input: "code-block",
+      language: "zod",
+      readOnly: true,
+    },
+    {
+      path: "handlerBody",
+      label: { en: "Handler body (source)", de: "Handler-Body (Source)" },
+      input: "code-block",
+      language: "typescript",
+      readOnly: true,
+    },
+    accessRuleField,
+    {
+      path: "rateLimit",
+      label: { en: "Rate limit", de: "Rate-Limit" },
+      input: "json-readonly",
+    },
+    {
+      path: "unsafeSkipTransitionGuard",
+      label: { en: "Skip transition guard", de: "Übergangs-Guard überspringen" },
+      input: "boolean",
+    },
+  ],
+};
+
+export const queryHandlerSchema: PatternFormSchema = {
+  kind: "queryHandler",
+  label: { en: "Query handler", de: "Query-Handler" },
+  summary: { en: "Read endpoint with Zod schema + closure body." },
+  category: "behaviour",
+  editability: "mixed",
+  fields: [
+    {
+      path: "handlerName",
+      label: { en: "Name", de: "Name" },
+      input: "text",
+      required: true,
+      placeholder: "task:list",
+    },
+    {
+      path: "schemaSource",
+      label: { en: "Zod schema (source)", de: "Zod-Schema (Source)" },
+      input: "code-block",
+      language: "zod",
+      readOnly: true,
+    },
+    {
+      path: "handlerBody",
+      label: { en: "Handler body (source)", de: "Handler-Body (Source)" },
+      input: "code-block",
+      language: "typescript",
+      readOnly: true,
+    },
+    accessRuleField,
+    {
+      path: "rateLimit",
+      label: { en: "Rate limit", de: "Rate-Limit" },
+      input: "json-readonly",
+    },
+  ],
+};
+
+export const hookSchema: PatternFormSchema = {
+  kind: "hook",
+  label: { en: "Lifecycle hook", de: "Lifecycle-Hook" },
+  summary: { en: "Pre-/post-save/delete/query hook on one or more entities." },
+  category: "behaviour",
+  editability: "mixed",
+  fields: [
+    {
+      path: "hookType",
+      label: { en: "Type", de: "Typ" },
+      input: "select",
+      options: HOOK_TYPE_OPTIONS,
+      required: true,
+    },
+    {
+      path: "target",
+      label: { en: "Target entity (or list)", de: "Ziel-Entität (oder Liste)" },
+      input: "json-readonly",
+      required: true,
+    },
+    {
+      path: "fnBody",
+      label: { en: "Hook body (source)", de: "Hook-Body (Source)" },
+      input: "code-block",
+      language: "typescript",
+      readOnly: true,
+    },
+    {
+      path: "phase",
+      label: { en: "Phase", de: "Phase" },
+      input: "select",
+      options: [
+        { value: "inTransaction", label: { en: "In transaction" } },
+        { value: "afterCommit", label: { en: "After commit" } },
+      ],
+    },
+  ],
+};
+
+export const entityHookSchema: PatternFormSchema = {
+  kind: "entityHook",
+  label: { en: "Entity hook", de: "Entity-Hook" },
+  summary: { en: "Hook scoped to a single entity (no cross-entity targets)." },
+  category: "behaviour",
+  editability: "mixed",
+  fields: [
+    {
+      path: "hookType",
+      label: { en: "Type", de: "Typ" },
+      input: "select",
+      options: ENTITY_HOOK_TYPE_OPTIONS,
+      required: true,
+    },
+    {
+      path: "entityName",
+      label: { en: "Entity", de: "Entität" },
+      input: "entity-ref",
+      required: true,
+    },
+    {
+      path: "fnBody",
+      label: { en: "Hook body (source)", de: "Hook-Body (Source)" },
+      input: "code-block",
+      language: "typescript",
+      readOnly: true,
+    },
+    {
+      path: "phase",
+      label: { en: "Phase", de: "Phase" },
+      input: "select",
+      options: [
+        { value: "inTransaction", label: { en: "In transaction" } },
+        { value: "afterCommit", label: { en: "After commit" } },
+      ],
+    },
+  ],
+};
+
+export const jobSchema: PatternFormSchema = {
+  kind: "job",
+  label: { en: "Job", de: "Job" },
+  summary: { en: "Scheduled background job (cron / interval)." },
+  category: "background",
+  editability: "mixed",
+  fields: [
+    {
+      path: "jobName",
+      label: { en: "Name", de: "Name" },
+      input: "text",
+      required: true,
+    },
+    {
+      path: "options",
+      label: { en: "Options", de: "Optionen" },
+      hint: { en: "Schedule, idempotencyKey, runIn, …" },
+      input: "json-readonly",
+    },
+    {
+      path: "handlerBody",
+      label: { en: "Handler body (source)", de: "Handler-Body (Source)" },
+      input: "code-block",
+      language: "typescript",
+      readOnly: true,
+    },
+  ],
+};
+
+export const notificationSchema: PatternFormSchema = {
+  kind: "notification",
+  label: { en: "Notification", de: "Benachrichtigung" },
+  summary: { en: "Trigger → recipient/data/template pipeline." },
+  category: "cross-cutting",
+  editability: "mixed",
+  fields: [
+    {
+      path: "notificationName",
+      label: { en: "Name", de: "Name" },
+      input: "text",
+      required: true,
+    },
+    {
+      path: "trigger.on",
+      label: { en: "Trigger on entity", de: "Trigger-Entität" },
+      input: "entity-ref",
+      required: true,
+    },
+    {
+      path: "recipientBody",
+      label: { en: "Recipient (source)", de: "Empfänger (Source)" },
+      input: "code-block",
+      language: "typescript",
+      readOnly: true,
+    },
+    {
+      path: "dataBody",
+      label: { en: "Data (source)", de: "Daten (Source)" },
+      input: "code-block",
+      language: "typescript",
+      readOnly: true,
+    },
+    {
+      path: "templates",
+      label: { en: "Templates per channel", de: "Templates pro Kanal" },
+      input: "key-value-map",
+      keyPlaceholder: "email",
+      valueInput: "code-block",
+    },
+  ],
+};
+
+export const authClaimsSchema: PatternFormSchema = {
+  kind: "authClaims",
+  label: { en: "Auth claims hook", de: "Auth-Claims-Hook" },
+  summary: { en: "Contributes claims into SessionUser at login." },
+  category: "cross-cutting",
+  editability: "opaque",
+  singleton: true,
+  fields: [
+    {
+      path: "fnBody",
+      label: { en: "Handler body (source)", de: "Handler-Body (Source)" },
+      input: "code-block",
+      language: "typescript",
+      readOnly: true,
+    },
+  ],
+};
+
+export const httpRouteSchema: PatternFormSchema = {
+  kind: "httpRoute",
+  label: { en: "HTTP route", de: "HTTP-Route" },
+  summary: { en: "Custom HTTP endpoint outside the dispatcher." },
+  category: "cross-cutting",
+  editability: "mixed",
+  fields: [
+    {
+      path: "method",
+      label: { en: "Method", de: "Methode" },
+      input: "select",
+      options: HTTP_METHOD_OPTIONS,
+      required: true,
+    },
+    {
+      path: "path",
+      label: { en: "Path", de: "Pfad" },
+      input: "text",
+      required: true,
+      placeholder: "/health",
+    },
+    {
+      path: "anonymous",
+      label: { en: "Anonymous (no auth)", de: "Anonym (keine Auth)" },
+      input: "boolean",
+    },
+    {
+      path: "handlerBody",
+      label: { en: "Handler body (source)", de: "Handler-Body (Source)" },
+      input: "code-block",
+      language: "typescript",
+      readOnly: true,
+    },
+  ],
+};
+
+export const projectionSchema: PatternFormSchema = {
+  kind: "projection",
+  label: { en: "Projection", de: "Projection" },
+  summary: { en: "Single-stream read-model in-TX with the source aggregate." },
+  category: "background",
+  editability: "mixed",
+  fields: [
+    {
+      path: "name",
+      label: { en: "Name", de: "Name" },
+      input: "text",
+      required: true,
+    },
+    {
+      path: "sourceEntity",
+      label: { en: "Source entity (or list)", de: "Quell-Entität (oder Liste)" },
+      input: "json-readonly",
+      required: true,
+    },
+    {
+      path: "applyBodies",
+      label: { en: "Apply per event-type", de: "Apply pro Event-Type" },
+      input: "key-value-map",
+      keyPlaceholder: "feature:event:type",
+      valueInput: "code-block",
+      required: true,
+    },
+  ],
+};
+
+export const multiStreamProjectionSchema: PatternFormSchema = {
+  kind: "multiStreamProjection",
+  label: { en: "Multi-stream projection", de: "Multi-Stream-Projection" },
+  summary: { en: "Async cross-aggregate read-model." },
+  category: "background",
+  editability: "mixed",
+  fields: [
+    {
+      path: "name",
+      label: { en: "Name", de: "Name" },
+      input: "text",
+      required: true,
+    },
+    {
+      path: "applyBodies",
+      label: { en: "Apply per event-type", de: "Apply pro Event-Type" },
+      input: "key-value-map",
+      keyPlaceholder: "feature:event:type",
+      valueInput: "code-block",
+      required: true,
+    },
+    {
+      path: "errorMode",
+      label: { en: "Error mode", de: "Fehler-Modus" },
+      input: "select",
+      options: [
+        { value: "skip", label: { en: "Skip" } },
+        { value: "halt", label: { en: "Halt" } },
+        { value: "dead-letter", label: { en: "Dead-letter" } },
+      ],
+    },
+    {
+      path: "runIn",
+      label: { en: "Run in", de: "Läuft in" },
+      input: "select",
+      options: [
+        { value: "tenant", label: { en: "Tenant scope" } },
+        { value: "system", label: { en: "System scope" } },
+      ],
+    },
+    {
+      path: "delivery",
+      label: { en: "Delivery", de: "Auslieferung" },
+      input: "select",
+      options: [
+        { value: "shared", label: { en: "Shared" } },
+        { value: "per-instance", label: { en: "Per instance" } },
+      ],
+    },
+  ],
+};
+
+export const defineEventSchema: PatternFormSchema = {
+  kind: "defineEvent",
+  label: { en: "Define event", de: "Event definieren" },
+  summary: { en: "Register an event payload shape with version." },
+  category: "data",
+  editability: "mixed",
+  fields: [
+    {
+      path: "eventName",
+      label: { en: "Name", de: "Name" },
+      input: "text",
+      required: true,
+      placeholder: "taskCompleted",
+    },
+    {
+      path: "schemaSource",
+      label: { en: "Zod schema (source)", de: "Zod-Schema (Source)" },
+      input: "code-block",
+      language: "zod",
+      readOnly: true,
+    },
+    {
+      path: "version",
+      label: { en: "Version", de: "Version" },
+      input: "number",
+      min: 1,
+    },
+  ],
+};
+
+export const eventMigrationSchema: PatternFormSchema = {
+  kind: "eventMigration",
+  label: { en: "Event migration", de: "Event-Migration" },
+  summary: { en: "Step-wise transform between event versions." },
+  category: "data",
+  editability: "mixed",
+  fields: [
+    {
+      path: "eventName",
+      label: { en: "Event", de: "Event" },
+      input: "text",
+      required: true,
+    },
+    {
+      path: "fromVersion",
+      label: { en: "From version", de: "Von Version" },
+      input: "number",
+      min: 1,
+      required: true,
+    },
+    {
+      path: "toVersion",
+      label: { en: "To version", de: "Auf Version" },
+      input: "number",
+      min: 2,
+      required: true,
+    },
+    {
+      path: "transformBody",
+      label: { en: "Transform (source)", de: "Transform (Source)" },
+      input: "code-block",
+      language: "typescript",
+      readOnly: true,
+    },
+  ],
+};

package/src/engine/pattern-library/opaque-schemas.ts

@@ -0,0 +1,124 @@
+import type { PatternFormSchema } from "./types";
+
+// --- Opaque patterns (entire pattern is read-only code) -------------------
+
+export const extendsRegistrarSchema: PatternFormSchema = {
+  kind: "extendsRegistrar",
+  label: { en: "Registrar extension", de: "Registrar-Erweiterung" },
+  summary: { en: "Meta-programming surface — the Designer treats it as code." },
+  category: "advanced",
+  editability: "opaque",
+  fields: [
+    {
+      path: "extensionName",
+      label: { en: "Name", de: "Name" },
+      input: "text",
+      required: true,
+      readOnly: true,
+    },
+    {
+      path: "defBody",
+      label: { en: "Definition body (source)", de: "Definitions-Body (Source)" },
+      input: "code-block",
+      language: "typescript",
+      readOnly: true,
+    },
+  ],
+};
+
+export const usesApiSchema: PatternFormSchema = {
+  kind: "usesApi",
+  label: { en: "Uses API", de: "Nutzt API" },
+  summary: {
+    en: "Cross-feature handler-ID dependency. Boot fails if no other feature exposes it.",
+  },
+  category: "advanced",
+  editability: "static",
+  fields: [
+    {
+      path: "apiName",
+      label: { en: "API name", de: "API-Name" },
+      input: "text",
+      required: true,
+    },
+  ],
+};
+
+export const exposesApiSchema: PatternFormSchema = {
+  kind: "exposesApi",
+  label: { en: "Exposes API", de: "Stellt API bereit" },
+  summary: { en: "Declares this feature provides a handler matching the cross-feature contract." },
+  category: "advanced",
+  editability: "static",
+  fields: [
+    {
+      path: "apiName",
+      label: { en: "API name", de: "API-Name" },
+      input: "text",
+      required: true,
+    },
+  ],
+};
+
+// Visual-Tree pattern schemas. treeActions is a static map (Designer
+// renders the action-name → ActionDef pairs as a nested form), tree is
+// closure-only (Designer shows the provider body as read-only code).
+export const treeActionsSchema: PatternFormSchema = {
+  kind: "treeActions",
+  label: { en: "Tree actions", de: "Tree-Actions" },
+  summary: { en: "Action verbs the Visual-Tree dispatches via buildTarget." },
+  category: "ui",
+  editability: "static",
+  singleton: true,
+  fields: [
+    {
+      path: "definitions",
+      label: { en: "Action definitions", de: "Action-Definitionen" },
+      input: "json-readonly",
+      readOnly: true,
+    },
+  ],
+};
+
+export const envSchemaSchema: PatternFormSchema = {
+  kind: "envSchema",
+  label: { en: "Env schema", de: "Env-Schema" },
+  summary: {
+    en: "Zod-object declaring this feature's required env-vars. Apps merge it via composeEnvSchema for boot-validation.",
+  },
+  category: "advanced",
+  editability: "opaque",
+  fields: [
+    {
+      path: "schemaBody",
+      label: { en: "Schema", de: "Schema" },
+      input: "json-readonly",
+      readOnly: true,
+    },
+  ],
+};
+
+export const unknownSchema: PatternFormSchema = {
+  kind: "unknown",
+  label: { en: "Unknown call", de: "Unbekannter Call" },
+  summary: { en: "Parser doesn't recognise this r.* method — read-only." },
+  category: "advanced",
+  editability: "opaque",
+  fields: [
+    {
+      path: "methodName",
+      label: { en: "Method", de: "Methode" },
+      input: "text",
+      readOnly: true,
+    },
+    {
+      path: "source",
+      label: { en: "Source", de: "Source" },
+      input: "json-readonly",
+      readOnly: true,
+    },
+  ],
+};
+
+// =============================================================================
+// Catalogue — exhaustive map keyed by FeaturePatternKind

package/src/engine/pattern-library/shared-fields.ts

@@ -0,0 +1,80 @@
+import type { FormFieldSpec } from "./types";
+
+// =============================================================================
+// Reusable field building blocks
+// =============================================================================
+
+export const HOOK_TYPE_OPTIONS = [
+  { value: "validation", label: { en: "Validation", de: "Validierung" } },
+  { value: "preSave", label: { en: "Pre-Save", de: "Vor Speichern" } },
+  { value: "postSave", label: { en: "Post-Save", de: "Nach Speichern" } },
+  { value: "preDelete", label: { en: "Pre-Delete", de: "Vor Löschen" } },
+  { value: "postDelete", label: { en: "Post-Delete", de: "Nach Löschen" } },
+  { value: "preQuery", label: { en: "Pre-Query", de: "Vor Abfrage" } },
+] as const;
+
+export const ENTITY_HOOK_TYPE_OPTIONS = [
+  { value: "postSave", label: { en: "Post-Save", de: "Nach Speichern" } },
+  { value: "preDelete", label: { en: "Pre-Delete", de: "Vor Löschen" } },
+  { value: "postDelete", label: { en: "Post-Delete", de: "Nach Löschen" } },
+] as const;
+
+export const HTTP_METHOD_OPTIONS = [
+  { value: "GET", label: { en: "GET" } },
+  { value: "POST", label: { en: "POST" } },
+  { value: "PUT", label: { en: "PUT" } },
+  { value: "PATCH", label: { en: "PATCH" } },
+  { value: "DELETE", label: { en: "DELETE" } },
+  { value: "HEAD", label: { en: "HEAD" } },
+  { value: "OPTIONS", label: { en: "OPTIONS" } },
+] as const;
+
+export const CLAIM_KEY_TYPE_OPTIONS = [
+  { value: "string", label: { en: "string" } },
+  { value: "number", label: { en: "number" } },
+  { value: "boolean", label: { en: "boolean" } },
+  { value: "string[]", label: { en: "string[]" } },
+  { value: "object", label: { en: "object" } },
+] as const;
+
+export const ID_TYPE_OPTIONS = [
+  { value: "uuid", label: { en: "UUID (default)", de: "UUID (Standard)" } },
+  { value: "serial", label: { en: "Serial integer", de: "Serial Integer" } },
+] as const;
+
+export const accessRuleField: FormFieldSpec = {
+  path: "access",
+  label: { en: "Access", de: "Zugriff" },
+  hint: { en: "Either a list of role names or `openToAll`." },
+  input: "discriminated-union",
+  discriminator: "type",
+  variants: [
+    {
+      tag: "roles",
+      label: { en: "Role-based", de: "Rollen-basiert" },
+      fields: [
+        {
+          path: "access.roles",
+          label: { en: "Roles", de: "Rollen" },
+          input: "string-list",
+          itemPlaceholder: "Admin",
+        },
+      ],
+    },
+    {
+      tag: "openToAll",
+      label: { en: "Open to all (auth still required)", de: "Für alle (Auth nötig)" },
+      fields: [
+        {
+          path: "access.openToAll",
+          label: { en: "Open to all", de: "Offen für alle" },
+          input: "boolean",
+        },
+      ],
+    },
+  ],
+};
+
+// =============================================================================
+// Pattern schemas
+// =============================================================================