digital-products 2.1.3 → 2.4.0

package/src/tiers/entitlements.ts

@@ -1,201 +0,0 @@
-/**
- * Entitlements
- * Feature and resource entitlement management
- */
-
-/**
- * Entitlement types
- */
-export type EntitlementType = 'boolean' | 'limit' | 'quota' | 'feature'
-
-/**
- * Quota period
- */
-export type QuotaPeriod = 'daily' | 'weekly' | 'monthly' | 'yearly'
-
-/**
- * Entitlement definition
- */
-export interface EntitlementDefinition {
-  /** Unique identifier */
-  id: string
-  /** Human-readable name */
-  name: string
-  /** Entitlement type */
-  type: EntitlementType
-  /** Description */
-  description?: string
-  /** Limit value (for limit type) */
-  limit?: number
-  /** Unit (for limit type) */
-  unit?: string
-  /** Quota value (for quota type) */
-  quota?: number
-  /** Period (for quota type) */
-  period?: QuotaPeriod
-  /** Feature ID (for feature type) */
-  featureId?: string
-  /** Tiers that have this entitlement */
-  tiers?: string[]
-  /** Tier-specific limits */
-  tierLimits?: Record<string, number>
-  /** Tier-specific quotas */
-  tierQuotas?: Record<string, number>
-}
-
-/**
- * Create an entitlement
- */
-export function Entitlement(config: EntitlementDefinition): EntitlementDefinition {
-  return {
-    id: config.id,
-    name: config.name,
-    type: config.type,
-    description: config.description,
-    limit: config.limit,
-    unit: config.unit,
-    quota: config.quota,
-    period: config.period,
-    featureId: config.featureId,
-    tiers: config.tiers,
-    tierLimits: config.tierLimits,
-    tierQuotas: config.tierQuotas,
-  }
-}
-
-/**
- * Entitlement check request
- */
-export interface EntitlementCheck {
-  entitlementId: string
-  tier: string
-  currentUsage?: number
-  requestedUsage?: number
-}
-
-/**
- * Quota check result
- */
-export interface QuotaCheckResult {
-  allowed: boolean
-  remaining: number
-  limit: number
-}
-
-/**
- * Entitlement comparison result
- */
-export interface EntitlementComparisonResult {
-  added: string[]
-  removed: string[]
-  unchanged: string[]
-}
-
-/**
- * Entitlement manager interface
- */
-export interface EntitlementManager {
-  /** Register an entitlement */
-  register(entitlement: EntitlementDefinition): void
-  /** Get an entitlement by ID */
-  get(id: string): EntitlementDefinition | undefined
-  /** Check if tier has entitlement */
-  hasEntitlement(entitlementId: string, tier: string): boolean
-  /** Get limit for tier */
-  getLimit(entitlementId: string, tier: string): number | undefined
-  /** Check quota */
-  checkQuota(check: EntitlementCheck): QuotaCheckResult
-  /** Get all entitlements for a tier */
-  getEntitlementsForTier(tier: string): EntitlementDefinition[]
-  /** Compare entitlements between tiers */
-  compareEntitlements(tierA: string, tierB: string): EntitlementComparisonResult
-}
-
-/**
- * Create an entitlement manager
- */
-export function createEntitlementManager(): EntitlementManager {
-  const entitlements = new Map<string, EntitlementDefinition>()
-
-  return {
-    register(entitlement: EntitlementDefinition): void {
-      entitlements.set(entitlement.id, entitlement)
-    },
-
-    get(id: string): EntitlementDefinition | undefined {
-      return entitlements.get(id)
-    },
-
-    hasEntitlement(entitlementId: string, tier: string): boolean {
-      const entitlement = entitlements.get(entitlementId)
-      if (!entitlement) return false
-
-      return entitlement.tiers?.includes(tier) ?? false
-    },
-
-    getLimit(entitlementId: string, tier: string): number | undefined {
-      const entitlement = entitlements.get(entitlementId)
-      if (!entitlement) return undefined
-
-      return entitlement.tierLimits?.[tier] ?? entitlement.limit
-    },
-
-    checkQuota(check: EntitlementCheck): QuotaCheckResult {
-      const entitlement = entitlements.get(check.entitlementId)
-      if (!entitlement) {
-        return { allowed: false, remaining: 0, limit: 0 }
-      }
-
-      const limit = entitlement.tierQuotas?.[check.tier] ?? entitlement.quota ?? 0
-      const currentUsage = check.currentUsage ?? 0
-      const requestedUsage = check.requestedUsage ?? 0
-
-      // Unlimited (-1)
-      if (limit === -1) {
-        return { allowed: true, remaining: Infinity, limit: -1 }
-      }
-
-      const remaining = Math.max(0, limit - currentUsage)
-      const allowed = currentUsage + requestedUsage <= limit
-
-      return { allowed, remaining: remaining - (allowed ? requestedUsage : 0), limit }
-    },
-
-    getEntitlementsForTier(tier: string): EntitlementDefinition[] {
-      return Array.from(entitlements.values()).filter((e) => e.tiers?.includes(tier))
-    },
-
-    compareEntitlements(tierA: string, tierB: string): EntitlementComparisonResult {
-      const tierAEnts = new Set(
-        Array.from(entitlements.values())
-          .filter((e) => e.tiers?.includes(tierA))
-          .map((e) => e.id)
-      )
-      const tierBEnts = new Set(
-        Array.from(entitlements.values())
-          .filter((e) => e.tiers?.includes(tierB))
-          .map((e) => e.id)
-      )
-
-      const added: string[] = []
-      const removed: string[] = []
-      const unchanged: string[] = []
-
-      for (const id of tierBEnts) {
-        if (tierAEnts.has(id)) {
-          unchanged.push(id)
-        } else {
-          added.push(id)
-        }
-      }
-
-      for (const id of tierAEnts) {
-        if (!tierBEnts.has(id)) {
-          removed.push(id)
-        }
-      }
-
-      return { added, removed, unchanged }
-    },
-  }
-}

package/src/types.js

@@ -1,4 +0,0 @@
-/**
- * Core types for digital products
- */
-export {};

package/test/analytics/events.test.ts

@@ -1,319 +0,0 @@
-/**
- * Tests for Analytics Events
- * Phase 1: RED - These tests should FAIL initially
- */
-
-import { describe, it, expect, beforeEach } from 'vitest'
-import {
-  ProductEvent,
-  createProductEvent,
-  EventSchema,
-  createEventSchema,
-  EventEmitter,
-  createEventEmitter,
-  EventTracker,
-  createEventTracker,
-} from '../../src/analytics/events.js'
-
-describe('Analytics Events', () => {
-  describe('ProductEvent', () => {
-    it('creates a basic event', () => {
-      const event = createProductEvent({
-        name: 'page.view',
-        properties: {
-          path: '/dashboard',
-          title: 'Dashboard',
-        },
-      })
-
-      expect(event.name).toBe('page.view')
-      expect(event.properties.path).toBe('/dashboard')
-      expect(event.timestamp).toBeDefined()
-    })
-
-    it('auto-generates timestamp', () => {
-      const before = Date.now()
-      const event = createProductEvent({
-        name: 'test.event',
-      })
-      const after = Date.now()
-
-      expect(event.timestamp.getTime()).toBeGreaterThanOrEqual(before)
-      expect(event.timestamp.getTime()).toBeLessThanOrEqual(after)
-    })
-
-    it('supports custom timestamp', () => {
-      const customTime = new Date('2024-01-15T10:00:00Z')
-      const event = createProductEvent({
-        name: 'test.event',
-        timestamp: customTime,
-      })
-
-      expect(event.timestamp).toEqual(customTime)
-    })
-
-    it('supports user context', () => {
-      const event = createProductEvent({
-        name: 'button.click',
-        userId: 'user-123',
-        sessionId: 'session-456',
-        properties: { button: 'submit' },
-      })
-
-      expect(event.userId).toBe('user-123')
-      expect(event.sessionId).toBe('session-456')
-    })
-
-    it('supports product context', () => {
-      const event = createProductEvent({
-        name: 'feature.used',
-        productId: 'my-product',
-        version: '2.0.0',
-        tier: 'pro',
-        properties: { feature: 'analytics' },
-      })
-
-      expect(event.productId).toBe('my-product')
-      expect(event.version).toBe('2.0.0')
-      expect(event.tier).toBe('pro')
-    })
-  })
-
-  describe('EventSchema', () => {
-    it('defines required properties', () => {
-      const schema = createEventSchema({
-        name: 'signup.completed',
-        properties: {
-          email: { type: 'string', required: true },
-          plan: { type: 'string', required: true },
-          source: { type: 'string', required: false },
-        },
-      })
-
-      expect(schema.properties.email.required).toBe(true)
-    })
-
-    it('validates event against schema', () => {
-      const schema = createEventSchema({
-        name: 'purchase.completed',
-        properties: {
-          amount: { type: 'number', required: true },
-          currency: { type: 'string', required: true },
-        },
-      })
-
-      const validEvent = createProductEvent({
-        name: 'purchase.completed',
-        properties: { amount: 99.99, currency: 'USD' },
-      })
-
-      const invalidEvent = createProductEvent({
-        name: 'purchase.completed',
-        properties: { amount: 99.99 }, // Missing currency
-      })
-
-      expect(schema.validate(validEvent)).toEqual({ valid: true })
-      expect(schema.validate(invalidEvent)).toEqual({
-        valid: false,
-        errors: ['Missing required property: currency'],
-      })
-    })
-
-    it('validates property types', () => {
-      const schema = createEventSchema({
-        name: 'test.event',
-        properties: {
-          count: { type: 'number', required: true },
-        },
-      })
-
-      const invalidEvent = createProductEvent({
-        name: 'test.event',
-        properties: { count: 'not-a-number' },
-      })
-
-      expect(schema.validate(invalidEvent)).toEqual({
-        valid: false,
-        errors: ['Property count should be number, got string'],
-      })
-    })
-
-    it('supports enum values', () => {
-      const schema = createEventSchema({
-        name: 'plan.selected',
-        properties: {
-          plan: {
-            type: 'string',
-            required: true,
-            enum: ['free', 'pro', 'enterprise'],
-          },
-        },
-      })
-
-      const valid = createProductEvent({
-        name: 'plan.selected',
-        properties: { plan: 'pro' },
-      })
-
-      const invalid = createProductEvent({
-        name: 'plan.selected',
-        properties: { plan: 'invalid-plan' },
-      })
-
-      expect(schema.validate(valid).valid).toBe(true)
-      expect(schema.validate(invalid).valid).toBe(false)
-    })
-  })
-
-  describe('EventEmitter', () => {
-    let emitter: EventEmitter
-
-    beforeEach(() => {
-      emitter = createEventEmitter()
-    })
-
-    it('emits events', () => {
-      const events: ProductEvent[] = []
-      emitter.on('page.view', (e) => events.push(e))
-
-      emitter.emit(
-        createProductEvent({
-          name: 'page.view',
-          properties: { path: '/' },
-        })
-      )
-
-      expect(events).toHaveLength(1)
-    })
-
-    it('supports wildcard listeners', () => {
-      const events: ProductEvent[] = []
-      emitter.on('*', (e) => events.push(e))
-
-      emitter.emit(createProductEvent({ name: 'event.one' }))
-      emitter.emit(createProductEvent({ name: 'event.two' }))
-
-      expect(events).toHaveLength(2)
-    })
-
-    it('supports pattern matching', () => {
-      const events: ProductEvent[] = []
-      emitter.on('user.*', (e) => events.push(e))
-
-      emitter.emit(createProductEvent({ name: 'user.signup' }))
-      emitter.emit(createProductEvent({ name: 'user.login' }))
-      emitter.emit(createProductEvent({ name: 'page.view' }))
-
-      expect(events).toHaveLength(2)
-    })
-
-    it('removes listeners', () => {
-      const events: ProductEvent[] = []
-      const handler = (e: ProductEvent) => events.push(e)
-
-      emitter.on('test', handler)
-      emitter.emit(createProductEvent({ name: 'test' }))
-      expect(events).toHaveLength(1)
-
-      emitter.off('test', handler)
-      emitter.emit(createProductEvent({ name: 'test' }))
-      expect(events).toHaveLength(1)
-    })
-
-    it('supports once listeners', () => {
-      const events: ProductEvent[] = []
-      emitter.once('once-event', (e) => events.push(e))
-
-      emitter.emit(createProductEvent({ name: 'once-event' }))
-      emitter.emit(createProductEvent({ name: 'once-event' }))
-
-      expect(events).toHaveLength(1)
-    })
-  })
-
-  describe('EventTracker', () => {
-    let tracker: EventTracker
-
-    beforeEach(() => {
-      tracker = createEventTracker({
-        productId: 'test-product',
-        version: '1.0.0',
-      })
-    })
-
-    it('tracks events with product context', () => {
-      const tracked = tracker.track('button.click', { button: 'submit' })
-
-      expect(tracked.productId).toBe('test-product')
-      expect(tracked.version).toBe('1.0.0')
-    })
-
-    it('batches events', async () => {
-      const sentBatches: ProductEvent[][] = []
-
-      tracker = createEventTracker({
-        productId: 'batch-test',
-        batchSize: 3,
-        onFlush: (events) => sentBatches.push(events),
-      })
-
-      tracker.track('event1')
-      tracker.track('event2')
-      expect(sentBatches).toHaveLength(0)
-
-      tracker.track('event3')
-      expect(sentBatches).toHaveLength(1)
-      expect(sentBatches[0]).toHaveLength(3)
-    })
-
-    it('flushes on interval', async () => {
-      const sentBatches: ProductEvent[][] = []
-
-      tracker = createEventTracker({
-        productId: 'interval-test',
-        flushInterval: 50,
-        onFlush: (events) => sentBatches.push(events),
-      })
-
-      tracker.track('event1')
-      await new Promise((r) => setTimeout(r, 100))
-
-      expect(sentBatches).toHaveLength(1)
-    })
-
-    it('enriches events with global context', () => {
-      tracker.setContext({
-        userId: 'global-user',
-        tier: 'enterprise',
-      })
-
-      const event = tracker.track('test.event')
-      expect(event.userId).toBe('global-user')
-      expect(event.tier).toBe('enterprise')
-    })
-
-    it('validates events against schemas', () => {
-      tracker.registerSchema(
-        createEventSchema({
-          name: 'validated.event',
-          properties: {
-            required_prop: { type: 'string', required: true },
-          },
-        })
-      )
-
-      expect(() => tracker.track('validated.event', {})).toThrow(
-        'Event validation failed'
-      )
-    })
-
-    it('provides analytics helpers', () => {
-      tracker.pageView('/dashboard', { title: 'Dashboard' })
-      tracker.identify('user-123', { email: 'user@example.com' })
-      tracker.track('feature.used', { feature: 'analytics' })
-
-      const events = tracker.getBuffer()
-      expect(events).toHaveLength(3)
-    })
-  })
-})