services-as-software 0.1.0 → 2.0.1

package/src/provider.ts

@@ -0,0 +1,183 @@
+/**
+ * Service provider for managing multiple services
+ */
+
+import type { Provider, ServiceClient, ClientConfig } from './types.js'
+import { Client } from './client.js'
+
+/**
+ * Provider configuration
+ */
+export interface ProviderConfig {
+  /** Provider name */
+  name: string
+  /** Base URL for all services */
+  baseUrl: string
+  /** Authentication configuration */
+  auth?: ClientConfig['auth']
+  /** Available services */
+  services?: string[]
+}
+
+/**
+ * Create a service provider
+ *
+ * @example
+ * ```ts
+ * const provider = Provider({
+ *   name: 'AWS',
+ *   baseUrl: 'https://api.aws.amazon.com',
+ *   auth: {
+ *     type: 'api-key',
+ *     credentials: { apiKey: process.env.AWS_API_KEY },
+ *   },
+ *   services: ['translate', 'comprehend', 'polly'],
+ * })
+ *
+ * // Get a service client
+ * const translate = provider.service('translate')
+ * const result = await translate.do('translate', {
+ *   text: 'Hello',
+ *   to: 'es',
+ * })
+ * ```
+ */
+export function Provider(config: ProviderConfig): Provider {
+  return {
+    name: config.name,
+    baseUrl: config.baseUrl,
+    auth: config.auth,
+    services: config.services || [],
+
+    service<T extends ServiceClient>(serviceName: string): T {
+      // Construct service URL
+      const serviceUrl = `${config.baseUrl}/${serviceName}`
+
+      // Create a client for this service
+      const client = Client({
+        url: serviceUrl,
+        auth: config.auth,
+      })
+
+      return client as T
+    },
+  }
+}
+
+/**
+ * Common cloud providers
+ */
+export const providers = {
+  /**
+   * AWS provider
+   */
+  aws(credentials: { accessKeyId: string; secretAccessKey: string; region?: string }): Provider {
+    return Provider({
+      name: 'AWS',
+      baseUrl: `https://api.${credentials.region || 'us-east-1'}.amazonaws.com`,
+      auth: {
+        type: 'api-key',
+        credentials: {
+          apiKey: credentials.accessKeyId,
+          secret: credentials.secretAccessKey,
+        },
+      },
+      services: [
+        'translate',
+        'comprehend',
+        'polly',
+        'rekognition',
+        'textract',
+        'transcribe',
+      ],
+    })
+  },
+
+  /**
+   * Google Cloud provider
+   */
+  gcp(credentials: { apiKey: string; projectId?: string }): Provider {
+    return Provider({
+      name: 'Google Cloud',
+      baseUrl: 'https://api.googleapis.com',
+      auth: {
+        type: 'api-key',
+        credentials: { apiKey: credentials.apiKey },
+      },
+      services: [
+        'translate',
+        'language',
+        'speech',
+        'texttospeech',
+        'vision',
+      ],
+    })
+  },
+
+  /**
+   * Azure provider
+   */
+  azure(credentials: { subscriptionKey: string; region?: string }): Provider {
+    return Provider({
+      name: 'Azure',
+      baseUrl: `https://${credentials.region || 'eastus'}.api.cognitive.microsoft.com`,
+      auth: {
+        type: 'api-key',
+        credentials: { apiKey: credentials.subscriptionKey },
+      },
+      services: [
+        'translator',
+        'language',
+        'speech',
+        'vision',
+        'form-recognizer',
+      ],
+    })
+  },
+
+  /**
+   * OpenAI provider
+   */
+  openai(credentials: { apiKey: string }): Provider {
+    return Provider({
+      name: 'OpenAI',
+      baseUrl: 'https://api.openai.com/v1',
+      auth: {
+        type: 'api-key',
+        credentials: { apiKey: credentials.apiKey },
+      },
+      services: [
+        'chat',
+        'completions',
+        'embeddings',
+        'images',
+        'audio',
+      ],
+    })
+  },
+
+  /**
+   * Anthropic provider
+   */
+  anthropic(credentials: { apiKey: string }): Provider {
+    return Provider({
+      name: 'Anthropic',
+      baseUrl: 'https://api.anthropic.com/v1',
+      auth: {
+        type: 'api-key',
+        credentials: { apiKey: credentials.apiKey },
+      },
+      services: [
+        'messages',
+        'completions',
+      ],
+    })
+  },
+
+  /**
+   * Custom provider
+   */
+  custom(config: ProviderConfig): Provider {
+    return Provider(config)
+  },
+}

package/src/service.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Tests for Service implementation
+ */
+
+import { describe, it, expect } from 'vitest'
+import { Service, Endpoint, POST, GET } from './index.js'
+import type { ServiceContext } from './types.js'
+
+describe('Service', () => {
+  it('should create a service with basic configuration', () => {
+    const service = Service({
+      name: 'test-service',
+      version: '1.0.0',
+      endpoints: [],
+    })
+
+    expect(service).toBeDefined()
+    expect(service.definition.name).toBe('test-service')
+    expect(service.definition.version).toBe('1.0.0')
+  })
+
+  it('should call an endpoint and return result', async () => {
+    const service = Service({
+      name: 'test-service',
+      version: '1.0.0',
+      endpoints: [
+        POST({
+          name: 'echo',
+          handler: async (input: { message: string }) => {
+            return { echoed: input.message }
+          },
+        }),
+      ],
+    })
+
+    const result = await service.call<{ message: string }, { echoed: string }>('echo', {
+      message: 'hello',
+    })
+
+    expect(result.echoed).toBe('hello')
+  })
+
+  it('should provide service context to handlers', async () => {
+    let capturedContext: ServiceContext | undefined
+
+    const service = Service({
+      name: 'test-service',
+      version: '1.0.0',
+      endpoints: [
+        POST({
+          name: 'test',
+          handler: async (_input: unknown, context?: ServiceContext) => {
+            capturedContext = context
+            return { ok: true }
+          },
+        }),
+      ],
+    })
+
+    await service.call('test', {}, { requestId: 'test-123', entitlements: ['test'] })
+
+    expect(capturedContext).toBeDefined()
+    expect(capturedContext?.requestId).toBe('test-123')
+    expect(capturedContext?.entitlements).toContain('test')
+  })
+
+  it('should throw error for unknown endpoint', async () => {
+    const service = Service({
+      name: 'test-service',
+      version: '1.0.0',
+      endpoints: [],
+    })
+
+    await expect(service.call('unknown', {})).rejects.toThrow('Endpoint not found: unknown')
+  })
+
+  it('should calculate KPIs', async () => {
+    const service = Service({
+      name: 'test-service',
+      version: '1.0.0',
+      endpoints: [],
+      kpis: [
+        {
+          id: 'test-kpi',
+          name: 'Test KPI',
+          calculate: async () => 42,
+        },
+      ],
+    })
+
+    const kpis = await service.kpis()
+    expect(kpis['test-kpi']).toBe(42)
+  })
+
+  it('should calculate OKRs with key results', async () => {
+    const service = Service({
+      name: 'test-service',
+      version: '1.0.0',
+      endpoints: [],
+      okrs: [
+        {
+          id: 'okr-1',
+          objective: 'Test objective',
+          keyResults: [
+            {
+              description: 'Test key result',
+              measure: async () => 75,
+              target: 100,
+              unit: 'points',
+            },
+          ],
+        },
+      ],
+    })
+
+    const okrs = await service.okrs()
+    expect(okrs).toHaveLength(1)
+    expect(okrs[0]?.objective).toBe('Test objective')
+    expect(okrs[0]?.keyResults[0]?.current).toBe(75)
+    expect(okrs[0]?.keyResults[0]?.target).toBe(100)
+  })
+
+  it('should register event handlers', () => {
+    const service = Service({
+      name: 'test-service',
+      version: '1.0.0',
+      endpoints: [],
+    })
+
+    let eventFired = false
+    service.on('test.event', () => {
+      eventFired = true
+    })
+
+    // Event handlers are registered (actual firing would happen in event system)
+    expect(eventFired).toBe(false) // Not fired yet
+  })
+
+  it('should register scheduled tasks', () => {
+    const service = Service({
+      name: 'test-service',
+      version: '1.0.0',
+      endpoints: [],
+    })
+
+    let taskRan = false
+    service.every('0 * * * *', () => {
+      taskRan = true
+    })
+
+    // Task is registered (actual execution would happen in scheduler)
+    expect(taskRan).toBe(false) // Not run yet
+  })
+})
+
+describe('Endpoint helpers', () => {
+  it('should create POST endpoint', () => {
+    const endpoint = POST({
+      name: 'test',
+      handler: async () => ({ ok: true }),
+    })
+
+    expect(endpoint.method).toBe('POST')
+    expect(endpoint.name).toBe('test')
+  })
+
+  it('should create GET endpoint', () => {
+    const endpoint = GET({
+      name: 'test',
+      handler: async () => ({ ok: true }),
+    })
+
+    expect(endpoint.method).toBe('GET')
+    expect(endpoint.name).toBe('test')
+  })
+
+  it('should default to requiring auth', () => {
+    const endpoint = Endpoint({
+      name: 'test',
+      handler: async () => ({ ok: true }),
+    })
+
+    expect(endpoint.requiresAuth).toBe(true)
+  })
+
+  it('should allow disabling auth requirement', () => {
+    const endpoint = Endpoint({
+      name: 'test',
+      handler: async () => ({ ok: true }),
+      requiresAuth: false,
+    })
+
+    expect(endpoint.requiresAuth).toBe(false)
+  })
+})

package/src/service.ts

@@ -0,0 +1,266 @@
+/**
+ * Service implementation
+ */
+
+import type {
+  ServiceDefinition,
+  Service,
+  ServiceContext,
+  EndpointDefinition,
+  EventHandler,
+  ScheduledTask,
+  Order,
+  Quote,
+  Subscription,
+  Notification,
+  OKRDefinition,
+  JSONSchema,
+} from './types.js'
+
+/**
+ * Create a service from a definition
+ *
+ * @example
+ * ```ts
+ * const service = Service({
+ *   name: 'translation-service',
+ *   version: '1.0.0',
+ *   description: 'AI-powered translation service',
+ *   pricing: {
+ *     model: 'per-use',
+ *     pricePerUnit: 0.01,
+ *     currency: 'USD',
+ *   },
+ *   endpoints: [
+ *     Endpoint({
+ *       name: 'translate',
+ *       method: 'POST',
+ *       path: '/translate',
+ *       input: {
+ *         type: 'object',
+ *         properties: {
+ *           text: { type: 'string' },
+ *           from: { type: 'string' },
+ *           to: { type: 'string' },
+ *         },
+ *         required: ['text', 'to'],
+ *       },
+ *       handler: async (input) => {
+ *         // Translation logic here
+ *         return { translatedText: input.text }
+ *       },
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export function Service(definition: ServiceDefinition): Service {
+  // Store endpoints by name for quick lookup
+  const endpointMap = new Map<string, EndpointDefinition>()
+  for (const endpoint of definition.endpoints) {
+    endpointMap.set(endpoint.name, endpoint)
+  }
+
+  // Store event handlers
+  const eventHandlers = new Map<string, EventHandler[]>()
+  if (definition.events) {
+    for (const [event, handler] of Object.entries(definition.events)) {
+      eventHandlers.set(event, [handler])
+    }
+  }
+
+  // Store scheduled tasks
+  const scheduledTasks = new Map<string, ScheduledTask>()
+  if (definition.scheduled) {
+    for (const task of definition.scheduled) {
+      scheduledTasks.set(task.name, task)
+    }
+  }
+
+  // Create the service instance
+  const service: Service = {
+    definition,
+
+    // Call an endpoint
+    async call<TInput, TOutput>(
+      endpoint: string,
+      input: TInput,
+      context?: ServiceContext
+    ): Promise<TOutput> {
+      const ep = endpointMap.get(endpoint)
+      if (!ep) {
+        throw new Error(`Endpoint not found: ${endpoint}`)
+      }
+
+      // Create context if not provided
+      const ctx: ServiceContext = context || {
+        requestId: generateRequestId(),
+        entitlements: [],
+      }
+
+      // Track usage if tracker is available
+      if (ctx.usage && ctx.customerId) {
+        await ctx.usage.track({
+          customerId: ctx.customerId,
+          resource: endpoint,
+          quantity: 1,
+          timestamp: new Date(),
+        })
+      }
+
+      // Call the handler
+      return ep.handler(input, ctx) as Promise<TOutput>
+    },
+
+    // Ask a question
+    async ask(question: string, context?: unknown): Promise<string> {
+      return service.call('ask', { question, context })
+    },
+
+    // Deliver results
+    async deliver(orderId: string, results: unknown): Promise<void> {
+      return service.call('deliver', { orderId, results })
+    },
+
+    // Execute a task
+    async do(action: string, input?: unknown): Promise<unknown> {
+      return service.call('do', { action, input })
+    },
+
+    // Generate content
+    async generate(prompt: string, options?: unknown): Promise<unknown> {
+      return service.call('generate', { prompt, options })
+    },
+
+    // Type checking/validation
+    async is(value: unknown, type: string | JSONSchema): Promise<boolean> {
+      return service.call('is', { value, type })
+    },
+
+    // Send notification
+    async notify(notification: Notification): Promise<void> {
+      return service.call('notify', notification)
+    },
+
+    // Place an order
+    async order<TProduct>(product: TProduct, quantity: number): Promise<Order<TProduct>> {
+      return service.call('order', { product, quantity })
+    },
+
+    // Request a quote
+    async quote<TProduct>(product: TProduct, quantity: number): Promise<Quote<TProduct>> {
+      return service.call('quote', { product, quantity })
+    },
+
+    // Subscribe to a plan
+    async subscribe(planId: string): Promise<Subscription> {
+      return service.call('subscribe', { planId })
+    },
+
+    // Get entitlements
+    async entitlements(): Promise<string[]> {
+      return service.call('entitlements', {})
+    },
+
+    // Get KPIs
+    async kpis(): Promise<Record<string, number | string>> {
+      const result: Record<string, number | string> = {}
+      if (definition.kpis) {
+        for (const kpi of definition.kpis) {
+          result[kpi.id] = await kpi.calculate()
+        }
+      }
+      return result
+    },
+
+    // Get OKRs
+    async okrs(): Promise<OKRDefinition[]> {
+      if (!definition.okrs) {
+        return []
+      }
+
+      // Calculate current values for key results
+      const okrs = await Promise.all(
+        definition.okrs.map(async (okr) => {
+          const keyResults = await Promise.all(
+            okr.keyResults.map(async (kr) => ({
+              ...kr,
+              current: await kr.measure(),
+            }))
+          )
+          return { ...okr, keyResults }
+        })
+      )
+
+      return okrs
+    },
+
+    // Register event handler
+    on<TPayload>(
+      event: string,
+      handler: (payload: TPayload, context?: ServiceContext) => void | Promise<void>
+    ): void {
+      const handlers = eventHandlers.get(event) || []
+      handlers.push({
+        event,
+        handler: handler as (payload: unknown, context?: ServiceContext) => void | Promise<void>,
+      })
+      eventHandlers.set(event, handlers)
+    },
+
+    // Schedule recurring task
+    every(
+      schedule: string,
+      handler: (context?: ServiceContext) => void | Promise<void>
+    ): void {
+      const taskName = `task-${scheduledTasks.size + 1}`
+      scheduledTasks.set(taskName, {
+        name: taskName,
+        schedule,
+        handler: (_input?: unknown, context?: ServiceContext) => handler(context),
+        enabled: true,
+      })
+    },
+
+    // Add queue processor
+    queue<TJob>(
+      name: string,
+      handler: (job: TJob, context?: ServiceContext) => void | Promise<void>
+    ): void {
+      // Queue processing would typically integrate with a queue system
+      // For now, we add it as an event handler
+      service.on(`queue:${name}`, handler)
+    },
+
+    // Get service as RPC target
+    asRPC(): unknown {
+      // This would integrate with the RPC system from ai-functions
+      // For now, return a placeholder
+      return {
+        _type: 'rpc-target',
+        service: definition.name,
+        version: definition.version,
+      }
+    },
+
+    // Get service as API routes
+    asAPI(): unknown {
+      // This would generate HTTP/REST API routes
+      // For now, return a placeholder with route definitions
+      return definition.endpoints.map((ep) => ({
+        method: ep.method || 'POST',
+        path: ep.path || `/${ep.name}`,
+        handler: ep.handler,
+      }))
+    },
+  }
+
+  return service
+}
+
+/**
+ * Generate a unique request ID
+ */
+function generateRequestId(): string {
+  return `req_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`
+}