@vrplatform/hyperline-client 1.0.25 → 1.0.26

package/src/types.ts

@@ -14,61 +14,6 @@ export type HyperlinePayload<T extends HyperlineWebhook> = {
   data: Record<string, any>;
 };
 
-export type HyperlineCreateSubscriptionPayload = {
-  customer_id: string;
-  invoicing_entity_id?: string | null;
-  activation_strategy?: 'start_date' | 'manually' | 'checkout';
-  starts_at?: string;
-  plan_id?: string;
-  template_id?: string;
-  template_configuration_id?: string;
-  trial?: {
-    end_strategy: 'manual' | 'end_date' | 'duration';
-    starts_at?: string;
-    ends_at?: string;
-    duration?: {
-      period: 'days' | 'weeks' | 'months' | 'years';
-      count: number;
-    };
-  };
-  cancellation_strategy?:
-    | 'refund_prorata'
-    | 'refund_custom'
-    | 'charge_prorata'
-    | 'charge_custom'
-    | 'end_of_period'
-    | 'do_nothing';
-  generate_draft_invoices?: boolean;
-  renew_automatically?: boolean;
-  contract_terms?: {
-    activation_strategy:
-      | 'start_date'
-      | 'immediately'
-      | 'manual'
-      | 'quote_signature'
-      | 'checkout';
-    end_strategy: 'end_date' | 'duration' | 'manual';
-    starts_at?: string;
-    duration?: {
-      period: 'days' | 'weeks' | 'months' | 'years';
-      count: number;
-    };
-    renew_automatically?: boolean;
-    renew_for_duration?: {
-      period: 'days' | 'weeks' | 'months' | 'years';
-      count: number;
-    };
-  };
-  billing_cycle_alignment?: 'calendar_period' | 'anniversary';
-  coupons?: {
-    id: string;
-    repeat: 'once' | 'forever' | 'custom';
-    expires_at?: string;
-    apply_at?: string;
-    product_ids?: string[];
-  }[];
-};
-
 export type BillableEvent = {
   record: {
     id: '202408_cus_w_Q7M9bXcHMKB6';

package/src/utils/calculateMrr.ts

@@ -0,0 +1,206 @@
+import {
+  GL_HYPERLINE_DEFAULT_DEV_PLAN_ID,
+  GL_HYPERLINE_DEFAULT_MIN_AMOUNT,
+  GL_HYPERLINE_DEFAULT_PLAN_ID,
+  HYPERLINE_DEFAULT_DEV_PLAN_ID,
+  HYPERLINE_DEFAULT_MIN_AMOUNT,
+  HYPERLINE_DEFAULT_PLAN_ID,
+} from '../const';
+import { useHyperlineByToken } from '../hooks';
+
+export async function calculateMrr(
+  subscriptionId: string,
+  estimated = false,
+  _activeListings?: number,
+  hyperline: {
+    getSubscription(
+      id: string,
+      liveBilling?: boolean
+    ): Promise<{
+      customer_id: string;
+      plan_id: string | null;
+      products?: unknown[];
+      coupons?: (
+        | {
+            type: 'amount';
+            repeat: 'once' | 'forever' | 'custom';
+            discount_amount: number;
+          }
+        | {
+            type: 'percent';
+            repeat: 'once' | 'forever' | 'custom';
+            discount_percent: number;
+          }
+      )[];
+      phases?: {
+        type: 'setup' | 'trial' | 'standard';
+        status: 'pending' | 'active' | 'finished';
+        products: {
+          min_amount?: number | null;
+          max_amount?: number | null;
+          prices: (
+            | {
+                type: 'volume';
+                amount: number;
+                from: number;
+                to: number | null;
+                unit_count: number;
+              }
+            | {
+                type:
+                  | 'bps'
+                  | 'bulk'
+                  | 'bundle'
+                  | 'fee'
+                  | 'flat_fee'
+                  | 'packaged';
+              }
+          )[];
+        }[];
+      }[];
+      live_billing?: { total_amount: number };
+    } | null>;
+    getInvoicesByCustomerId(id: string): Promise<{
+      data: {
+        emitted_at: string;
+        total_amount: number;
+      }[];
+    } | null>;
+  } = useHyperlineByToken(process.env.HYPERLINE_TOKEN!),
+  includeLiveBilling = false
+) {
+  const _subscription = await hyperline.getSubscription(
+    subscriptionId,
+    includeLiveBilling
+  );
+  if (!_subscription) throw new Error('Subscription not found');
+
+  const { products, phases, ...subscription } = _subscription;
+
+  let mrr = 0;
+  const activeListings = _activeListings || 0;
+  const phase = phases?.filter((x) =>
+    estimated
+      ? x.type === 'standard'
+      : (x.type === 'trial' && x.status === 'active') || x.type === 'standard'
+  )?.[0];
+  const product = phase?.products?.[0];
+  const type = product?.prices?.[0].type;
+  if (type === 'volume') {
+    const volumePrices: Array<{
+      amount: number;
+      from: number;
+      to: number | null;
+      unit_count: number;
+    }> = [];
+
+    product?.prices?.forEach((price) => {
+      if (
+        price.type !== 'volume' ||
+        !('amount' in price) ||
+        !('from' in price) ||
+        !('to' in price) ||
+        !('unit_count' in price)
+      )
+        return;
+
+      volumePrices.push({
+        amount: price.amount,
+        from: price.from,
+        to: price.to,
+        unit_count: price.unit_count,
+      });
+    });
+    volumePrices.sort((a, b) => a.from - b.from);
+
+    mrr =
+      volumePrices.reduce((acc, price) => {
+        const listings =
+          price.to && activeListings >= price.to
+            ? price.to - price.from
+            : activeListings >= price.from
+              ? activeListings - price.from
+              : 0;
+
+        acc += (price.amount / 100) * (listings / price.unit_count);
+
+        return acc;
+      }, 0) || 0;
+
+    const firstTier = volumePrices[0];
+    const secondTier = volumePrices[1];
+    const product_min_amount =
+      product &&
+      'min_amount' in product &&
+      typeof product.min_amount === 'number'
+        ? product.min_amount
+        : null;
+    const product_max_amount =
+      product &&
+      'max_amount' in product &&
+      typeof product.max_amount === 'number'
+        ? product.max_amount
+        : null;
+    const inferred_min_amount =
+      firstTier &&
+      secondTier &&
+      firstTier.from === 0 &&
+      firstTier.to != null &&
+      secondTier.from === firstTier.to &&
+      firstTier.amount === secondTier.amount &&
+      firstTier.unit_count === secondTier.unit_count
+        ? firstTier.amount *
+          ((firstTier.to - firstTier.from) / firstTier.unit_count)
+        : 0;
+    const plan_min_amount = [
+      GL_HYPERLINE_DEFAULT_PLAN_ID,
+      GL_HYPERLINE_DEFAULT_DEV_PLAN_ID,
+    ].includes(subscription.plan_id!)
+      ? GL_HYPERLINE_DEFAULT_MIN_AMOUNT
+      : [HYPERLINE_DEFAULT_PLAN_ID, HYPERLINE_DEFAULT_DEV_PLAN_ID].includes(
+            subscription.plan_id!
+          )
+        ? HYPERLINE_DEFAULT_MIN_AMOUNT
+        : 0;
+
+    const min_amount =
+      ((product_min_amount || plan_min_amount || inferred_min_amount) ?? 0) /
+      100;
+    mrr = Math.max(mrr, min_amount);
+
+    const max_amount = ((product_max_amount || 0) ?? 0) / 100;
+    mrr = max_amount > 0 ? Math.min(mrr, max_amount) : mrr;
+
+    // apply discounts (only these who repeat forever if estimated is true)
+    (subscription.coupons || [])
+      .filter((coupon) => (estimated ? coupon.repeat === 'forever' : true))
+      .forEach((x) => {
+        if ('discount_amount' in x && x.discount_amount)
+          mrr -= x.discount_amount / 100;
+        else if ('discount_percent' in x && x.discount_percent)
+          mrr -= (x.discount_percent / 100) * mrr;
+      });
+  } else if (type === 'bps') {
+    const { data } = subscription?.customer_id
+      ? (await hyperline.getInvoicesByCustomerId(subscription.customer_id)) || {
+          data: [],
+        }
+      : { data: [] };
+
+    // sort invoices by date
+    const invoices = data
+      ?.sort((a, b) => a.emitted_at.localeCompare(b.emitted_at))
+      .reverse();
+
+    // get the last invoice
+    mrr = (invoices[0]?.total_amount || 0) / 100;
+  }
+
+  return {
+    mrr,
+    mrrAlt:
+      subscription.live_billing?.total_amount == null
+        ? null
+        : subscription.live_billing.total_amount / 100,
+  };
+}

package/src/utils/index.ts

@@ -1,2 +1,3 @@
 export * from './arrayBufferToBase64';
+export * from './calculateMrr';
 export * from './getMrrDiffReasons';