@cosmicdrift/kumiko-framework 0.25.0 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-framework",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "Framework core — engine, pipeline, API, DB, and every other bit that makes Kumiko go.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",

package/src/files/__tests__/in-memory-provider.test.ts

@@ -0,0 +1,94 @@
+// createInMemoryFileProvider Unit-Tests (Phase 1, test-luecken-integration).
+//
+// Pinnt den FileStorageProvider-Contract der In-Memory-Impl — inkl. der
+// non-obvious Eigenschaften: defensive Buffer-Copies (write UND read),
+// lazy readStream-throw (erst beim ersten Chunk-Pull), und die bewusst
+// erkennbare memory://-Fake-URL.
+
+import { describe, expect, test } from "bun:test";
+import { createInMemoryFileProvider } from "../in-memory-provider";
+
+const bytes = (s: string) => new TextEncoder().encode(s);
+const decode = (u: Uint8Array) => new TextDecoder().decode(u);
+
+describe("createInMemoryFileProvider — write/read roundtrip", () => {
+  test("read liefert die geschriebenen Bytes zurück", async () => {
+    const p = createInMemoryFileProvider();
+    await p.write("a.txt", bytes("hello"));
+    expect(decode(await p.read("a.txt"))).toBe("hello");
+  });
+
+  test("write kopiert defensiv — Caller-Mutation nach write ändert Storage nicht", async () => {
+    const p = createInMemoryFileProvider();
+    const data = bytes("orig");
+    await p.write("k", data);
+    data[0] = 0;
+    expect(decode(await p.read("k"))).toBe("orig");
+  });
+
+  test("read kopiert defensiv — Mutation des Ergebnisses ändert Storage nicht", async () => {
+    const p = createInMemoryFileProvider();
+    await p.write("k", bytes("orig"));
+    const first = await p.read("k");
+    first[0] = 0;
+    expect(decode(await p.read("k"))).toBe("orig");
+  });
+
+  test("read auf fehlenden Key wirft", async () => {
+    const p = createInMemoryFileProvider();
+    await expect(p.read("missing")).rejects.toThrow("in-memory file not found: missing");
+  });
+});
+
+describe("createInMemoryFileProvider — writeStream/readStream", () => {
+  test("writeStream fügt Chunks zusammen, readStream liest zurück", async () => {
+    const p = createInMemoryFileProvider();
+    async function* src() {
+      yield bytes("foo");
+      yield bytes("bar");
+    }
+    await p.writeStream("s", src());
+    let out = "";
+    for await (const chunk of p.readStream("s")) out += decode(chunk);
+    expect(out).toBe("foobar");
+  });
+
+  test("readStream auf fehlenden Key wirft erst beim ersten Chunk-Pull (lazy, wie S3)", async () => {
+    const p = createInMemoryFileProvider();
+    const it = p.readStream("missing")[Symbol.asyncIterator]();
+    await expect(it.next()).rejects.toThrow("in-memory file not found: missing");
+  });
+});
+
+describe("createInMemoryFileProvider — exists/delete", () => {
+  test("exists spiegelt write + delete", async () => {
+    const p = createInMemoryFileProvider();
+    expect(await p.exists("k")).toBe(false);
+    await p.write("k", bytes("x"));
+    expect(await p.exists("k")).toBe(true);
+    await p.delete("k");
+    expect(await p.exists("k")).toBe(false);
+  });
+
+  test("delete auf fehlenden Key ist no-op", async () => {
+    const p = createInMemoryFileProvider();
+    await expect(p.delete("nope")).resolves.toBeUndefined();
+  });
+});
+
+describe("createInMemoryFileProvider — getSignedUrl/keys/clear", () => {
+  test("getSignedUrl liefert deterministische memory://-Fake-URL", async () => {
+    const p = createInMemoryFileProvider();
+    expect(p.getSignedUrl).toBeDefined();
+    expect(await p.getSignedUrl?.("path/to/f.jpg", 300)).toBe("memory://path/to/f.jpg?expires=300");
+  });
+
+  test("keys listet geschriebene Keys, clear leert alles", async () => {
+    const p = createInMemoryFileProvider();
+    await p.write("a", bytes("1"));
+    await p.write("b", bytes("2"));
+    expect([...p.keys()].sort()).toEqual(["a", "b"]);
+    p.clear();
+    expect(p.keys()).toEqual([]);
+  });
+});

package/src/logging/__tests__/fallback-logger.test.ts

@@ -0,0 +1,47 @@
+// createFallbackLogger Unit-Tests (Phase 1, test-luecken-integration).
+//
+// Pinnt beide Pfade des Fallback-Loggers — inkl. des non-obvious
+// Format-Unterschieds: der wrapped-Pfad schreibt "[ns] msg", der
+// console-Fallback "[ns] msg:" (trailing colon).
+
+import { describe, expect, mock, spyOn, test } from "bun:test";
+import { createFallbackLogger } from "../utils";
+
+describe("createFallbackLogger", () => {
+  describe("mit wrapped logger", () => {
+    test("delegiert an logger.error mit [namespace]-Prefix (kein colon)", () => {
+      const error = mock((_msg: string, _data?: Record<string, unknown>) => {});
+      const fallback = createFallbackLogger("redis", { error });
+
+      fallback.error("connection lost", { attempt: 3 });
+
+      expect(error).toHaveBeenCalledTimes(1);
+      expect(error).toHaveBeenCalledWith("[redis] connection lost", { attempt: 3 });
+    });
+
+    test("reicht fehlendes data-Argument als undefined durch", () => {
+      const error = mock((_msg: string, _data?: Record<string, unknown>) => {});
+      const fallback = createFallbackLogger("jobs", { error });
+
+      fallback.error("boom");
+
+      expect(error).toHaveBeenCalledWith("[jobs] boom", undefined);
+    });
+  });
+
+  describe("ohne logger (console-Fallback)", () => {
+    test("schreibt auf console.error mit [namespace]-Prefix UND trailing colon", () => {
+      const spy = spyOn(console, "error").mockImplementation(() => {});
+      try {
+        const fallback = createFallbackLogger("boot");
+
+        fallback.error("no logger wired", { phase: "init" });
+
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy).toHaveBeenCalledWith("[boot] no logger wired:", { phase: "init" });
+      } finally {
+        spy.mockRestore();
+      }
+    });
+  });
+});

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