standard-typed-config 0.0.1

package/test/types.test-d.ts

@@ -0,0 +1,199 @@
+import { expectType } from 'tsd';
+import { createBuilder, type Builder } from '../src/index';
+
+// ══════════════════════════════════════════════════════════════════════════════════
+// DOMAIN 1: AI Model Testing — verify types
+// ══════════════════════════════════════════════════════════════════════════════════
+
+type AIModelConfig = {
+  models: Array<{ provider: string; model: string }>;
+  systemPrompt?: string;
+  temperature?: number;
+};
+
+type AIHooks = {
+  beforeEachRun: { input: {}; output: { cost: number } };
+  test: { input: { cost: number }; output: Record<string, unknown> };
+  afterEachRun: { input: { cost: number }; output: Record<string, unknown> };
+};
+
+const { define: aiDefine } = createBuilder<AIModelConfig, AIHooks>([
+  'beforeEachRun',
+  'test',
+  'afterEachRun',
+]);
+
+const aiBuilder = aiDefine({
+  opus: { models: [{ provider: "anthropic", model: "claude-opus" }], temperature: 0.7 },
+  gpt4: { models: [{ provider: "openai", model: "gpt-4" }] },
+})
+  .beforeEachRun((ctx) => {
+    expectType<"opus" | "gpt4">(ctx.key);
+    expectType<AIModelConfig>(ctx.opus);
+    expectType<number>(ctx.opus.temperature!);
+    expectType<string>(ctx.gpt4.models[0].provider);
+    return { cost: 0.01 };
+  })
+  .test((ctx) => {
+    expectType<"opus" | "gpt4">(ctx.key);
+    expectType<number>(ctx.cost);
+    expectType<AIModelConfig>(ctx.opus);
+  })
+  .afterEachRun((ctx) => {
+    expectType<"opus" | "gpt4">(ctx.key);
+    expectType<number>(ctx.cost);
+    expectType<AIModelConfig>(ctx.opus);
+  });
+
+// ══════════════════════════════════════════════════════════════════════════════════
+// DOMAIN 2: Restaurant — DIFFERENT hook names
+// ══════════════════════════════════════════════════════════════════════════════════
+
+type MenuItemConfig = {
+  inStock: boolean;
+  price: number;
+  calories: number;
+  allergens: string[];
+};
+
+type RestaurantHooks = {
+  beforePrep: { input: {}; output: { totalPrice: number; hasAllergens: boolean } };
+  receipt: { input: { totalPrice: number; hasAllergens: boolean }; output: Record<string, unknown> };
+};
+
+const { define: menuDefine } = createBuilder<MenuItemConfig, RestaurantHooks>([
+  'beforePrep',
+  'receipt',
+]);
+
+const menuBuilder = menuDefine({
+  burger: { inStock: true, price: 12.99, calories: 650, allergens: ["gluten", "dairy"] },
+  salad: { inStock: true, price: 8.99, calories: 320, allergens: [] },
+})
+  .beforePrep((ctx) => {
+    expectType<"burger" | "salad">(ctx.key);
+    expectType<MenuItemConfig>(ctx.burger);
+    expectType<number>(ctx.salad.price);
+    return { totalPrice: 15.49, hasAllergens: true };
+  })
+  .receipt((ctx) => {
+    expectType<"burger" | "salad">(ctx.key);
+    expectType<number>(ctx.totalPrice);
+    expectType<boolean>(ctx.hasAllergens);
+  });
+
+// ══════════════════════════════════════════════════════════════════════════════════
+// DOMAIN 3: CI/CD — .use() composition
+// ══════════════════════════════════════════════════════════════════════════════════
+
+type RunnerConfig = { capabilities: string[]; maxParallel: number; costPerMinute: number; region: string };
+
+type CIHooks = {
+  beforeJob: { input: {}; output: { estimatedCost: number; region: string } };
+  execute: { input: { estimatedCost: number; region: string }; output: Record<string, unknown> };
+  afterJob: { input: { estimatedCost: number; region: string }; output: Record<string, unknown> };
+};
+
+const { define: ciDefine } = createBuilder<RunnerConfig, CIHooks>([
+  'beforeJob',
+  'execute',
+  'afterJob',
+]);
+
+const gpuRunner = ciDefine({
+  "gpu-runner": { capabilities: ["gpu"], maxParallel: 4, costPerMinute: 0.5, region: "us-east" },
+  "cpu-runner": { capabilities: ["cpu"], maxParallel: 16, costPerMinute: 0.05, region: "eu-west" },
+});
+
+const ciBuilder = ciDefine()
+  .use(gpuRunner)
+  .beforeJob((ctx) => {
+    expectType<"gpu-runner" | "cpu-runner">(ctx.key);
+    expectType<string[]>(ctx["gpu-runner"].capabilities);
+    return { estimatedCost: 2.5, region: "us-east" };
+  })
+  .execute((ctx) => {
+    expectType<"gpu-runner" | "cpu-runner">(ctx.key);
+    expectType<number>(ctx.estimatedCost);
+    expectType<string>(ctx.region);
+  });
+
+// ══════════════════════════════════════════════════════════════════════════════════
+// DOMAIN 4: llm-proxy MatchContext — verify THooksMap generic with unrelated input
+// ══════════════════════════════════════════════════════════════════════════════════
+
+type MatchContext = { body: unknown; headers: Record<string, string>; wireFormat: 'anthropic' | 'openai'; requestedModel: string };
+
+type ProxyHooks = {
+  router: { input: MatchContext; output: { selected: string[] } };
+};
+
+const { define: proxyDefine } = createBuilder<
+  { model: string },
+  ProxyHooks
+>(['router']);
+
+const proxyBuilder = proxyDefine({
+  smart: { model: 'opus' },
+  fast: { model: 'haiku' },
+})
+  .router((ctx) => {
+    expectType<"smart" | "fast">(ctx.key);
+    expectType<'anthropic' | 'openai'>(ctx.wireFormat);
+    expectType<string>(ctx.requestedModel);
+    expectType<Record<string, string>>(ctx.headers);
+    expectType<unknown>(ctx.body);
+    return { selected: ctx.wireFormat === 'anthropic' ? ['smart'] : ['fast'] };
+  });
+
+// ══════════════════════════════════════════════════════════════════════════════════
+// CROSS-DOMAIN REJECTION
+// ══════════════════════════════════════════════════════════════════════════════════
+
+// @ts-expect-error — cannot .use() a CI builder in an AI builder
+aiDefine().use(gpuRunner);
+
+// @ts-expect-error — AI builder has no .beforePrep()
+aiDefine({ opus: { models: [{ provider: "a", model: "b" }] } }).beforePrep(() => {});
+
+// @ts-expect-error — Restaurant builder has no .test()
+menuDefine({ salad: { inStock: true, price: 5, calories: 200, allergens: [] } }).test(() => {});
+
+// @ts-expect-error — CI builder has no .beforeEachRun()
+ciDefine({ r: { capabilities: [], maxParallel: 1, costPerMinute: 0, region: "us" } }).beforeEachRun(() => {});
+
+// ══════════════════════════════════════════════════════════════════════════════════
+// DOMAIN 4: Terminal Hooks — output: never returns TerminalResult
+// ══════════════════════════════════════════════════════════════════════════════════
+
+type TerminalHooks = {
+  accumulate: { input: {}; output: { accumulated: string } };
+  terminal: { input: { accumulated: string }; output: never };
+};
+
+const { define: terminalDefine } = createBuilder<{ value: number }, TerminalHooks>([
+  'accumulate',
+  'terminal',
+]);
+
+// Terminal hook returns TerminalResult with correct types
+const terminalResult = terminalDefine({ item: { value: 42 } })
+  .accumulate((ctx) => {
+    expectType<"item">(ctx.key);
+    expectType<{ value: number }>(ctx.item);
+    return { accumulated: "hello" };
+  })
+  .terminal((ctx) => {
+    expectType<"item">(ctx.key);
+    expectType<string>(ctx.accumulated);
+  });
+
+expectType<{ value: number }>(terminalResult.config);
+expectType<{ item: { value: number } }>(terminalResult.items);
+expectType<{ accumulated: string }>(terminalResult.context);
+
+const terminalChainResult = terminalDefine({ item: { value: 42 } })
+  .accumulate((ctx) => ({ accumulated: "hello" }))
+  .terminal((ctx) => {});
+// @ts-expect-error — cannot chain after terminal hook (no return type to continue with)
+terminalChainResult.accumulate;

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "test"]
+}