Functional Weave
Code in Rust

subscriptions.stripe-state@1.0.0

impl/rust.rs

11,760 bytes · the Rust implementation · view raw

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

const STATUSES: [&str; 8] = ["incomplete", "incomplete_expired", "trialing", "active", "past_due", "canceled", "unpaid", "paused"];
const SUBSCRIPTION_EVENTS: [&str; 6] = [
    "customer.subscription.created",
    "customer.subscription.updated",
    "customer.subscription.deleted",
    "customer.subscription.paused",
    "customer.subscription.resumed",
    "customer.subscription.trial_will_end",
];

// An id Stripe sends either as a string or, when expanded, as an object with one.
fn id_of(v: &Value) -> Option<String> {
    match v {
        Value::Str(s) if !s.is_empty() => Some(s.clone()),
        Value::Obj(_) => match v.get("id") {
            Value::Str(s) if !s.is_empty() => Some(s.clone()),
            _ => None,
        },
        _ => None,
    }
}

fn opt_int(o: &Value, key: &str) -> Option<i64> {
    match o.get(key) {
        Value::Null => None,
        Value::Int(i) => Some(*i),
        _ => panic!("subscription field {} must be a whole number or null", key),
    }
}

fn entitled_for(status: &str) -> bool {
    status == "active" || status == "trialing" || status == "past_due"
}

// Where an invoice event happened after a snapshot was taken, the snapshot
// does not know about the payment yet: keep the invoice's effect on top.
fn with_invoice_effect(status: &str, payment_failed: bool) -> String {
    if !payment_failed && (status == "incomplete" || status == "past_due" || status == "unpaid") {
        return "active".to_string();
    }
    if payment_failed && status == "active" {
        return "past_due".to_string();
    }
    status.to_string()
}

fn invoice_subscription(invoice: &Value) -> Option<String> {
    if let Some(direct) = id_of(invoice.get("subscription")) {
        return Some(direct);
    }
    // API versions from 2025 move it under parent.subscription_details.
    id_of(invoice.get("parent").get("subscription_details").get("subscription"))
}

/// Folds one verified Stripe webhook event into the stored state of one
/// subscription. Stripe does not promise delivery order or delivery once, so
/// subscription snapshots and invoice events each keep their own clock and an
/// older one is ignored, a redelivered event changes nothing, and a cancelled
/// subscription stays cancelled.
///
/// # Panics
/// Panics on a malformed event, or one for another subscription than `state`.
pub fn apply_stripe_event(state: Option<&SubscriptionState>, event: &Value) -> Option<SubscriptionState> {
    if !matches!(event, Value::Obj(_)) {
        panic!("event must be a JSON object");
    }
    let event_id = match event.get("id") {
        Value::Str(s) if !s.is_empty() => s.clone(),
        _ => panic!("event id must be a non-empty string"),
    };
    let kind = match event.get("type") {
        Value::Str(s) if !s.is_empty() => s.clone(),
        _ => panic!("event type must be a non-empty string"),
    };
    let created = match event.get("created") {
        Value::Int(i) if *i >= 0 => *i,
        _ => panic!("event created must be a whole number of seconds"),
    };
    let obj = event.get("object");
    if !matches!(obj, Value::Obj(_)) {
        panic!("event object must be a JSON object");
    }
    if let Some(s) = state {
        if event_id == s.last_event_id {
            return Some(s.clone());
        }
    }
    let kind = kind.as_str();

    if SUBSCRIPTION_EVENTS.contains(&kind) {
        let id = id_of(obj.get("id"));
        let customer = id_of(obj.get("customer"));
        let raw_status = match obj.get("status") {
            Value::Str(s) => Some(s.clone()),
            _ => None,
        };
        let (id, customer, raw_status) = match (id, customer, raw_status) {
            (Some(a), Some(b), Some(c)) => (a, b, c),
            _ => panic!("subscription object needs id, customer and status"),
        };
        if !STATUSES.contains(&raw_status.as_str()) {
            panic!("unknown subscription status \"{}\"", raw_status);
        }
        if let Some(s) = state {
            if id != s.subscription_id {
                panic!("event is for subscription {}, not {}", id, s.subscription_id);
            }
        }
        let snapshot_status = if kind == "customer.subscription.deleted" { "canceled".to_string() } else { raw_status };
        if let Some(s) = state {
            // Cancelled is final in Stripe: a late snapshot never revives it.
            if s.status == "canceled" && snapshot_status != "canceled" {
                return Some(s.clone());
            }
            if created < s.subscription_event_at {
                return Some(s.clone());
            }
        }
        let item = obj.get("items").get("data").at(0);
        let item = if matches!(item, Value::Obj(_)) { item.clone() } else { Value::Obj(vec![]) };
        let quantity = opt_int(&item, "quantity").unwrap_or(1);
        let period_start = opt_int(obj, "current_period_start").or_else(|| opt_int(&item, "current_period_start"));
        let period_end = opt_int(obj, "current_period_end").or_else(|| opt_int(&item, "current_period_end"));
        let cape = match obj.get("cancel_at_period_end") {
            Value::Null => false,
            Value::Bool(b) => *b,
            _ => panic!("subscription field cancel_at_period_end must be true or false"),
        };
        let payment_failed = state.map(|s| s.payment_failed).unwrap_or(false);
        let invoice_event_at = state.map(|s| s.invoice_event_at).unwrap_or(0);
        let status = if invoice_event_at > created {
            with_invoice_effect(&snapshot_status, payment_failed)
        } else {
            snapshot_status
        };
        let latest = id_of(obj.get("latest_invoice")).or_else(|| state.and_then(|s| s.latest_invoice_id.clone()));
        return Some(SubscriptionState {
            subscription_id: id,
            customer_id: customer,
            entitled: entitled_for(&status),
            status,
            price_id: id_of(item.get("price")),
            quantity,
            current_period_start: period_start,
            current_period_end: period_end,
            cancel_at_period_end: cape,
            cancel_at: opt_int(obj, "cancel_at"),
            canceled_at: opt_int(obj, "canceled_at"),
            ended_at: opt_int(obj, "ended_at"),
            trial_end: opt_int(obj, "trial_end"),
            latest_invoice_id: latest,
            payment_failed,
            subscription_event_at: created,
            invoice_event_at,
            last_event_id: event_id.clone(),
        });
    }

    let paid = kind == "invoice.paid" || kind == "invoice.payment_succeeded";
    if paid || kind == "invoice.payment_failed" {
        let sub = match invoice_subscription(obj) {
            Some(s) => s,
            None => return state.cloned(),
        };
        let invoice_id = id_of(obj.get("id"));
        let s = match state {
            None => {
                let customer = match id_of(obj.get("customer")) {
                    Some(c) => c,
                    None => panic!("invoice object needs customer"),
                };
                let status = if paid { "active" } else { "incomplete" };
                return Some(SubscriptionState {
                    subscription_id: sub,
                    customer_id: customer,
                    status: status.to_string(),
                    price_id: None,
                    quantity: 1,
                    current_period_start: None,
                    current_period_end: None,
                    cancel_at_period_end: false,
                    cancel_at: None,
                    canceled_at: None,
                    ended_at: None,
                    trial_end: None,
                    latest_invoice_id: invoice_id,
                    payment_failed: !paid,
                    entitled: entitled_for(status),
                    subscription_event_at: 0,
                    invoice_event_at: created,
                    last_event_id: event_id.clone(),
                });
            }
            Some(s) => s,
        };
        if sub != s.subscription_id {
            panic!("event is for subscription {}, not {}", sub, s.subscription_id);
        }
        if created < s.invoice_event_at {
            return Some(s.clone());
        }
        let status = with_invoice_effect(&s.status, !paid);
        let mut next = s.clone();
        next.entitled = entitled_for(&status);
        next.status = status;
        next.latest_invoice_id = invoice_id.or_else(|| s.latest_invoice_id.clone());
        next.payment_failed = !paid;
        next.invoice_event_at = created;
        next.last_event_id = event_id.clone();
        return Some(next);
    }

    state.cloned()
}

fn opt_int_value(v: Option<i64>) -> Value {
    v.map(Value::Int).unwrap_or(Value::Null)
}

fn opt_str_value(v: &Option<String>) -> Value {
    v.as_ref().map(|s| Value::str(s)).unwrap_or(Value::Null)
}

pub fn subscription_state_to_value(s: &SubscriptionState) -> Value {
    Value::obj(vec![
        ("subscriptionId", Value::str(&s.subscription_id)),
        ("customerId", Value::str(&s.customer_id)),
        ("status", Value::str(&s.status)),
        ("priceId", opt_str_value(&s.price_id)),
        ("quantity", Value::Int(s.quantity)),
        ("currentPeriodStart", opt_int_value(s.current_period_start)),
        ("currentPeriodEnd", opt_int_value(s.current_period_end)),
        ("cancelAtPeriodEnd", Value::Bool(s.cancel_at_period_end)),
        ("cancelAt", opt_int_value(s.cancel_at)),
        ("canceledAt", opt_int_value(s.canceled_at)),
        ("endedAt", opt_int_value(s.ended_at)),
        ("trialEnd", opt_int_value(s.trial_end)),
        ("latestInvoiceId", opt_str_value(&s.latest_invoice_id)),
        ("paymentFailed", Value::Bool(s.payment_failed)),
        ("entitled", Value::Bool(s.entitled)),
        ("subscriptionEventAt", Value::Int(s.subscription_event_at)),
        ("invoiceEventAt", Value::Int(s.invoice_event_at)),
        ("lastEventId", Value::str(&s.last_event_id)),
    ])
}

fn state_from_value(v: &Value) -> SubscriptionState {
    let text = |k: &str| match v.get(k) {
        Value::Str(s) => s.clone(),
        _ => panic!("state field {} must be a string", k),
    };
    let opt_text = |k: &str| match v.get(k) {
        Value::Str(s) => Some(s.clone()),
        _ => None,
    };
    let int = |k: &str| match v.get(k) {
        Value::Int(i) => *i,
        _ => panic!("state field {} must be a whole number", k),
    };
    let opt = |k: &str| match v.get(k) {
        Value::Int(i) => Some(*i),
        _ => None,
    };
    SubscriptionState {
        subscription_id: text("subscriptionId"),
        customer_id: text("customerId"),
        status: text("status"),
        price_id: opt_text("priceId"),
        quantity: int("quantity"),
        current_period_start: opt("currentPeriodStart"),
        current_period_end: opt("currentPeriodEnd"),
        cancel_at_period_end: v.get("cancelAtPeriodEnd").as_bool(),
        cancel_at: opt("cancelAt"),
        canceled_at: opt("canceledAt"),
        ended_at: opt("endedAt"),
        trial_end: opt("trialEnd"),
        latest_invoice_id: opt_text("latestInvoiceId"),
        payment_failed: v.get("paymentFailed").as_bool(),
        entitled: v.get("entitled").as_bool(),
        subscription_event_at: int("subscriptionEventAt"),
        invoice_event_at: int("invoiceEventAt"),
        last_event_id: text("lastEventId"),
    }
}

pub fn fune_vector(args: &[Value]) -> Value {
    let state = match &args[0] {
        Value::Null => None,
        v => Some(state_from_value(v)),
    };
    match apply_stripe_event(state.as_ref(), &args[1]) {
        Some(s) => subscription_state_to_value(&s),
        None => Value::Null,
    }
}