services-as-software 0.1.0 → 2.0.1

package/dist/service.js

@@ -0,0 +1,206 @@
+/**
+ * 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)}`;
+}
+//# sourceMappingURL=service.js.map

package/dist/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,469 @@
+/**
+ * Core types for services-as-software
+ */
+import type { AIFunctionDefinition, JSONSchema as AIJSONSchema } from 'ai-functions';
+export type JSONSchema = AIJSONSchema;
+type RpcPromise<T> = Promise<T>;
+/**
+ * Pricing models for services
+ */
+export type PricingModel = 'free' | 'fixed' | 'per-use' | 'subscription' | 'tiered' | 'usage-based' | 'custom';
+/**
+ * Billing intervals for subscriptions
+ */
+export type BillingInterval = 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'custom';
+/**
+ * Service status
+ */
+export type ServiceStatus = 'active' | 'inactive' | 'deprecated' | 'beta' | 'alpha';
+/**
+ * Order status
+ */
+export type OrderStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Subscription status
+ */
+export type SubscriptionStatus = 'active' | 'paused' | 'cancelled' | 'expired' | 'pending';
+/**
+ * Currency code (ISO 4217)
+ */
+export type Currency = 'USD' | 'EUR' | 'GBP' | 'JPY' | 'CNY' | string;
+/**
+ * Pricing configuration
+ */
+export interface PricingConfig {
+    /** Pricing model type */
+    model: PricingModel;
+    /** Base price (for fixed or subscription) */
+    basePrice?: number;
+    /** Currency code */
+    currency?: Currency;
+    /** Price per unit (for per-use or usage-based) */
+    pricePerUnit?: number;
+    /** Billing interval (for subscriptions) */
+    interval?: BillingInterval;
+    /** Usage tiers (for tiered pricing) */
+    tiers?: PricingTier[];
+    /** Free tier limits */
+    freeTier?: {
+        requests?: number;
+        units?: number;
+        resetInterval?: BillingInterval;
+    };
+}
+/**
+ * Pricing tier for tiered pricing models
+ */
+export interface PricingTier {
+    /** Starting quantity for this tier */
+    from: number;
+    /** Ending quantity (exclusive) - undefined means no upper limit */
+    to?: number;
+    /** Price per unit in this tier */
+    pricePerUnit: number;
+    /** Fixed price for this tier */
+    fixedPrice?: number;
+}
+/**
+ * Service endpoint definition
+ */
+export interface EndpointDefinition<TInput = unknown, TOutput = unknown> {
+    /** Endpoint name */
+    name: string;
+    /** Description of what this endpoint does */
+    description?: string;
+    /** HTTP method (for REST endpoints) */
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    /** Path pattern (e.g., '/users/:id') */
+    path?: string;
+    /** Input schema */
+    input?: JSONSchema;
+    /** Output schema */
+    output?: JSONSchema;
+    /** Handler function */
+    handler: (input: TInput, context?: ServiceContext) => TOutput | Promise<TOutput>;
+    /** Pricing specific to this endpoint */
+    pricing?: PricingConfig;
+    /** Rate limiting */
+    rateLimit?: {
+        requests: number;
+        window: number;
+    };
+    /** Whether authentication is required */
+    requiresAuth?: boolean;
+}
+/**
+ * Service context provided to endpoint handlers
+ */
+export interface ServiceContext {
+    /** Customer/user ID */
+    customerId?: string;
+    /** Subscription ID */
+    subscriptionId?: string;
+    /** Request ID for tracing */
+    requestId: string;
+    /** Request metadata */
+    metadata?: Record<string, unknown>;
+    /** Entitlements for this customer */
+    entitlements: string[];
+    /** Usage tracking */
+    usage?: UsageTracker;
+}
+/**
+ * Usage tracker for billing and analytics
+ */
+export interface UsageTracker {
+    /** Track a usage event */
+    track(event: UsageEvent): Promise<void>;
+    /** Get current usage for a customer */
+    get(customerId: string, period?: {
+        start: Date;
+        end: Date;
+    }): Promise<Usage>;
+}
+/**
+ * Usage event
+ */
+export interface UsageEvent {
+    /** Customer ID */
+    customerId: string;
+    /** Endpoint or resource that was used */
+    resource: string;
+    /** Quantity used */
+    quantity: number;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+    /** Timestamp */
+    timestamp?: Date;
+}
+/**
+ * Usage summary
+ */
+export interface Usage {
+    /** Customer ID */
+    customerId: string;
+    /** Usage by resource */
+    byResource: Record<string, number>;
+    /** Total usage */
+    total: number;
+    /** Period start */
+    periodStart: Date;
+    /** Period end */
+    periodEnd: Date;
+}
+/**
+ * Service definition
+ */
+export interface ServiceDefinition {
+    /** Service name */
+    name: string;
+    /** Service version */
+    version: string;
+    /** Description */
+    description?: string;
+    /** Service status */
+    status?: ServiceStatus;
+    /** Service endpoints */
+    endpoints: EndpointDefinition[];
+    /** Default pricing configuration */
+    pricing?: PricingConfig;
+    /** Service-level functions (AI tools) */
+    functions?: AIFunctionDefinition[];
+    /** Event handlers */
+    events?: Record<string, EventHandler>;
+    /** Scheduled tasks */
+    scheduled?: ScheduledTask[];
+    /** Subscription plans */
+    plans?: SubscriptionPlan[];
+    /** Entitlement definitions */
+    entitlements?: EntitlementDefinition[];
+    /** KPI definitions */
+    kpis?: KPIDefinition[];
+    /** OKR definitions */
+    okrs?: OKRDefinition[];
+}
+/**
+ * Event handler definition
+ */
+export interface EventHandler<TPayload = unknown> {
+    /** Event name/pattern */
+    event: string;
+    /** Handler function */
+    handler: (payload: TPayload, context?: ServiceContext) => void | Promise<void>;
+    /** Whether to retry on failure */
+    retry?: boolean;
+    /** Max retry attempts */
+    maxRetries?: number;
+}
+/**
+ * Scheduled task definition
+ */
+export interface ScheduledTask<TInput = unknown> {
+    /** Task name */
+    name: string;
+    /** Cron expression or interval */
+    schedule: string;
+    /** Task handler */
+    handler: (input?: TInput, context?: ServiceContext) => void | Promise<void>;
+    /** Whether task is enabled */
+    enabled?: boolean;
+}
+/**
+ * Subscription plan
+ */
+export interface SubscriptionPlan {
+    /** Plan ID */
+    id: string;
+    /** Plan name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Pricing configuration */
+    pricing: PricingConfig;
+    /** Entitlements included */
+    entitlements: string[];
+    /** Features included */
+    features: string[];
+    /** Usage limits */
+    limits?: Record<string, number>;
+    /** Trial period (days) */
+    trialDays?: number;
+}
+/**
+ * Entitlement definition
+ */
+export interface EntitlementDefinition {
+    /** Entitlement ID */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Resource type this entitlement grants access to */
+    resource?: string;
+    /** Actions permitted */
+    actions?: string[];
+}
+/**
+ * KPI (Key Performance Indicator) definition
+ */
+export interface KPIDefinition {
+    /** KPI ID */
+    id: string;
+    /** KPI name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** How to calculate this KPI */
+    calculate: () => Promise<number | string>;
+    /** Target value */
+    target?: number | string;
+    /** Unit of measurement */
+    unit?: string;
+    /** Update frequency */
+    updateInterval?: BillingInterval;
+}
+/**
+ * OKR (Objectives and Key Results) definition
+ */
+export interface OKRDefinition {
+    /** OKR ID */
+    id: string;
+    /** Objective statement */
+    objective: string;
+    /** Key results */
+    keyResults: KeyResult[];
+    /** Quarter or time period */
+    period?: string;
+    /** Owner */
+    owner?: string;
+}
+/**
+ * Key Result within an OKR
+ */
+export interface KeyResult {
+    /** Key result description */
+    description: string;
+    /** How to measure this result */
+    measure: () => Promise<number>;
+    /** Target value */
+    target: number;
+    /** Current value */
+    current?: number;
+    /** Unit of measurement */
+    unit?: string;
+}
+/**
+ * Order definition
+ */
+export interface Order<TProduct = unknown> {
+    /** Order ID */
+    id: string;
+    /** Customer ID */
+    customerId: string;
+    /** Product or service being ordered */
+    product: TProduct;
+    /** Quantity */
+    quantity: number;
+    /** Total price */
+    total: number;
+    /** Currency */
+    currency: Currency;
+    /** Order status */
+    status: OrderStatus;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Updated timestamp */
+    updatedAt: Date;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Quote definition
+ */
+export interface Quote<TProduct = unknown> {
+    /** Quote ID */
+    id: string;
+    /** Customer ID */
+    customerId: string;
+    /** Product or service being quoted */
+    product: TProduct;
+    /** Quantity */
+    quantity: number;
+    /** Quoted price */
+    price: number;
+    /** Currency */
+    currency: Currency;
+    /** Valid until */
+    expiresAt: Date;
+    /** Quote metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Subscription definition
+ */
+export interface Subscription {
+    /** Subscription ID */
+    id: string;
+    /** Customer ID */
+    customerId: string;
+    /** Plan ID */
+    planId: string;
+    /** Subscription status */
+    status: SubscriptionStatus;
+    /** Current period start */
+    currentPeriodStart: Date;
+    /** Current period end */
+    currentPeriodEnd: Date;
+    /** Cancel at period end */
+    cancelAtPeriodEnd?: boolean;
+    /** Trial end date */
+    trialEnd?: Date;
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Notification definition
+ */
+export interface Notification {
+    /** Notification ID */
+    id: string;
+    /** Recipient(s) */
+    to: string | string[];
+    /** Subject */
+    subject: string;
+    /** Message body */
+    body: string;
+    /** Channel (email, slack, sms, etc.) */
+    channel: string;
+    /** Priority */
+    priority?: 'low' | 'normal' | 'high' | 'urgent';
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Service client interface
+ */
+export interface ServiceClient {
+    /** Ask a question to the service */
+    ask(question: string, context?: unknown): RpcPromise<string>;
+    /** Deliver results */
+    deliver(orderId: string, results: unknown): RpcPromise<void>;
+    /** Execute a task */
+    do(action: string, input?: unknown): RpcPromise<unknown>;
+    /** Generate content */
+    generate(prompt: string, options?: unknown): RpcPromise<unknown>;
+    /** Type checking/validation */
+    is(value: unknown, type: string | JSONSchema): RpcPromise<boolean>;
+    /** Send notification */
+    notify(notification: Notification): RpcPromise<void>;
+    /** Place an order */
+    order<TProduct>(product: TProduct, quantity: number): RpcPromise<Order<TProduct>>;
+    /** Request a quote */
+    quote<TProduct>(product: TProduct, quantity: number): RpcPromise<Quote<TProduct>>;
+    /** Subscribe to a plan */
+    subscribe(planId: string): RpcPromise<Subscription>;
+    /** Get entitlements */
+    entitlements(): RpcPromise<string[]>;
+    /** Get KPIs */
+    kpis(): RpcPromise<Record<string, number | string>>;
+    /** Get OKRs */
+    okrs(): RpcPromise<OKRDefinition[]>;
+}
+/**
+ * Service instance returned by Service()
+ */
+export interface Service extends ServiceClient {
+    /** Service definition */
+    definition: ServiceDefinition;
+    /** Call an endpoint directly */
+    call<TInput, TOutput>(endpoint: string, input: TInput, context?: ServiceContext): RpcPromise<TOutput>;
+    /** Register an event handler */
+    on<TPayload>(event: string, handler: (payload: TPayload, context?: ServiceContext) => void | Promise<void>): void;
+    /** Schedule a recurring task */
+    every(schedule: string, handler: (context?: ServiceContext) => void | Promise<void>): void;
+    /** Add a queue processor */
+    queue<TJob>(name: string, handler: (job: TJob, context?: ServiceContext) => void | Promise<void>): void;
+    /** Get service as RPC target */
+    asRPC(): unknown;
+    /** Get service as API routes */
+    asAPI(): unknown;
+}
+/**
+ * Provider interface for services
+ */
+export interface Provider {
+    /** Provider name */
+    name: string;
+    /** Base URL */
+    baseUrl: string;
+    /** Authentication configuration */
+    auth?: {
+        type: 'api-key' | 'oauth' | 'jwt' | 'basic';
+        credentials: Record<string, string>;
+    };
+    /** Available services */
+    services: string[];
+    /** Get a service client */
+    service<T extends ServiceClient>(serviceName: string): T;
+}
+/**
+ * Client configuration for connecting to remote services
+ */
+export interface ClientConfig {
+    /** Service URL or provider */
+    url?: string;
+    /** Provider instance */
+    provider?: Provider;
+    /** Authentication */
+    auth?: {
+        type: 'api-key' | 'oauth' | 'jwt' | 'basic';
+        credentials: Record<string, string>;
+    };
+    /** Custom headers */
+    headers?: Record<string, string>;
+    /** Timeout (milliseconds) */
+    timeout?: number;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map