@drawbridge/drawbridge-utils 0.0.103 → 0.0.104

package/dist/pricing.js

@@ -0,0 +1,757 @@
+// lib/features.js
+var page = {
+  qrcode: {
+    key: "page:qrcode",
+    error: "Plan does not include qrcodes",
+    feature: "Page qrcode management"
+  },
+  shortcode: {
+    key: "page:shortcode",
+    error: "Plan does not include shortcodes",
+    feature: "Page shortcode management"
+  },
+  slug: {
+    key: "page:slug",
+    error: "Plan does not include url customization",
+    feature: "Page slug customization"
+  }
+};
+var fields = {
+  additional: {
+    key: "campaign:fields:additional",
+    error: "Plan does not include additional fields",
+    feature: "Campaign additional fields"
+  },
+  lead: {
+    key: "campaign:fields:lead",
+    error: "Plan does not include lead fields",
+    feature: "Campaign lead fields"
+  }
+};
+var field = {
+  email: {
+    key: "campaign:field:email",
+    error: "Plan does not include email field",
+    feature: "Campaign email field"
+  },
+  name: {
+    key: "campaign:field:name",
+    error: "Plan does not include name field",
+    feature: "Campaign name field"
+  },
+  number: {
+    key: "campaign:field:number",
+    error: "Plan does not include number field",
+    feature: "Campaign number field"
+  },
+  phone: {
+    key: "campaign:field:phone",
+    error: "Plan does not include phone field",
+    feature: "Campaign phone field"
+  },
+  select: {
+    key: "campaign:field:select",
+    error: "Plan does not include dropdown field",
+    feature: "Campaign dropdown field"
+  },
+  text: {
+    key: "campaign:field:text",
+    error: "Plan does not include short text field",
+    feature: "Campaign short text field"
+  },
+  textarea: {
+    key: "campaign:field:textarea",
+    error: "Plan does not include long text field",
+    feature: "Campaign long text field"
+  }
+};
+var connection = {
+  mailchimp: {
+    key: "organization:connection:mailchimp",
+    error: "Plan does not include Mailchimp connection",
+    feature: "Mailchimp connection"
+  },
+  sender: {
+    key: "organization:connection:sender",
+    error: "Plan does not include a verified sending domain",
+    feature: "Sending domain connection"
+  },
+  sendgrid: {
+    key: "organization:connection:sendgrid",
+    error: "Plan does not include SendGrid connection",
+    feature: "SendGrid connection"
+  },
+  shopify: {
+    key: "organization:connection:shopify",
+    error: "Plan does not include Shopify connection",
+    feature: "Shopify connection"
+  },
+  twilio: {
+    key: "organization:connection:twilio",
+    error: "Plan does not include Twilio connection",
+    feature: "Twilio connection"
+  },
+  webhook: {
+    key: "organization:connection:webhook",
+    error: "Plan does not include Webhook connection",
+    feature: "Webhook connection"
+  }
+};
+var organization = {
+  advertisements: {
+    key: "organization:advertisements",
+    error: "Your plan does not include advertisements",
+    feature: "Organization advertisement management"
+  },
+  affiliates: {
+    key: "organization:affiliates",
+    error: "Your plan does not include affiliates",
+    feature: "Organization affiliates management"
+  },
+  analytics: {
+    key: "organization:analytics",
+    error: "Your plan does not include analytics",
+    feature: "Organization analytics management"
+  },
+  brands: {
+    key: "organization:brands",
+    error: "Your plan does not include brands",
+    feature: "Organization brands management"
+  },
+  members: {
+    key: "organization:members",
+    error: "Your plan does not include team members",
+    feature: "Organization members management"
+  },
+  reports: {
+    key: "organization:report",
+    error: "Plan does not include report generation",
+    feature: "Organization report generation"
+  },
+  subdomain: {
+    key: "organization:subdomain",
+    error: "Plan does not include subdomain customization",
+    feature: "Organization subdomain customization"
+  }
+};
+
+// index.js
+import { code, data } from "currency-codes";
+import { customAlphabet } from "nanoid";
+
+// lib/color.js
+import tinycolor from "tinycolor2";
+var colorFormatted = (value) => {
+  const color = tinycolor(value);
+  const attributes = {
+    brightness: color.getBrightness(),
+    dark: color.isDark(),
+    light: color.isLight(),
+    luminance: color.getLuminance()
+  };
+  return {
+    attributes,
+    hex: color.toHexString(),
+    hsl: color.toHsl(),
+    hsv: color.toHsv(),
+    rgb: color.toRgbString()
+  };
+};
+var colorAccessible = (background2) => {
+  const white = "#ffffff";
+  const black = "#000000";
+  return tinycolor.isReadable(
+    background2,
+    white,
+    {
+      level: "AA",
+      size: "normal"
+    }
+  ) ? white : black;
+};
+
+// lib/constants.js
+var font = {
+  family: "Roboto Flex",
+  transform: "none",
+  weight: "regular"
+};
+var background = "#ffffff";
+var style = {
+  background: {
+    color: colorFormatted(background)
+  },
+  body: font,
+  button: {
+    background: {
+      color: colorFormatted(background)
+    },
+    radius: 0,
+    text: {
+      color: colorFormatted(colorAccessible(background))
+    }
+  },
+  heading: font,
+  input: {
+    radius: 0
+  },
+  text: {
+    color: colorFormatted(colorAccessible(background))
+  }
+};
+
+// index.js
+var nanoid = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyz", 8);
+var infinite = 1e300;
+var megabyte = 1024 * 1024;
+var gigabyte = megabyte * 1024;
+var currencies = data.map((item) => ({
+  ...item,
+  key: item.currency,
+  value: item.code
+}));
+
+// lib/plans.js
+var featuresFor = (array = []) => Object.values({
+  ...connection,
+  ...organization,
+  ...fields,
+  ...field,
+  ...page
+}).reduce(
+  (accumulator, { key, error, feature }) => {
+    if (array.includes(key)) {
+      accumulator.granted[key] = feature;
+    } else {
+      accumulator.denied[key] = error;
+    }
+    return accumulator;
+  },
+  { denied: {}, granted: {} }
+);
+var overage = (actionCents) => ({
+  actionCents,
+  overages: { actions: String(actionCents) }
+});
+var unitAmountDecimal = (cents) => {
+  const value = Number(cents);
+  if (cents == null || !Number.isFinite(value)) throw new Error(`Invalid overage rate: ${cents}`);
+  return String(value);
+};
+var all = {
+  features: (array = []) => featuresFor([
+    connection.mailchimp.key,
+    connection.sendgrid.key,
+    connection.shopify.key,
+    connection.twilio.key,
+    connection.webhook.key,
+    organization.affiliates.key,
+    organization.brands.key,
+    fields.additional.key,
+    fields.lead.key,
+    field.email.key,
+    field.name.key,
+    field.number.key,
+    field.phone.key,
+    field.select.key,
+    field.text.key,
+    field.textarea.key,
+    page.qrcode.key,
+    page.shortcode.key,
+    ...array
+  ]),
+  // `members` and `storage` default to infinite so an unnamed term on a custom
+  // plan reads as UNLIMITED rather than absent. Storage used to have no
+  // default, so a deal that did not name it resolved to undefined and the
+  // organization's usage card simply omitted the row — the same blank field
+  // that showed "Unlimited" for members showed nothing at all for storage.
+  // Every catalog plan names both, so the defaults only ever apply to a
+  // custom plan. `actions` has no default on purpose: an unnamed allowance
+  // bills nothing, which is why the availability switch refuses to flip
+  // without one.
+  limits: ({ actions, members = infinite, storage = infinite }) => ({
+    campaign: {
+      advertisements: infinite,
+      links: infinite,
+      fields: infinite,
+      pages: infinite
+    },
+    organization: {
+      actions,
+      affiliates: infinite,
+      brands: infinite,
+      campaigns: infinite,
+      members,
+      storage
+    }
+  })
+};
+var free = {
+  conversion: 3,
+  features: all.features(),
+  limits: all.limits({
+    actions: 200,
+    members: 0,
+    storage: gigabyte * 5
+  }),
+  title: "Free"
+};
+var plans = {
+  DB00002: {
+    // A verified sending domain is a PAID capability: free plans cannot send
+    // lead-facing email at all (the send path gates on an active
+    // subscription), so granting it there would offer a domain that can
+    // never send from.
+    features: all.features([connection.sender.key, organization.members.key]),
+    limits: all.limits({ actions: 5e3, members: 3, storage: gigabyte * 10 }),
+    marketing: {
+      description: "Tools to fine-tune campaigns and improve lead quality.",
+      features: [],
+      limits: [
+        ["Actions per month", "5,000"],
+        ["Affiliates", "Unlimited"],
+        ["Brands", "Unlimited"],
+        ["Campaigns", "Unlimited"],
+        ["Pages", "Unlimited"],
+        ["Members", "3"],
+        ["Storage", "10GB"]
+      ]
+    },
+    ...overage(2.5),
+    title: "Starter",
+    conversion: 2
+  },
+  DB00003: {
+    features: all.features([
+      connection.sender.key,
+      organization.advertisements.key,
+      organization.analytics.key,
+      organization.members.key,
+      organization.subdomain.key,
+      page.slug.key
+    ]),
+    limits: all.limits({ actions: 15e3, members: 5, storage: gigabyte * 20 }),
+    marketing: {
+      description: "Expand your reach and grow your lead pipeline.",
+      features: [
+        "Analytics",
+        "Custom subdomain / URLs",
+        "Confirmation page ads"
+      ],
+      limits: [
+        ["Actions per month", "15,000"],
+        ["Affiliates", "Unlimited"],
+        ["Brands", "Unlimited"],
+        ["Campaigns", "Unlimited"],
+        ["Pages", "Unlimited"],
+        ["Members", "5"],
+        ["Storage", "20GB"]
+      ]
+    },
+    ...overage(2),
+    title: "Pro",
+    conversion: 1.5
+  },
+  DB00004: {
+    features: all.features([
+      connection.sender.key,
+      organization.advertisements.key,
+      organization.analytics.key,
+      organization.members.key,
+      organization.subdomain.key,
+      page.slug.key
+    ]),
+    limits: all.limits({ actions: 4e4, members: 10, storage: gigabyte * 50 }),
+    marketing: {
+      description: "Accelerate acquisition with more power and flexibility.",
+      features: [
+        "Analytics",
+        "Custom subdomain / URLs",
+        "Confirmation page ads"
+      ],
+      limits: [
+        ["Actions per month", "40,000"],
+        ["Affiliates", "Unlimited"],
+        ["Brands", "Unlimited"],
+        ["Campaigns", "Unlimited"],
+        ["Pages", "Unlimited"],
+        ["Members", "10"],
+        ["Storage", "50GB"]
+      ]
+    },
+    ...overage(1.85),
+    title: "Premium",
+    conversion: 1
+  },
+  DB00005: {
+    features: all.features([
+      connection.sender.key,
+      organization.advertisements.key,
+      organization.analytics.key,
+      organization.members.key,
+      organization.subdomain.key,
+      page.slug.key
+    ]),
+    limits: all.limits({ actions: 1e5, members: infinite, storage: gigabyte * 100 }),
+    marketing: {
+      description: "Built for brands focused on results.",
+      features: [
+        "Analytics",
+        "Custom subdomain / URLs",
+        "Confirmation page ads"
+      ],
+      limits: [
+        ["Actions per month", "100,000"],
+        ["Affiliates", "Unlimited"],
+        ["Brands", "Unlimited"],
+        ["Campaigns", "Unlimited"],
+        ["Pages", "Unlimited"],
+        ["Members", "Unlimited"],
+        ["Storage", "100GB"]
+      ]
+    },
+    ...overage(1.5),
+    title: "Elite",
+    conversion: 0.5
+  }
+};
+var resolvePlan = (subscription) => {
+  var _a, _b;
+  const custom = subscription == null ? void 0 : subscription.custom;
+  if (!custom) return plans[subscription == null ? void 0 : subscription.plan] ?? free;
+  return {
+    // Reusing all.features / all.limits is what keeps a custom plan the same
+    // SHAPE as a catalog one: the base feature grants every plan carries, the
+    // campaign limits that are always infinite, and members defaulting to
+    // infinite when a deal does not name it.
+    conversion: custom.conversion ?? free.conversion,
+    custom: true,
+    // A custom plan is a negotiated PAID deal, so it carries the paid-tier
+    // baseline whether or not the deal thought to name it. Today that is the
+    // sending domain: every catalog paid tier grants it, and a custom plan
+    // silently lacking it would be a support ticket, not a pricing decision.
+    features: all.features([connection.sender.key, ...((_a = custom.features) == null ? void 0 : _a.granted) || []]),
+    limits: all.limits(((_b = custom.limits) == null ? void 0 : _b.organization) || {}),
+    // A custom plan stores its overage BARE on `custom.overages` — a different
+    // shape from the catalog's nested one. Number() so a deal stored as a string
+    // still resolves to cents-per-action; an unnamed overage stays undefined
+    // (it bills nothing) rather than becoming NaN.
+    actionCents: custom.overages == null ? void 0 : Number(custom.overages),
+    overages: { actions: custom.overages },
+    title: custom.title || "Custom"
+  };
+};
+var conversionRate = (subscription) => {
+  var _a;
+  return ((_a = resolvePlan(subscription)) == null ? void 0 : _a.conversion) ?? free.conversion;
+};
+
+// lib/transactions.js
+import { currentTraceId } from "@drawbridge/drawbridge-telemetry";
+var insertTransaction = async ({
+  db,
+  user,
+  type,
+  category,
+  source,
+  amount,
+  _id,
+  stripeInvoiceId,
+  stripeEventId,
+  session,
+  ...rest
+}) => {
+  const trace = currentTraceId();
+  await db.create({
+    authenticated: user,
+    collection: "transaction",
+    data: {
+      ..._id && { _id },
+      user: user == null ? void 0 : user.id,
+      type,
+      category,
+      source,
+      amount,
+      ...trace && { trace },
+      ...rest,
+      ...stripeInvoiceId && { stripeInvoiceId },
+      ...stripeEventId && { stripeEventId }
+    },
+    ...session && { options: { session } }
+  });
+};
+var debit = async ({
+  db,
+  user,
+  amount,
+  type,
+  category,
+  source,
+  stripeInvoiceId,
+  stripeEventId,
+  session,
+  ...rest
+}) => {
+  if (!Number.isInteger(amount) || amount <= 0) {
+    throw new Error(`debit() requires a positive integer amount, got ${amount}`);
+  }
+  if (!type) {
+    throw new Error('debit() requires a type (e.g., "ai")');
+  }
+  if (!source) {
+    throw new Error('debit() requires a source ("system" | "admin" | "user")');
+  }
+  await insertTransaction({
+    db,
+    user,
+    type,
+    category,
+    source,
+    amount: -amount,
+    stripeInvoiceId,
+    stripeEventId,
+    session,
+    ...rest
+  });
+};
+
+// lib/billing.js
+import { createLogger } from "@drawbridge/drawbridge-telemetry";
+var logger = createLogger();
+var MARKUP = 1.3;
+var cost = {
+  // gemini-3.5-flash — verified against Google's pricing page 2026-07-09:
+  // $0.15 cached / $1.50 input / $9.00 output per 1M tokens (thinking billed at
+  // output). ~3.6x the retired 2.5-flash output rate.
+  "gemini-3.5-flash": {
+    cached: 15,
+    input: 150,
+    output: 900
+  },
+  // gemini-3.5-flash-lite — verified against Google's pricing page 2026-08-20:
+  // $0.03 cached / $0.30 input / $2.50 output per 1M tokens (thinking billed at
+  // output). A fifth of flash on input, ~a quarter on output. Growth's assistant
+  // ranks the feed on this tier — one call per page — so its rows were the
+  // unpriced ones until now.
+  "gemini-3.5-flash-lite": {
+    cached: 3,
+    input: 30,
+    output: 250
+  },
+  "gemini-2.5-flash": {
+    cached: 3,
+    input: 30,
+    output: 250
+  },
+  "gemini-2.5-flash-image": {
+    cached: 3,
+    input: 30,
+    output: 3e3
+  },
+  // gemini-3-pro-image-preview — verified against Google's pricing page
+  // 2026-08-12: $2.00 input / $12.00 text output per 1M, and image output
+  // tokens at ~$120/1M (a 1K-2K image is 1120 tokens = $0.134, a 4K image
+  // 2000 tokens = $0.24). Encoded the flash-image way: one flat output rate
+  // that reproduces the per-image price from the tokens usageMetadata
+  // reports. Growth's hero generation runs this model today.
+  "gemini-3-pro-image-preview": {
+    cached: 20,
+    input: 200,
+    output: 12e3
+  }
+};
+var toolCost = {
+  search: 3.5
+};
+var toolPricing = Object.fromEntries(
+  Object.entries(toolCost).map(([tool, value]) => [
+    tool,
+    Math.ceil(value * MARKUP)
+  ])
+);
+var pricing = Object.fromEntries(
+  Object.entries(cost).map(([model, rates]) => [
+    model,
+    {
+      cached: Math.round(rates.cached * MARKUP),
+      input: Math.round(rates.input * MARKUP),
+      output: Math.round(rates.output * MARKUP)
+    }
+  ])
+);
+var sumCents = (rates, tokens) => Math.ceil(
+  (Number((tokens == null ? void 0 : tokens.cached) || 0) * rates.cached + Number((tokens == null ? void 0 : tokens.input) || 0) * rates.input + (Number((tokens == null ? void 0 : tokens.output) || 0) + Number((tokens == null ? void 0 : tokens.thinking) || 0)) * rates.output) / 1e6
+);
+var sumToolCents = (table, tools) => Object.entries(tools || {}).reduce(
+  (total, [name, used]) => total + (used && table[name] ? table[name] : 0),
+  0
+);
+var priceForRequest = (model, usage, tools) => {
+  const rates = pricing[model];
+  if (!rates) {
+    throw new Error(`Unknown model for pricing: ${model}`);
+  }
+  return sumCents(rates, usage) + Math.ceil(sumToolCents(toolPricing, tools));
+};
+var costForRequest = (model, usage, tools) => {
+  const rates = cost[model];
+  if (!rates) {
+    throw new Error(`Unknown model for cost: ${model}`);
+  }
+  return sumCents(rates, usage) + Math.ceil(sumToolCents(toolCost, tools));
+};
+var billRequest = async ({ db, user, model, usage, tools }) => {
+  const gross = priceForRequest(model, usage, tools);
+  const cogs = costForRequest(model, usage, tools);
+  await debit({
+    db,
+    user,
+    amount: gross,
+    type: "ai",
+    category: "usage",
+    source: "user",
+    ai: {
+      name: "google",
+      model,
+      tokens: usage,
+      tools,
+      rates: {
+        wholesale: cost[model],
+        retail: pricing[model]
+      },
+      totals: {
+        cost: cogs,
+        net: gross - cogs,
+        gross
+      }
+    }
+  });
+};
+var ai = {
+  // The rate tables themselves, in cents per 1,000,000 tokens (`tools` in cents
+  // per request). Read-only surface for lib/pricing.js — the fee math above is
+  // still the only thing that should compute from them.
+  rates: { wholesale: cost, retail: pricing, tools: { wholesale: toolCost, retail: toolPricing } },
+  // Retail cents for a request (what the user pays).
+  price: priceForRequest,
+  // Wholesale cents for a request (what we pay the provider).
+  cost: costForRequest,
+  // Deferred bill() the caller fires on success, so the debit lands only when
+  // the request succeeds and bundles into that request's Sentry trace. No user
+  // → a no-op.
+  bill: ({ db, user, model, usage, tools }) => (user == null ? void 0 : user.id) ? () => billRequest({ db, user, model, usage, tools }) : () => Promise.resolve()
+};
+var STANDARD_RATE_PER_GB = 8;
+var PREMIUM_RATE_PER_GB = 11;
+var STANDARD_CPM_CENTS = 0.15;
+var PREMIUM_CPM_CENTS = 0.25;
+var PREMIUM_HOSTS = /* @__PURE__ */ new Set();
+var LOCAL_FLAT_CENTS = 1;
+var REUSE_FLAT_CENTS = 1;
+var isPremium = (url) => {
+  try {
+    return PREMIUM_HOSTS.has(new URL(url).hostname);
+  } catch {
+    return false;
+  }
+};
+var ratePerGB = (url) => isPremium(url) ? PREMIUM_RATE_PER_GB : STANDARD_RATE_PER_GB;
+var cpmCents = (url) => isPremium(url) ? PREMIUM_CPM_CENTS : STANDARD_CPM_CENTS;
+var scrapeFee = ({ provider, bytes, requests, url, cold }) => {
+  if (!cold) return REUSE_FLAT_CENTS;
+  if (provider === "brightdata") {
+    return Math.ceil((bytes || 0) / 1e9 * ratePerGB(url) * 100 * MARKUP);
+  }
+  if (provider === "brightdata-unlocker") {
+    return Math.ceil((requests || 0) * cpmCents(url) * MARKUP);
+  }
+  return LOCAL_FLAT_CENTS;
+};
+var scrapeBreakdown = ({ provider, bytes, requests, url }) => {
+  if (provider === "brightdata") {
+    return {
+      provider,
+      basis: "bytes",
+      units: bytes || 0,
+      rate: ratePerGB(url),
+      rateUnit: "GB",
+      cents: scrapeFee({ provider, bytes, url, cold: true })
+    };
+  }
+  if (provider === "brightdata-unlocker") {
+    return {
+      provider,
+      basis: "requests",
+      units: requests || 0,
+      // cpmCents is cents-per-request; ×10 expresses it as dollars per 1,000.
+      rate: cpmCents(url) * 10,
+      rateUnit: "1K requests",
+      cents: scrapeFee({ provider, requests, url, cold: true })
+    };
+  }
+  return { provider: provider || "local", basis: "local", units: null, rate: null, rateUnit: null, cents: LOCAL_FLAT_CENTS };
+};
+var scrape = {
+  // Cents for a scrape given its provider/bytes/cold basis.
+  fee: scrapeFee,
+  // Itemized cold-fee breakdown (basis/units/rate/cents) for display + the scrape doc.
+  breakdown: scrapeBreakdown,
+  // Deferred bill(scrapeId) the scrape store's resolve() hands the generation
+  // flow. Atomically claims the cold (first-time) fee via the `charged` flag so
+  // a BrightData scrape's metered cost is recovered ONCE; later reuses pay the
+  // flat rate. Best-effort — a billing hiccup never fails generation.
+  bill: ({ controller, user, page: page2, url }) => async (scrapeId) => {
+    var _a;
+    if (!(user == null ? void 0 : user.id) || !scrapeId) return;
+    try {
+      const claim = await controller.update({
+        collection: "scrape",
+        data: { $set: { charged: true } },
+        options: { bypassDocumentValidation: true },
+        query: { id: scrapeId, charged: { $ne: true } }
+      });
+      const cents = scrapeFee({
+        provider: (_a = page2 == null ? void 0 : page2.provider) == null ? void 0 : _a.name,
+        bytes: page2 == null ? void 0 : page2.bytes,
+        requests: page2 == null ? void 0 : page2.requests,
+        url: (page2 == null ? void 0 : page2.url) || url,
+        cold: Boolean(claim == null ? void 0 : claim.value)
+      });
+      if (cents > 0) await debit({ db: controller, user, amount: cents, type: "ai", category: "usage", source: "user" });
+    } catch (error) {
+      logger.error(error, { extra: { action: "generation.scrape.bill", scrapeId } });
+    }
+  }
+};
+
+// lib/pricing.js
+var channels = {
+  email: {
+    actionsPerSend: 1,
+    includedInAllowance: true
+  },
+  sms: {
+    // Two actions PER SEGMENT (a long message is several segments), billed from
+    // the FIRST segment and never drawn from the plan's included allowance —
+    // carrier cost is real from message one, so there is no free tier of it.
+    actionsPerSegment: 2,
+    includedInAllowance: false
+  }
+};
+export {
+  LOCAL_FLAT_CENTS,
+  MARKUP,
+  PREMIUM_CPM_CENTS,
+  PREMIUM_RATE_PER_GB,
+  REUSE_FLAT_CENTS,
+  STANDARD_CPM_CENTS,
+  STANDARD_RATE_PER_GB,
+  ai,
+  channels,
+  conversionRate,
+  free,
+  plans,
+  resolvePlan,
+  scrape,
+  unitAmountDecimal
+};