dialekt 0.1.0 → 0.1.1

package/src/translation/missing-keys.test.ts

@@ -1,179 +1,172 @@
-import { describe, expect, it } from 'vitest';
-import { Effect } from 'effect';
-import { computeMissingKeys } from './missing-keys.js';
-import type { TranslationAdapter } from '../adapter/types.js';
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import { computeMissingKeys } from "./missing-keys.js";
+import type { TranslationAdapter } from "../adapter/types.js";
 
-describe('computeMissingKeys', () => {
-  it('lists missing keys per resource/locale', async () => {
+describe("computeMissingKeys", () => {
+  it("lists missing keys per resource/locale", async () => {
     const adapter: TranslationAdapter = {
-      name: 'test',
+      name: "test",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
-      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
+      listLocales: () => Effect.succeed(["en", "de"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
       readResource: (locale: string) =>
-        Effect.succeed(
-          locale === 'en' ? { hello: 'Hello', bye: 'Bye' } : { hello: 'Hallo' },
-        ),
+        Effect.succeed(locale === "en" ? { hello: "Hello", bye: "Bye" } : { hello: "Hallo" }),
       writeResource: () => Effect.void,
     };
 
-    const result = await Effect.runPromise(
-      computeMissingKeys(adapter, 'en', ['de']),
-    ) as ReadonlyArray<{ missing: readonly string[] }>;
+    const result = (await Effect.runPromise(
+      computeMissingKeys(adapter, "en", ["de"]),
+    )) as ReadonlyArray<{ missing: readonly string[] }>;
     expect(result).toHaveLength(1);
-    expect(result[0]!.missing).toEqual(['bye']);
+    expect(result[0]!.missing).toEqual(["bye"]);
   });
 
-  it('returns empty when nothing is missing', async () => {
+  it("returns empty when nothing is missing", async () => {
     const adapter: TranslationAdapter = {
-      name: 'test',
+      name: "test",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
-      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
-      readResource: () => Effect.succeed({ hello: 'Hello' }),
+      listLocales: () => Effect.succeed(["en", "de"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
+      readResource: () => Effect.succeed({ hello: "Hello" }),
       writeResource: () => Effect.void,
     };
 
-    const result = await Effect.runPromise(
-      computeMissingKeys(adapter, 'en', ['de']),
-    ) as ReadonlyArray<{ missing: readonly string[] }>;
+    const result = (await Effect.runPromise(
+      computeMissingKeys(adapter, "en", ["de"]),
+    )) as ReadonlyArray<{ missing: readonly string[] }>;
     expect(result).toHaveLength(0);
   });
 
-  it('handles multiple resources', async () => {
+  it("handles multiple resources", async () => {
     const adapter: TranslationAdapter = {
-      name: 'test',
+      name: "test",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
+      listLocales: () => Effect.succeed(["en", "de"]),
       listResources: () =>
         Effect.succeed([
-          { key: 'auth', label: 'auth' },
-          { key: 'validation', label: 'validation' },
+          { key: "auth", label: "auth" },
+          { key: "validation", label: "validation" },
         ]),
       readResource: (locale: string, resource) =>
         Effect.succeed(
-          locale === 'en'
-            ? resource.key === 'auth'
-              ? { login: 'Login' }
-              : { email: 'Email' }
-            : resource.key === 'auth'
-              ? { login: 'Anmelden' }
+          locale === "en"
+            ? resource.key === "auth"
+              ? { login: "Login" }
+              : { email: "Email" }
+            : resource.key === "auth"
+              ? { login: "Anmelden" }
               : {},
         ),
       writeResource: () => Effect.void,
     };
 
-    const result = await Effect.runPromise(
-      computeMissingKeys(adapter, 'en', ['de']),
-    ) as ReadonlyArray<{ resource: { label: string }; missing: readonly string[] }>;
+    const result = (await Effect.runPromise(
+      computeMissingKeys(adapter, "en", ["de"]),
+    )) as ReadonlyArray<{ resource: { label: string }; missing: readonly string[] }>;
     expect(result).toHaveLength(1);
-    expect(result[0]!.resource.label).toBe('validation');
-    expect(result[0]!.missing).toEqual(['email']);
+    expect(result[0]!.resource.label).toBe("validation");
+    expect(result[0]!.missing).toEqual(["email"]);
   });
 
-  it('handles multiple target locales', async () => {
+  it("handles multiple target locales", async () => {
     const adapter: TranslationAdapter = {
-      name: 'test',
+      name: "test",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de', 'fr']),
-      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
-      readResource: (locale: string) =>
-        Effect.succeed(
-          locale === 'en' ? { hello: 'Hello' } : {},
-        ),
+      listLocales: () => Effect.succeed(["en", "de", "fr"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
+      readResource: (locale: string) => Effect.succeed(locale === "en" ? { hello: "Hello" } : {}),
       writeResource: () => Effect.void,
     };
 
-    const result = await Effect.runPromise(
-      computeMissingKeys(adapter, 'en', ['de', 'fr']),
-    ) as ReadonlyArray<{ locale: string; missing: readonly string[] }>;
+    const result = (await Effect.runPromise(
+      computeMissingKeys(adapter, "en", ["de", "fr"]),
+    )) as ReadonlyArray<{ locale: string; missing: readonly string[] }>;
     expect(result).toHaveLength(2);
     const locales = result.map((r) => r.locale);
-    expect(locales).toContain('de');
-    expect(locales).toContain('fr');
+    expect(locales).toContain("de");
+    expect(locales).toContain("fr");
   });
 
-  it('handles empty target locales', async () => {
+  it("handles empty target locales", async () => {
     const adapter: TranslationAdapter = {
-      name: 'test',
+      name: "test",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en']),
-      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
+      listLocales: () => Effect.succeed(["en"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
       readResource: () => Effect.succeed({}),
       writeResource: () => Effect.void,
     };
 
-    const result = await Effect.runPromise(
-      computeMissingKeys(adapter, 'en', []),
-    ) as ReadonlyArray<{ missing: readonly string[] }>;
+    const result = (await Effect.runPromise(
+      computeMissingKeys(adapter, "en", []),
+    )) as ReadonlyArray<{ missing: readonly string[] }>;
     expect(result).toHaveLength(0);
   });
 
-  it('handles empty resources', async () => {
+  it("handles empty resources", async () => {
     const adapter: TranslationAdapter = {
-      name: 'test',
+      name: "test",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
+      listLocales: () => Effect.succeed(["en", "de"]),
       listResources: () => Effect.succeed([]),
       readResource: () => Effect.succeed({}),
       writeResource: () => Effect.void,
     };
 
-    const result = await Effect.runPromise(
-      computeMissingKeys(adapter, 'en', ['de']),
-    ) as ReadonlyArray<{ missing: readonly string[] }>;
+    const result = (await Effect.runPromise(
+      computeMissingKeys(adapter, "en", ["de"]),
+    )) as ReadonlyArray<{ missing: readonly string[] }>;
     expect(result).toHaveLength(0);
   });
 
-  it('handles adapter readResource failure', async () => {
+  it("handles adapter readResource failure", async () => {
     const adapter: TranslationAdapter = {
-      name: 'broken',
+      name: "broken",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
-      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
-      readResource: () => Effect.fail(new Error('read failed') as never),
+      listLocales: () => Effect.succeed(["en", "de"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
+      readResource: () => Effect.fail(new Error("read failed") as never),
       writeResource: () => Effect.void,
     };
 
-    await expect(Effect.runPromise(computeMissingKeys(adapter, 'en', ['de']))).rejects.toThrow('read failed');
+    await expect(Effect.runPromise(computeMissingKeys(adapter, "en", ["de"]))).rejects.toThrow(
+      "read failed",
+    );
   });
 
-  it('handles all keys missing', async () => {
+  it("handles all keys missing", async () => {
     const adapter: TranslationAdapter = {
-      name: 'test',
+      name: "test",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
-      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
+      listLocales: () => Effect.succeed(["en", "de"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
       readResource: (locale: string) =>
-        Effect.succeed(
-          locale === 'en' ? { a: 'A', b: 'B', c: 'C' } : {},
-        ),
+        Effect.succeed(locale === "en" ? { a: "A", b: "B", c: "C" } : {}),
       writeResource: () => Effect.void,
     };
 
-    const result = await Effect.runPromise(
-      computeMissingKeys(adapter, 'en', ['de']),
-    ) as ReadonlyArray<{ missing: readonly string[] }>;
+    const result = (await Effect.runPromise(
+      computeMissingKeys(adapter, "en", ["de"]),
+    )) as ReadonlyArray<{ missing: readonly string[] }>;
     expect(result).toHaveLength(1);
-    expect(result[0]!.missing).toEqual(['a', 'b', 'c']);
+    expect(result[0]!.missing).toEqual(["a", "b", "c"]);
   });
 
-  it('ignores target keys not present in source', async () => {
+  it("ignores target keys not present in source", async () => {
     const adapter: TranslationAdapter = {
-      name: 'test',
+      name: "test",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
-      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
+      listLocales: () => Effect.succeed(["en", "de"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
       readResource: (locale: string) =>
-        Effect.succeed(
-          locale === 'en' ? { a: 'A' } : { a: 'A-de', b: 'B-de' },
-        ),
+        Effect.succeed(locale === "en" ? { a: "A" } : { a: "A-de", b: "B-de" }),
       writeResource: () => Effect.void,
     };
 
-    const result = await Effect.runPromise(
-      computeMissingKeys(adapter, 'en', ['de']),
-    ) as ReadonlyArray<{ missing: readonly string[] }>;
+    const result = (await Effect.runPromise(
+      computeMissingKeys(adapter, "en", ["de"]),
+    )) as ReadonlyArray<{ missing: readonly string[] }>;
     expect(result).toHaveLength(0);
   });
 });

package/src/translation/missing-keys.ts

@@ -1,6 +1,6 @@
-import { Effect } from 'effect';
-import type { TranslationAdapter, ResourceRef, AdapterReadError } from '../adapter/types.js';
-import { diffKeys } from '../keys/flatten.js';
+import { Effect } from "effect";
+import type { TranslationAdapter, ResourceRef, AdapterReadError } from "../adapter/types.js";
+import { diffKeys } from "../keys/flatten.js";
 
 export interface MissingKeyEntry {
   readonly adapter: string;
@@ -23,9 +23,7 @@ export function computeMissingKeys(
           Effect.gen(function* () {
             const targetMap = yield* adapter.readResource(locale, resource);
             const missing = diffKeys(sourceMap, targetMap);
-            return missing.length > 0
-              ? [{ adapter: adapter.name, locale, resource, missing }]
-              : [];
+            return missing.length > 0 ? [{ adapter: adapter.name, locale, resource, missing }] : [];
           }),
         );
         return localeEntries.flat();

package/src/translation/model-registry.test.ts

@@ -1,54 +1,63 @@
-import { describe, expect, it } from 'vitest';
-import { Effect, Either } from 'effect';
-import { resolveModel, UnknownProviderError } from './model-registry.js';
+import { describe, expect, it } from "vitest";
+import { Effect, Either } from "effect";
+import { resolveModel, UnknownProviderError } from "./model-registry.js";
 
-describe('resolveModel', () => {
-  it('returns UnknownProviderError for unknown provider', async () => {
-    const program = resolveModel({ provider: 'unknown', modelId: 'x' });
-    const exit = await Effect.runPromise(Effect.either(program)) as Either.Either<unknown, UnknownProviderError>;
-    if (exit._tag === 'Left') {
-      expect(exit.left._tag).toBe('UnknownProviderError');
-      expect(exit.left.provider).toBe('unknown');
+describe("resolveModel", () => {
+  it("returns UnknownProviderError for unknown provider", async () => {
+    const program = resolveModel({ provider: "unknown", modelId: "x" });
+    const exit = (await Effect.runPromise(Effect.either(program))) as Either.Either<
+      unknown,
+      UnknownProviderError
+    >;
+    if (exit._tag === "Left") {
+      expect(exit.left._tag).toBe("UnknownProviderError");
+      expect(exit.left.provider).toBe("unknown");
     } else {
-      throw new Error('Expected Left');
+      throw new Error("Expected Left");
     }
   });
 
-  it('returns UnknownProviderError for empty provider string', async () => {
-    const program = resolveModel({ provider: '', modelId: 'x' });
-    const exit = await Effect.runPromise(Effect.either(program)) as Either.Either<unknown, UnknownProviderError>;
-    if (exit._tag === 'Left') {
-      expect(exit.left._tag).toBe('UnknownProviderError');
-      expect(exit.left.provider).toBe('');
+  it("returns UnknownProviderError for empty provider string", async () => {
+    const program = resolveModel({ provider: "", modelId: "x" });
+    const exit = (await Effect.runPromise(Effect.either(program))) as Either.Either<
+      unknown,
+      UnknownProviderError
+    >;
+    if (exit._tag === "Left") {
+      expect(exit.left._tag).toBe("UnknownProviderError");
+      expect(exit.left.provider).toBe("");
     } else {
-      throw new Error('Expected Left');
+      throw new Error("Expected Left");
     }
   });
 
-  it('resolves openai provider when package is available', async () => {
-    const program = resolveModel({ provider: 'openai', modelId: 'gpt-4o' });
-    const exit = await Effect.runPromise(Effect.either(program)) as Either.Either<unknown, UnknownProviderError>;
+  it("resolves openai provider when package is available", async () => {
+    const program = resolveModel({ provider: "openai", modelId: "gpt-4o" });
+    const exit = (await Effect.runPromise(Effect.either(program))) as Either.Either<
+      unknown,
+      UnknownProviderError
+    >;
     // Package is installed in this repo, so it should succeed
-    expect(exit._tag).toBe('Right');
+    expect(exit._tag).toBe("Right");
   });
 
-  it('UnknownProviderError preserves provider in message', () => {
-    const err = new UnknownProviderError({ provider: 'foo' });
-    expect(err.provider).toBe('foo');
-    expect(err._tag).toBe('UnknownProviderError');
+  it("UnknownProviderError preserves provider in message", () => {
+    const err = new UnknownProviderError({ provider: "foo" });
+    expect(err.provider).toBe("foo");
+    expect(err._tag).toBe("UnknownProviderError");
   });
 
-  it('accepts all known providers without type error', () => {
-    const providers = ['openai', 'anthropic', 'google'] as const;
+  it("accepts all known providers without type error", () => {
+    const providers = ["openai", "anthropic", "google"] as const;
     for (const provider of providers) {
       // Should compile without error
-      const config = { provider, modelId: 'test' };
+      const config = { provider, modelId: "test" };
       expect(config.provider).toBe(provider);
     }
   });
 
-  it('modelId is passed through', () => {
-    const config = { provider: 'openai' as const, modelId: 'gpt-4o' };
-    expect(config.modelId).toBe('gpt-4o');
+  it("modelId is passed through", () => {
+    const config = { provider: "openai" as const, modelId: "gpt-4o" };
+    expect(config.modelId).toBe("gpt-4o");
   });
 });

package/src/translation/model-registry.ts

@@ -1,7 +1,7 @@
-import { Effect, Data } from 'effect';
-import type { LanguageModel } from 'ai';
+import { Effect, Data } from "effect";
+import type { LanguageModel } from "ai";
 
-export class UnknownProviderError extends Data.TaggedError('UnknownProviderError')<{
+export class UnknownProviderError extends Data.TaggedError("UnknownProviderError")<{
   readonly provider: string;
 }> {}
 
@@ -19,16 +19,16 @@ export function resolveModel(
   return Effect.tryPromise({
     try: async () => {
       switch (config.provider) {
-        case 'openai': {
-          const { openai } = await import('@ai-sdk/openai');
+        case "openai": {
+          const { openai } = await import("@ai-sdk/openai");
           return openai(config.modelId);
         }
-        case 'anthropic': {
-          const { anthropic } = await import('@ai-sdk/anthropic');
+        case "anthropic": {
+          const { anthropic } = await import("@ai-sdk/anthropic");
           return anthropic(config.modelId);
         }
-        case 'google': {
-          const { google } = await import('@ai-sdk/google');
+        case "google": {
+          const { google } = await import("@ai-sdk/google");
           return google(config.modelId);
         }
         default: