@celilo/cli 0.1.0

package/src/services/module-config.test.ts

@@ -0,0 +1,237 @@
+/**
+ * Tests for module configuration service
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { closeDb, createDbClient } from '../db/client';
+import { runMigrations } from '../db/migrate';
+import { modules } from '../db/schema';
+import {
+  formatConfigValue,
+  getAllModuleConfigValues,
+  getModuleConfigValue,
+  isComplexValue,
+  parseConfigValue,
+  setModuleConfigValue,
+} from './module-config';
+
+describe('module-config service', () => {
+  let testDbPath: string;
+  let testDir: string;
+
+  beforeEach(async () => {
+    // Create temp directory for test database
+    testDir = mkdtempSync(join(tmpdir(), 'celilo-test-'));
+    testDbPath = join(testDir, 'test.db');
+
+    // Set environment variable for database path
+    process.env.CELILO_DB_PATH = testDbPath;
+
+    // Initialize database and run migrations
+    await runMigrations(testDbPath);
+
+    // Insert test module
+    const db = createDbClient({ path: testDbPath });
+    db.insert(modules)
+      .values({
+        id: 'test-module',
+        name: 'Test Module',
+        version: '1.0.0',
+        manifestData: {
+          variables: {
+            owns: [
+              { name: 'string_var', type: 'string' },
+              { name: 'number_var', type: 'number' },
+              { name: 'bool_var', type: 'boolean' },
+              { name: 'array_var', type: 'array' },
+              { name: 'object_var', type: 'object' },
+            ],
+          },
+        },
+        sourcePath: '/test/path',
+      })
+      .run();
+  });
+
+  afterEach(() => {
+    closeDb();
+    // Clean up environment variable
+    process.env.CELILO_DB_PATH = undefined;
+    // Clean up test database
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('isComplexValue', () => {
+    it('should return false for primitives', () => {
+      expect(isComplexValue('string')).toBe(false);
+      expect(isComplexValue(123)).toBe(false);
+      expect(isComplexValue(true)).toBe(false);
+      expect(isComplexValue(null)).toBe(false);
+      expect(isComplexValue(undefined)).toBe(false);
+    });
+
+    it('should return true for arrays', () => {
+      expect(isComplexValue([])).toBe(true);
+      expect(isComplexValue([1, 2, 3])).toBe(true);
+      expect(isComplexValue(['a', 'b'])).toBe(true);
+    });
+
+    it('should return true for objects', () => {
+      expect(isComplexValue({})).toBe(false); // Empty object
+      expect(isComplexValue({ key: 'value' })).toBe(true);
+      expect(isComplexValue({ a: 1, b: 2 })).toBe(true);
+    });
+  });
+
+  describe('parseConfigValue', () => {
+    it('should parse primitives from strings', async () => {
+      expect(await parseConfigValue('hello')).toBe('hello');
+      expect(await parseConfigValue('123')).toBe(123);
+      expect(await parseConfigValue('true')).toBe(true);
+      expect(await parseConfigValue('false')).toBe(false);
+    });
+
+    it('should parse JSON strings', async () => {
+      expect(await parseConfigValue('{"key":"value"}')).toEqual({ key: 'value' });
+      expect(await parseConfigValue('[1,2,3]')).toEqual([1, 2, 3]);
+    });
+
+    it('should read from @file syntax', async () => {
+      const filePath = join(testDir, 'config.json');
+      writeFileSync(filePath, JSON.stringify({ key: 'value' }));
+
+      const result = await parseConfigValue(`@${filePath}`);
+      expect(result).toEqual({ key: 'value' });
+    });
+  });
+
+  describe('setModuleConfigValue and getModuleConfigValue', () => {
+    it('should store and retrieve primitive string', async () => {
+      await setModuleConfigValue('test-module', 'string_var', 'hello');
+
+      const result = getModuleConfigValue('test-module', 'string_var');
+      expect(result).not.toBeNull();
+      expect(result?.value).toBe('hello');
+      expect(result?.isPrimitive).toBe(true);
+    });
+
+    it('should store and retrieve primitive number', async () => {
+      await setModuleConfigValue('test-module', 'number_var', '42');
+
+      const result = getModuleConfigValue('test-module', 'number_var');
+      expect(result).not.toBeNull();
+      expect(result?.value).toBe(42);
+      expect(result?.isPrimitive).toBe(true);
+    });
+
+    it('should store and retrieve primitive boolean', async () => {
+      await setModuleConfigValue('test-module', 'bool_var', 'true');
+
+      const result = getModuleConfigValue('test-module', 'bool_var');
+      expect(result).not.toBeNull();
+      expect(result?.value).toBe(true);
+      expect(result?.isPrimitive).toBe(true);
+    });
+
+    it('should store and retrieve complex array', async () => {
+      const arrayValue = JSON.stringify([1, 2, 3]);
+      await setModuleConfigValue('test-module', 'array_var', arrayValue);
+
+      const result = getModuleConfigValue('test-module', 'array_var');
+      expect(result).not.toBeNull();
+      expect(result?.value).toEqual([1, 2, 3]);
+      expect(result?.isPrimitive).toBe(false);
+    });
+
+    it('should store and retrieve complex object', async () => {
+      const objectValue = JSON.stringify({ key: 'value', nested: { foo: 'bar' } });
+      await setModuleConfigValue('test-module', 'object_var', objectValue);
+
+      const result = getModuleConfigValue('test-module', 'object_var');
+      expect(result).not.toBeNull();
+      expect(result?.value).toEqual({ key: 'value', nested: { foo: 'bar' } });
+      expect(result?.isPrimitive).toBe(false);
+    });
+
+    it('should update existing config', async () => {
+      await setModuleConfigValue('test-module', 'string_var', 'first');
+      await setModuleConfigValue('test-module', 'string_var', 'second');
+
+      const result = getModuleConfigValue('test-module', 'string_var');
+      expect(result?.value).toBe('second');
+    });
+
+    it('should reject type mismatch based on manifest (primitive to complex)', async () => {
+      // array_var is declared as type: array in manifest
+      // Setting it to a string should fail manifest validation
+      await expect(
+        setModuleConfigValue('test-module', 'array_var', 'simple string'),
+      ).rejects.toThrow('Expected array');
+    });
+
+    it('should reject type mismatch based on manifest (complex to primitive)', async () => {
+      // string_var is declared as type: string in manifest
+      // Setting it to an object (via JSON) should fail manifest validation
+      await expect(
+        setModuleConfigValue('test-module', 'string_var', '{"key":"value"}'),
+      ).rejects.toThrow('Expected string');
+    });
+  });
+
+  describe('getAllModuleConfigValues', () => {
+    it('should return empty array when no config exists', () => {
+      const result = getAllModuleConfigValues('test-module');
+      expect(result).toEqual([]);
+    });
+
+    it('should return all config values', async () => {
+      await setModuleConfigValue('test-module', 'string_var', 'hello');
+      await setModuleConfigValue('test-module', 'number_var', '42');
+      await setModuleConfigValue('test-module', 'array_var', '[1,2,3]');
+
+      const result = getAllModuleConfigValues('test-module');
+      expect(result).toHaveLength(3);
+
+      const stringVar = result.find((c) => c.key === 'string_var');
+      expect(stringVar?.value).toBe('hello');
+      expect(stringVar?.isPrimitive).toBe(true);
+
+      const numberVar = result.find((c) => c.key === 'number_var');
+      expect(numberVar?.value).toBe(42);
+      expect(numberVar?.isPrimitive).toBe(true);
+
+      const arrayVar = result.find((c) => c.key === 'array_var');
+      expect(arrayVar?.value).toEqual([1, 2, 3]);
+      expect(arrayVar?.isPrimitive).toBe(false);
+    });
+  });
+
+  describe('formatConfigValue', () => {
+    it('should format primitive values', () => {
+      expect(formatConfigValue({ key: 'test', value: 'hello', isPrimitive: true })).toBe('hello');
+      expect(formatConfigValue({ key: 'test', value: 42, isPrimitive: true })).toBe('42');
+      expect(formatConfigValue({ key: 'test', value: true, isPrimitive: true })).toBe('true');
+    });
+
+    it('should format complex values as JSON', () => {
+      const result = formatConfigValue({
+        key: 'test',
+        value: [1, 2, 3],
+        isPrimitive: false,
+      });
+      expect(result).toBe('[\n  1,\n  2,\n  3\n]');
+    });
+
+    it('should format object values as JSON', () => {
+      const result = formatConfigValue({
+        key: 'test',
+        value: { key: 'value' },
+        isPrimitive: false,
+      });
+      expect(result).toBe('{\n  "key": "value"\n}');
+    });
+  });
+});

package/src/services/module-config.ts

@@ -0,0 +1,298 @@
+/**
+ * Module configuration service
+ * Handles storage and retrieval of module configuration values
+ * Supports both primitive types (string, number, boolean) and complex types (arrays, objects)
+ */
+
+import { readFile } from 'node:fs/promises';
+import { and, eq } from 'drizzle-orm';
+import { type DbClient, getDb } from '../db/client';
+import { moduleConfigs, modules } from '../db/schema';
+import { formatManifestValidationErrors, validateAgainstManifest } from './manifest-validation';
+import { formatValidationErrors, validateConfigValue } from './schema-validation';
+
+export interface ConfigValue {
+  key: string;
+  value: string | number | boolean | unknown[] | Record<string, unknown>;
+  isPrimitive: boolean;
+}
+
+/**
+ * Check if a value is a complex type (array or object)
+ */
+export function isComplexValue(value: unknown): boolean {
+  if (value === null || typeof value !== 'object') {
+    return false;
+  }
+
+  // Arrays are complex
+  if (Array.isArray(value)) {
+    return true;
+  }
+
+  // Non-empty objects are complex
+  return Object.keys(value).length > 0;
+}
+
+/**
+ * Parse a configuration value
+ * Handles @file syntax for reading from files
+ * Handles JSON strings for complex types
+ */
+export async function parseConfigValue(
+  valueStr: string,
+): Promise<string | number | boolean | unknown[] | Record<string, unknown>> {
+  // Handle @file syntax
+  if (valueStr.startsWith('@')) {
+    const filePath = valueStr.slice(1);
+    const fileContent = await readFile(filePath, 'utf-8');
+    return JSON.parse(fileContent);
+  }
+
+  // Try to parse as JSON (for complex types or JSON strings)
+  try {
+    const parsed = JSON.parse(valueStr);
+    return parsed;
+  } catch {
+    // Not valid JSON, treat as string
+    // Check for boolean values
+    if (valueStr === 'true') return true;
+    if (valueStr === 'false') return false;
+
+    // Check for number values
+    const num = Number(valueStr);
+    if (!Number.isNaN(num) && valueStr.trim() !== '') {
+      return num;
+    }
+
+    // Return as string
+    return valueStr;
+  }
+}
+
+/**
+ * Get module configuration value
+ * Returns parsed value (primitive or complex type)
+ */
+export function getModuleConfigValue(
+  moduleId: string,
+  key: string,
+  db: DbClient = getDb(),
+): ConfigValue | null {
+  const config = db
+    .select()
+    .from(moduleConfigs)
+    .where(and(eq(moduleConfigs.moduleId, moduleId), eq(moduleConfigs.key, key)))
+    .get();
+
+  if (!config) {
+    return null;
+  }
+
+  // Check if complex type (stored in valueJson)
+  if (config.valueJson) {
+    try {
+      const parsed = JSON.parse(config.valueJson);
+      return {
+        key: config.key,
+        value: parsed,
+        isPrimitive: false,
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to parse config value for ${moduleId}.${config.key}: ${error instanceof Error ? error.message : 'Invalid JSON'}`,
+      );
+    }
+  }
+
+  // Primitive type (stored in value)
+  // Parse the string value to correct type
+  let parsedValue: string | number | boolean = config.value;
+
+  // Boolean
+  if (config.value === 'true') parsedValue = true;
+  else if (config.value === 'false') parsedValue = false;
+  // Number
+  else {
+    const num = Number(config.value);
+    if (!Number.isNaN(num)) {
+      parsedValue = num;
+    }
+  }
+
+  return {
+    key: config.key,
+    value: parsedValue,
+    isPrimitive: true,
+  };
+}
+
+/**
+ * Get all module configuration values
+ */
+export function getAllModuleConfigValues(moduleId: string, db: DbClient = getDb()): ConfigValue[] {
+  const configs = db.select().from(moduleConfigs).where(eq(moduleConfigs.moduleId, moduleId)).all();
+
+  return configs.map((config: typeof moduleConfigs.$inferSelect) => {
+    // Check if complex type
+    if (config.valueJson) {
+      try {
+        const parsed = JSON.parse(config.valueJson);
+        return {
+          key: config.key,
+          value: parsed,
+          isPrimitive: false,
+        };
+      } catch (error) {
+        throw new Error(
+          `Failed to parse config value for ${moduleId}.${config.key}: ${error instanceof Error ? error.message : 'Invalid JSON'}`,
+        );
+      }
+    }
+
+    // Primitive type
+    let parsedValue: string | number | boolean = config.value;
+
+    // Boolean
+    if (config.value === 'true') parsedValue = true;
+    else if (config.value === 'false') parsedValue = false;
+    // Number
+    else {
+      const num = Number(config.value);
+      if (!Number.isNaN(num)) {
+        parsedValue = num;
+      }
+    }
+
+    return {
+      key: config.key,
+      value: parsedValue,
+      isPrimitive: true,
+    };
+  });
+}
+
+/**
+ * Set module configuration value
+ * Automatically detects primitive vs complex types and stores appropriately
+ */
+export async function setModuleConfigValue(
+  moduleId: string,
+  key: string,
+  valueStr: string,
+  db: DbClient = getDb(),
+): Promise<void> {
+  // Parse the value
+  const parsedValue = await parseConfigValue(valueStr);
+
+  // Get module manifest for validation
+  const module = db.select().from(modules).where(eq(modules.id, moduleId)).get();
+  if (!module) {
+    throw new Error(`Module not found: ${moduleId}`);
+  }
+
+  const manifest = module.manifestData as Record<string, unknown>;
+  const variables = manifest.variables as
+    | {
+        owns?: Array<{
+          name: string;
+          type?: string;
+          minimum?: number;
+          maximum?: number;
+          pattern?: string;
+        }>;
+      }
+    | undefined;
+  const declaredVars = variables?.owns || [];
+  const variable = declaredVars.find((v) => v.name === key);
+
+  // Validate against manifest type (if type is declared)
+  if (variable?.type) {
+    const manifestValidation = validateAgainstManifest(parsedValue, {
+      name: variable.name,
+      type: variable.type as 'string' | 'integer' | 'number' | 'boolean' | 'array' | 'object',
+      minimum: variable.minimum,
+      maximum: variable.maximum,
+      pattern: variable.pattern,
+    });
+
+    if (!manifestValidation.valid) {
+      throw new Error(formatManifestValidationErrors(manifestValidation.errors || []));
+    }
+  }
+
+  // Validate against JSON Schema (if schema exists)
+  // This provides deeper validation for complex types
+  const validation = await validateConfigValue(moduleId, key, parsedValue, db);
+  if (!validation.valid) {
+    throw new Error(formatValidationErrors(validation.errors || []));
+  }
+
+  // Determine if complex type
+  const isComplex = isComplexValue(parsedValue);
+
+  // Check if config already exists
+  const existingConfig = db
+    .select()
+    .from(moduleConfigs)
+    .where(and(eq(moduleConfigs.moduleId, moduleId), eq(moduleConfigs.key, key)))
+    .get();
+
+  if (existingConfig) {
+    // Update existing config
+    if (isComplex) {
+      // Store in valueJson column
+      db.update(moduleConfigs)
+        .set({
+          value: '', // Empty string for complex types
+          valueJson: JSON.stringify(parsedValue),
+          updatedAt: new Date(),
+        })
+        .where(eq(moduleConfigs.id, existingConfig.id))
+        .run();
+    } else {
+      // Store in value column
+      db.update(moduleConfigs)
+        .set({
+          value: String(parsedValue),
+          valueJson: null,
+          updatedAt: new Date(),
+        })
+        .where(eq(moduleConfigs.id, existingConfig.id))
+        .run();
+    }
+  } else {
+    // Insert new config
+    if (isComplex) {
+      db.insert(moduleConfigs)
+        .values({
+          moduleId,
+          key,
+          value: '', // Empty string for complex types
+          valueJson: JSON.stringify(parsedValue),
+        })
+        .run();
+    } else {
+      db.insert(moduleConfigs)
+        .values({
+          moduleId,
+          key,
+          value: String(parsedValue),
+          valueJson: null,
+        })
+        .run();
+    }
+  }
+}
+
+/**
+ * Format a config value for display
+ */
+export function formatConfigValue(configValue: ConfigValue): string {
+  if (configValue.isPrimitive) {
+    return String(configValue.value);
+  }
+
+  // Complex type - format as JSON
+  return JSON.stringify(configValue.value, null, 2);
+}