@omega.js/backend 0.1.0

package/test/events/payments/webhook-uid-trust.test.js

@@ -0,0 +1,203 @@
+/**
+ * Test: on a successful lookup, the PROVIDER's record says whose event this is
+ *
+ * The failed-lookup half of the trust rule was closed by
+ * [#506](https://github.com/Omega-JS-Stack/omega/issues/506). This is the
+ * successful half: the event's own payload carried a uid, and that uid steered
+ * the write — `library.getUid(resource)` was consulted only when the payload had
+ * none. So an event naming a REAL subscription id with a different metadata uid
+ * moved that subscription onto the uid the caller chose
+ * ([#509](https://github.com/Omega-JS-Stack/omega/issues/509)).
+ *
+ * The provider's record steers now, and the payload's uid is only what it is
+ * checked against: a mismatch refuses the event and writes nothing at all.
+ *
+ * Stripe is the provider under test on purpose — `provider=test` is a
+ * pass-through of Stripe's shape (its fetchResource may legitimately answer with
+ * the payload object), so a mismatch can never arise there and proving anything
+ * against it would prove nothing. Its protection stays the #506 production
+ * refusal. The SDK is the ONE thing stubbed: it is the transport boundary, and
+ * everything inward — the library, the trigger, the transformers, the writes —
+ * runs for real.
+ *
+ * Plain-node control-flow test (no emulator, no network): the real trigger module
+ * runs against the shared in-memory Firestore stand-in (_webhook-harness.js).
+ *
+ * Run: npx omega test backend:events/payments/webhook-uid-trust
+ */
+const assert = require('node:assert');
+const { runTrigger, subscriptionPayload } = require('./_webhook-harness.js');
+const Stripe = require('../../../dist/manager/libraries/payment/providers/stripe.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+// The subscriber the subscription actually belongs to, on Stripe's own record
+const OWNER_UID = '_test-uid-trust-owner';
+const OWNER_ORDER_ID = '5091-5091-5091';
+
+// The uid the forged event claims, and the order it names
+const FORGED_UID = '_test-uid-trust-forged';
+const FORGED_ORDER_ID = '5090-5090-5090';
+
+const RESOURCE_ID = 'sub_test_uid_trust';
+const EVENT_ID = '_test-uid-trust-evt';
+
+/** Run fn with the library's SDK replaced by one that answers with `subscription` */
+async function withStripeAnswering(subscription, fn) {
+  const realInit = Stripe.init;
+
+  Stripe.init = () => ({ subscriptions: { retrieve: async () => subscription } });
+
+  try {
+    return await fn();
+  } finally {
+    Stripe.init = realInit;
+  }
+}
+
+/**
+ * The event under test: a subscription update whose payload claims `payloadUid`,
+ * answered by a Stripe record that carries `recordMetadata`.
+ */
+function runSubscriptionUpdated({ payloadUid, payloadOrderId, recordMetadata }) {
+  const record = subscriptionPayload({ uid: OWNER_UID, orderId: OWNER_ORDER_ID, resourceId: RESOURCE_ID });
+
+  record.metadata = recordMetadata;
+
+  return withStripeAnswering(record, () => runTrigger({
+    uid: payloadUid,
+    orderId: payloadOrderId,
+    resourceId: RESOURCE_ID,
+    eventId: EVENT_ID,
+    provider: 'stripe',
+    payload: subscriptionPayload({ uid: payloadUid, orderId: payloadOrderId, resourceId: RESOURCE_ID }),
+    // Both uids are real accounts in this project — what is forged is the CLAIM,
+    // not the identity, so the #399 auth guard is not what refuses this event
+    authUids: [OWNER_UID, FORGED_UID],
+  }));
+}
+
+/** The forged event: a real subscription id, someone else's uid in the metadata */
+function runForgedEvent() {
+  return runSubscriptionUpdated({
+    payloadUid: FORGED_UID,
+    payloadOrderId: FORGED_ORDER_ID,
+    recordMetadata: { uid: OWNER_UID, orderId: OWNER_ORDER_ID },
+  });
+}
+
+module.exports = defineCases({
+  description: 'A webhook write is steered by the uid on the provider\'s record, never by the uid its payload claimed',
+  type: 'group',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'a forged uid on a real subscription writes nothing to the forged uid',
+
+      async run() {
+        const { store } = await runForgedEvent();
+
+        assert.ok(!store.get(`users/${FORGED_UID}`), 'the uid the caller chose must never receive a subscription it did not buy');
+        assert.ok(!store.get(`payments-orders/${FORGED_ORDER_ID}`), 'nor the order behind it');
+        assert.ok(!store.get(`payments-intents/${FORGED_ORDER_ID}`), 'nor an intent closed out for it');
+      },
+    },
+
+    {
+      name: 'the real owner is not written either — a refused event acts on nobody',
+
+      async run() {
+        const { store } = await runForgedEvent();
+
+        assert.ok(!store.get(`users/${OWNER_UID}`), 'a mismatch is refused, not redirected: nothing about this event is trustworthy enough to act on');
+        assert.ok(!store.get(`payments-orders/${OWNER_ORDER_ID}`), 'and no order is written under the real owner');
+      },
+    },
+
+    {
+      name: 'the refusal is acknowledged on the event doc and names both uids',
+
+      async run() {
+        const { store } = await runForgedEvent();
+        const event = store.get(`payments-webhooks/${EVENT_ID}`);
+
+        assert.equal(event.status, 'completed', 'no retry can make the payload agree with the provider — the event must not be redelivered forever');
+        assert.equal(event.refusal?.reason, 'uid-mismatch', 'the stamp names what is wrong');
+        assert.equal(event.refusal?.payloadUid, FORGED_UID, 'the stamp names the uid the payload claimed');
+        assert.equal(event.refusal?.providerUid, OWNER_UID, 'and the uid the provider\'s record actually carries');
+        assert.equal(event.transition, null, 'nothing happened to a subscription, so the trail must not say it did');
+        assert.ok(!event.retryCount, 'a terminal decision never burns the retry ladder');
+      },
+    },
+
+    {
+      name: 'the refusal is loud and names the provider, the resource and both uids',
+
+      async run() {
+        const { logs } = await runForgedEvent();
+        const output = logs.join('\n');
+
+        assert.match(output, /UID MISMATCH/, 'the refusal is loud');
+        assert.match(output, /stripe/, 'the log names the provider that was asked');
+        assert.match(output, new RegExp(`subscription ${RESOURCE_ID}`), 'the log names the resource the event claimed');
+        assert.match(output, new RegExp(FORGED_UID), 'the log names the claimed uid');
+        assert.match(output, new RegExp(OWNER_UID), 'and the uid the provider answered with');
+      },
+    },
+
+    {
+      name: 'a payload uid that AGREES with the provider still writes as before',
+
+      async run() {
+        const { store } = await runSubscriptionUpdated({
+          payloadUid: OWNER_UID,
+          payloadOrderId: OWNER_ORDER_ID,
+          recordMetadata: { uid: OWNER_UID, orderId: OWNER_ORDER_ID },
+        });
+
+        assert.ok(!store.get(`payments-webhooks/${EVENT_ID}`)?.refusal, 'an event whose claim matches the record is refused nothing');
+        assert.equal(store.get(`users/${OWNER_UID}`)?.subscription?.status, 'active', 'the subscription lands on the owner\'s doc');
+        assert.equal(store.get(`payments-orders/${OWNER_ORDER_ID}`)?.owner, OWNER_UID, 'the order is written as before');
+      },
+    },
+
+    {
+      name: 'a provider record with no uid on it lets the payload steer, loudly',
+
+      async run() {
+        // Chargebee hosted-page checkouts are the real instance of this: the
+        // subscription carries no meta_data until the backfill runs. There is
+        // nothing to check the payload against, so it steers — and the log says so.
+        const { store, logs } = await runSubscriptionUpdated({
+          payloadUid: FORGED_UID,
+          payloadOrderId: FORGED_ORDER_ID,
+          recordMetadata: { orderId: FORGED_ORDER_ID },
+        });
+
+        assert.ok(!store.get(`payments-webhooks/${EVENT_ID}`)?.refusal, 'with no provider uid to disagree with, there is no mismatch to refuse');
+        assert.equal(store.get(`users/${FORGED_UID}`)?.subscription?.status, 'active', 'the payload uid steers the write');
+        assert.match(logs.join('\n'), /UID FALLBACK/, 'the fallback is named out loud — this write was never cross-checked');
+      },
+    },
+
+    {
+      name: 'a payload with no uid at all still resolves it from the provider record',
+
+      async run() {
+        // The pre-existing resolution path ([#347] PayPal PAYMENT.SALE) — the
+        // payload carries no uid, so the provider's record is the only source.
+        const { store } = await runSubscriptionUpdated({
+          payloadUid: null,
+          payloadOrderId: OWNER_ORDER_ID,
+          recordMetadata: { uid: OWNER_UID, orderId: OWNER_ORDER_ID },
+        });
+
+        const event = store.get(`payments-webhooks/${EVENT_ID}`);
+
+        assert.ok(!event.refusal, 'a payload that claims nothing contradicts nothing');
+        assert.equal(event.owner, OWNER_UID, 'the resolved uid is persisted on the event doc');
+        assert.equal(store.get(`users/${OWNER_UID}`)?.subscription?.status, 'active', 'the subscription lands on the uid the provider named');
+      },
+    },
+  ],
+});

package/test/events/payments/webhook-user-without-auth.test.js

@@ -0,0 +1,161 @@
+/**
+ * Test: a webhook for a uid with no auth user never creates a user doc
+ *
+ * A local QA checkout runs against the emulator with real test-mode keys, and the
+ * provider delivers the resulting webhooks to the DEPLOYED backend (the emulator
+ * has no webhook path). `customer.subscription.created` then resolved an
+ * emulator-only uid and minted a LIVE users/{uid} carrying nothing but a
+ * subscription block — an orphan the users migration later had to clean up
+ * ([#399](https://github.com/Omega-JS-Stack/omega/issues/399)).
+ *
+ * The pipeline now refuses to CREATE a user doc for a uid this project has no auth
+ * user for, and stamps the refusal on the event's own doc. A uid that HAS an auth
+ * user is untouched by the guard, which the last case pins.
+ *
+ * Plain-node control-flow test (no emulator, no network): the real trigger module
+ * runs against the shared in-memory Firestore stand-in (_webhook-harness.js), whose
+ * auth store is exactly the list of uids that exist.
+ *
+ * Run: npm test -- backend:events/payments/webhook-user-without-auth
+ */
+const assert = require('node:assert');
+const { runTrigger } = require('./_webhook-harness.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+const UID = '_test-journey-flows-upgrade';
+const ORDER_ID = '2403-2403-2403';
+const RESOURCE_ID = '_test-orphan-subscription';
+const EVENT_ID = '_test-orphan-uid-evt';
+
+/** The subscription event this suite is about, with only the starting state left to choose */
+function runSubscriptionCreated({ authUids, seed = {}, reporting = true }) {
+  return runTrigger({
+    uid: UID,
+    orderId: ORDER_ID,
+    resourceId: RESOURCE_ID,
+    eventId: EVENT_ID,
+    eventType: 'customer.subscription.created',
+    authUids: authUids,
+    seed: seed,
+    reporting: reporting,
+  });
+}
+
+/** The user doc of a subscriber who already exists — what an UPDATE lands on */
+function existingUser() {
+  return {
+    auth: { uid: UID, email: `${UID}@example.com` },
+    roles: {},
+    subscription: { product: { id: 'basic', name: 'Basic' }, status: 'cancelled' },
+  };
+}
+
+module.exports = defineCases({
+  description: 'A payment webhook never creates a user doc for a uid with no auth user',
+  type: 'group',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'a uid with no auth user gets NO user doc, and no order or intent behind it',
+
+      async run() {
+        const { store } = await runSubscriptionCreated({ authUids: [] });
+
+        assert.ok(!store.get(`users/${UID}`), 'a payment event must never mint a user doc');
+        assert.ok(!store.get(`payments-orders/${ORDER_ID}`), 'the event was refused, so nothing else is written either');
+        assert.ok(!store.get(`payments-intents/${ORDER_ID}`), 'no intent is closed out for a refused event');
+      },
+    },
+
+    {
+      name: 'the refusal is stamped on the event doc and the event is not retryable',
+
+      async run() {
+        const { store } = await runSubscriptionCreated({ authUids: [] });
+        const event = store.get(`payments-webhooks/${EVENT_ID}`);
+
+        assert.equal(event.refusal?.reason, 'user-without-auth', 'the stamp names what is wrong');
+        assert.equal(event.status, 'completed', 'the event reached a decision — the provider must not redeliver it forever');
+        assert.equal(event.transition, null, 'nothing happened to a subscription, so the trail must not say it did');
+        assert.equal(event.owner, UID, 'the uid it resolved to stays on the record');
+      },
+    },
+
+    {
+      name: 'the refusal is loud and names the uid and the event',
+
+      async run() {
+        const { logs } = await runSubscriptionCreated({ authUids: [] });
+        const output = logs.join('\n');
+
+        assert.match(output, /USER WITHOUT AUTH/, 'the refusal is loud');
+        assert.match(output, new RegExp(`uid=${UID}`), 'the warning names the uid');
+        assert.match(output, new RegExp(`event=${EVENT_ID}`), 'the warning names the event');
+      },
+    },
+
+    {
+      name: 'the refusal reports a warning carrying the uid, the event and the reason',
+
+      async run() {
+        const { captures } = await runSubscriptionCreated({ authUids: [] });
+
+        assert.equal(captures.length, 1, 'the refusal reports exactly once');
+
+        const capture = captures[0];
+
+        assert.equal(capture.level, 'warning', 'a refusal is a warning, not a server fault');
+        assert.match(capture.message, /user without auth/i, 'the message says what happened');
+        assert.equal(capture.extra.uid, UID, 'the uid is the join key back to the account');
+        assert.equal(capture.extra.eventId, EVENT_ID, 'the event is nameable in the provider dashboard');
+        assert.equal(capture.extra.reason, 'user-without-auth', 'the refusal reason matches the stamp on the doc');
+        assert.equal(capture.user?.id, UID, 'the uid rides as the user id');
+        assert.ok(!JSON.stringify(capture).includes('@'), 'no email is ever assembled into the report');
+      },
+    },
+
+    {
+      name: 'with no DSN configured the refusal still lands, reporting nothing',
+
+      async run() {
+        // `libraries.sentry` is null whenever no DSN is set — the capture must be a
+        // clean no-op, never a second failure on top of the refusal
+        const { store, captures } = await runSubscriptionCreated({ authUids: [], reporting: false });
+
+        assert.equal(captures.length, 0, 'nothing is reported when reporting is off');
+        assert.equal(store.get(`payments-webhooks/${EVENT_ID}`)?.refusal?.reason, 'user-without-auth', 'the stamp still lands');
+        assert.ok(!store.get(`users/${UID}`), 'and the guard still refuses the write');
+      },
+    },
+
+    {
+      name: 'an EXISTING user doc updates even with no auth user behind it',
+
+      async run() {
+        // The guard is about CREATION only. A customer whose auth record was
+        // deleted still has a live subscription to keep in step, and refusing here
+        // would strand it — so an existing doc is never even looked up in Auth.
+        const { store, captures } = await runSubscriptionCreated({ authUids: [], seed: { [`users/${UID}`]: existingUser() } });
+
+        assert.equal(captures.length, 0, 'an ordinary update reports nothing — only the refusal does');
+        assert.equal(store.get(`users/${UID}`)?.subscription?.status, 'active', 'the subscription updates exactly as before');
+        assert.equal(store.get(`users/${UID}`)?.auth?.email, `${UID}@example.com`, 'the rest of the doc is untouched');
+        assert.ok(!store.get(`payments-webhooks/${EVENT_ID}`)?.refusal, 'an update is refused nothing');
+        assert.equal(store.get(`payments-orders/${ORDER_ID}`)?.owner, UID, 'the order is written as before');
+      },
+    },
+
+    {
+      name: 'a uid WITH an auth user still gets its subscription written',
+
+      async run() {
+        const { store } = await runSubscriptionCreated({ authUids: [UID] });
+
+        assert.ok(!store.get(`payments-webhooks/${EVENT_ID}`)?.refusal, 'a real customer is refused nothing');
+        assert.equal(store.get(`users/${UID}`)?.subscription?.status, 'active', 'the subscription lands on the user doc as before');
+        assert.equal(store.get(`payments-orders/${ORDER_ID}`)?.owner, UID, 'the order is written as before');
+      },
+    },
+  ],
+});

package/test/fixtures/chargebee/invoice-one-time.json

@@ -0,0 +1,27 @@
+{
+  "id": "inv_cb_onetime_001",
+  "customer_id": "cb_cust_006",
+  "status": "paid",
+  "total": 999,
+  "amount_paid": 999,
+  "amount_due": 0,
+  "recurring": false,
+  "date": 1700000000,
+  "paid_at": 1700000001,
+  "currency_code": "USD",
+  "object": "invoice",
+  "meta_data": "{\"uid\":\"test-uid-006\",\"orderId\":\"6789-0123-4567\",\"productId\":\"credits-100\"}",
+  "line_items": [
+    {
+      "id": "li_cb_001",
+      "date_from": 1700000000,
+      "date_to": 1700000000,
+      "unit_amount": 999,
+      "quantity": 1,
+      "amount": 999,
+      "description": "100 Credits",
+      "entity_type": "charge",
+      "object": "line_item"
+    }
+  ]
+}

package/test/fixtures/chargebee/subscription-active.json

@@ -0,0 +1,44 @@
+{
+  "id": "cb_sub_active_001",
+  "customer_id": "cb_cust_001",
+  "status": "active",
+  "current_term_start": 1700000000,
+  "current_term_end": 1702592000,
+  "next_billing_at": 1702592000,
+  "created_at": 1697321600,
+  "started_at": 1697321600,
+  "activated_at": 1697321600,
+  "updated_at": 1700000000,
+  "has_scheduled_changes": false,
+  "channel": "web",
+  "resource_version": 1700000000000,
+  "deleted": false,
+  "object": "subscription",
+  "currency_code": "USD",
+  "subscription_items": [
+    {
+      "item_price_id": "somiibo-pro-monthly",
+      "item_type": "plan",
+      "quantity": 1,
+      "unit_price": 499,
+      "amount": 499,
+      "object": "subscription_item"
+    }
+  ],
+  "meta_data": "{\"uid\":\"test-uid-001\",\"orderId\":\"1234-5678-9012\"}",
+  "shipping_address": {
+    "first_name": "Test",
+    "last_name": "User",
+    "line1": "123 Main Street",
+    "city": "San Francisco",
+    "state": "CA",
+    "country": "US",
+    "validation_status": "not_validated",
+    "object": "shipping_address"
+  },
+  "due_invoices_count": 0,
+  "mrr": 499,
+  "exchange_rate": 1,
+  "base_currency_code": "USD",
+  "has_scheduled_advance_invoices": false
+}

package/test/fixtures/chargebee/subscription-cancelled.json

@@ -0,0 +1,42 @@
+{
+  "id": "cb_sub_cancelled_001",
+  "customer_id": "cb_cust_002",
+  "status": "cancelled",
+  "current_term_start": 1697321600,
+  "current_term_end": 1700000000,
+  "created_at": 1694643200,
+  "started_at": 1694643200,
+  "activated_at": 1694643200,
+  "cancelled_at": 1699500000,
+  "updated_at": 1699500000,
+  "has_scheduled_changes": false,
+  "channel": "web",
+  "resource_version": 1699500000000,
+  "deleted": false,
+  "object": "subscription",
+  "currency_code": "USD",
+  "subscription_items": [
+    {
+      "item_price_id": "somiibo-pro-annually",
+      "item_type": "plan",
+      "quantity": 1,
+      "unit_price": 4999,
+      "amount": 4999,
+      "object": "subscription_item"
+    }
+  ],
+  "meta_data": "{\"uid\":\"test-uid-002\",\"orderId\":\"2345-6789-0123\"}",
+  "shipping_address": {
+    "first_name": "Cancelled",
+    "last_name": "User",
+    "line1": "456 Oak Avenue",
+    "city": "New York",
+    "state": "NY",
+    "country": "US",
+    "validation_status": "not_validated",
+    "object": "shipping_address"
+  },
+  "due_invoices_count": 0,
+  "mrr": 0,
+  "has_scheduled_advance_invoices": false
+}

package/test/fixtures/chargebee/subscription-in-trial.json

@@ -0,0 +1,41 @@
+{
+  "id": "cb_sub_trial_001",
+  "customer_id": "cb_cust_003",
+  "status": "in_trial",
+  "trial_start": 1700000000,
+  "trial_end": 1701209600,
+  "next_billing_at": 1701209600,
+  "created_at": 1700000000,
+  "started_at": 1700000000,
+  "updated_at": 1700000000,
+  "has_scheduled_changes": false,
+  "channel": "web",
+  "resource_version": 1700000000000,
+  "deleted": false,
+  "object": "subscription",
+  "currency_code": "USD",
+  "subscription_items": [
+    {
+      "item_price_id": "somiibo-pro-monthly",
+      "item_type": "plan",
+      "quantity": 1,
+      "unit_price": 499,
+      "amount": 499,
+      "object": "subscription_item"
+    }
+  ],
+  "meta_data": "{\"uid\":\"test-uid-003\",\"orderId\":\"3456-7890-1234\"}",
+  "shipping_address": {
+    "first_name": "Trial",
+    "last_name": "User",
+    "line1": "789 Elm Drive",
+    "city": "Chicago",
+    "state": "IL",
+    "country": "US",
+    "validation_status": "not_validated",
+    "object": "shipping_address"
+  },
+  "due_invoices_count": 0,
+  "mrr": 0,
+  "has_scheduled_advance_invoices": false
+}

package/test/fixtures/chargebee/subscription-legacy-plan.json

@@ -0,0 +1,41 @@
+{
+  "id": "AzZMxvTYTQUmw1Iw7",
+  "plan_id": "somiibo-premium-monthly-1",
+  "plan_quantity": 1,
+  "plan_unit_price": 1995,
+  "billing_period": 1,
+  "billing_period_unit": "month",
+  "customer_id": "AzZMxvTYTQUmw1Iw7",
+  "plan_amount": 1995,
+  "plan_free_quantity": 0,
+  "status": "active",
+  "current_term_start": 1692009453,
+  "current_term_end": 1694687853,
+  "next_billing_at": 1694687853,
+  "created_at": 1678790253,
+  "started_at": 1678790253,
+  "activated_at": 1678790253,
+  "updated_at": 1692009461,
+  "has_scheduled_changes": false,
+  "channel": "web",
+  "resource_version": 1692009461863,
+  "deleted": false,
+  "object": "subscription",
+  "currency_code": "USD",
+  "shipping_address": {
+    "first_name": "Legacy",
+    "last_name": "User",
+    "line1": "Kalograion",
+    "city": "Larnaca",
+    "state": "Larnaca",
+    "country": "CY",
+    "validation_status": "not_validated",
+    "object": "shipping_address"
+  },
+  "due_invoices_count": 0,
+  "mrr": 1995,
+  "exchange_rate": 1,
+  "base_currency_code": "USD",
+  "cf_clientorderid": "1678790168794-0784",
+  "has_scheduled_advance_invoices": false
+}

package/test/fixtures/chargebee/subscription-non-renewing.json

@@ -0,0 +1,41 @@
+{
+  "id": "cb_sub_nonrenew_001",
+  "customer_id": "cb_cust_004",
+  "status": "non_renewing",
+  "current_term_start": 1700000000,
+  "current_term_end": 1702592000,
+  "created_at": 1694643200,
+  "started_at": 1694643200,
+  "activated_at": 1694643200,
+  "updated_at": 1701000000,
+  "has_scheduled_changes": false,
+  "channel": "web",
+  "resource_version": 1701000000000,
+  "deleted": false,
+  "object": "subscription",
+  "currency_code": "USD",
+  "subscription_items": [
+    {
+      "item_price_id": "somiibo-pro-monthly",
+      "item_type": "plan",
+      "quantity": 1,
+      "unit_price": 499,
+      "amount": 499,
+      "object": "subscription_item"
+    }
+  ],
+  "meta_data": "{\"uid\":\"test-uid-004\",\"orderId\":\"4567-8901-2345\"}",
+  "shipping_address": {
+    "first_name": "NonRenew",
+    "last_name": "User",
+    "line1": "321 Pine Road",
+    "city": "Austin",
+    "state": "TX",
+    "country": "US",
+    "validation_status": "not_validated",
+    "object": "shipping_address"
+  },
+  "due_invoices_count": 0,
+  "mrr": 0,
+  "has_scheduled_advance_invoices": false
+}

package/test/fixtures/chargebee/subscription-paused.json

@@ -0,0 +1,42 @@
+{
+  "id": "cb_sub_paused_001",
+  "customer_id": "cb_cust_005",
+  "status": "paused",
+  "current_term_start": 1700000000,
+  "current_term_end": 1702592000,
+  "pause_date": 1701000000,
+  "created_at": 1694643200,
+  "started_at": 1694643200,
+  "activated_at": 1694643200,
+  "updated_at": 1701000000,
+  "has_scheduled_changes": false,
+  "channel": "web",
+  "resource_version": 1701000000000,
+  "deleted": false,
+  "object": "subscription",
+  "currency_code": "USD",
+  "subscription_items": [
+    {
+      "item_price_id": "somiibo-pro-monthly",
+      "item_type": "plan",
+      "quantity": 1,
+      "unit_price": 499,
+      "amount": 499,
+      "object": "subscription_item"
+    }
+  ],
+  "meta_data": "{\"uid\":\"test-uid-005\",\"orderId\":\"5678-9012-3456\"}",
+  "shipping_address": {
+    "first_name": "Paused",
+    "last_name": "User",
+    "line1": "654 Maple Lane",
+    "city": "Seattle",
+    "state": "WA",
+    "country": "US",
+    "validation_status": "not_validated",
+    "object": "shipping_address"
+  },
+  "due_invoices_count": 0,
+  "mrr": 0,
+  "has_scheduled_advance_invoices": false
+}