@cosmicdrift/kumiko-framework 0.158.2 → 0.160.0

package/src/testing/file-provider-contract.ts

@@ -0,0 +1,84 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import type { FileStorageProvider } from "../files/types";
+
+const bytes = (s: string) => new TextEncoder().encode(s);
+const decode = (u: Uint8Array) => new TextDecoder().decode(u);
+
+async function* fromChunks(chunks: Uint8Array[]): AsyncIterable<Uint8Array> {
+  for (const c of chunks) yield c;
+}
+
+// Mirrors describeKmsAdapterContract (crypto/__tests__/kms-adapter-contract.ts):
+// pins the FileStorageProvider contract against whatever implementation the
+// factory returns. Provider-specific behavior (error messages, buffer
+// copies, multipart details) stays in each provider's dedicated tests.
+export function describeFileProviderContract(
+  name: string,
+  factory: () => FileStorageProvider | Promise<FileStorageProvider>,
+): void {
+  describe(`${name} — FileStorageProvider contract`, () => {
+    let provider: FileStorageProvider;
+
+    beforeEach(async () => {
+      provider = await factory();
+    });
+
+    test("write + read roundtrip preserves bytes", async () => {
+      const key = `contract/${crypto.randomUUID()}.bin`;
+      await provider.write(key, bytes("hello contract"));
+      expect(decode(await provider.read(key))).toBe("hello contract");
+    });
+
+    test("write on an existing key overwrites it (last-write-wins)", async () => {
+      const key = `contract/${crypto.randomUUID()}.bin`;
+      await provider.write(key, bytes("first"));
+      await provider.write(key, bytes("second"));
+      expect(decode(await provider.read(key))).toBe("second");
+    });
+
+    test("read throws for a missing key", async () => {
+      await expect(provider.read(`contract/missing-${crypto.randomUUID()}`)).rejects.toThrow();
+    });
+
+    test("exists reflects write + delete", async () => {
+      const key = `contract/${crypto.randomUUID()}.txt`;
+      expect(await provider.exists(key)).toBe(false);
+      await provider.write(key, bytes("x"));
+      expect(await provider.exists(key)).toBe(true);
+      await provider.delete(key);
+      expect(await provider.exists(key)).toBe(false);
+    });
+
+    test("delete on a missing key is a no-op", async () => {
+      await expect(
+        provider.delete(`contract/never-existed-${crypto.randomUUID()}`),
+      ).resolves.toBeUndefined();
+    });
+
+    test("writeStream + readStream roundtrip preserves bytes", async () => {
+      const key = `contract/${crypto.randomUUID()}.stream`;
+      await provider.writeStream(key, fromChunks([bytes("foo"), bytes("bar")]));
+      let out = "";
+      for await (const chunk of provider.readStream(key)) out += decode(chunk);
+      expect(out).toBe("foobar");
+    });
+
+    test("readStream on a missing key throws on the first chunk pull", async () => {
+      const it = provider
+        .readStream(`contract/missing-${crypto.randomUUID()}`)
+        [Symbol.asyncIterator]();
+      await expect(it.next()).rejects.toThrow();
+    });
+
+    test("getSignedUrl, when implemented, returns a URL string", async () => {
+      // skip: getSignedUrl is optional on the contract — feature-detected
+      if (!provider.getSignedUrl) return;
+
+      const key = `contract/${crypto.randomUUID()}.txt`;
+      await provider.write(key, bytes("signed"));
+      const url = await provider.getSignedUrl(key, 60);
+      expect(typeof url).toBe("string");
+      expect(url.length).toBeGreaterThan(0);
+    });
+  });
+}

package/src/testing/handler-context.ts

@@ -117,7 +117,7 @@ export function bridgeStub(opts?: {
     ) as unknown as HandlerContext["resolveAuthClaims"],
     // Stub defaults to always-enabled — matches the dispatcher's behaviour
     // when no effectiveFeatures resolver is wired (tests without toggles).
-    hasFeature: () => true,
+    hasFeature: async () => true,
     metrics: createNoopMetricsHandle(),
     tracer: noopTracer,
     // Echter TzContext, kein notAvailable — Test-Code nutzt ctx.tz häufig

package/src/testing/index.ts

@@ -15,6 +15,7 @@ export {
   generateZodFixture,
 } from "./e2e-generator";
 export { expectErrorIncludes } from "./expect-error";
+export { describeFileProviderContract } from "./file-provider-contract";
 export { bridgeStub } from "./handler-context";
 export {
   getSetCookieRaw,

package/src/time/geo-tz.ts

@@ -1,32 +1 @@
-// GeoTzProvider — optionaler Adapter Geo-Position → IANA-Zone. Das Framework
-// definiert NUR das Interface + den Injection-Seam (ctx.tz.fromCoordinates /
-// fromAddress); eine konkrete Implementation kommt aus einem separaten Paket
-// (z.B. ein geo-tz-basiertes Offline-Paket). v1-Default: kein Provider — die
-// fromCoordinates/fromAddress-Methoden werfen klar statt still falsch zu raten.
-//
-// `fromCoordinates` ist die PRIMÄRE Methode: Offline-geo-tz-Libs lösen
-// lat/lng → Zone (genau, offline, kostenlos) — sie kennen keine Postadressen.
-// `fromAddress` ist optional, für Provider die eine Geocoding-API (Adresse →
-// Zone, online) anbinden. Diese Trennung hält das Interface kompatibel mit
-// beiden Provider-Klassen, statt eine Adress-Form zu erzwingen die der
-// Offline-Fall gar nicht bedienen kann.
-
-export type GeoCoordinates = {
-  readonly latitude: number;
-  readonly longitude: number;
-};
-
-export type GeoAddress = {
-  readonly street?: string;
-  readonly city?: string;
-  readonly region?: string;
-  readonly postalCode?: string;
-  readonly country?: string;
-};
-
-export type GeoTzProvider = {
-  /** Geo-Koordinaten → IANA-Zone (offline lat/lng → tz). */
-  readonly fromCoordinates: (coords: GeoCoordinates) => string | Promise<string>;
-  /** Optional: Postadresse → IANA-Zone (Geocoding-API-Provider). */
-  readonly fromAddress?: (address: GeoAddress) => string | Promise<string>;
-};
+export * from "@cosmicdrift/kumiko-types/geo-tz";

package/src/time/tz-context.ts

@@ -13,65 +13,18 @@
 // `tenant` + `user` sind die TZ-Defaults für den aktuellen Request. Aktueller
 // Stand: beide default auf "UTC" — sobald tenant.timezone +
 // user.timezone Felder existieren, lese ich sie aus dem Request-Context.
+//
+// Die reinen Type-Contracts (TzContext, TzContextOptions, LocatedTimestampJson)
+// leben in @cosmicdrift/kumiko-types/tz-context — hier nur die Factories.
 
-import type { GeoAddress, GeoCoordinates, GeoTzProvider } from "./geo-tz";
+import type { TzContext, TzContextOptions } from "@cosmicdrift/kumiko-types/tz-context";
 import { ensureTemporalPolyfill, getTemporal } from "./polyfill";
 
-// JSON-Form für Wall-Clock+TZ — siehe createLocatedTimestampField() in
-// engine/factories.ts. Zwei Felder, idiotensicher.
-export type LocatedTimestampJson = {
-  /** Wall-Clock-ISO ohne Offset, z.B. "2026-04-03T10:00:00" */
-  readonly at: string;
-  /** IANA-Zone, z.B. "Europe/Lisbon" */
-  readonly tz: string;
-};
-
-export type TzContext = {
-  /** Default-TZ des Mandanten (aus tenant.timezone, default "UTC"). */
-  readonly tenant: string;
-  /** Anzeige-TZ des aktuellen Users (User-Profil-Override, fallback Tenant). */
-  readonly user: string;
-
-  /** Aktueller Moment als UTC-Instant. */
-  now(): Temporal.Instant;
-  /** Aktueller Moment als ZonedDateTime in der gewünschten Zone. */
-  nowIn(tz: string): Temporal.ZonedDateTime;
-
-  /** Heutiges Kalender-Datum in der gewünschten Zone. */
-  today(tz: string): Temporal.PlainDate;
-  /** Tagesgrenzen (00:00 bis 24:00 nächster Tag) als UTC-Instants — für DB-Range-Queries. */
-  todayRange(tz: string): { readonly start: Temporal.Instant; readonly end: Temporal.Instant };
-
-  /** Wall-Clock-String + IANA-Zone → ZonedDateTime. */
-  parse(wallClock: string, tz: string): Temporal.ZonedDateTime;
-
-  /** ZonedDateTime → UTC-Instant. */
-  toInstant(zdt: Temporal.ZonedDateTime): Temporal.Instant;
-
-  /** ZonedDateTime → JSON-Pair { at, tz } (API-Boundary). */
-  toLocatedJson(zdt: Temporal.ZonedDateTime): LocatedTimestampJson;
-
-  /** JSON-Pair { at, tz } → ZonedDateTime (Wall-Clock + IANA). */
-  fromLocatedJson(obj: LocatedTimestampJson): Temporal.ZonedDateTime;
-
-  /** Geo-Koordinaten → IANA-Zone via konfiguriertem GeoTzProvider.
-   *  Wirft wenn kein Provider konfiguriert ist (v1-Default). */
-  fromCoordinates(coords: GeoCoordinates): Promise<string>;
-  /** Postadresse → IANA-Zone via GeoTzProvider. Wirft wenn kein Provider
-   *  konfiguriert ist ODER der Provider kein fromAddress unterstützt (der
-   *  Offline-lat/lng-Provider tut das nicht). */
-  fromAddress(address: GeoAddress): Promise<string>;
-};
-
-export type TzContextOptions = {
-  /** Tenant-Default-TZ. Default "UTC" wenn nicht gesetzt. */
-  readonly tenant?: string;
-  /** User-Override. Default = tenant. */
-  readonly user?: string;
-  /** Optionaler Geo→Zone-Adapter für ctx.tz.fromCoordinates / fromAddress.
-   *  Ohne Provider werfen diese Methoden. */
-  readonly geoTz?: GeoTzProvider;
-};
+export type {
+  LocatedTimestampJson,
+  TzContext,
+  TzContextOptions,
+} from "@cosmicdrift/kumiko-types/tz-context";
 
 /**
  * Factory: erzeugt einen TzContext für den aktuellen Request.

package/src/ui-types/index.ts

@@ -22,6 +22,13 @@
 
 export type { ParsedRefTarget } from "../engine/parse-ref-target";
 export { parseRefTarget } from "../engine/parse-ref-target";
+export {
+  evalFieldCondition,
+  isExtensionEditSection,
+  isFormatSpec,
+  normalizeEditField,
+  normalizeListColumn,
+} from "../engine/screen-helpers";
 // Entity + field types. EntityDefinition is the canonical shape that
 // view-model builders iterate; FieldDefinition is the per-field union
 // (text, number, boolean, ...) they branch on. AccessRule is used by
@@ -79,13 +86,6 @@ export type {
   ScreenSlots,
   ToolbarAction,
 } from "../engine/types/screen";
-export {
-  evalFieldCondition,
-  isExtensionEditSection,
-  isFormatSpec,
-  normalizeEditField,
-  normalizeListColumn,
-} from "../engine/types/screen";
 export type { TargetRef } from "../engine/types/target-ref";
 export type { TreeAction, TreeNode, TreeNodeState } from "../engine/types/tree-node";
 export type { WorkspaceDefinition } from "../engine/types/workspace";