services-as-software 2.0.2 → 2.1.3

package/src/service.js

@@ -0,0 +1,205 @@
+/**
+ * Service implementation
+ */
+/**
+ * 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) {
+    // Store endpoints by name for quick lookup
+    const endpointMap = new Map();
+    for (const endpoint of definition.endpoints) {
+        endpointMap.set(endpoint.name, endpoint);
+    }
+    // Store event handlers
+    const eventHandlers = new Map();
+    if (definition.events) {
+        for (const [event, handler] of Object.entries(definition.events)) {
+            eventHandlers.set(event, [handler]);
+        }
+    }
+    // Store scheduled tasks
+    const scheduledTasks = new Map();
+    if (definition.scheduled) {
+        for (const task of definition.scheduled) {
+            scheduledTasks.set(task.name, task);
+        }
+    }
+    // Create the service instance
+    const service = {
+        definition,
+        // Call an endpoint
+        async call(endpoint, input, context) {
+            const ep = endpointMap.get(endpoint);
+            if (!ep) {
+                throw new Error(`Endpoint not found: ${endpoint}`);
+            }
+            // Create context if not provided
+            const ctx = 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);
+        },
+        // Ask a question
+        async ask(question, context) {
+            return service.call('ask', { question, context });
+        },
+        // Deliver results
+        async deliver(orderId, results) {
+            return service.call('deliver', { orderId, results });
+        },
+        // Execute a task
+        async do(action, input) {
+            return service.call('do', { action, input });
+        },
+        // Generate content
+        async generate(prompt, options) {
+            return service.call('generate', { prompt, options });
+        },
+        // Type checking/validation
+        async is(value, type) {
+            return service.call('is', { value, type });
+        },
+        // Send notification
+        async notify(notification) {
+            return service.call('notify', notification);
+        },
+        // Place an order
+        async order(product, quantity) {
+            return service.call('order', { product, quantity });
+        },
+        // Request a quote
+        async quote(product, quantity) {
+            return service.call('quote', { product, quantity });
+        },
+        // Subscribe to a plan
+        async subscribe(planId) {
+            return service.call('subscribe', { planId });
+        },
+        // Get entitlements
+        async entitlements() {
+            return service.call('entitlements', {});
+        },
+        // Get KPIs
+        async kpis() {
+            const result = {};
+            if (definition.kpis) {
+                for (const kpi of definition.kpis) {
+                    result[kpi.id] = await kpi.calculate();
+                }
+            }
+            return result;
+        },
+        // Get OKRs
+        async okrs() {
+            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(event, handler) {
+            const handlers = eventHandlers.get(event) || [];
+            handlers.push({
+                event,
+                handler: handler,
+            });
+            eventHandlers.set(event, handlers);
+        },
+        // Schedule recurring task
+        every(schedule, handler) {
+            const taskName = `task-${scheduledTasks.size + 1}`;
+            scheduledTasks.set(taskName, {
+                name: taskName,
+                schedule,
+                handler: (_input, context) => handler(context),
+                enabled: true,
+            });
+        },
+        // Add queue processor
+        queue(name, handler) {
+            // 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() {
+            // 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() {
+            // 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() {
+    return `req_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+}

package/src/service.test.js

@@ -0,0 +1,164 @@
+/**
+ * Tests for Service implementation
+ */
+import { describe, it, expect } from 'vitest';
+import { Service, Endpoint, POST, GET } from './index.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) => {
+                        return { echoed: input.message };
+                    },
+                }),
+            ],
+        });
+        const result = await service.call('echo', {
+            message: 'hello',
+        });
+        expect(result.echoed).toBe('hello');
+    });
+    it('should provide service context to handlers', async () => {
+        let capturedContext;
+        const service = Service({
+            name: 'test-service',
+            version: '1.0.0',
+            endpoints: [
+                POST({
+                    name: 'test',
+                    handler: async (_input, context) => {
+                        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/types.js

@@ -0,0 +1,4 @@
+/**
+ * Core types for services-as-software
+ */
+export {};