@parsrun/payments 0.1.0

package/dist/usage/index.js

@@ -0,0 +1,2916 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/usage/types.ts
+var UsageErrorCodes = {
+  QUOTA_EXCEEDED: "QUOTA_EXCEEDED",
+  PLAN_NOT_FOUND: "PLAN_NOT_FOUND",
+  FEATURE_NOT_FOUND: "FEATURE_NOT_FOUND",
+  CUSTOMER_NOT_FOUND: "CUSTOMER_NOT_FOUND",
+  DUPLICATE_EVENT: "DUPLICATE_EVENT",
+  STORAGE_ERROR: "STORAGE_ERROR",
+  INVALID_PERIOD: "INVALID_PERIOD"
+};
+var UsageError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "UsageError";
+  }
+};
+var QuotaExceededError = class extends UsageError {
+  constructor(featureKey, limit, currentUsage, requestedQuantity = 1) {
+    super(
+      `Quota exceeded for feature "${featureKey}": ${currentUsage}/${limit ?? "unlimited"} used`,
+      "QUOTA_EXCEEDED",
+      { featureKey, limit, currentUsage, requestedQuantity }
+    );
+    this.featureKey = featureKey;
+    this.limit = limit;
+    this.currentUsage = currentUsage;
+    this.requestedQuantity = requestedQuantity;
+    this.name = "QuotaExceededError";
+  }
+};
+
+// src/usage/memory-storage.ts
+function generateId() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var MemoryUsageStorage = class {
+  plans = /* @__PURE__ */ new Map();
+  planFeatures = /* @__PURE__ */ new Map();
+  customerPlans = /* @__PURE__ */ new Map();
+  usageEvents = [];
+  usageAggregates = /* @__PURE__ */ new Map();
+  alerts = /* @__PURE__ */ new Map();
+  idempotencyKeys = /* @__PURE__ */ new Set();
+  accessStatuses = /* @__PURE__ */ new Map();
+  billingCycles = /* @__PURE__ */ new Map();
+  // ============================================================================
+  // Plans
+  // ============================================================================
+  async getPlan(planId) {
+    return this.plans.get(planId) ?? null;
+  }
+  async getPlanByName(name) {
+    for (const plan of this.plans.values()) {
+      if (plan.name === name) {
+        return plan;
+      }
+    }
+    return null;
+  }
+  async listPlans(options) {
+    const plans2 = Array.from(this.plans.values());
+    if (options?.activeOnly) {
+      return plans2.filter((p) => p.isActive);
+    }
+    return plans2;
+  }
+  /**
+   * Add a plan (for testing/setup)
+   */
+  addPlan(plan) {
+    this.plans.set(plan.id, plan);
+    if (plan.features.length > 0) {
+      this.planFeatures.set(plan.id, plan.features);
+    }
+  }
+  // ============================================================================
+  // Plan Features
+  // ============================================================================
+  async getPlanFeatures(planId) {
+    return this.planFeatures.get(planId) ?? [];
+  }
+  async getFeatureLimit(planId, featureKey) {
+    const features = this.planFeatures.get(planId);
+    if (!features) return null;
+    return features.find((f) => f.featureKey === featureKey) ?? null;
+  }
+  /**
+   * Add plan features (for testing/setup)
+   */
+  addPlanFeatures(planId, features) {
+    this.planFeatures.set(planId, features);
+  }
+  // ============================================================================
+  // Customer-Plan Mapping
+  // ============================================================================
+  async getCustomerPlanId(customerId) {
+    return this.customerPlans.get(customerId) ?? null;
+  }
+  async setCustomerPlanId(customerId, planId) {
+    this.customerPlans.set(customerId, planId);
+  }
+  // ============================================================================
+  // Usage Events
+  // ============================================================================
+  async recordUsage(event) {
+    if (event.idempotencyKey) {
+      if (this.idempotencyKeys.has(event.idempotencyKey)) {
+        const existing = this.usageEvents.find(
+          (e) => e.idempotencyKey === event.idempotencyKey
+        );
+        if (existing) return existing;
+      }
+      this.idempotencyKeys.add(event.idempotencyKey);
+    }
+    const usageEvent = {
+      id: generateId(),
+      ...event,
+      timestamp: event.timestamp ?? /* @__PURE__ */ new Date()
+    };
+    this.usageEvents.push(usageEvent);
+    return usageEvent;
+  }
+  async recordUsageBatch(events) {
+    const results = [];
+    for (const event of events) {
+      results.push(await this.recordUsage(event));
+    }
+    return results;
+  }
+  async getUsageEvents(customerId, options) {
+    let events = this.usageEvents.filter((e) => e.customerId === customerId);
+    if (options.featureKey) {
+      events = events.filter((e) => e.featureKey === options.featureKey);
+    }
+    if (options.subscriptionId) {
+      events = events.filter((e) => e.subscriptionId === options.subscriptionId);
+    }
+    if (options.startDate) {
+      events = events.filter((e) => e.timestamp >= options.startDate);
+    }
+    if (options.endDate) {
+      events = events.filter((e) => e.timestamp <= options.endDate);
+    }
+    return events;
+  }
+  // ============================================================================
+  // Usage Aggregates
+  // ============================================================================
+  getAggregateKey(customerId, featureKey, periodType, periodStart) {
+    return `${customerId}:${featureKey}:${periodType}:${periodStart.toISOString()}`;
+  }
+  async getAggregate(customerId, featureKey, periodType, periodStart) {
+    const key = this.getAggregateKey(customerId, featureKey, periodType, periodStart);
+    return this.usageAggregates.get(key) ?? null;
+  }
+  async upsertAggregate(aggregate) {
+    const key = this.getAggregateKey(
+      aggregate.customerId,
+      aggregate.featureKey,
+      aggregate.periodType,
+      aggregate.periodStart
+    );
+    const existing = this.usageAggregates.get(key);
+    const result = {
+      id: existing?.id ?? generateId(),
+      ...aggregate,
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+    this.usageAggregates.set(key, result);
+    return result;
+  }
+  async getAggregates(customerId, options) {
+    let aggregates = Array.from(this.usageAggregates.values()).filter(
+      (a) => a.customerId === customerId
+    );
+    if (options.featureKey) {
+      aggregates = aggregates.filter((a) => a.featureKey === options.featureKey);
+    }
+    if (options.periodType) {
+      aggregates = aggregates.filter((a) => a.periodType === options.periodType);
+    }
+    if (options.subscriptionId) {
+      aggregates = aggregates.filter((a) => a.subscriptionId === options.subscriptionId);
+    }
+    if (options.startDate) {
+      aggregates = aggregates.filter((a) => a.periodStart >= options.startDate);
+    }
+    if (options.endDate) {
+      aggregates = aggregates.filter((a) => a.periodEnd <= options.endDate);
+    }
+    return aggregates;
+  }
+  async getCurrentPeriodUsage(customerId, featureKey, periodStart) {
+    const aggregate = await this.getAggregate(customerId, featureKey, "month", periodStart);
+    if (aggregate) {
+      return aggregate.totalQuantity;
+    }
+    const events = this.usageEvents.filter(
+      (e) => e.customerId === customerId && e.featureKey === featureKey && e.timestamp >= periodStart
+    );
+    return events.reduce((sum, e) => sum + e.quantity, 0);
+  }
+  // ============================================================================
+  // Alerts
+  // ============================================================================
+  async createAlert(alert) {
+    const usageAlert = {
+      id: generateId(),
+      ...alert,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.alerts.set(usageAlert.id, usageAlert);
+    return usageAlert;
+  }
+  async getActiveAlerts(customerId) {
+    return Array.from(this.alerts.values()).filter(
+      (a) => a.customerId === customerId && (a.status === "pending" || a.status === "triggered")
+    );
+  }
+  async updateAlertStatus(alertId, status) {
+    const alert = this.alerts.get(alertId);
+    if (alert) {
+      alert.status = status;
+      if (status === "triggered") {
+        alert.triggeredAt = /* @__PURE__ */ new Date();
+      } else if (status === "acknowledged") {
+        alert.acknowledgedAt = /* @__PURE__ */ new Date();
+      } else if (status === "resolved") {
+        alert.resolvedAt = /* @__PURE__ */ new Date();
+      }
+    }
+  }
+  // ============================================================================
+  // Usage Reset
+  // ============================================================================
+  async resetUsage(customerId, featureKeys, periodStart) {
+    this.usageEvents = this.usageEvents.filter((e) => {
+      if (e.customerId !== customerId) return true;
+      if (featureKeys && !featureKeys.includes(e.featureKey)) return true;
+      if (periodStart && e.timestamp < periodStart) return true;
+      return false;
+    });
+    await this.resetAggregates(customerId, featureKeys);
+  }
+  async resetAggregates(customerId, featureKeys) {
+    const keysToDelete = [];
+    for (const [key, aggregate] of this.usageAggregates) {
+      if (aggregate.customerId !== customerId) continue;
+      if (featureKeys && !featureKeys.includes(aggregate.featureKey)) continue;
+      keysToDelete.push(key);
+    }
+    for (const key of keysToDelete) {
+      this.usageAggregates.delete(key);
+    }
+  }
+  // ============================================================================
+  // Access Status
+  // ============================================================================
+  async getAccessStatus(customerId) {
+    return this.accessStatuses.get(customerId) ?? null;
+  }
+  async setAccessStatus(customerId, status) {
+    this.accessStatuses.set(customerId, status);
+  }
+  // ============================================================================
+  // Billing Cycle
+  // ============================================================================
+  async getBillingCycle(customerId) {
+    return this.billingCycles.get(customerId) ?? null;
+  }
+  async setBillingCycle(customerId, start, end) {
+    this.billingCycles.set(customerId, { start, end });
+  }
+  // ============================================================================
+  // Utilities
+  // ============================================================================
+  /**
+   * Clear all data (for testing)
+   */
+  clear() {
+    this.plans.clear();
+    this.planFeatures.clear();
+    this.customerPlans.clear();
+    this.usageEvents = [];
+    this.usageAggregates.clear();
+    this.alerts.clear();
+    this.idempotencyKeys.clear();
+    this.accessStatuses.clear();
+    this.billingCycles.clear();
+  }
+  /**
+   * Get stats (for debugging)
+   */
+  getStats() {
+    return {
+      plans: this.plans.size,
+      customers: this.customerPlans.size,
+      events: this.usageEvents.length,
+      aggregates: this.usageAggregates.size,
+      alerts: this.alerts.size,
+      accessStatuses: this.accessStatuses.size,
+      billingCycles: this.billingCycles.size
+    };
+  }
+};
+function createMemoryUsageStorage() {
+  return new MemoryUsageStorage();
+}
+
+// src/usage/drizzle-storage.ts
+import { eq, and, gte, lte, sql, inArray } from "drizzle-orm";
+
+// src/usage/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  customerAccessStatus: () => customerAccessStatus,
+  customerBillingCycles: () => customerBillingCycles,
+  customerPlans: () => customerPlans,
+  planFeatures: () => planFeatures,
+  plans: () => plans,
+  usageAggregates: () => usageAggregates,
+  usageAlerts: () => usageAlerts,
+  usageEvents: () => usageEvents
+});
+import {
+  pgTable,
+  text,
+  integer,
+  boolean,
+  timestamp,
+  jsonb,
+  uniqueIndex,
+  index
+} from "drizzle-orm/pg-core";
+var plans = pgTable("usage_plans", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull().unique(),
+  displayName: text("display_name").notNull(),
+  description: text("description"),
+  tier: integer("tier").notNull().default(0),
+  // 0=free, 1=starter, 2=pro, 3=enterprise, 4=custom
+  basePrice: integer("base_price").notNull().default(0),
+  // cents
+  currency: text("currency").notNull().default("usd"),
+  billingInterval: text("billing_interval").notNull().default("month"),
+  // month, year
+  isActive: boolean("is_active").notNull().default(true),
+  metadata: jsonb("metadata").$type(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+});
+var planFeatures = pgTable(
+  "usage_plan_features",
+  {
+    id: text("id").primaryKey(),
+    planId: text("plan_id").notNull().references(() => plans.id, { onDelete: "cascade" }),
+    featureKey: text("feature_key").notNull(),
+    // "api_calls", "storage_gb", "team_members"
+    limitValue: integer("limit_value"),
+    // null = unlimited
+    limitPeriod: text("limit_period"),
+    // "hour", "day", "month", null = total
+    isEnabled: boolean("is_enabled").notNull().default(true),
+    metadata: jsonb("metadata").$type()
+  },
+  (table) => ({
+    planFeatureIdx: uniqueIndex("usage_plan_features_plan_feature_idx").on(
+      table.planId,
+      table.featureKey
+    )
+  })
+);
+var customerPlans = pgTable("usage_customer_plans", {
+  customerId: text("customer_id").primaryKey(),
+  planId: text("plan_id").notNull().references(() => plans.id),
+  assignedAt: timestamp("assigned_at").defaultNow().notNull(),
+  metadata: jsonb("metadata").$type()
+});
+var customerAccessStatus = pgTable("usage_customer_access_status", {
+  customerId: text("customer_id").primaryKey(),
+  status: text("status").notNull().default("active"),
+  // active, past_due, suspended, canceled, unpaid
+  reason: text("reason"),
+  suspensionDate: timestamp("suspension_date"),
+  failedPaymentAttempts: integer("failed_payment_attempts").default(0),
+  gracePeriodEnd: timestamp("grace_period_end"),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+});
+var customerBillingCycles = pgTable("usage_customer_billing_cycles", {
+  customerId: text("customer_id").primaryKey(),
+  periodStart: timestamp("period_start").notNull(),
+  periodEnd: timestamp("period_end").notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+});
+var usageEvents = pgTable(
+  "usage_events",
+  {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    customerId: text("customer_id").notNull(),
+    subscriptionId: text("subscription_id"),
+    featureKey: text("feature_key").notNull(),
+    quantity: integer("quantity").notNull().default(1),
+    timestamp: timestamp("timestamp").defaultNow().notNull(),
+    metadata: jsonb("metadata").$type(),
+    idempotencyKey: text("idempotency_key")
+  },
+  (table) => ({
+    customerIdx: index("usage_events_customer_idx").on(table.customerId),
+    featureIdx: index("usage_events_feature_idx").on(table.featureKey),
+    timestampIdx: index("usage_events_timestamp_idx").on(table.timestamp),
+    idempotencyIdx: uniqueIndex("usage_events_idempotency_idx").on(
+      table.idempotencyKey
+    ),
+    // Composite index for common queries
+    customerFeatureTimestampIdx: index(
+      "usage_events_customer_feature_timestamp_idx"
+    ).on(table.customerId, table.featureKey, table.timestamp)
+  })
+);
+var usageAggregates = pgTable(
+  "usage_aggregates",
+  {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    customerId: text("customer_id").notNull(),
+    subscriptionId: text("subscription_id"),
+    featureKey: text("feature_key").notNull(),
+    periodStart: timestamp("period_start").notNull(),
+    periodEnd: timestamp("period_end").notNull(),
+    periodType: text("period_type").notNull(),
+    // "hour", "day", "month"
+    totalQuantity: integer("total_quantity").notNull().default(0),
+    eventCount: integer("event_count").notNull().default(0),
+    lastUpdated: timestamp("last_updated").defaultNow().notNull()
+  },
+  (table) => ({
+    // Unique constraint for upsert
+    lookupIdx: uniqueIndex("usage_aggregates_lookup_idx").on(
+      table.customerId,
+      table.featureKey,
+      table.periodType,
+      table.periodStart
+    ),
+    // Index for customer queries
+    customerIdx: index("usage_aggregates_customer_idx").on(table.customerId)
+  })
+);
+var usageAlerts = pgTable(
+  "usage_alerts",
+  {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    customerId: text("customer_id").notNull(),
+    subscriptionId: text("subscription_id"),
+    featureKey: text("feature_key").notNull(),
+    thresholdPercent: integer("threshold_percent").notNull(),
+    // 80, 100, 120
+    status: text("status").notNull().default("pending"),
+    // pending, triggered, acknowledged, resolved
+    currentUsage: integer("current_usage").notNull(),
+    limit: integer("limit").notNull(),
+    triggeredAt: timestamp("triggered_at"),
+    acknowledgedAt: timestamp("acknowledged_at"),
+    resolvedAt: timestamp("resolved_at"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (table) => ({
+    customerIdx: index("usage_alerts_customer_idx").on(table.customerId),
+    statusIdx: index("usage_alerts_status_idx").on(table.status)
+  })
+);
+
+// src/usage/drizzle-storage.ts
+function generateId2() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var DrizzleUsageStorage = class {
+  db;
+  constructor(config) {
+    this.db = config.db;
+  }
+  // ============================================================================
+  // Plans
+  // ============================================================================
+  async getPlan(planId) {
+    const rows = await this.db.select().from(plans).where(eq(plans.id, planId)).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    const features = await this.getPlanFeatures(planId);
+    return this.mapRowToPlan(row, features);
+  }
+  async getPlanByName(name) {
+    const rows = await this.db.select().from(plans).where(eq(plans.name, name)).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    const features = await this.getPlanFeatures(row.id);
+    return this.mapRowToPlan(row, features);
+  }
+  async listPlans(options) {
+    let query = this.db.select().from(plans);
+    if (options?.activeOnly) {
+      query = query.where(eq(plans.isActive, true));
+    }
+    const rows = await query;
+    const result = [];
+    for (const row of rows) {
+      const features = await this.getPlanFeatures(row.id);
+      result.push(this.mapRowToPlan(row, features));
+    }
+    return result;
+  }
+  mapRowToPlan(row, features) {
+    const plan = {
+      id: row.id,
+      name: row.name,
+      displayName: row.displayName,
+      description: row.description,
+      tier: row.tier,
+      basePrice: row.basePrice,
+      currency: row.currency,
+      billingInterval: row.billingInterval,
+      features,
+      isActive: row.isActive,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+    if (row.metadata !== null) {
+      plan.metadata = row.metadata;
+    }
+    return plan;
+  }
+  // ============================================================================
+  // Plan Features
+  // ============================================================================
+  async getPlanFeatures(planId) {
+    const rows = await this.db.select().from(planFeatures).where(eq(planFeatures.planId, planId));
+    return rows.map((row) => this.mapRowToPlanFeature(row));
+  }
+  async getFeatureLimit(planId, featureKey) {
+    const rows = await this.db.select().from(planFeatures).where(
+      and(
+        eq(planFeatures.planId, planId),
+        eq(planFeatures.featureKey, featureKey)
+      )
+    ).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    return this.mapRowToPlanFeature(row);
+  }
+  mapRowToPlanFeature(row) {
+    const feature = {
+      id: row.id,
+      planId: row.planId,
+      featureKey: row.featureKey,
+      limitValue: row.limitValue,
+      limitPeriod: row.limitPeriod,
+      isEnabled: row.isEnabled
+    };
+    if (row.metadata !== null) {
+      feature.metadata = row.metadata;
+    }
+    return feature;
+  }
+  // ============================================================================
+  // Customer-Plan Mapping
+  // ============================================================================
+  async getCustomerPlanId(customerId) {
+    const rows = await this.db.select({ planId: customerPlans.planId }).from(customerPlans).where(eq(customerPlans.customerId, customerId)).limit(1);
+    const row = rows[0];
+    return row ? row.planId : null;
+  }
+  async setCustomerPlanId(customerId, planId) {
+    await this.db.insert(customerPlans).values({
+      customerId,
+      planId,
+      assignedAt: /* @__PURE__ */ new Date()
+    }).onConflictDoUpdate({
+      target: customerPlans.customerId,
+      set: {
+        planId,
+        assignedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  // ============================================================================
+  // Usage Events
+  // ============================================================================
+  async recordUsage(event) {
+    const id = generateId2();
+    if (event.idempotencyKey) {
+      const existing = await this.db.select().from(usageEvents).where(eq(usageEvents.idempotencyKey, event.idempotencyKey)).limit(1);
+      const existingRow = existing[0];
+      if (existingRow) {
+        return this.mapRowToUsageEvent(existingRow);
+      }
+    }
+    const insertData = {
+      id,
+      tenantId: event.tenantId,
+      customerId: event.customerId,
+      featureKey: event.featureKey,
+      quantity: event.quantity,
+      timestamp: event.timestamp ?? /* @__PURE__ */ new Date()
+    };
+    if (event.subscriptionId !== void 0) {
+      insertData.subscriptionId = event.subscriptionId;
+    }
+    if (event.metadata !== void 0) {
+      insertData.metadata = event.metadata;
+    }
+    if (event.idempotencyKey !== void 0) {
+      insertData.idempotencyKey = event.idempotencyKey;
+    }
+    await this.db.insert(usageEvents).values(insertData);
+    return {
+      id,
+      ...event,
+      timestamp: event.timestamp ?? /* @__PURE__ */ new Date()
+    };
+  }
+  async recordUsageBatch(events) {
+    const results = [];
+    for (const event of events) {
+      results.push(await this.recordUsage(event));
+    }
+    return results;
+  }
+  async getUsageEvents(customerId, options) {
+    const conditions = [eq(usageEvents.customerId, customerId)];
+    if (options.featureKey) {
+      conditions.push(eq(usageEvents.featureKey, options.featureKey));
+    }
+    if (options.subscriptionId) {
+      conditions.push(eq(usageEvents.subscriptionId, options.subscriptionId));
+    }
+    if (options.startDate) {
+      conditions.push(gte(usageEvents.timestamp, options.startDate));
+    }
+    if (options.endDate) {
+      conditions.push(lte(usageEvents.timestamp, options.endDate));
+    }
+    const rows = await this.db.select().from(usageEvents).where(and(...conditions)).orderBy(usageEvents.timestamp);
+    return rows.map((row) => this.mapRowToUsageEvent(row));
+  }
+  mapRowToUsageEvent(row) {
+    const event = {
+      id: row.id,
+      tenantId: row.tenantId,
+      customerId: row.customerId,
+      featureKey: row.featureKey,
+      quantity: row.quantity,
+      timestamp: row.timestamp
+    };
+    if (row.subscriptionId !== null) {
+      event.subscriptionId = row.subscriptionId;
+    }
+    if (row.metadata !== null) {
+      event.metadata = row.metadata;
+    }
+    if (row.idempotencyKey !== null) {
+      event.idempotencyKey = row.idempotencyKey;
+    }
+    return event;
+  }
+  // ============================================================================
+  // Usage Aggregates
+  // ============================================================================
+  async getAggregate(customerId, featureKey, periodType, periodStart) {
+    const rows = await this.db.select().from(usageAggregates).where(
+      and(
+        eq(usageAggregates.customerId, customerId),
+        eq(usageAggregates.featureKey, featureKey),
+        eq(usageAggregates.periodType, periodType),
+        eq(usageAggregates.periodStart, periodStart)
+      )
+    ).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    return this.mapRowToUsageAggregate(row);
+  }
+  async upsertAggregate(aggregate) {
+    const id = generateId2();
+    const insertData = {
+      id,
+      tenantId: aggregate.tenantId,
+      customerId: aggregate.customerId,
+      featureKey: aggregate.featureKey,
+      periodStart: aggregate.periodStart,
+      periodEnd: aggregate.periodEnd,
+      periodType: aggregate.periodType,
+      totalQuantity: aggregate.totalQuantity,
+      eventCount: aggregate.eventCount,
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+    if (aggregate.subscriptionId !== void 0) {
+      insertData.subscriptionId = aggregate.subscriptionId;
+    }
+    await this.db.insert(usageAggregates).values(insertData).onConflictDoUpdate({
+      target: [
+        usageAggregates.customerId,
+        usageAggregates.featureKey,
+        usageAggregates.periodType,
+        usageAggregates.periodStart
+      ],
+      set: {
+        totalQuantity: aggregate.totalQuantity,
+        eventCount: aggregate.eventCount,
+        lastUpdated: /* @__PURE__ */ new Date()
+      }
+    });
+    return {
+      id,
+      ...aggregate,
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+  }
+  async getAggregates(customerId, options) {
+    const conditions = [eq(usageAggregates.customerId, customerId)];
+    if (options.featureKey) {
+      conditions.push(eq(usageAggregates.featureKey, options.featureKey));
+    }
+    if (options.periodType) {
+      conditions.push(eq(usageAggregates.periodType, options.periodType));
+    }
+    if (options.subscriptionId) {
+      conditions.push(
+        eq(usageAggregates.subscriptionId, options.subscriptionId)
+      );
+    }
+    if (options.startDate) {
+      conditions.push(gte(usageAggregates.periodStart, options.startDate));
+    }
+    if (options.endDate) {
+      conditions.push(lte(usageAggregates.periodEnd, options.endDate));
+    }
+    const rows = await this.db.select().from(usageAggregates).where(and(...conditions)).orderBy(usageAggregates.periodStart);
+    return rows.map((row) => this.mapRowToUsageAggregate(row));
+  }
+  async getCurrentPeriodUsage(customerId, featureKey, periodStart) {
+    const aggregate = await this.getAggregate(
+      customerId,
+      featureKey,
+      "month",
+      periodStart
+    );
+    if (aggregate) {
+      return aggregate.totalQuantity;
+    }
+    const result = await this.db.select({
+      total: sql`COALESCE(SUM(${usageEvents.quantity}), 0)`
+    }).from(usageEvents).where(
+      and(
+        eq(usageEvents.customerId, customerId),
+        eq(usageEvents.featureKey, featureKey),
+        gte(usageEvents.timestamp, periodStart)
+      )
+    );
+    return Number(result[0]?.total ?? 0);
+  }
+  mapRowToUsageAggregate(row) {
+    const aggregate = {
+      id: row.id,
+      tenantId: row.tenantId,
+      customerId: row.customerId,
+      featureKey: row.featureKey,
+      periodStart: row.periodStart,
+      periodEnd: row.periodEnd,
+      periodType: row.periodType,
+      totalQuantity: row.totalQuantity,
+      eventCount: row.eventCount,
+      lastUpdated: row.lastUpdated
+    };
+    if (row.subscriptionId !== null) {
+      aggregate.subscriptionId = row.subscriptionId;
+    }
+    return aggregate;
+  }
+  // ============================================================================
+  // Alerts
+  // ============================================================================
+  async createAlert(alert) {
+    const id = generateId2();
+    const createdAt = /* @__PURE__ */ new Date();
+    const insertData = {
+      id,
+      tenantId: alert.tenantId,
+      customerId: alert.customerId,
+      featureKey: alert.featureKey,
+      thresholdPercent: alert.thresholdPercent,
+      status: alert.status,
+      currentUsage: alert.currentUsage,
+      limit: alert.limit,
+      createdAt
+    };
+    if (alert.subscriptionId !== void 0) {
+      insertData.subscriptionId = alert.subscriptionId;
+    }
+    if (alert.triggeredAt !== void 0) {
+      insertData.triggeredAt = alert.triggeredAt;
+    }
+    if (alert.acknowledgedAt !== void 0) {
+      insertData.acknowledgedAt = alert.acknowledgedAt;
+    }
+    if (alert.resolvedAt !== void 0) {
+      insertData.resolvedAt = alert.resolvedAt;
+    }
+    if (alert.metadata !== void 0) {
+      insertData.metadata = alert.metadata;
+    }
+    await this.db.insert(usageAlerts).values(insertData);
+    return {
+      id,
+      ...alert,
+      createdAt
+    };
+  }
+  async getActiveAlerts(customerId) {
+    const rows = await this.db.select().from(usageAlerts).where(
+      and(
+        eq(usageAlerts.customerId, customerId),
+        inArray(usageAlerts.status, ["pending", "triggered"])
+      )
+    );
+    return rows.map((row) => this.mapRowToUsageAlert(row));
+  }
+  async updateAlertStatus(alertId, status) {
+    const updateData = { status };
+    if (status === "triggered") {
+      updateData.triggeredAt = /* @__PURE__ */ new Date();
+    } else if (status === "acknowledged") {
+      updateData.acknowledgedAt = /* @__PURE__ */ new Date();
+    } else if (status === "resolved") {
+      updateData.resolvedAt = /* @__PURE__ */ new Date();
+    }
+    await this.db.update(usageAlerts).set(updateData).where(eq(usageAlerts.id, alertId));
+  }
+  mapRowToUsageAlert(row) {
+    const alert = {
+      id: row.id,
+      tenantId: row.tenantId,
+      customerId: row.customerId,
+      featureKey: row.featureKey,
+      thresholdPercent: row.thresholdPercent,
+      status: row.status,
+      currentUsage: row.currentUsage,
+      limit: row.limit,
+      createdAt: row.createdAt
+    };
+    if (row.subscriptionId !== null) {
+      alert.subscriptionId = row.subscriptionId;
+    }
+    if (row.triggeredAt !== null) {
+      alert.triggeredAt = row.triggeredAt;
+    }
+    if (row.acknowledgedAt !== null) {
+      alert.acknowledgedAt = row.acknowledgedAt;
+    }
+    if (row.resolvedAt !== null) {
+      alert.resolvedAt = row.resolvedAt;
+    }
+    if (row.metadata !== null) {
+      alert.metadata = row.metadata;
+    }
+    return alert;
+  }
+  // ============================================================================
+  // Usage Reset
+  // ============================================================================
+  async resetUsage(customerId, featureKeys, periodStart) {
+    const eventConditions = [eq(usageEvents.customerId, customerId)];
+    const aggregateConditions = [eq(usageAggregates.customerId, customerId)];
+    if (featureKeys && featureKeys.length > 0) {
+      eventConditions.push(inArray(usageEvents.featureKey, featureKeys));
+      aggregateConditions.push(
+        inArray(usageAggregates.featureKey, featureKeys)
+      );
+    }
+    if (periodStart) {
+      eventConditions.push(gte(usageEvents.timestamp, periodStart));
+      aggregateConditions.push(gte(usageAggregates.periodStart, periodStart));
+    }
+    await this.db.delete(usageEvents).where(and(...eventConditions));
+    await this.db.delete(usageAggregates).where(and(...aggregateConditions));
+  }
+  async resetAggregates(customerId, featureKeys) {
+    const conditions = [eq(usageAggregates.customerId, customerId)];
+    if (featureKeys && featureKeys.length > 0) {
+      conditions.push(inArray(usageAggregates.featureKey, featureKeys));
+    }
+    await this.db.delete(usageAggregates).where(and(...conditions));
+  }
+  // ============================================================================
+  // Access Status
+  // ============================================================================
+  async getAccessStatus(customerId) {
+    const rows = await this.db.select().from(customerAccessStatus).where(eq(customerAccessStatus.customerId, customerId)).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    const status = {
+      status: row.status,
+      updatedAt: row.updatedAt
+    };
+    if (row.reason !== null) {
+      status.reason = row.reason;
+    }
+    if (row.suspensionDate !== null) {
+      status.suspensionDate = row.suspensionDate;
+    }
+    if (row.failedPaymentAttempts !== null) {
+      status.failedPaymentAttempts = row.failedPaymentAttempts;
+    }
+    if (row.gracePeriodEnd !== null) {
+      status.gracePeriodEnd = row.gracePeriodEnd;
+    }
+    return status;
+  }
+  async setAccessStatus(customerId, status) {
+    const insertData = {
+      customerId,
+      status: status.status,
+      updatedAt: status.updatedAt
+    };
+    if (status.reason !== void 0) {
+      insertData.reason = status.reason;
+    }
+    if (status.suspensionDate !== void 0) {
+      insertData.suspensionDate = status.suspensionDate;
+    }
+    if (status.failedPaymentAttempts !== void 0) {
+      insertData.failedPaymentAttempts = status.failedPaymentAttempts;
+    }
+    if (status.gracePeriodEnd !== void 0) {
+      insertData.gracePeriodEnd = status.gracePeriodEnd;
+    }
+    await this.db.insert(customerAccessStatus).values(insertData).onConflictDoUpdate({
+      target: customerAccessStatus.customerId,
+      set: {
+        status: status.status,
+        reason: status.reason ?? null,
+        suspensionDate: status.suspensionDate ?? null,
+        failedPaymentAttempts: status.failedPaymentAttempts ?? null,
+        gracePeriodEnd: status.gracePeriodEnd ?? null,
+        updatedAt: status.updatedAt
+      }
+    });
+  }
+  // ============================================================================
+  // Billing Cycle
+  // ============================================================================
+  async getBillingCycle(customerId) {
+    const rows = await this.db.select().from(customerBillingCycles).where(eq(customerBillingCycles.customerId, customerId)).limit(1);
+    const row = rows[0];
+    if (!row) return null;
+    return {
+      start: row.periodStart,
+      end: row.periodEnd
+    };
+  }
+  async setBillingCycle(customerId, start, end) {
+    await this.db.insert(customerBillingCycles).values({
+      customerId,
+      periodStart: start,
+      periodEnd: end,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).onConflictDoUpdate({
+      target: customerBillingCycles.customerId,
+      set: {
+        periodStart: start,
+        periodEnd: end,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    });
+  }
+  // ============================================================================
+  // Admin Methods (for setup)
+  // ============================================================================
+  /**
+   * Create or update a plan
+   */
+  async upsertPlan(plan) {
+    const now = /* @__PURE__ */ new Date();
+    await this.db.insert(plans).values({
+      id: plan.id,
+      name: plan.name,
+      displayName: plan.displayName,
+      description: plan.description,
+      tier: plan.tier,
+      basePrice: plan.basePrice,
+      currency: plan.currency,
+      billingInterval: plan.billingInterval,
+      isActive: plan.isActive,
+      metadata: plan.metadata,
+      createdAt: now,
+      updatedAt: now
+    }).onConflictDoUpdate({
+      target: plans.id,
+      set: {
+        name: plan.name,
+        displayName: plan.displayName,
+        description: plan.description,
+        tier: plan.tier,
+        basePrice: plan.basePrice,
+        currency: plan.currency,
+        billingInterval: plan.billingInterval,
+        isActive: plan.isActive,
+        metadata: plan.metadata,
+        updatedAt: now
+      }
+    });
+    await this.db.delete(planFeatures).where(eq(planFeatures.planId, plan.id));
+    for (const feature of plan.features) {
+      await this.db.insert(planFeatures).values({
+        id: feature.id || generateId2(),
+        planId: plan.id,
+        featureKey: feature.featureKey,
+        limitValue: feature.limitValue,
+        limitPeriod: feature.limitPeriod,
+        isEnabled: feature.isEnabled,
+        metadata: feature.metadata
+      });
+    }
+    return {
+      ...plan,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  /**
+   * Delete a plan
+   */
+  async deletePlan(planId) {
+    await this.db.delete(plans).where(eq(plans.id, planId));
+  }
+};
+function createDrizzleUsageStorage(config) {
+  return new DrizzleUsageStorage(config);
+}
+
+// src/usage/quota-manager.ts
+var nullLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+function getPeriodBoundaries(limitPeriod) {
+  const now = /* @__PURE__ */ new Date();
+  switch (limitPeriod) {
+    case "hour": {
+      const start = new Date(now);
+      start.setMinutes(0, 0, 0);
+      const end = new Date(start);
+      end.setHours(end.getHours() + 1);
+      return { start, end };
+    }
+    case "day": {
+      const start = new Date(now);
+      start.setHours(0, 0, 0, 0);
+      const end = new Date(start);
+      end.setDate(end.getDate() + 1);
+      return { start, end };
+    }
+    case "month":
+    default: {
+      const start = new Date(now.getFullYear(), now.getMonth(), 1);
+      const end = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+      return { start, end };
+    }
+  }
+}
+var QuotaManager = class {
+  storage;
+  logger;
+  softLimits;
+  gracePercent;
+  overageAllowedFeatures;
+  onOverage;
+  constructor(config) {
+    this.storage = config.storage;
+    this.logger = config.logger ?? nullLogger;
+    this.softLimits = config.softLimits ?? false;
+    this.gracePercent = config.gracePercent ?? 0;
+    this.overageAllowedFeatures = config.overageAllowedFeatures ?? null;
+    if (config.onOverage !== void 0) {
+      this.onOverage = config.onOverage;
+    }
+  }
+  /**
+   * Check if overage is allowed for a feature
+   */
+  isOverageAllowed(featureKey) {
+    if (!this.softLimits) return false;
+    if (this.overageAllowedFeatures === null) return true;
+    return this.overageAllowedFeatures.includes(featureKey);
+  }
+  /**
+   * Check if quota allows the requested quantity
+   */
+  async checkQuota(customerId, featureKey, requestedQuantity = 1) {
+    const planId = await this.storage.getCustomerPlanId(customerId);
+    if (!planId) {
+      return {
+        allowed: true,
+        currentUsage: 0,
+        limit: null,
+        remaining: null,
+        wouldExceed: false,
+        percentAfter: null
+      };
+    }
+    const feature = await this.storage.getFeatureLimit(planId, featureKey);
+    if (!feature) {
+      return {
+        allowed: true,
+        currentUsage: 0,
+        limit: null,
+        remaining: null,
+        wouldExceed: false,
+        percentAfter: null
+      };
+    }
+    if (!feature.isEnabled) {
+      return {
+        allowed: false,
+        currentUsage: 0,
+        limit: 0,
+        remaining: 0,
+        wouldExceed: true,
+        percentAfter: 100
+      };
+    }
+    if (feature.limitValue === null) {
+      return {
+        allowed: true,
+        currentUsage: 0,
+        limit: null,
+        remaining: null,
+        wouldExceed: false,
+        percentAfter: null
+      };
+    }
+    const { start } = getPeriodBoundaries(feature.limitPeriod);
+    const currentUsage = await this.storage.getCurrentPeriodUsage(
+      customerId,
+      featureKey,
+      start
+    );
+    const effectiveLimit = Math.ceil(feature.limitValue * (1 + this.gracePercent / 100));
+    const usageAfter = currentUsage + requestedQuantity;
+    const wouldExceed = usageAfter > effectiveLimit;
+    const percentAfter = Math.round(usageAfter / feature.limitValue * 100);
+    const overageAllowed = this.isOverageAllowed(featureKey);
+    const allowed = overageAllowed ? true : !wouldExceed;
+    this.logger.debug("Quota check", {
+      customerId,
+      featureKey,
+      currentUsage,
+      requestedQuantity,
+      limit: feature.limitValue,
+      effectiveLimit,
+      allowed,
+      wouldExceed
+    });
+    return {
+      allowed,
+      currentUsage,
+      limit: feature.limitValue,
+      remaining: Math.max(0, feature.limitValue - currentUsage),
+      wouldExceed,
+      percentAfter
+    };
+  }
+  /**
+   * Enforce quota - throws if exceeded
+   */
+  async enforceQuota(customerId, featureKey, requestedQuantity = 1) {
+    const result = await this.checkQuota(customerId, featureKey, requestedQuantity);
+    if (!result.allowed) {
+      this.logger.warn("Quota exceeded", {
+        customerId,
+        featureKey,
+        currentUsage: result.currentUsage,
+        limit: result.limit,
+        requestedQuantity
+      });
+      throw new QuotaExceededError(
+        featureKey,
+        result.limit,
+        result.currentUsage,
+        requestedQuantity
+      );
+    }
+  }
+  /**
+   * Get quota status for a feature
+   */
+  async getQuotaStatus(customerId, featureKey) {
+    const planId = await this.storage.getCustomerPlanId(customerId);
+    if (!planId) {
+      const now = /* @__PURE__ */ new Date();
+      return {
+        featureKey,
+        limit: null,
+        used: 0,
+        remaining: null,
+        percentUsed: null,
+        periodStart: new Date(now.getFullYear(), now.getMonth(), 1),
+        periodEnd: new Date(now.getFullYear(), now.getMonth() + 1, 1),
+        isExceeded: false,
+        isUnlimited: true
+      };
+    }
+    const feature = await this.storage.getFeatureLimit(planId, featureKey);
+    if (!feature) {
+      const now = /* @__PURE__ */ new Date();
+      return {
+        featureKey,
+        limit: null,
+        used: 0,
+        remaining: null,
+        percentUsed: null,
+        periodStart: new Date(now.getFullYear(), now.getMonth(), 1),
+        periodEnd: new Date(now.getFullYear(), now.getMonth() + 1, 1),
+        isExceeded: false,
+        isUnlimited: true
+      };
+    }
+    const { start, end } = getPeriodBoundaries(feature.limitPeriod);
+    const used = await this.storage.getCurrentPeriodUsage(customerId, featureKey, start);
+    const isUnlimited = feature.limitValue === null;
+    const limit = feature.limitValue;
+    const remaining = isUnlimited ? null : Math.max(0, limit - used);
+    const percentUsed = isUnlimited ? null : Math.round(used / limit * 100);
+    const isExceeded = !isUnlimited && used >= limit;
+    const overageAllowed = this.isOverageAllowed(featureKey);
+    const overage = isUnlimited ? void 0 : used > limit ? used - limit : void 0;
+    if (overage !== void 0 && overage > 0 && overageAllowed && this.onOverage) {
+      try {
+        await this.onOverage(customerId, featureKey, overage, limit);
+      } catch (error) {
+        this.logger.error("Overage callback failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    const result = {
+      featureKey,
+      limit,
+      used,
+      remaining,
+      percentUsed,
+      periodStart: start,
+      periodEnd: end,
+      isExceeded,
+      isUnlimited
+    };
+    if (overage !== void 0) {
+      result.overage = overage;
+    }
+    if (overageAllowed) {
+      result.overageAllowed = true;
+    }
+    return result;
+  }
+  /**
+   * Get all quota statuses for a customer
+   */
+  async getAllQuotas(customerId) {
+    const planId = await this.storage.getCustomerPlanId(customerId);
+    if (!planId) return [];
+    const features = await this.storage.getPlanFeatures(planId);
+    const quotas = [];
+    for (const feature of features) {
+      const status = await this.getQuotaStatus(customerId, feature.featureKey);
+      quotas.push(status);
+    }
+    return quotas;
+  }
+  /**
+   * Check if any quota is exceeded
+   */
+  async hasExceededQuotas(customerId) {
+    const quotas = await this.getAllQuotas(customerId);
+    return quotas.some((q) => q.isExceeded);
+  }
+  /**
+   * Get exceeded quotas
+   */
+  async getExceededQuotas(customerId) {
+    const quotas = await this.getAllQuotas(customerId);
+    return quotas.filter((q) => q.isExceeded);
+  }
+};
+function createQuotaManager(config) {
+  return new QuotaManager(config);
+}
+
+// src/usage/usage-tracker.ts
+var nullLogger2 = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+function getPeriodStart(timestamp2, periodType) {
+  const date = new Date(timestamp2);
+  switch (periodType) {
+    case "hour":
+      date.setMinutes(0, 0, 0);
+      return date;
+    case "day":
+      date.setHours(0, 0, 0, 0);
+      return date;
+    case "month":
+      return new Date(date.getFullYear(), date.getMonth(), 1);
+  }
+}
+function getPeriodEnd(periodStart, periodType) {
+  const date = new Date(periodStart);
+  switch (periodType) {
+    case "hour":
+      date.setHours(date.getHours() + 1);
+      return date;
+    case "day":
+      date.setDate(date.getDate() + 1);
+      return date;
+    case "month":
+      return new Date(date.getFullYear(), date.getMonth() + 1, 1);
+  }
+}
+var UsageTracker = class {
+  storage;
+  logger;
+  aggregateOnRecord;
+  alertThresholds;
+  onThresholdReached;
+  constructor(config) {
+    this.storage = config.storage;
+    this.logger = config.logger ?? nullLogger2;
+    this.aggregateOnRecord = config.aggregateOnRecord ?? true;
+    this.alertThresholds = config.alertThresholds ?? [80, 100];
+    if (config.onThresholdReached !== void 0) {
+      this.onThresholdReached = config.onThresholdReached;
+    }
+  }
+  /**
+   * Track a usage event
+   */
+  async trackUsage(options) {
+    const timestamp2 = options.timestamp ?? /* @__PURE__ */ new Date();
+    const quantity = options.quantity ?? 1;
+    this.logger.debug("Recording usage", {
+      customerId: options.customerId,
+      featureKey: options.featureKey,
+      quantity
+    });
+    const eventData = {
+      tenantId: options.tenantId,
+      customerId: options.customerId,
+      featureKey: options.featureKey,
+      quantity,
+      timestamp: timestamp2
+    };
+    if (options.subscriptionId !== void 0) {
+      eventData.subscriptionId = options.subscriptionId;
+    }
+    if (options.metadata !== void 0) {
+      eventData.metadata = options.metadata;
+    }
+    if (options.idempotencyKey !== void 0) {
+      eventData.idempotencyKey = options.idempotencyKey;
+    }
+    const event = await this.storage.recordUsage(eventData);
+    if (this.aggregateOnRecord) {
+      await this.updateAggregates(event);
+    }
+    await this.checkThresholds(options.customerId, options.featureKey);
+    return event;
+  }
+  /**
+   * Track multiple usage events
+   */
+  async trackBatch(events) {
+    const results = [];
+    for (const event of events) {
+      const result = await this.trackUsage(event);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Update aggregates for an event
+   */
+  async updateAggregates(event) {
+    const periodTypes = ["hour", "day", "month"];
+    for (const periodType of periodTypes) {
+      const periodStart = getPeriodStart(event.timestamp, periodType);
+      const periodEnd = getPeriodEnd(periodStart, periodType);
+      const existing = await this.storage.getAggregate(
+        event.customerId,
+        event.featureKey,
+        periodType,
+        periodStart
+      );
+      const aggregateData = {
+        tenantId: event.tenantId,
+        customerId: event.customerId,
+        featureKey: event.featureKey,
+        periodStart,
+        periodEnd,
+        periodType,
+        totalQuantity: (existing?.totalQuantity ?? 0) + event.quantity,
+        eventCount: (existing?.eventCount ?? 0) + 1,
+        lastUpdated: /* @__PURE__ */ new Date()
+      };
+      if (event.subscriptionId !== void 0) {
+        aggregateData.subscriptionId = event.subscriptionId;
+      }
+      await this.storage.upsertAggregate(aggregateData);
+    }
+  }
+  /**
+   * Check thresholds and create alerts if needed
+   */
+  async checkThresholds(customerId, featureKey) {
+    const planId = await this.storage.getCustomerPlanId(customerId);
+    if (!planId) return;
+    const feature = await this.storage.getFeatureLimit(planId, featureKey);
+    if (!feature || feature.limitValue === null) return;
+    const periodStart = getPeriodStart(/* @__PURE__ */ new Date(), "month");
+    const currentUsage = await this.storage.getCurrentPeriodUsage(
+      customerId,
+      featureKey,
+      periodStart
+    );
+    const percentUsed = Math.round(currentUsage / feature.limitValue * 100);
+    const activeAlerts = await this.storage.getActiveAlerts(customerId);
+    const alertedThresholds = new Set(
+      activeAlerts.filter((a) => a.featureKey === featureKey).map((a) => a.thresholdPercent)
+    );
+    for (const threshold of this.alertThresholds) {
+      if (percentUsed >= threshold && !alertedThresholds.has(threshold)) {
+        const alert = await this.storage.createAlert({
+          tenantId: "",
+          // Will be filled from customer
+          customerId,
+          featureKey,
+          thresholdPercent: threshold,
+          status: "triggered",
+          currentUsage,
+          limit: feature.limitValue,
+          triggeredAt: /* @__PURE__ */ new Date()
+        });
+        this.logger.info("Usage threshold reached", {
+          customerId,
+          featureKey,
+          threshold,
+          percentUsed,
+          currentUsage,
+          limit: feature.limitValue
+        });
+        if (this.onThresholdReached) {
+          try {
+            await this.onThresholdReached(alert);
+          } catch (error) {
+            this.logger.error("Threshold callback failed", {
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Get usage for a customer
+   */
+  async getUsage(customerId, featureKey, periodType = "month") {
+    const periodStart = getPeriodStart(/* @__PURE__ */ new Date(), periodType);
+    return this.storage.getCurrentPeriodUsage(customerId, featureKey, periodStart);
+  }
+  /**
+   * Get usage aggregates
+   */
+  async getAggregates(customerId, featureKey, periodType, startDate, endDate) {
+    const options = {
+      featureKey,
+      periodType
+    };
+    if (startDate !== void 0) {
+      options.startDate = startDate;
+    }
+    if (endDate !== void 0) {
+      options.endDate = endDate;
+    }
+    return this.storage.getAggregates(customerId, options);
+  }
+  /**
+   * Force aggregate recalculation for a period
+   */
+  async recalculateAggregates(customerId, featureKey, periodType, periodStart) {
+    const periodEnd = getPeriodEnd(periodStart, periodType);
+    const events = await this.storage.getUsageEvents(customerId, {
+      featureKey,
+      startDate: periodStart,
+      endDate: periodEnd
+    });
+    const totalQuantity = events.reduce((sum, e) => sum + e.quantity, 0);
+    const eventCount = events.length;
+    const tenantId = events[0]?.tenantId ?? "";
+    const subscriptionId = events[0]?.subscriptionId;
+    const aggregateData = {
+      tenantId,
+      customerId,
+      featureKey,
+      periodStart,
+      periodEnd,
+      periodType,
+      totalQuantity,
+      eventCount,
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+    if (subscriptionId !== void 0) {
+      aggregateData.subscriptionId = subscriptionId;
+    }
+    return this.storage.upsertAggregate(aggregateData);
+  }
+};
+function createUsageTracker(config) {
+  return new UsageTracker(config);
+}
+
+// src/usage/lifecycle-hooks.ts
+var nullLogger3 = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var SubscriptionLifecycle = class {
+  handlers;
+  logger;
+  constructor(logger) {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.logger = logger ?? nullLogger3;
+  }
+  /**
+   * Register an event handler
+   */
+  on(event, handler) {
+    const handlers = this.handlers.get(event) ?? [];
+    handlers.push(handler);
+    this.handlers.set(event, handlers);
+    this.logger.debug("Lifecycle handler registered", { event });
+    return this;
+  }
+  /**
+   * Remove an event handler
+   */
+  off(event, handler) {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      const index2 = handlers.indexOf(handler);
+      if (index2 !== -1) {
+        handlers.splice(index2, 1);
+      }
+    }
+    return this;
+  }
+  /**
+   * Emit an event to all handlers
+   */
+  async emit(event) {
+    this.logger.info("Lifecycle event", {
+      type: event.type,
+      subscriptionId: event.subscription.id,
+      provider: event.provider
+    });
+    const specificHandlers = this.handlers.get(event.type) ?? [];
+    const wildcardHandlers = this.handlers.get("*") ?? [];
+    const allHandlers = [...specificHandlers, ...wildcardHandlers];
+    const results = await Promise.allSettled(
+      allHandlers.map((handler) => handler(event))
+    );
+    for (const result of results) {
+      if (result.status === "rejected") {
+        this.logger.error("Lifecycle handler failed", {
+          type: event.type,
+          error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+        });
+      }
+    }
+  }
+  /**
+   * Check if there are handlers for an event
+   */
+  hasHandlers(event) {
+    const handlers = this.handlers.get(event);
+    return handlers !== void 0 && handlers.length > 0;
+  }
+  /**
+   * Get handler count for an event
+   */
+  handlerCount(event) {
+    return this.handlers.get(event)?.length ?? 0;
+  }
+  /**
+   * Clear all handlers
+   */
+  clear() {
+    this.handlers.clear();
+  }
+  // ============================================================================
+  // Convenience Methods
+  // ============================================================================
+  /**
+   * Handle subscription created
+   */
+  onCreated(handler) {
+    return this.on("subscription.created", handler);
+  }
+  /**
+   * Handle subscription activated
+   */
+  onActivated(handler) {
+    return this.on("subscription.activated", handler);
+  }
+  /**
+   * Handle subscription updated
+   */
+  onUpdated(handler) {
+    return this.on("subscription.updated", handler);
+  }
+  /**
+   * Handle plan changed
+   */
+  onPlanChanged(handler) {
+    return this.on("subscription.plan_changed", handler);
+  }
+  /**
+   * Handle subscription canceled
+   */
+  onCanceled(handler) {
+    return this.on("subscription.canceled", handler);
+  }
+  /**
+   * Handle subscription expired
+   */
+  onExpired(handler) {
+    return this.on("subscription.expired", handler);
+  }
+  /**
+   * Handle subscription renewed
+   */
+  onRenewed(handler) {
+    return this.on("subscription.renewed", handler);
+  }
+  /**
+   * Handle trial started
+   */
+  onTrialStarted(handler) {
+    return this.on("subscription.trial_started", handler);
+  }
+  /**
+   * Handle trial ended
+   */
+  onTrialEnded(handler) {
+    return this.on("subscription.trial_ended", handler);
+  }
+  /**
+   * Handle payment failed
+   */
+  onPaymentFailed(handler) {
+    return this.on("subscription.payment_failed", handler);
+  }
+  /**
+   * Handle payment succeeded
+   */
+  onPaymentSucceeded(handler) {
+    return this.on("subscription.payment_succeeded", handler);
+  }
+  /**
+   * Handle period reset
+   */
+  onPeriodReset(handler) {
+    return this.on("subscription.period_reset", handler);
+  }
+  /**
+   * Handle all events
+   */
+  onAll(handler) {
+    return this.on("*", handler);
+  }
+};
+function createSubscriptionLifecycle(logger) {
+  return new SubscriptionLifecycle(logger);
+}
+
+// src/usage/usage-service.ts
+var nullLogger4 = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var UsageService = class {
+  storage;
+  logger;
+  quotaManager;
+  usageTracker;
+  lifecycle;
+  limitExceededHandler;
+  resetPeriod;
+  autoResetOnRenewal;
+  paymentGraceDays;
+  maxFailedPayments;
+  accessStatusChangedHandler;
+  periodResetHandler;
+  constructor(config) {
+    this.storage = config.storage;
+    this.logger = config.logger ?? nullLogger4;
+    this.resetPeriod = config.resetPeriod ?? "monthly";
+    this.autoResetOnRenewal = config.autoResetOnRenewal ?? true;
+    this.paymentGraceDays = config.paymentGraceDays ?? 3;
+    this.maxFailedPayments = config.maxFailedPayments ?? 3;
+    if (config.onAccessStatusChanged !== void 0) {
+      this.accessStatusChangedHandler = config.onAccessStatusChanged;
+    }
+    if (config.onPeriodReset !== void 0) {
+      this.periodResetHandler = config.onPeriodReset;
+    }
+    if (config.onLimitExceeded !== void 0) {
+      this.limitExceededHandler = config.onLimitExceeded;
+    }
+    const quotaManagerConfig = {
+      storage: config.storage
+    };
+    if (config.logger !== void 0) {
+      quotaManagerConfig.logger = config.logger;
+    }
+    this.quotaManager = new QuotaManager(quotaManagerConfig);
+    const usageTrackerConfig = {
+      storage: config.storage,
+      aggregateOnRecord: config.aggregateImmediately ?? true,
+      alertThresholds: config.alertThresholds ?? [80, 100]
+    };
+    if (config.logger !== void 0) {
+      usageTrackerConfig.logger = config.logger;
+    }
+    if (config.onThresholdReached !== void 0) {
+      usageTrackerConfig.onThresholdReached = config.onThresholdReached;
+    }
+    this.usageTracker = new UsageTracker(usageTrackerConfig);
+    this.lifecycle = config.logger !== void 0 ? new SubscriptionLifecycle(config.logger) : new SubscriptionLifecycle();
+    this.logger.info("UsageService initialized");
+  }
+  // ============================================================================
+  // Usage Tracking
+  // ============================================================================
+  /**
+   * Track a usage event
+   */
+  async trackUsage(options) {
+    return this.usageTracker.trackUsage(options);
+  }
+  /**
+   * Track multiple usage events
+   */
+  async trackBatch(events) {
+    return this.usageTracker.trackBatch(events);
+  }
+  /**
+   * Get current usage for a feature
+   */
+  async getUsage(customerId, featureKey, periodType = "month") {
+    return this.usageTracker.getUsage(customerId, featureKey, periodType);
+  }
+  /**
+   * Get usage aggregates
+   */
+  async getAggregates(customerId, options = {}) {
+    return this.storage.getAggregates(customerId, options);
+  }
+  // ============================================================================
+  // Quota Management
+  // ============================================================================
+  /**
+   * Check if quota allows the requested quantity
+   */
+  async checkQuota(customerId, featureKey, quantity = 1) {
+    return this.quotaManager.checkQuota(customerId, featureKey, quantity);
+  }
+  /**
+   * Enforce quota - throws if exceeded
+   */
+  async enforceQuota(customerId, featureKey, quantity = 1) {
+    return this.quotaManager.enforceQuota(customerId, featureKey, quantity);
+  }
+  /**
+   * Get quota status for a feature
+   */
+  async getQuotaStatus(customerId, featureKey) {
+    const status = await this.quotaManager.getQuotaStatus(customerId, featureKey);
+    if (status.isExceeded && this.limitExceededHandler) {
+      try {
+        await this.limitExceededHandler(status, customerId);
+      } catch (error) {
+        this.logger.error("Limit exceeded callback failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return status;
+  }
+  /**
+   * Get all quota statuses for a customer
+   */
+  async getAllQuotas(customerId) {
+    return this.quotaManager.getAllQuotas(customerId);
+  }
+  /**
+   * Check if any quota is exceeded
+   */
+  async hasExceededQuotas(customerId) {
+    return this.quotaManager.hasExceededQuotas(customerId);
+  }
+  // ============================================================================
+  // Plan Management
+  // ============================================================================
+  /**
+   * Get customer's current plan
+   */
+  async getCustomerPlan(customerId) {
+    const planId = await this.storage.getCustomerPlanId(customerId);
+    if (!planId) return null;
+    return this.storage.getPlan(planId);
+  }
+  /**
+   * Set customer's plan
+   */
+  async setCustomerPlan(customerId, planId) {
+    this.logger.info("Setting customer plan", { customerId, planId });
+    await this.storage.setCustomerPlanId(customerId, planId);
+  }
+  /**
+   * Get plan by ID
+   */
+  async getPlan(planId) {
+    return this.storage.getPlan(planId);
+  }
+  /**
+   * Get plan by name
+   */
+  async getPlanByName(name) {
+    return this.storage.getPlanByName(name);
+  }
+  /**
+   * List all plans
+   */
+  async listPlans(options) {
+    return this.storage.listPlans(options);
+  }
+  /**
+   * Get plan features
+   */
+  async getPlanFeatures(planId) {
+    return this.storage.getPlanFeatures(planId);
+  }
+  // ============================================================================
+  // Subscription Lifecycle
+  // ============================================================================
+  /**
+   * Register a subscription event handler
+   */
+  on(event, handler) {
+    this.lifecycle.on(event, handler);
+    return this;
+  }
+  /**
+   * Remove a subscription event handler
+   */
+  off(event, handler) {
+    this.lifecycle.off(event, handler);
+    return this;
+  }
+  /**
+   * Handle subscription created
+   */
+  onSubscriptionCreated(handler) {
+    this.lifecycle.onCreated(handler);
+    return this;
+  }
+  /**
+   * Handle subscription updated
+   */
+  onSubscriptionUpdated(handler) {
+    this.lifecycle.onUpdated(handler);
+    return this;
+  }
+  /**
+   * Handle subscription canceled
+   */
+  onSubscriptionCanceled(handler) {
+    this.lifecycle.onCanceled(handler);
+    return this;
+  }
+  /**
+   * Handle plan changed
+   */
+  onPlanChanged(handler) {
+    this.lifecycle.onPlanChanged(handler);
+    return this;
+  }
+  /**
+   * Handle subscription renewed
+   */
+  onRenewed(handler) {
+    this.lifecycle.onRenewed(handler);
+    return this;
+  }
+  /**
+   * Handle payment failed
+   */
+  onPaymentFailed(handler) {
+    this.lifecycle.onPaymentFailed(handler);
+    return this;
+  }
+  /**
+   * Handle period reset
+   */
+  onPeriodReset(handler) {
+    this.lifecycle.onPeriodReset(handler);
+    return this;
+  }
+  /**
+   * Get the lifecycle manager for advanced usage
+   */
+  get lifecycleManager() {
+    return this.lifecycle;
+  }
+  // ============================================================================
+  // Alerts
+  // ============================================================================
+  /**
+   * Get active alerts for a customer
+   */
+  async getActiveAlerts(customerId) {
+    return this.storage.getActiveAlerts(customerId);
+  }
+  /**
+   * Acknowledge an alert
+   */
+  async acknowledgeAlert(alertId) {
+    await this.storage.updateAlertStatus(alertId, "acknowledged");
+  }
+  /**
+   * Resolve an alert
+   */
+  async resolveAlert(alertId) {
+    await this.storage.updateAlertStatus(alertId, "resolved");
+  }
+  // ============================================================================
+  // Usage Reset
+  // ============================================================================
+  /**
+   * Reset usage for a customer
+   * Typically called on subscription renewal
+   */
+  async resetUsage(customerId, featureKeys) {
+    this.logger.info("Resetting usage", { customerId, featureKeys });
+    const periodStart = await this.getResetPeriodStart(customerId);
+    await this.storage.resetUsage(customerId, featureKeys, periodStart);
+    if (this.periodResetHandler) {
+      const features = featureKeys ?? await this.getCustomerFeatureKeys(customerId);
+      for (const featureKey of features) {
+        try {
+          await this.periodResetHandler(customerId, featureKey);
+        } catch (error) {
+          this.logger.error("Period reset callback failed", {
+            customerId,
+            featureKey,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+    const plan = await this.getCustomerPlan(customerId);
+    if (plan) {
+      await this.lifecycle.emit({
+        type: "subscription.period_reset",
+        subscription: {
+          id: "",
+          customerId,
+          status: "active",
+          priceId: "",
+          currentPeriodStart: periodStart,
+          currentPeriodEnd: /* @__PURE__ */ new Date(),
+          cancelAtPeriodEnd: false,
+          provider: "stripe"
+          // Default, will be overridden by BillingIntegration
+        },
+        newPlan: plan,
+        timestamp: /* @__PURE__ */ new Date(),
+        provider: "stripe"
+      });
+    }
+    this.logger.info("Usage reset complete", { customerId });
+  }
+  /**
+   * Get the period start date based on reset period setting
+   */
+  async getResetPeriodStart(customerId) {
+    if (this.resetPeriod === "billing_cycle") {
+      const billingCycle = await this.storage.getBillingCycle(customerId);
+      if (billingCycle) {
+        return billingCycle.start;
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    return new Date(now.getFullYear(), now.getMonth(), 1);
+  }
+  /**
+   * Get feature keys for a customer's plan
+   */
+  async getCustomerFeatureKeys(customerId) {
+    const planId = await this.storage.getCustomerPlanId(customerId);
+    if (!planId) return [];
+    const features = await this.storage.getPlanFeatures(planId);
+    return features.map((f) => f.featureKey);
+  }
+  /**
+   * Check if auto-reset on renewal is enabled
+   */
+  get autoResetEnabled() {
+    return this.autoResetOnRenewal;
+  }
+  /**
+   * Get current reset period setting
+   */
+  get currentResetPeriod() {
+    return this.resetPeriod;
+  }
+  // ============================================================================
+  // Access Status
+  // ============================================================================
+  /**
+   * Get customer access status
+   */
+  async getAccessStatus(customerId) {
+    const status = await this.storage.getAccessStatus(customerId);
+    if (status) {
+      return status;
+    }
+    return {
+      status: "active",
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Set customer access status
+   */
+  async setAccessStatus(customerId, status, options) {
+    const previousStatusInfo = await this.storage.getAccessStatus(customerId);
+    const previousStatus = previousStatusInfo?.status;
+    const newStatus = {
+      status,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    if (options?.reason !== void 0) {
+      newStatus.reason = options.reason;
+    }
+    if (options?.suspensionDate !== void 0) {
+      newStatus.suspensionDate = options.suspensionDate;
+    }
+    if (options?.failedPaymentAttempts !== void 0) {
+      newStatus.failedPaymentAttempts = options.failedPaymentAttempts;
+    }
+    if (options?.gracePeriodEnd !== void 0) {
+      newStatus.gracePeriodEnd = options.gracePeriodEnd;
+    }
+    await this.storage.setAccessStatus(customerId, newStatus);
+    this.logger.info("Access status changed", {
+      customerId,
+      previousStatus,
+      newStatus: status,
+      reason: options?.reason
+    });
+    if (this.accessStatusChangedHandler) {
+      try {
+        await this.accessStatusChangedHandler(customerId, newStatus, previousStatus);
+      } catch (error) {
+        this.logger.error("Access status change callback failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  /**
+   * Handle payment failure - update access status
+   */
+  async handlePaymentFailure(customerId) {
+    const currentStatus = await this.getAccessStatus(customerId);
+    const failedAttempts = (currentStatus.failedPaymentAttempts ?? 0) + 1;
+    if (failedAttempts >= this.maxFailedPayments) {
+      await this.setAccessStatus(customerId, "suspended", {
+        reason: `Payment failed ${failedAttempts} times`,
+        failedPaymentAttempts: failedAttempts
+      });
+    } else {
+      const gracePeriodEnd = /* @__PURE__ */ new Date();
+      gracePeriodEnd.setDate(gracePeriodEnd.getDate() + this.paymentGraceDays);
+      await this.setAccessStatus(customerId, "past_due", {
+        reason: `Payment failed (attempt ${failedAttempts}/${this.maxFailedPayments})`,
+        failedPaymentAttempts: failedAttempts,
+        gracePeriodEnd,
+        suspensionDate: gracePeriodEnd
+      });
+    }
+  }
+  /**
+   * Handle successful payment - restore access status
+   */
+  async handlePaymentSuccess(customerId) {
+    const currentStatus = await this.getAccessStatus(customerId);
+    if (currentStatus.status !== "active") {
+      await this.setAccessStatus(customerId, "active", {
+        reason: "Payment successful",
+        failedPaymentAttempts: 0
+      });
+    }
+  }
+  /**
+   * Check if customer has access (not suspended/canceled)
+   */
+  async hasAccess(customerId) {
+    const status = await this.getAccessStatus(customerId);
+    return status.status === "active" || status.status === "past_due";
+  }
+  /**
+   * Check if customer is in grace period
+   */
+  async isInGracePeriod(customerId) {
+    const status = await this.getAccessStatus(customerId);
+    if (status.status !== "past_due") return false;
+    if (!status.gracePeriodEnd) return false;
+    return /* @__PURE__ */ new Date() < status.gracePeriodEnd;
+  }
+  // ============================================================================
+  // Billing Cycle
+  // ============================================================================
+  /**
+   * Set customer billing cycle
+   */
+  async setBillingCycle(customerId, start, end) {
+    await this.storage.setBillingCycle(customerId, start, end);
+    this.logger.debug("Billing cycle set", { customerId, start, end });
+  }
+  /**
+   * Get customer billing cycle
+   */
+  async getBillingCycle(customerId) {
+    return this.storage.getBillingCycle(customerId);
+  }
+  // ============================================================================
+  // Internal
+  // ============================================================================
+  /**
+   * Get the underlying storage
+   */
+  get storageBackend() {
+    return this.storage;
+  }
+  /**
+   * Get the quota manager
+   */
+  get quotas() {
+    return this.quotaManager;
+  }
+  /**
+   * Get the usage tracker
+   */
+  get tracker() {
+    return this.usageTracker;
+  }
+};
+function createUsageService(config) {
+  return new UsageService(config);
+}
+
+// src/usage/billing-integration.ts
+var nullLogger5 = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var BillingIntegration = class {
+  billing;
+  usage;
+  logger;
+  autoInitializePlan;
+  autoResetOnRenewal;
+  autoManageAccessStatus;
+  resolvePlanId;
+  config;
+  constructor(config) {
+    this.billing = config.billing;
+    this.usage = config.usage;
+    this.logger = config.logger ?? nullLogger5;
+    this.autoInitializePlan = config.autoInitializePlan ?? true;
+    this.autoResetOnRenewal = config.autoResetOnRenewal ?? true;
+    this.autoManageAccessStatus = config.autoManageAccessStatus ?? true;
+    this.resolvePlanId = config.resolvePlanId ?? ((priceId) => priceId);
+    this.config = config;
+    this.setupWebhookHandlers();
+  }
+  /**
+   * Setup webhook handlers on billing service
+   */
+  setupWebhookHandlers() {
+    this.billing.onWebhook("subscription.created", async (event) => {
+      await this.handleSubscriptionCreated(event);
+    });
+    this.billing.onWebhook("subscription.updated", async (event) => {
+      await this.handleSubscriptionUpdated(event);
+    });
+    this.billing.onWebhook("subscription.deleted", async (event) => {
+      await this.handleSubscriptionCanceled(event);
+    });
+    this.billing.onWebhook("invoice.paid", async (event) => {
+      await this.handleInvoicePaid(event);
+    });
+    this.billing.onWebhook("invoice.payment_failed", async (event) => {
+      await this.handlePaymentFailed(event);
+    });
+    this.logger.info("Billing integration initialized");
+  }
+  /**
+   * Handle subscription created webhook
+   */
+  async handleSubscriptionCreated(event) {
+    const subscription = event.data;
+    this.logger.info("Subscription created", {
+      subscriptionId: subscription.id,
+      customerId: subscription.customerId,
+      provider: event.provider
+    });
+    if (this.autoInitializePlan && subscription.priceId) {
+      const planId = await this.resolvePlanId(subscription.priceId, event.provider);
+      await this.usage.setCustomerPlan(subscription.customerId, planId);
+      this.logger.debug("Customer plan initialized", {
+        customerId: subscription.customerId,
+        planId
+      });
+    }
+    if (subscription.currentPeriodStart && subscription.currentPeriodEnd) {
+      await this.usage.setBillingCycle(
+        subscription.customerId,
+        subscription.currentPeriodStart,
+        subscription.currentPeriodEnd
+      );
+    }
+    if (this.autoManageAccessStatus) {
+      await this.usage.setAccessStatus(subscription.customerId, "active", {
+        reason: "Subscription created"
+      });
+    }
+    const plan = subscription.priceId ? await this.usage.getPlan(await this.resolvePlanId(subscription.priceId, event.provider)) : null;
+    const lifecycleEvent = {
+      type: "subscription.created",
+      subscription: {
+        id: subscription.id,
+        customerId: subscription.customerId,
+        status: subscription.status,
+        priceId: subscription.priceId ?? "",
+        currentPeriodStart: subscription.currentPeriodStart ?? /* @__PURE__ */ new Date(),
+        currentPeriodEnd: subscription.currentPeriodEnd ?? /* @__PURE__ */ new Date(),
+        cancelAtPeriodEnd: false,
+        provider: event.provider
+      },
+      timestamp: /* @__PURE__ */ new Date(),
+      provider: event.provider
+    };
+    if (plan !== null) {
+      lifecycleEvent.newPlan = plan;
+    }
+    await this.usage.lifecycleManager.emit(lifecycleEvent);
+    if (this.config.onSubscriptionCreated) {
+      await this.config.onSubscriptionCreated(lifecycleEvent);
+    }
+  }
+  /**
+   * Handle subscription updated webhook
+   */
+  async handleSubscriptionUpdated(event) {
+    const subscription = event.data;
+    this.logger.info("Subscription updated", {
+      subscriptionId: subscription.id,
+      customerId: subscription.customerId,
+      provider: event.provider
+    });
+    const priceChanged = subscription.priceId !== subscription.previousPriceId;
+    let previousPlan = null;
+    let newPlan = null;
+    if (priceChanged && subscription.priceId) {
+      if (subscription.previousPriceId) {
+        const previousPlanId = await this.resolvePlanId(subscription.previousPriceId, event.provider);
+        previousPlan = await this.usage.getPlan(previousPlanId);
+      }
+      const newPlanId = await this.resolvePlanId(subscription.priceId, event.provider);
+      await this.usage.setCustomerPlan(subscription.customerId, newPlanId);
+      newPlan = await this.usage.getPlan(newPlanId);
+      this.logger.info("Customer plan changed", {
+        customerId: subscription.customerId,
+        previousPlanId: previousPlan?.id,
+        newPlanId
+      });
+    }
+    const eventType = priceChanged ? "subscription.plan_changed" : "subscription.updated";
+    const lifecycleEvent = {
+      type: eventType,
+      subscription: {
+        id: subscription.id,
+        customerId: subscription.customerId,
+        status: subscription.status,
+        priceId: subscription.priceId ?? "",
+        currentPeriodStart: subscription.currentPeriodStart ?? /* @__PURE__ */ new Date(),
+        currentPeriodEnd: subscription.currentPeriodEnd ?? /* @__PURE__ */ new Date(),
+        cancelAtPeriodEnd: false,
+        provider: event.provider
+      },
+      timestamp: /* @__PURE__ */ new Date(),
+      provider: event.provider
+    };
+    if (previousPlan !== null) {
+      lifecycleEvent.previousPlan = previousPlan;
+    }
+    if (newPlan !== null) {
+      lifecycleEvent.newPlan = newPlan;
+    }
+    await this.usage.lifecycleManager.emit(lifecycleEvent);
+    if (priceChanged && this.config.onPlanChanged) {
+      await this.config.onPlanChanged(lifecycleEvent);
+    }
+  }
+  /**
+   * Handle subscription canceled webhook
+   */
+  async handleSubscriptionCanceled(event) {
+    const subscription = event.data;
+    this.logger.info("Subscription canceled", {
+      subscriptionId: subscription.id,
+      customerId: subscription.customerId,
+      provider: event.provider
+    });
+    if (this.autoManageAccessStatus) {
+      await this.usage.setAccessStatus(subscription.customerId, "canceled", {
+        reason: "Subscription canceled"
+      });
+    }
+    const currentPlan = await this.usage.getCustomerPlan(subscription.customerId);
+    const lifecycleEvent = {
+      type: "subscription.canceled",
+      subscription: {
+        id: subscription.id,
+        customerId: subscription.customerId,
+        status: "canceled",
+        priceId: subscription.priceId ?? "",
+        currentPeriodStart: /* @__PURE__ */ new Date(),
+        currentPeriodEnd: subscription.currentPeriodEnd ?? /* @__PURE__ */ new Date(),
+        cancelAtPeriodEnd: true,
+        provider: event.provider
+      },
+      timestamp: /* @__PURE__ */ new Date(),
+      provider: event.provider
+    };
+    if (currentPlan !== null) {
+      lifecycleEvent.previousPlan = currentPlan;
+    }
+    await this.usage.lifecycleManager.emit(lifecycleEvent);
+    if (this.config.onSubscriptionCanceled) {
+      await this.config.onSubscriptionCanceled(lifecycleEvent);
+    }
+  }
+  /**
+   * Handle invoice paid webhook (renewal)
+   */
+  async handleInvoicePaid(event) {
+    const invoice = event.data;
+    if (invoice.billingReason !== "subscription_cycle") {
+      return;
+    }
+    this.logger.info("Subscription renewed", {
+      invoiceId: invoice.id,
+      customerId: invoice.customerId,
+      subscriptionId: invoice.subscriptionId,
+      provider: event.provider
+    });
+    if (invoice.periodStart && invoice.periodEnd) {
+      await this.usage.setBillingCycle(
+        invoice.customerId,
+        invoice.periodStart,
+        invoice.periodEnd
+      );
+    }
+    if (this.autoResetOnRenewal && this.usage.autoResetEnabled) {
+      this.logger.info("Auto-resetting quotas on renewal", {
+        customerId: invoice.customerId
+      });
+      await this.usage.resetUsage(invoice.customerId);
+    }
+    if (this.autoManageAccessStatus) {
+      await this.usage.handlePaymentSuccess(invoice.customerId);
+    }
+    const currentPlan = await this.usage.getCustomerPlan(invoice.customerId);
+    const periodStart = invoice.periodStart ?? /* @__PURE__ */ new Date();
+    const periodEnd = invoice.periodEnd ?? /* @__PURE__ */ new Date();
+    const lifecycleEvent = {
+      type: "subscription.renewed",
+      subscription: {
+        id: invoice.subscriptionId ?? invoice.id,
+        customerId: invoice.customerId,
+        status: "active",
+        priceId: "",
+        currentPeriodStart: periodStart,
+        currentPeriodEnd: periodEnd,
+        cancelAtPeriodEnd: false,
+        provider: event.provider
+      },
+      timestamp: /* @__PURE__ */ new Date(),
+      provider: event.provider
+    };
+    if (currentPlan !== null) {
+      lifecycleEvent.newPlan = currentPlan;
+    }
+    await this.usage.lifecycleManager.emit(lifecycleEvent);
+    if (this.config.onSubscriptionRenewed) {
+      await this.config.onSubscriptionRenewed(lifecycleEvent);
+    }
+  }
+  /**
+   * Handle payment failed webhook
+   */
+  async handlePaymentFailed(event) {
+    const invoice = event.data;
+    this.logger.warn("Payment failed", {
+      invoiceId: invoice.id,
+      customerId: invoice.customerId,
+      subscriptionId: invoice.subscriptionId,
+      provider: event.provider
+    });
+    if (this.autoManageAccessStatus) {
+      await this.usage.handlePaymentFailure(invoice.customerId);
+    }
+    const currentPlan = await this.usage.getCustomerPlan(invoice.customerId);
+    const lifecycleEvent = {
+      type: "subscription.payment_failed",
+      subscription: {
+        id: invoice.subscriptionId ?? invoice.id,
+        customerId: invoice.customerId,
+        status: "past_due",
+        priceId: "",
+        currentPeriodStart: /* @__PURE__ */ new Date(),
+        currentPeriodEnd: /* @__PURE__ */ new Date(),
+        cancelAtPeriodEnd: false,
+        provider: event.provider
+      },
+      timestamp: /* @__PURE__ */ new Date(),
+      provider: event.provider
+    };
+    if (currentPlan !== null) {
+      lifecycleEvent.newPlan = currentPlan;
+    }
+    await this.usage.lifecycleManager.emit(lifecycleEvent);
+    if (this.config.onPaymentFailed) {
+      await this.config.onPaymentFailed(lifecycleEvent);
+    }
+  }
+  /**
+   * Manually sync customer plan from billing provider
+   */
+  async syncCustomerPlan(customerId, provider) {
+    const subscriptionOptions = {
+      customerId
+    };
+    if (provider !== void 0) {
+      subscriptionOptions.provider = provider;
+    }
+    const subscriptions = await this.billing.getSubscriptions(subscriptionOptions);
+    const activeSubscription = subscriptions.find(
+      (sub) => sub.status === "active" || sub.status === "trialing"
+    );
+    if (!activeSubscription) {
+      this.logger.debug("No active subscription found", { customerId });
+      return null;
+    }
+    const planId = await this.resolvePlanId(
+      activeSubscription.priceId,
+      activeSubscription.provider
+    );
+    await this.usage.setCustomerPlan(customerId, planId);
+    const plan = await this.usage.getPlan(planId);
+    this.logger.info("Customer plan synced", {
+      customerId,
+      planId,
+      subscriptionId: activeSubscription.id
+    });
+    return plan;
+  }
+};
+function integrateBillingWithUsage(config) {
+  return new BillingIntegration(config);
+}
+var createBillingIntegration = integrateBillingWithUsage;
+
+// src/usage/usage-meter.ts
+var nullLogger6 = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var UsageMeter = class {
+  reporter;
+  providerType;
+  logger;
+  strategy;
+  maxRetries;
+  retryDelayMs;
+  maxBufferSize;
+  config;
+  buffer = [];
+  intervalId = null;
+  isSyncing = false;
+  isRunning = false;
+  constructor(config) {
+    this.reporter = config.reporter;
+    this.providerType = config.providerType;
+    this.logger = config.logger ?? nullLogger6;
+    this.strategy = config.strategy;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.retryDelayMs = config.retryDelayMs ?? 1e3;
+    this.maxBufferSize = config.maxBufferSize ?? 1e4;
+    this.config = config;
+    this.start();
+  }
+  /**
+   * Start the meter (auto-sync based on strategy)
+   */
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    if (this.strategy.type === "interval") {
+      this.intervalId = setInterval(() => {
+        this.flush().catch((err) => {
+          this.logger.error("Auto-sync failed", { error: err.message });
+        });
+      }, this.strategy.intervalMs);
+      this.logger.info("Usage meter started", {
+        strategy: "interval",
+        intervalMs: this.strategy.intervalMs,
+        provider: this.providerType
+      });
+    } else if (this.strategy.type === "threshold") {
+      this.logger.info("Usage meter started", {
+        strategy: "threshold",
+        maxRecords: this.strategy.maxRecords,
+        maxAgeMs: this.strategy.maxAgeMs,
+        provider: this.providerType
+      });
+    } else {
+      this.logger.info("Usage meter started", {
+        strategy: "manual",
+        provider: this.providerType
+      });
+    }
+  }
+  /**
+   * Stop the meter
+   */
+  stop() {
+    this.isRunning = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.logger.info("Usage meter stopped");
+  }
+  /**
+   * Record usage (buffered)
+   */
+  record(options) {
+    const usageRecord = {
+      subscriptionItemId: options.subscriptionItemId,
+      quantity: options.quantity,
+      action: options.action ?? "increment"
+    };
+    if (options.timestamp !== void 0) {
+      usageRecord.timestamp = options.timestamp;
+    }
+    if (options.idempotencyKey !== void 0) {
+      usageRecord.idempotencyKey = options.idempotencyKey;
+    }
+    const record = {
+      record: usageRecord,
+      customerId: options.customerId,
+      featureKey: options.featureKey,
+      addedAt: /* @__PURE__ */ new Date(),
+      attempts: 0
+    };
+    this.buffer.push(record);
+    this.logger.debug("Usage recorded", {
+      customerId: options.customerId,
+      featureKey: options.featureKey,
+      quantity: options.quantity,
+      bufferSize: this.buffer.length
+    });
+    if (this.buffer.length > this.maxBufferSize * 0.8) {
+      this.config.onBufferWarning?.(this.buffer.length, this.maxBufferSize);
+    }
+    if (this.buffer.length >= this.maxBufferSize) {
+      this.logger.warn("Buffer full, forcing sync", { size: this.buffer.length });
+      this.flush().catch((err) => {
+        this.logger.error("Forced sync failed", { error: err.message });
+      });
+      return;
+    }
+    if (this.strategy.type === "threshold") {
+      this.checkThreshold();
+    }
+  }
+  /**
+   * Check threshold and trigger sync if needed
+   */
+  checkThreshold() {
+    if (this.strategy.type !== "threshold") return;
+    if (this.isSyncing) return;
+    const { maxRecords, maxAgeMs } = this.strategy;
+    if (this.buffer.length >= maxRecords) {
+      this.logger.debug("Threshold reached (count)", { count: this.buffer.length });
+      this.flush().catch((err) => {
+        this.logger.error("Threshold sync failed", { error: err.message });
+      });
+      return;
+    }
+    const oldestRecord = this.buffer[0];
+    if (oldestRecord) {
+      const age = Date.now() - oldestRecord.addedAt.getTime();
+      if (age >= maxAgeMs) {
+        this.logger.debug("Threshold reached (age)", { ageMs: age });
+        this.flush().catch((err) => {
+          this.logger.error("Threshold sync failed", {
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      }
+    }
+  }
+  /**
+   * Flush buffer to provider
+   */
+  async flush() {
+    if (this.isSyncing) {
+      this.logger.debug("Sync already in progress, skipping");
+      return 0;
+    }
+    if (this.buffer.length === 0) {
+      return 0;
+    }
+    this.isSyncing = true;
+    try {
+      const toSync = [...this.buffer];
+      this.buffer = [];
+      this.logger.info("Syncing usage to provider", {
+        count: toSync.length,
+        provider: this.providerType
+      });
+      const aggregated = this.aggregateRecords(toSync);
+      const failed = [];
+      for (const [subscriptionItemId, records] of aggregated) {
+        try {
+          const totalQuantity = records.reduce((sum, r) => sum + r.record.quantity, 0);
+          const syncRecord = {
+            subscriptionItemId,
+            quantity: totalQuantity,
+            action: "increment"
+          };
+          const firstTimestamp = records[0]?.record.timestamp;
+          if (firstTimestamp !== void 0) {
+            syncRecord.timestamp = firstTimestamp;
+          }
+          await this.syncWithRetry(syncRecord);
+          this.logger.debug("Usage synced", {
+            subscriptionItemId,
+            quantity: totalQuantity,
+            recordCount: records.length
+          });
+        } catch (error) {
+          this.logger.error("Failed to sync usage", {
+            subscriptionItemId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          for (const record of records) {
+            record.attempts++;
+            if (record.attempts < this.maxRetries) {
+              failed.push(record);
+            } else {
+              this.logger.error("Record exceeded max retries, dropping", {
+                customerId: record.customerId,
+                featureKey: record.featureKey,
+                attempts: record.attempts
+              });
+            }
+          }
+        }
+      }
+      if (failed.length > 0) {
+        this.buffer.unshift(...failed);
+        this.config.onSyncError?.(new Error("Some records failed to sync"), failed);
+      }
+      const syncedCount = toSync.length - failed.length;
+      if (syncedCount > 0) {
+        this.config.onSyncSuccess?.(syncedCount);
+      }
+      return syncedCount;
+    } finally {
+      this.isSyncing = false;
+    }
+  }
+  /**
+   * Aggregate records by subscription item ID
+   */
+  aggregateRecords(records) {
+    const map = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const key = record.record.subscriptionItemId;
+      const existing = map.get(key) ?? [];
+      existing.push(record);
+      map.set(key, existing);
+    }
+    return map;
+  }
+  /**
+   * Sync single record with retry
+   */
+  async syncWithRetry(record) {
+    let lastError = null;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        await this.reporter.reportUsage(record);
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        this.logger.warn("Sync attempt failed, retrying", {
+          attempt: attempt + 1,
+          maxRetries: this.maxRetries,
+          error: lastError.message
+        });
+        if (attempt < this.maxRetries - 1) {
+          await this.delay(this.retryDelayMs * (attempt + 1));
+        }
+      }
+    }
+    throw lastError ?? new Error("Sync failed after retries");
+  }
+  /**
+   * Delay helper
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get buffer size
+   */
+  get bufferSize() {
+    return this.buffer.length;
+  }
+  /**
+   * Get sync status
+   */
+  get syncing() {
+    return this.isSyncing;
+  }
+  /**
+   * Get running status
+   */
+  get running() {
+    return this.isRunning;
+  }
+  /**
+   * Get buffer contents (for debugging)
+   */
+  getBuffer() {
+    return this.buffer;
+  }
+};
+function createUsageMeter(config) {
+  return new UsageMeter(config);
+}
+var SubscriptionItemResolver = class {
+  reporter;
+  cacheTtlMs;
+  logger;
+  cache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.reporter = config.reporter;
+    this.cacheTtlMs = config.cacheTtlMs ?? 60 * 60 * 1e3;
+    this.logger = config.logger ?? nullLogger6;
+  }
+  /**
+   * Get subscription item ID
+   */
+  async resolve(subscriptionId, priceId) {
+    const cacheKey = `${subscriptionId}:${priceId}`;
+    const cached = this.cache.get(cacheKey);
+    if (cached && cached.expiresAt > /* @__PURE__ */ new Date()) {
+      return cached.itemId;
+    }
+    if (!this.reporter.getSubscriptionItemId) {
+      this.logger.warn("Reporter does not support getSubscriptionItemId");
+      return null;
+    }
+    const itemId = await this.reporter.getSubscriptionItemId(subscriptionId, priceId);
+    if (itemId) {
+      this.cache.set(cacheKey, {
+        itemId,
+        expiresAt: new Date(Date.now() + this.cacheTtlMs)
+      });
+    }
+    return itemId;
+  }
+  /**
+   * Set cache entry manually (useful when creating subscriptions)
+   */
+  setCache(subscriptionId, priceId, itemId) {
+    const cacheKey = `${subscriptionId}:${priceId}`;
+    this.cache.set(cacheKey, {
+      itemId,
+      expiresAt: new Date(Date.now() + this.cacheTtlMs)
+    });
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache size
+   */
+  get cacheSize() {
+    return this.cache.size;
+  }
+};
+function createSubscriptionItemResolver(config) {
+  return new SubscriptionItemResolver(config);
+}
+export {
+  BillingIntegration,
+  DrizzleUsageStorage,
+  MemoryUsageStorage,
+  QuotaExceededError,
+  QuotaManager,
+  SubscriptionItemResolver,
+  SubscriptionLifecycle,
+  UsageError,
+  UsageErrorCodes,
+  UsageMeter,
+  UsageService,
+  UsageTracker,
+  createBillingIntegration,
+  createDrizzleUsageStorage,
+  createMemoryUsageStorage,
+  createQuotaManager,
+  createSubscriptionItemResolver,
+  createSubscriptionLifecycle,
+  createUsageMeter,
+  createUsageService,
+  createUsageTracker,
+  integrateBillingWithUsage,
+  schema_exports as usageSchema
+};
+//# sourceMappingURL=index.js.map