digital-products 2.1.3 → 2.4.0

package/src/mcp.js

@@ -1,139 +0,0 @@
-/**
- * MCP() - Define a Model Context Protocol server
- */
-import { registerProduct } from './product.js';
-/**
- * Create an MCP server definition
- *
- * @example
- * ```ts
- * const mcpServer = MCP({
- *   id: 'my-mcp',
- *   name: 'My MCP Server',
- *   description: 'Custom MCP server for AI tools',
- *   version: '1.0.0',
- *   transport: 'stdio',
- *   tools: [
- *     Tool('searchFiles', 'Search for files in the project', {
- *       query: 'Search query',
- *       path: 'Directory to search in',
- *     }),
- *     Tool('readFile', 'Read file contents', {
- *       path: 'File path to read',
- *     }),
- *   ],
- *   resources: [
- *     Resource('file://', 'Project Files', 'Access to project files'),
- *   ],
- *   prompts: [
- *     Prompt('codeReview', 'Review code for best practices',
- *       'Review the following code:\n\n{{code}}'),
- *   ],
- * })
- * ```
- */
-export function MCP(config) {
-    const mcp = {
-        type: 'mcp',
-        id: config.id,
-        name: config.name,
-        description: config.description,
-        version: config.version,
-        transport: config.transport,
-        tools: config.tools,
-        resources: config.resources,
-        prompts: config.prompts,
-        config: config.config,
-        metadata: config.metadata,
-        tags: config.tags,
-        status: config.status || 'active',
-    };
-    return registerProduct(mcp);
-}
-/**
- * Helper to create an MCP tool
- *
- * @example
- * ```ts
- * const tool = Tool(
- *   'searchCode',
- *   'Search code using regex',
- *   {
- *     pattern: 'Regex pattern to search for',
- *     path: 'Directory to search in',
- *   },
- *   async (input) => {
- *     // Tool implementation
- *     return { matches: [] }
- *   }
- * )
- * ```
- */
-export function Tool(name, description, inputSchema, handler) {
-    return {
-        name,
-        description,
-        inputSchema,
-        handler,
-    };
-}
-/**
- * Helper to create an MCP resource
- *
- * @example
- * ```ts
- * const resource = Resource(
- *   'file://project',
- *   'Project Files',
- *   'Access to all project files',
- *   'application/json'
- * )
- * ```
- */
-export function Resource(uri, name, description, mimeType) {
-    return {
-        uri,
-        name,
-        description,
-        mimeType,
-    };
-}
-/**
- * Helper to create an MCP prompt
- *
- * @example
- * ```ts
- * const prompt = Prompt(
- *   'summarize',
- *   'Summarize text',
- *   'Summarize the following:\n\n{{text}}',
- *   { text: 'Text to summarize' }
- * )
- * ```
- */
-export function Prompt(name, description, template, args) {
-    return {
-        name,
-        description,
-        template,
-        arguments: args,
-    };
-}
-/**
- * Helper to configure MCP server
- *
- * @example
- * ```ts
- * const config = MCPConfig({
- *   port: 3000,
- *   host: 'localhost',
- *   auth: {
- *     type: 'bearer',
- *     token: process.env.MCP_TOKEN,
- *   },
- * })
- * ```
- */
-export function MCPConfig(config) {
-    return config;
-}

package/src/pricing/billing.ts

@@ -1,386 +0,0 @@
-/**
- * Billing Service
- * Subscription and invoice management
- */
-
-import { randomUUID } from 'crypto'
-
-/**
- * Subscription status
- */
-export type SubscriptionStatus = 'active' | 'trialing' | 'canceled' | 'past_due' | 'paused'
-
-/**
- * Invoice status
- */
-export type InvoiceStatus = 'draft' | 'open' | 'paid' | 'void' | 'uncollectible'
-
-/**
- * Payment method type
- */
-export type PaymentMethodType = 'card' | 'bank_transfer' | 'paypal'
-
-/**
- * Subscription definition
- */
-export interface Subscription {
-  id: string
-  customerId: string
-  planId: string
-  status: SubscriptionStatus
-  startDate: Date
-  currentPeriodStart: Date
-  currentPeriodEnd: Date
-  trialEnd?: Date
-  cancelAtPeriodEnd: boolean
-  scheduledPlanId?: string
-  metadata?: Record<string, unknown>
-}
-
-/**
- * Invoice definition
- */
-export interface Invoice {
-  id: string
-  subscriptionId: string
-  customerId: string
-  status: InvoiceStatus
-  subtotal: number
-  discountAmount: number
-  total: number
-  currency: string
-  usageCharges?: { metric: string; quantity: number; amount: number }[]
-  paidAt?: Date
-  createdAt: Date
-  dueDate: Date
-}
-
-/**
- * Payment method
- */
-export interface PaymentMethod {
-  id: string
-  customerId: string
-  type: PaymentMethodType
-  details: {
-    last4?: string
-    brand?: string
-    expMonth?: number
-    expYear?: number
-  }
-  isDefault: boolean
-}
-
-/**
- * Usage record
- */
-export interface UsageRecord {
-  subscriptionId: string
-  metric: string
-  quantity: number
-  timestamp: Date
-}
-
-/**
- * Billing event
- */
-export interface BillingEvent {
-  type: string
-  timestamp: Date
-  data: Record<string, unknown>
-}
-
-/**
- * Billing service options
- */
-export interface BillingServiceOptions {
-  planPrices?: Record<string, number>
-  coupons?: Record<string, number>
-}
-
-/**
- * Billing service interface
- */
-export interface BillingService {
-  // Subscriptions
-  createSubscription(params: {
-    customerId: string
-    planId: string
-    startDate: Date
-    trialDays?: number
-  }): Subscription
-
-  cancelSubscription(
-    subscriptionId: string,
-    options: { immediate: boolean }
-  ): Subscription
-
-  changeSubscription(
-    subscriptionId: string,
-    options: { newPlanId: string; prorate: boolean }
-  ): Subscription
-
-  getSubscription(id: string): Subscription | undefined
-  getSubscriptionsByCustomer(customerId: string): Subscription[]
-
-  // Invoices
-  generateInvoice(
-    subscriptionId: string,
-    options?: { couponCode?: string }
-  ): Invoice
-
-  markInvoicePaid(
-    invoiceId: string,
-    options: { paymentMethodId: string; paidAt: Date }
-  ): Invoice
-
-  getInvoice(id: string): Invoice | undefined
-  getInvoicesByCustomer(customerId: string): Invoice[]
-
-  // Usage
-  recordUsage(
-    subscriptionId: string,
-    usage: { metric: string; quantity: number; timestamp: Date }
-  ): void
-
-  // Payment methods
-  addPaymentMethod(params: {
-    customerId: string
-    type: PaymentMethodType
-    details: PaymentMethod['details']
-  }): PaymentMethod
-
-  setDefaultPaymentMethod(customerId: string, paymentMethodId: string): void
-  getDefaultPaymentMethod(customerId: string): PaymentMethod | undefined
-  getPaymentMethods(customerId: string): PaymentMethod[]
-  removePaymentMethod(paymentMethodId: string): void
-
-  // Events
-  on(event: string, handler: (e: BillingEvent) => void): void
-  off(event: string, handler: (e: BillingEvent) => void): void
-}
-
-/**
- * Create a billing service
- */
-export function createBillingService(options: BillingServiceOptions = {}): BillingService {
-  const subscriptions = new Map<string, Subscription>()
-  const invoices = new Map<string, Invoice>()
-  const paymentMethods = new Map<string, PaymentMethod>()
-  const usageRecords: UsageRecord[] = []
-  const eventHandlers = new Map<string, Set<(e: BillingEvent) => void>>()
-
-  const defaultPrices: Record<string, number> = {
-    'pro-monthly': 29,
-    'enterprise-monthly': 99,
-    metered: 0,
-    ...options.planPrices,
-  }
-
-  const coupons: Record<string, number> = {
-    SAVE20: 20,
-    ...options.coupons,
-  }
-
-  const emit = (type: string, data: Record<string, unknown>) => {
-    const event: BillingEvent = { type, timestamp: new Date(), data }
-    const handlers = eventHandlers.get(type)
-    if (handlers) {
-      for (const handler of handlers) {
-        handler(event)
-      }
-    }
-  }
-
-  return {
-    createSubscription(params): Subscription {
-      const id = randomUUID()
-      const periodEnd = new Date(params.startDate)
-      periodEnd.setMonth(periodEnd.getMonth() + 1)
-
-      let trialEnd: Date | undefined
-      let status: SubscriptionStatus = 'active'
-
-      if (params.trialDays) {
-        trialEnd = new Date(params.startDate)
-        trialEnd.setDate(trialEnd.getDate() + params.trialDays)
-        status = 'trialing'
-      }
-
-      const subscription: Subscription = {
-        id,
-        customerId: params.customerId,
-        planId: params.planId,
-        status,
-        startDate: params.startDate,
-        currentPeriodStart: params.startDate,
-        currentPeriodEnd: periodEnd,
-        trialEnd,
-        cancelAtPeriodEnd: false,
-      }
-
-      subscriptions.set(id, subscription)
-      emit('subscription.created', { subscriptionId: id, customerId: params.customerId })
-      return subscription
-    },
-
-    cancelSubscription(subscriptionId, options): Subscription {
-      const subscription = subscriptions.get(subscriptionId)
-      if (!subscription) {
-        throw new Error('Subscription not found')
-      }
-
-      if (options.immediate) {
-        subscription.status = 'canceled'
-      } else {
-        subscription.cancelAtPeriodEnd = true
-      }
-
-      emit('subscription.canceled', { subscriptionId })
-      return subscription
-    },
-
-    changeSubscription(subscriptionId, options): Subscription {
-      const subscription = subscriptions.get(subscriptionId)
-      if (!subscription) {
-        throw new Error('Subscription not found')
-      }
-
-      if (options.prorate) {
-        subscription.planId = options.newPlanId
-      } else {
-        subscription.scheduledPlanId = options.newPlanId
-      }
-
-      emit('subscription.updated', { subscriptionId, newPlanId: options.newPlanId })
-      return subscription
-    },
-
-    getSubscription(id): Subscription | undefined {
-      return subscriptions.get(id)
-    },
-
-    getSubscriptionsByCustomer(customerId): Subscription[] {
-      return Array.from(subscriptions.values()).filter((s) => s.customerId === customerId)
-    },
-
-    generateInvoice(subscriptionId, invoiceOptions = {}): Invoice {
-      const subscription = subscriptions.get(subscriptionId)
-      if (!subscription) {
-        throw new Error('Subscription not found')
-      }
-
-      const id = randomUUID()
-      const subtotal = defaultPrices[subscription.planId] ?? 29
-      let discountAmount = 0
-
-      if (invoiceOptions.couponCode && coupons[invoiceOptions.couponCode]) {
-        discountAmount = (subtotal * coupons[invoiceOptions.couponCode]) / 100
-      }
-
-      // Add usage charges if applicable
-      let usageCharges: Invoice['usageCharges']
-      const subscriptionUsage = usageRecords.filter((u) => u.subscriptionId === subscriptionId)
-      if (subscriptionUsage.length > 0) {
-        usageCharges = subscriptionUsage.map((u) => ({
-          metric: u.metric,
-          quantity: u.quantity,
-          amount: u.quantity * 0.001, // Example rate
-        }))
-      }
-
-      const invoice: Invoice = {
-        id,
-        subscriptionId,
-        customerId: subscription.customerId,
-        status: 'draft',
-        subtotal,
-        discountAmount,
-        total: subtotal - discountAmount + (usageCharges?.reduce((sum, c) => sum + c.amount, 0) ?? 0),
-        currency: 'USD',
-        usageCharges,
-        createdAt: new Date(),
-        dueDate: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
-      }
-
-      invoices.set(id, invoice)
-      return invoice
-    },
-
-    markInvoicePaid(invoiceId, options): Invoice {
-      const invoice = invoices.get(invoiceId)
-      if (!invoice) {
-        throw new Error('Invoice not found')
-      }
-
-      invoice.status = 'paid'
-      invoice.paidAt = options.paidAt
-
-      emit('invoice.paid', { invoiceId, amount: invoice.total })
-      return invoice
-    },
-
-    getInvoice(id): Invoice | undefined {
-      return invoices.get(id)
-    },
-
-    getInvoicesByCustomer(customerId): Invoice[] {
-      return Array.from(invoices.values()).filter((i) => i.customerId === customerId)
-    },
-
-    recordUsage(subscriptionId, usage): void {
-      usageRecords.push({ subscriptionId, ...usage })
-    },
-
-    addPaymentMethod(params): PaymentMethod {
-      const id = randomUUID()
-      const existingMethods = Array.from(paymentMethods.values()).filter(
-        (pm) => pm.customerId === params.customerId
-      )
-
-      const method: PaymentMethod = {
-        id,
-        customerId: params.customerId,
-        type: params.type,
-        details: params.details,
-        isDefault: existingMethods.length === 0,
-      }
-
-      paymentMethods.set(id, method)
-      return method
-    },
-
-    setDefaultPaymentMethod(customerId, paymentMethodId): void {
-      for (const method of paymentMethods.values()) {
-        if (method.customerId === customerId) {
-          method.isDefault = method.id === paymentMethodId
-        }
-      }
-    },
-
-    getDefaultPaymentMethod(customerId): PaymentMethod | undefined {
-      return Array.from(paymentMethods.values()).find(
-        (pm) => pm.customerId === customerId && pm.isDefault
-      )
-    },
-
-    getPaymentMethods(customerId): PaymentMethod[] {
-      return Array.from(paymentMethods.values()).filter((pm) => pm.customerId === customerId)
-    },
-
-    removePaymentMethod(paymentMethodId): void {
-      paymentMethods.delete(paymentMethodId)
-    },
-
-    on(event, handler): void {
-      if (!eventHandlers.has(event)) {
-        eventHandlers.set(event, new Set())
-      }
-      eventHandlers.get(event)!.add(handler)
-    },
-
-    off(event, handler): void {
-      eventHandlers.get(event)?.delete(handler)
-    },
-  }
-}