@aaronshaf/ger 1.2.10 → 2.0.0

package/src/schemas/config.test.ts

@@ -0,0 +1,245 @@
+import { describe, expect, test } from 'bun:test'
+import { Schema } from '@effect/schema'
+import { Effect } from 'effect'
+import { AppConfig, AiConfig, aiConfigFromFlat, migrateFromNestedConfig } from './config'
+
+describe('Config Schemas', () => {
+  describe('AppConfig (Flat Structure)', () => {
+    test('validates complete flat config', () => {
+      const validConfig = {
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass123',
+        aiTool: 'claude' as const,
+        aiAutoDetect: true,
+      }
+
+      const result = Schema.decodeUnknownSync(AppConfig)(validConfig)
+      expect(result).toEqual(validConfig)
+    })
+
+    test('validates minimal flat config with defaults', () => {
+      const minimalConfig = {
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass123',
+      }
+
+      const result = Schema.decodeUnknownSync(AppConfig)(minimalConfig)
+      expect(result).toEqual({
+        ...minimalConfig,
+        aiAutoDetect: true, // default value
+        aiTool: undefined,
+      })
+    })
+
+    test('rejects invalid host URL', () => {
+      const invalidConfig = {
+        host: 'not-a-url',
+        username: 'testuser',
+        password: 'testpass123',
+      }
+
+      expect(() => Schema.decodeUnknownSync(AppConfig)(invalidConfig)).toThrow()
+    })
+
+    test('rejects empty username', () => {
+      const invalidConfig = {
+        host: 'https://gerrit.example.com',
+        username: '',
+        password: 'testpass123',
+      }
+
+      expect(() => Schema.decodeUnknownSync(AppConfig)(invalidConfig)).toThrow()
+    })
+
+    test('rejects empty password', () => {
+      const invalidConfig = {
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: '',
+      }
+
+      expect(() => Schema.decodeUnknownSync(AppConfig)(invalidConfig)).toThrow()
+    })
+
+    test('validates all AI tool options', () => {
+      const tools = ['claude', 'llm', 'opencode', 'gemini'] as const
+
+      tools.forEach((tool) => {
+        const config = {
+          host: 'https://gerrit.example.com',
+          username: 'testuser',
+          password: 'testpass123',
+          aiTool: tool,
+        }
+
+        const result = Schema.decodeUnknownSync(AppConfig)(config)
+        expect(result.aiTool).toBe(tool)
+      })
+    })
+
+    test('rejects invalid AI tool', () => {
+      const invalidConfig = {
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass123',
+        aiTool: 'invalid-tool',
+      }
+
+      expect(() => Schema.decodeUnknownSync(AppConfig)(invalidConfig)).toThrow()
+    })
+  })
+
+  describe('Legacy AiConfig (Backward Compatibility)', () => {
+    test('validates legacy AI config structure', () => {
+      const validAiConfig = {
+        tool: 'claude' as const,
+        autoDetect: false,
+      }
+
+      const result = Schema.decodeUnknownSync(AiConfig)(validAiConfig)
+      expect(result).toEqual(validAiConfig)
+    })
+
+    test('validates minimal legacy AI config with defaults', () => {
+      const minimalAiConfig = {}
+
+      const result = Schema.decodeUnknownSync(AiConfig)(minimalAiConfig)
+      expect(result).toEqual({
+        autoDetect: true, // default value
+        tool: undefined,
+      })
+    })
+  })
+
+  describe('Helper Functions', () => {
+    test('aiConfigFromFlat converts flat config to legacy AI config', () => {
+      const flatConfig = {
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass123',
+        aiTool: 'claude' as const,
+        aiAutoDetect: false,
+      }
+
+      const aiConfig = aiConfigFromFlat(flatConfig)
+      expect(aiConfig).toEqual({
+        tool: 'claude',
+        autoDetect: false,
+      })
+    })
+
+    test('aiConfigFromFlat handles undefined AI options', () => {
+      const flatConfig = {
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass123',
+        aiAutoDetect: true,
+      }
+
+      const aiConfig = aiConfigFromFlat(flatConfig)
+      expect(aiConfig).toEqual({
+        tool: undefined,
+        autoDetect: true,
+      })
+    })
+
+    test('migrateFromNestedConfig converts old nested format', () => {
+      const nestedConfig = {
+        credentials: {
+          host: 'https://gerrit.example.com',
+          username: 'testuser',
+          password: 'testpass123',
+        },
+        ai: {
+          tool: 'claude' as const,
+          autoDetect: false,
+        },
+      }
+
+      const flatConfig = migrateFromNestedConfig(nestedConfig)
+      expect(flatConfig).toEqual({
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass123',
+        aiTool: 'claude',
+        aiAutoDetect: false,
+      })
+    })
+
+    test('migrateFromNestedConfig handles missing AI config', () => {
+      const nestedConfig = {
+        credentials: {
+          host: 'https://gerrit.example.com',
+          username: 'testuser',
+          password: 'testpass123',
+        },
+      }
+
+      const flatConfig = migrateFromNestedConfig(nestedConfig)
+      expect(flatConfig).toEqual({
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass123',
+        aiTool: undefined,
+        aiAutoDetect: true, // default
+      })
+    })
+
+    test('migrateFromNestedConfig handles partial AI config', () => {
+      const nestedConfig = {
+        credentials: {
+          host: 'https://gerrit.example.com',
+          username: 'testuser',
+          password: 'testpass123',
+        },
+        ai: {
+          tool: 'llm' as const,
+          // autoDetect missing
+        },
+      }
+
+      const flatConfig = migrateFromNestedConfig(nestedConfig)
+      expect(flatConfig).toEqual({
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass123',
+        aiTool: 'llm',
+        aiAutoDetect: true, // default when missing
+      })
+    })
+  })
+
+  describe('Effect Schema Integration', () => {
+    test('Effect.gen with valid flat config', async () => {
+      const config = {
+        host: 'https://gerrit.example.com',
+        username: 'testuser',
+        password: 'testpass123',
+        aiTool: 'claude' as const,
+        aiAutoDetect: true,
+      }
+
+      const result = await Effect.gen(function* () {
+        return yield* Schema.decodeUnknown(AppConfig)(config)
+      }).pipe(Effect.runPromise)
+
+      expect(result).toEqual(config)
+    })
+
+    test('Effect.gen with validation error', async () => {
+      const invalidConfig = {
+        host: 'not-a-url',
+        username: 'testuser',
+        password: 'testpass123',
+      }
+
+      await expect(
+        Effect.gen(function* () {
+          return yield* Schema.decodeUnknown(AppConfig)(invalidConfig)
+        }).pipe(Effect.runPromise),
+      ).rejects.toThrow()
+    })
+  })
+})

package/src/schemas/config.ts

@@ -0,0 +1,84 @@
+import { Schema } from '@effect/schema'
+
+// Flat Application Configuration (similar to ji structure)
+export const AppConfig: Schema.Struct<{
+  host: typeof Schema.String
+  username: typeof Schema.String
+  password: typeof Schema.String
+  aiTool: Schema.optional<Schema.Literal<['claude', 'llm', 'opencode', 'gemini']>>
+  aiAutoDetect: Schema.optionalWith<typeof Schema.Boolean, { default: () => boolean }>
+}> = Schema.Struct({
+  // Gerrit credentials (flattened)
+  host: Schema.String.pipe(
+    Schema.pattern(/^https?:\/\/.+$/),
+    Schema.annotations({ description: 'Gerrit server URL' }),
+  ),
+  username: Schema.String.pipe(
+    Schema.minLength(1),
+    Schema.annotations({ description: 'Gerrit username' }),
+  ),
+  password: Schema.String.pipe(
+    Schema.minLength(1),
+    Schema.annotations({ description: 'HTTP password or API token' }),
+  ),
+  // AI configuration (flattened)
+  aiTool: Schema.optional(Schema.Literal('claude', 'llm', 'opencode', 'gemini')),
+  aiAutoDetect: Schema.optionalWith(Schema.Boolean, { default: (): boolean => true }),
+})
+
+export type AppConfig = Schema.Schema.Type<typeof AppConfig>
+
+// Legacy schemas for backward compatibility (deprecated)
+export const AiConfig: Schema.Struct<{
+  tool: Schema.optional<Schema.Literal<['claude', 'llm', 'opencode', 'gemini']>>
+  autoDetect: Schema.optionalWith<typeof Schema.Boolean, { default: () => boolean }>
+}> = Schema.Struct({
+  tool: Schema.optional(Schema.Literal('claude', 'llm', 'opencode', 'gemini')),
+  autoDetect: Schema.optionalWith(Schema.Boolean, { default: (): boolean => true }),
+})
+
+export type AiConfig = Schema.Schema.Type<typeof AiConfig>
+
+// Helper to convert from flat config to legacy AI config
+export const aiConfigFromFlat = (config: AppConfig): AiConfig => ({
+  tool: config.aiTool,
+  autoDetect: config.aiAutoDetect,
+})
+
+// Schema for validating legacy nested config structure
+const LegacyNestedConfig = Schema.Struct({
+  credentials: Schema.Struct({
+    host: Schema.String.pipe(
+      Schema.pattern(/^https?:\/\/.+$/),
+      Schema.annotations({ description: 'Gerrit server URL' }),
+    ),
+    username: Schema.String.pipe(Schema.minLength(1)),
+    password: Schema.String.pipe(Schema.minLength(1)),
+  }),
+  ai: Schema.optional(
+    Schema.Struct({
+      tool: Schema.optional(Schema.Literal('claude', 'llm', 'opencode', 'gemini')),
+      autoDetect: Schema.optional(Schema.Boolean),
+    }),
+  ),
+})
+
+type LegacyNestedConfig = Schema.Schema.Type<typeof LegacyNestedConfig>
+
+// Helper to convert from legacy nested format to flat format with validation
+export const migrateFromNestedConfig = (nested: unknown): AppConfig => {
+  // Validate input structure using Schema
+  const validatedNested = Schema.decodeUnknownSync(LegacyNestedConfig)(nested)
+
+  // Convert to flat structure
+  const flatConfig = {
+    host: validatedNested.credentials.host,
+    username: validatedNested.credentials.username,
+    password: validatedNested.credentials.password,
+    aiTool: validatedNested.ai?.tool,
+    aiAutoDetect: validatedNested.ai?.autoDetect ?? true,
+  }
+
+  // Validate the resulting flat config
+  return Schema.decodeUnknownSync(AppConfig)(flatConfig)
+}