@cosmicdrift/kumiko-framework 0.24.1 → 0.26.0

package/src/random/__tests__/words.test.ts

@@ -0,0 +1,44 @@
+// words.ts Invarianten-Tests (Phase 1, test-luecken-integration).
+//
+// Schützt die Slug-Wortlisten gegen fehlerhafte Edits (Duplikate,
+// Großbuchstaben, Bindestriche, Müll-Einträge). Bewusst NICHT an die
+// veralteten Inline-Kommentare gebunden ("150 × 150", "4-8 Buchstaben") —
+// real sind es mehr Wörter und weitere Längen; getestet werden die echten
+// harten Invarianten + die dokumentierte Mindest-Diversität.
+
+import { describe, expect, test } from "bun:test";
+import { ADJECTIVES, NOUNS } from "../index";
+
+const LISTS: ReadonlyArray<readonly [string, readonly string[]]> = [
+  ["ADJECTIVES", ADJECTIVES],
+  ["NOUNS", NOUNS],
+];
+
+describe("words — Slug-Wortlisten Invarianten", () => {
+  for (const [name, list] of LISTS) {
+    describe(name, () => {
+      test("nur lowercase a-z (keine Ziffern, Bindestriche, Whitespace, Umlaute)", () => {
+        const offenders = list.filter((w) => !/^[a-z]+$/.test(w));
+        expect(offenders).toEqual([]);
+      });
+
+      test("keine Duplikate", () => {
+        const dupes = list.filter((w, i) => list.indexOf(w) !== i);
+        expect(dupes).toEqual([]);
+      });
+
+      test("mindestens 150 Wörter (untere Schranke für Combo-Diversität)", () => {
+        expect(list.length).toBeGreaterThanOrEqual(150);
+      });
+
+      test("Wortlänge im Müll-Schutz-Korridor 3..12 (fängt leere/Satz-Einträge)", () => {
+        const outliers = list.filter((w) => w.length < 3 || w.length > 12);
+        expect(outliers).toEqual([]);
+      });
+    });
+  }
+
+  test("ergibt ≥ 22.500 saubere Kombinationen (dokumentierte Mindest-Diversität)", () => {
+    expect(ADJECTIVES.length * NOUNS.length).toBeGreaterThanOrEqual(22_500);
+  });
+});

package/src/random/generate.ts

@@ -42,9 +42,9 @@ export type AdjNounNameOptions = {
    *  (no-confusable-Alphabet). Empfohlen 3 Zeichen = 32^3 = 32.768
    *  zusätzliche Combinations pro Wortpaar. */
   readonly suffix?: { readonly length: number };
-  /** Custom Adjective-Liste — default ADJECTIVES (150 generic). */
+  /** Custom Adjective-Liste — default ADJECTIVES (191 generic). */
   readonly adjectives?: readonly string[];
-  /** Custom Noun-Liste — default NOUNS (150 generic). Apps die Domain-
+  /** Custom Noun-Liste — default NOUNS (173 generic). Apps die Domain-
    *  spezifische Slugs wollen (z.B. webhook-feature mit eigenen
    *  -receiver/-listener-Substantiven) reichen ihre eigene Liste. */
   readonly nouns?: readonly string[];
@@ -83,7 +83,7 @@ export type GenerateUniqueNameOptions = {
    *  ist (typisch: DB-Query "select where slug=$1" → row count === 0). */
   readonly isAvailable: (name: string) => Promise<boolean>;
   /** Max Versuche OHNE Suffix bevor wir auf suffix-mode wechseln.
-   *  Default 3. Bei 22.500 Default-Combos und ~150 existierenden
+   *  Default 3. Bei 33.043 Default-Combos und ~150 existierenden
    *  Tenants liegt p(Kollision) < 1% — 3 Versuche reichen weit. */
   readonly maxCleanAttempts?: number;
   /** Suffix-Länge bei Kollision-Mode. Default 3 (= 32.768 Combinations

package/src/random/words.ts

@@ -9,12 +9,12 @@
 //   - Keine Personennamen (cultural appropriation, prominenten-collision)
 //   - Keine Themen-Cluster (kein Wetter-only, kein Geographie-only)
 //   - Lowercase, ASCII-only, keine Bindestriche im Wort selbst
-//   - 4-8 Buchstaben pro Wort (kompakter Slug)
+//   - 3-10 Buchstaben pro Wort (kompakter Slug)
 //   - Aussprechbar in Deutsch UND Englisch (User-Telefon-Support)
 //   - Keine Wörter mit ambiguer Bedeutung in Englisch+Deutsch
 //
-// 150 × 150 = 22.500 saubere Kombinationen — bei einer Standard-
-// Hashing-Kollision (Birthday-Bound) reicht das für ~150 Tenants ohne
+// 191 × 173 = 33.043 saubere Kombinationen — bei einer Standard-
+// Hashing-Kollision (Birthday-Bound) reicht das für ~180 Tenants ohne
 // Suffix. Drüber kommt der Suffix-Pfad in generateUniqueName.
 //
 // Erweiterung: weitere Wörter unten anhängen reicht (sortiert ist

package/src/stack/table-helpers.ts

@@ -60,8 +60,8 @@ function isMetaShape(v: unknown): v is EntityTableMeta {
     v !== null &&
     typeof (v as EntityTableMeta).tableName === "string" &&
     Array.isArray((v as EntityTableMeta).columns) &&
-    "indexes" in v &&
-    "source" in v
+    Array.isArray((v as EntityTableMeta).indexes) &&
+    ((v as EntityTableMeta).source === "managed" || (v as EntityTableMeta).source === "unmanaged")
   );
 }
 

package/src/stack/test-stack.ts

@@ -171,8 +171,8 @@ export async function setupTestStack(options: TestStackOptions): Promise<TestSta
   // everything registered via r.projection() — keeps tests from having to
   // know which projections a feature happens to declare. Two projections
   // backed by the same physical table (e.g. an alternative apply-shape for
-  // the same read-model in a test feature) are deduped by Drizzle-table
-  // reference so drizzle-kit doesn't emit duplicate CREATE TABLE statements.
+  // the same read-model in a test feature) are deduped by table reference so
+  // we emit only one CREATE TABLE per physical table.
   const projectionTables: Record<string, unknown> = {};
   const seenTables = new Set<unknown>();
   for (const feature of options.features) {
@@ -205,8 +205,7 @@ export async function setupTestStack(options: TestStackOptions): Promise<TestSta
     // unsafePushTables emits raw CREATE TABLE — fine for ephemeral test DBs but
     // collides on re-boot against a persistent DB whose projection tables
     // were created during a previous run. Filter out the ones that already
-    // exist; drizzle-kit's diff machinery would otherwise emit CREATE for
-    // them again.
+    // exist so the re-boot doesn't fail on duplicate CREATE TABLE.
     const { tableExists } = await import("../db/schema-inspection");
     const missing: Record<string, unknown> = {};
     for (const [key, tbl] of Object.entries(projectionTables)) {

package/src/errors/__tests__/field-issue-compat.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { FieldIssue as FrameworkFieldIssue } from "@cosmicdrift/kumiko-framework/errors";
-import type { FieldIssue as HeadlessFieldIssue } from "@cosmicdrift/kumiko-headless";
-
-describe("FieldIssue cross-package contract", () => {
-  test("framework and headless FieldIssue shapes are assignable", () => {
-    const frameworkIssue: FrameworkFieldIssue = {
-      path: "title",
-      code: "too_small",
-      i18nKey: "errors.validation.too_small",
-      params: { minimum: 1 },
-    };
-    const headlessIssue: HeadlessFieldIssue = frameworkIssue;
-    expect(headlessIssue.path).toBe("title");
-  });
-});