@almadar/integrations 2.6.3 → 2.8.0

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createLogger } from '@almadar/logger';
 import { integratorsRegistry } from '@almadar/patterns';
 import Stripe from 'stripe';
 import { google } from 'googleapis';
@@ -13,32 +14,20 @@ import { tmpdir } from 'os';
 
 // src/core/logger.ts
 var ConsoleLogger = class {
-  constructor(level = "info") {
-    this.level = level;
+  constructor(_level = "info") {
+    this.log = createLogger("almadar:integrations");
   }
   debug(message, meta) {
-    if (this.shouldLog("debug")) {
-      console.debug(`[DEBUG] ${message}`, meta || "");
-    }
+    this.log.debug(message, meta);
   }
   info(message, meta) {
-    if (this.shouldLog("info")) {
-      console.log(`[INFO] ${message}`, meta || "");
-    }
+    this.log.info(message, meta);
   }
   warn(message, meta) {
-    if (this.shouldLog("warn")) {
-      console.warn(`[WARN] ${message}`, meta || "");
-    }
+    this.log.warn(message, meta);
   }
   error(message, meta) {
-    if (this.shouldLog("error")) {
-      console.error(`[ERROR] ${message}`, meta || "");
-    }
-  }
-  shouldLog(level) {
-    const levels = ["debug", "info", "warn", "error"];
-    return levels.indexOf(level) >= levels.indexOf(this.level);
+    this.log.error(message, meta);
   }
 };
 function validateParams(integration, action, params) {
@@ -289,6 +278,179 @@ function resetIntegrationFactory() {
   _factory?.reset();
   _factory = null;
 }
+var STRIPE_API_VERSION = "2025-02-24.acacia";
+function priceToTier(priceId, prices) {
+  if (priceId === prices.solo) return "solo";
+  if (priceId === prices.teams) return "teams";
+  return null;
+}
+function mapStatus(status) {
+  switch (status) {
+    case "active":
+    case "past_due":
+    case "canceled":
+    case "incomplete":
+    case "incomplete_expired":
+    case "trialing":
+    case "unpaid":
+      return status;
+    case "paused":
+      return "unpaid";
+    default: {
+      return "incomplete";
+    }
+  }
+}
+function isoFromUnix(seconds) {
+  return new Date(seconds * 1e3).toISOString();
+}
+function shapeSubscription(sub, prices) {
+  const firstItem = sub.items.data[0];
+  const priceId = firstItem?.price.id ?? "";
+  const quantity = firstItem?.quantity ?? 1;
+  const customerId = typeof sub.customer === "string" ? sub.customer : sub.customer.id;
+  return {
+    subscriptionId: sub.id,
+    customerId,
+    status: mapStatus(sub.status),
+    priceId,
+    quantity,
+    currentPeriodStart: isoFromUnix(sub.current_period_start),
+    currentPeriodEnd: isoFromUnix(sub.current_period_end),
+    cancelAtPeriodEnd: sub.cancel_at_period_end,
+    tier: priceToTier(priceId, prices)
+  };
+}
+function customerIdOf(customer) {
+  if (customer === null) return "";
+  return typeof customer === "string" ? customer : customer.id;
+}
+function verifyAndParseStripeEvent(input) {
+  const stripe = new Stripe("placeholder-only-for-webhook-utility", {
+    apiVersion: STRIPE_API_VERSION
+  });
+  let event;
+  try {
+    event = stripe.webhooks.constructEvent(
+      input.rawBody,
+      input.signature,
+      input.secret
+    );
+  } catch {
+    return { error: "bad-signature" };
+  }
+  switch (event.type) {
+    case "customer.subscription.created": {
+      const sub = event.data.object;
+      return {
+        type: "subscription.created",
+        eventId: event.id,
+        data: shapeSubscription(sub, input.prices)
+      };
+    }
+    case "customer.subscription.updated": {
+      const sub = event.data.object;
+      return {
+        type: "subscription.updated",
+        eventId: event.id,
+        data: shapeSubscription(sub, input.prices)
+      };
+    }
+    case "customer.subscription.deleted": {
+      const sub = event.data.object;
+      return {
+        type: "subscription.deleted",
+        eventId: event.id,
+        data: {
+          subscriptionId: sub.id,
+          customerId: customerIdOf(sub.customer)
+        }
+      };
+    }
+    case "invoice.payment_succeeded": {
+      const invoice = event.data.object;
+      const subRef = invoice.subscription;
+      return {
+        type: "invoice.payment_succeeded",
+        eventId: event.id,
+        data: {
+          customerId: customerIdOf(invoice.customer),
+          subscriptionId: typeof subRef === "string" ? subRef : subRef?.id ?? null,
+          paidAt: isoFromUnix(invoice.status_transitions.paid_at ?? invoice.created),
+          amountUsd: invoice.amount_paid / 100
+        }
+      };
+    }
+    case "invoice.payment_failed": {
+      const invoice = event.data.object;
+      const subRef = invoice.subscription;
+      return {
+        type: "invoice.payment_failed",
+        eventId: event.id,
+        data: {
+          customerId: customerIdOf(invoice.customer),
+          subscriptionId: typeof subRef === "string" ? subRef : subRef?.id ?? null,
+          failedAt: isoFromUnix(invoice.created),
+          reason: invoice.last_finalization_error?.message ?? "Payment failed; reason not provided by Stripe."
+        }
+      };
+    }
+    default:
+      return { error: "unknown-event-type", stripeType: event.type };
+  }
+}
+
+// src/integrations/stripe/index.ts
+var STRIPE_API_VERSION2 = "2025-02-24.acacia";
+function isoFromUnix2(seconds) {
+  return new Date(seconds * 1e3).toISOString();
+}
+function priceToTier2(priceId, prices) {
+  if (priceId === prices.solo) return "solo";
+  if (priceId === prices.teams) return "teams";
+  return null;
+}
+function mapStatus2(status) {
+  switch (status) {
+    case "active":
+    case "past_due":
+    case "canceled":
+    case "incomplete":
+    case "incomplete_expired":
+    case "trialing":
+    case "unpaid":
+      return status;
+    case "paused":
+      return "unpaid";
+    default: {
+      return "incomplete";
+    }
+  }
+}
+function shapeSubscription2(sub, prices) {
+  const firstItem = sub.items.data[0];
+  const priceId = firstItem?.price.id ?? "";
+  const quantity = firstItem?.quantity ?? 1;
+  const customerId = typeof sub.customer === "string" ? sub.customer : sub.customer.id;
+  return {
+    subscriptionId: sub.id,
+    customerId,
+    status: mapStatus2(sub.status),
+    priceId,
+    quantity,
+    currentPeriodStart: isoFromUnix2(sub.current_period_start),
+    currentPeriodEnd: isoFromUnix2(sub.current_period_end),
+    cancelAtPeriodEnd: sub.cancel_at_period_end,
+    tier: priceToTier2(priceId, prices)
+  };
+}
+function shapeCustomer(customer) {
+  return {
+    customerId: customer.id,
+    email: customer.email ?? null,
+    almadarUid: customer.metadata?.almadarUid ?? null
+  };
+}
 var StripeIntegration = class extends BaseIntegration {
   constructor(config) {
     super(config);
@@ -297,10 +459,18 @@ var StripeIntegration = class extends BaseIntegration {
       throw new Error("STRIPE_SECRET_KEY not configured");
     }
     this.client = new Stripe(apiKey, {
-      apiVersion: "2025-02-24.acacia"
+      apiVersion: STRIPE_API_VERSION2
     });
+    this.prices = {
+      solo: config.env.STRIPE_PRICE_SOLO ?? "",
+      teams: config.env.STRIPE_PRICE_TEAMS ?? ""
+    };
     this.logger.info("Stripe integration initialized");
   }
+  /** Provisioned Price IDs the integration was constructed with. */
+  getPrices() {
+    return this.prices;
+  }
   async execute(action, params) {
     const validation = this.validateParams(action, params);
     if (!validation.valid) {
@@ -316,7 +486,7 @@ var StripeIntegration = class extends BaseIntegration {
       };
     }
     const startTime = Date.now();
-    let retries = 0;
+    const retries = 0;
     try {
       let data;
       switch (action) {
@@ -345,7 +515,10 @@ var StripeIntegration = class extends BaseIntegration {
   }
   async createPaymentIntent(params) {
     const { amount, currency, metadata } = params;
-    this.logger.debug("Creating payment intent", { amount: Number(amount), currency: String(currency ?? "") });
+    this.logger.debug("Creating payment intent", {
+      amount: Number(amount),
+      currency: String(currency ?? "")
+    });
     return await this.client.paymentIntents.create({
       amount,
       currency,
@@ -354,17 +527,164 @@ var StripeIntegration = class extends BaseIntegration {
   }
   async confirmPayment(params) {
     const { paymentIntentId } = params;
-    this.logger.debug("Confirming payment", { paymentIntentId: String(paymentIntentId ?? "") });
+    this.logger.debug("Confirming payment", {
+      paymentIntentId: String(paymentIntentId ?? "")
+    });
     return await this.client.paymentIntents.confirm(paymentIntentId);
   }
   async refund(params) {
     const { paymentIntentId, amount } = params;
-    this.logger.debug("Creating refund", { paymentIntentId: String(paymentIntentId ?? ""), amount: Number(amount) });
+    this.logger.debug("Creating refund", {
+      paymentIntentId: String(paymentIntentId ?? ""),
+      amount: Number(amount)
+    });
     return await this.client.refunds.create({
       payment_intent: paymentIntentId,
       amount
     });
   }
+  // ───────────────────────────────────────────────────────────────────
+  // Typed action surface — canonical Almadar shapes only.
+  // ───────────────────────────────────────────────────────────────────
+  /** Look up an existing customer by Stripe ID. */
+  async getCustomer(customerId) {
+    this.logger.debug("Fetching customer", { customerId });
+    const customer = await this.client.customers.retrieve(customerId);
+    if (customer.deleted === true) return null;
+    return shapeCustomer(customer);
+  }
+  /**
+   * Create a Stripe Customer for the given Almadar user. `almadarUid` is
+   * stored as Stripe metadata so webhook handlers can resolve back to
+   * the right `users/{uid}` document.
+   */
+  async createCustomer(input) {
+    this.logger.debug("Creating customer", { almadarUid: input.almadarUid });
+    const customer = await this.client.customers.create({
+      email: input.email,
+      name: input.displayName ?? void 0,
+      metadata: { almadarUid: input.almadarUid }
+    });
+    return shapeCustomer(customer);
+  }
+  /**
+   * Create a Stripe-hosted Checkout Session for the given tier. Client
+   * redirects the user to the returned `url`; on success Stripe fires
+   * `customer.subscription.created`, which the apps/builder webhook
+   * handler turns into a `users/{uid}.tier` write.
+   */
+  async createCheckoutSession(input) {
+    const price = input.tier === "solo" ? this.prices.solo : this.prices.teams;
+    if (!price) {
+      throw new Error(`STRIPE_PRICE_${input.tier.toUpperCase()} not configured`);
+    }
+    this.logger.debug("Creating Checkout session", {
+      tier: input.tier,
+      quantity: input.quantity,
+      hasCustomer: input.customerId !== null
+    });
+    const session = await this.client.checkout.sessions.create({
+      mode: "subscription",
+      customer: input.customerId ?? void 0,
+      line_items: [{ price, quantity: input.quantity }],
+      success_url: input.successUrl,
+      cancel_url: input.cancelUrl,
+      subscription_data: {
+        metadata: input.metadata
+      },
+      automatic_tax: { enabled: true },
+      allow_promotion_codes: true
+    });
+    return {
+      url: session.url ?? "",
+      sessionId: session.id,
+      customerId: typeof session.customer === "string" ? session.customer : session.customer?.id ?? null
+    };
+  }
+  /** Create a Billing Portal session for self-service plan management. */
+  async createBillingPortalSession(input) {
+    this.logger.debug("Creating Portal session", { customerId: input.customerId });
+    const session = await this.client.billingPortal.sessions.create({
+      customer: input.customerId,
+      return_url: input.returnUrl
+    });
+    return {
+      url: session.url,
+      customerId: input.customerId
+    };
+  }
+  /** Fetch a subscription and shape it into the canonical form. */
+  async getSubscription(subscriptionId) {
+    this.logger.debug("Fetching subscription", { subscriptionId });
+    const sub = await this.client.subscriptions.retrieve(subscriptionId);
+    return shapeSubscription2(sub, this.prices);
+  }
+  /**
+   * Create a subscription directly (server-side, no Checkout). Used by
+   * P13.3 Solo → Teams upgrade flow.
+   */
+  async createSubscription(input) {
+    const price = input.tier === "solo" ? this.prices.solo : this.prices.teams;
+    if (!price) {
+      throw new Error(`STRIPE_PRICE_${input.tier.toUpperCase()} not configured`);
+    }
+    this.logger.debug("Creating subscription", {
+      customerId: input.customerId,
+      tier: input.tier,
+      quantity: input.quantity
+    });
+    const sub = await this.client.subscriptions.create({
+      customer: input.customerId,
+      items: [{ price, quantity: input.quantity }],
+      metadata: input.metadata,
+      proration_behavior: "create_prorations",
+      automatic_tax: { enabled: true }
+    });
+    return shapeSubscription2(sub, this.prices);
+  }
+  /**
+   * Update quantity or cancel-at-period-end. Used for Teams seat resize
+   * and Solo → Teams transition.
+   */
+  async updateSubscription(input) {
+    this.logger.debug("Updating subscription", { subscriptionId: input.subscriptionId });
+    const update = {
+      proration_behavior: "create_prorations"
+    };
+    if (typeof input.quantity === "number") {
+      const existing = await this.client.subscriptions.retrieve(input.subscriptionId);
+      const itemId = existing.items.data[0]?.id;
+      if (itemId !== void 0) {
+        update.items = [{ id: itemId, quantity: input.quantity }];
+      }
+    }
+    if (typeof input.cancelAtPeriodEnd === "boolean") {
+      update.cancel_at_period_end = input.cancelAtPeriodEnd;
+    }
+    const sub = await this.client.subscriptions.update(
+      input.subscriptionId,
+      update
+    );
+    return shapeSubscription2(sub, this.prices);
+  }
+  /**
+   * Cancel a subscription. Defaults to `atPeriodEnd: true` so the user
+   * keeps access until the current period ends.
+   */
+  async cancelSubscription(input) {
+    this.logger.debug("Canceling subscription", {
+      subscriptionId: input.subscriptionId,
+      atPeriodEnd: input.atPeriodEnd
+    });
+    if (input.atPeriodEnd) {
+      const sub2 = await this.client.subscriptions.update(input.subscriptionId, {
+        cancel_at_period_end: true
+      });
+      return shapeSubscription2(sub2, this.prices);
+    }
+    const sub = await this.client.subscriptions.cancel(input.subscriptionId);
+    return shapeSubscription2(sub, this.prices);
+  }
 };
 registerIntegration("stripe", StripeIntegration);
 var YouTubeIntegration = class extends BaseIntegration {
@@ -2701,6 +3021,6 @@ var DockerIntegration = class extends BaseIntegration {
 };
 registerIntegration("docker", DockerIntegration);
 
-export { BaseIntegration, CLIIntegration, ConsoleLogger, DeepAgentIntegration, DockerIntegration, EmailIntegration, GitHubIntegration, IntegrationFactory, LLMIntegration, OAuthIntegration, OtelIntegration, QueueIntegration, RedisIntegration, StorageIntegration, StripeIntegration, TwilioIntegration, YouTubeIntegration, getIntegration, getIntegrationFactory, getRegisteredIntegrations, isKnownIntegration, registerIntegration, resetIntegrationFactory, validateParams, withRetry };
+export { BaseIntegration, CLIIntegration, ConsoleLogger, DeepAgentIntegration, DockerIntegration, EmailIntegration, GitHubIntegration, IntegrationFactory, LLMIntegration, OAuthIntegration, OtelIntegration, QueueIntegration, RedisIntegration, StorageIntegration, StripeIntegration, TwilioIntegration, YouTubeIntegration, getIntegration, getIntegrationFactory, getRegisteredIntegrations, isKnownIntegration, registerIntegration, resetIntegrationFactory, validateParams, verifyAndParseStripeEvent, withRetry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map