@cosmicdrift/kumiko-framework 0.14.0 → 0.16.0

package/src/testing/shared-entities.ts

@@ -1,4 +1,4 @@
-import { buildDrizzleTable } from "../db/table-builder";
+import { buildEntityTable } from "../db/table-builder";
 import {
   createBooleanField,
   createEntity,
@@ -8,7 +8,7 @@ import {
 
 // --- Shared Entity Fixtures -------------------------------------------------
 //
-// Replaces inline `createEntity(...) + buildDrizzleTable(...)` boilerplate
+// Replaces inline `createEntity(...) + buildEntityTable(...)` boilerplate
 // that appeared in 20+ integration tests. Pick the shape closest to what
 // the test needs; if a feature needs extras (hooks, state-machine, fields),
 // keep a local inline entity rather than bloating these shared ones.
@@ -20,7 +20,7 @@ export const sharedWidgetEntity = createEntity({
   fields: { name: createTextField({ required: true }) },
   softDelete: true,
 });
-export const sharedWidgetTable = buildDrizzleTable("widget", sharedWidgetEntity);
+export const sharedWidgetTable = buildEntityTable("widget", sharedWidgetEntity);
 
 // User with searchable name/email fields. Used by full-stack, cascade,
 // and any test that exercises search-indexing or field-access on a
@@ -35,7 +35,7 @@ export const sharedUserEntity = createEntity({
   softDelete: true,
   searchWeight: 10,
 });
-export const sharedUserTable = buildDrizzleTable("user", sharedUserEntity);
+export const sharedUserTable = buildEntityTable("user", sharedUserEntity);
 
 // Item with name + optional price. Used by error-contract, batch,
 // projection-rebuild — tests that need "a thing you can CRUD".
@@ -46,4 +46,4 @@ export const sharedItemEntity = createEntity({
   },
   softDelete: true,
 });
-export const sharedItemTable = buildDrizzleTable("item", sharedItemEntity);
+export const sharedItemTable = buildEntityTable("item", sharedItemEntity);

package/src/time/__tests__/polyfill.test.ts

@@ -2,7 +2,7 @@
 // Sicher dass nach ensureTemporalPolyfill() die wichtigsten Temporal-Typen
 // (Instant, PlainDate, ZonedDateTime) konstruktor-fähig sind.
 
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { ensureTemporalPolyfill, getTemporal } from "../polyfill";
 
 describe("Temporal Polyfill", () => {

package/src/time/__tests__/tz-context.test.ts

@@ -1,7 +1,7 @@
 // Unit-Tests für ctx.tz API.
 // Test-Fokus: korrekte Konvertierung Wall-Clock+TZ ↔ Instant ↔ JSON-Pair.
 
-import { beforeAll, describe, expect, test } from "vitest";
+import { beforeAll, describe, expect, test } from "bun:test";
 import { ensureTemporalPolyfill } from "../polyfill";
 import { createTzContext } from "../tz-context";
 

package/src/utils/__tests__/assert.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { assertUnreachable } from "../assert";
 
 describe("assertUnreachable", () => {

package/src/utils/__tests__/case.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test";
+import { toSnakeCase } from "../case";
+
+describe("toSnakeCase", () => {
+  test("camelCase → snake_case", () => {
+    expect(toSnakeCase("tenantMembership")).toBe("tenant_membership");
+  });
+
+  test("kebab-case → snake_case", () => {
+    expect(toSnakeCase("billing-period")).toBe("billing_period");
+  });
+
+  test("single segment unchanged", () => {
+    expect(toSnakeCase("users")).toBe("users");
+  });
+});

package/src/utils/__tests__/env-parse.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test } from "bun:test";
 import { readPositiveIntEnv } from "../env-parse";
 
 describe("readPositiveIntEnv", () => {

package/src/utils/__tests__/is-plain-object.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test";
+import { isPlainObject } from "../is-plain-object";
+
+describe("isPlainObject", () => {
+  test("accepts plain objects", () => {
+    expect(isPlainObject({})).toBe(true);
+    expect(isPlainObject({ a: 1 })).toBe(true);
+  });
+
+  test("rejects null, arrays, and primitives", () => {
+    expect(isPlainObject(null)).toBe(false);
+    expect(isPlainObject([])).toBe(false);
+    expect(isPlainObject("x")).toBe(false);
+    expect(isPlainObject(42)).toBe(false);
+  });
+});

package/src/utils/__tests__/parse-string-array-json.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test";
+import { parseStringArrayJson } from "../parse-string-array-json";
+
+describe("parseStringArrayJson", () => {
+  test("parses string array", () => {
+    expect(parseStringArrayJson('["admin","editor"]')).toEqual(["admin", "editor"]);
+  });
+
+  test("returns fallback on invalid JSON", () => {
+    expect(parseStringArrayJson("{bad", ["guest"])).toEqual(["guest"]);
+  });
+
+  test("returns fallback when JSON is not a string array", () => {
+    expect(parseStringArrayJson("[1,2]", [])).toEqual([]);
+  });
+});

package/src/utils/__tests__/safe-json.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+import { parseJsonOrThrow, parseJsonSafe } from "../safe-json";
+
+describe("parseJsonSafe", () => {
+  test("parses valid JSON", () => {
+    expect(parseJsonSafe<{ a: number } | null>('{"a":1}', null)).toEqual({ a: 1 });
+  });
+
+  test("returns fallback on invalid JSON", () => {
+    expect(parseJsonSafe("{bad", { ok: false })).toEqual({ ok: false });
+  });
+});
+
+describe("parseJsonOrThrow", () => {
+  test("parses valid JSON", () => {
+    expect(parseJsonOrThrow<number[]>("[1,2]", "test")).toEqual([1, 2]);
+  });
+
+  test("throws with context on invalid JSON", () => {
+    expect(() => parseJsonOrThrow("{", "roles column")).toThrow(/Invalid JSON in roles column/);
+  });
+});

package/src/utils/case.ts

@@ -0,0 +1,6 @@
+// Accepts both camelCase (`tenantMembership`) and kebab-case (`tenant-membership`)
+// names. Kebab is canonical for new multi-word identifiers; camelCase remains
+// supported for shipped code.
+export function toSnakeCase(str: string): string {
+  return str.replace(/-/g, "_").replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}

package/src/utils/index.ts

@@ -1,5 +1,8 @@
 export { assertUnreachable } from "./assert";
+export { toSnakeCase } from "./case";
 export { readPositiveIntEnv } from "./env-parse";
 export { generateId } from "./ids";
+export { isPlainObject } from "./is-plain-object";
+export { parseStringArrayJson } from "./parse-string-array-json";
 export { parseJsonOrThrow, parseJsonSafe } from "./safe-json";
 export { parseRoles } from "./serialization";

package/src/utils/is-plain-object.ts

@@ -0,0 +1,4 @@
+/** Non-null object that is not an array — shared guard for deep-merge and AST extractors. */
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/utils/parse-string-array-json.ts

@@ -0,0 +1,14 @@
+import { parseJsonSafe } from "./safe-json";
+
+/** Parses a JSON-encoded string array from DB/cache columns; returns fallback on invalid input. */
+export function parseStringArrayJson(
+  raw: string,
+  fallback: readonly string[] = [],
+): readonly string[] {
+  const parsed = parseJsonSafe<unknown>(raw, null);
+  if (parsed === null) return fallback;
+  if (Array.isArray(parsed) && parsed.every((x) => typeof x === "string")) {
+    return parsed;
+  }
+  return fallback;
+}