@fantastic.dev/better-stripe 0.9.0 → 0.10.1

package/src/client/utils/webhookEndpoints.ts

@@ -1,3 +1,5 @@
+import { STRIPE_CUSTOMER_PREVIEW_API_VERSION } from "../apiVersion.js";
+import { throwStripeError } from "../errors.js";
 import type Stripe from "stripe";
 
 import type { RunCtx } from "../helpers.js";
@@ -73,6 +75,13 @@ export const BETTER_STRIPE_V2_WEBHOOK_EVENTS = [
   "v2.core.account_link.returned",
 ] as const;
 
+/** Minimal customer lifecycle subscription for non-Connect preview merchants. */
+export const BETTER_STRIPE_CUSTOMER_ACCOUNT_EVENTS = [
+  "v2.core.account.created",
+  "v2.core.account[configuration.customer].updated",
+  "v2.core.account[identity].updated",
+] as const;
+
 export type BetterStripeV2WebhookEvent =
   (typeof BETTER_STRIPE_V2_WEBHOOK_EVENTS)[number];
 
@@ -103,14 +112,19 @@ export async function listWebhookEndpoints(
   }));
 }
 
+export type WebhookEndpointOptions = {
+  url: string;
+  description?: string;
+  enabledEvents?: string[];
+};
+export type EventDestinationOptions = WebhookEndpointOptions & {
+  name?: string;
+  eventPayload?: "snapshot" | "thin";
+};
 export async function createWebhookEndpoint(
   stripe: Stripe,
   _ctx: RunCtx,
-  opts: {
-    url: string;
-    description?: string;
-    enabledEvents?: string[];
-  },
+  opts: WebhookEndpointOptions & { apiVersion?: string },
 ): Promise<{ id: string; secret: string; url: string }> {
   // Remove existing endpoint with same URL (secret is only available on create)
   const existing = await stripe.webhookEndpoints.list({ limit: 100 });
@@ -121,6 +135,12 @@ export async function createWebhookEndpoint(
 
   const endpoint = await stripe.webhookEndpoints.create({
     url: opts.url,
+    ...(opts.apiVersion
+      ? {
+          api_version:
+            opts.apiVersion as Stripe.WebhookEndpointCreateParams.ApiVersion,
+        }
+      : {}),
     enabled_events: (opts.enabledEvents ??
       BETTER_STRIPE_WEBHOOK_EVENTS) as Stripe.WebhookEndpointCreateParams.EnabledEvent[],
     description:
@@ -189,14 +209,7 @@ export async function listEventDestinations(
 export async function setupEventDestination(
   stripe: Stripe,
   _ctx: RunCtx,
-  opts: {
-    url: string;
-    name?: string;
-    description?: string;
-    enabledEvents?: string[];
-    /** 'snapshot' for V1 events, 'thin' for V2 events. Defaults to 'thin'. */
-    eventPayload?: "snapshot" | "thin";
-  },
+  opts: EventDestinationOptions & { apiVersion?: string },
 ): Promise<{
   id: string;
   secret: string;
@@ -208,7 +221,9 @@ export async function setupEventDestination(
   const events =
     opts.enabledEvents ??
     (payloadType === "thin"
-      ? [...BETTER_STRIPE_V2_WEBHOOK_EVENTS]
+      ? opts.apiVersion === STRIPE_CUSTOMER_PREVIEW_API_VERSION
+        ? [...BETTER_STRIPE_CUSTOMER_ACCOUNT_EVENTS]
+        : [...BETTER_STRIPE_V2_WEBHOOK_EVENTS]
       : [...BETTER_STRIPE_WEBHOOK_EVENTS]);
   const name =
     opts.name ??
@@ -228,6 +243,36 @@ export async function setupEventDestination(
       d.webhook_endpoint?.url === opts.url && d.event_payload === payloadType,
   );
 
+  if (
+    match &&
+    payloadType === "snapshot" &&
+    opts.apiVersion &&
+    match.snapshot_api_version !== opts.apiVersion
+  )
+    throwStripeError(
+      "INVALID_CONFIGURATION",
+      "Existing snapshot destination API version differs. Create a replacement destination with the selected version and configure its signing secret before retiring the old destination.",
+    );
+
+  if (match && opts.apiVersion === STRIPE_CUSTOMER_PREVIEW_API_VERSION) {
+    const scopes = new Set(
+      (match.events_from ?? []).map((scope) =>
+        scope === "self"
+          ? "@self"
+          : scope === "other_accounts"
+            ? "@accounts"
+            : scope,
+      ),
+    );
+    const required =
+      payloadType === "thin" ? ["@self", "@accounts"] : ["@self"];
+    if (required.some((scope) => !scopes.has(scope)))
+      throwStripeError(
+        "INVALID_CONFIGURATION",
+        "Existing destination event scope differs. Create a replacement with the customer preview scopes before retiring the old destination.",
+      );
+  }
+
   if (match) {
     const updated = await stripe.v2.core.eventDestinations.update(match.id, {
       name,
@@ -256,7 +301,17 @@ export async function setupEventDestination(
     type: "webhook_endpoint",
     event_payload: payloadType,
     enabled_events: events,
-    events_from: payloadType === "thin" ? ["self", "other_accounts"] : ["self"],
+    ...(payloadType === "snapshot" && opts.apiVersion
+      ? { snapshot_api_version: opts.apiVersion }
+      : {}),
+    events_from:
+      opts.apiVersion === STRIPE_CUSTOMER_PREVIEW_API_VERSION
+        ? payloadType === "thin"
+          ? ["@self", "@accounts"]
+          : ["@self"]
+        : payloadType === "thin"
+          ? ["self", "other_accounts"]
+          : ["self"],
     webhook_endpoint: { url: opts.url },
     include: ["webhook_endpoint.signing_secret", "webhook_endpoint.url"],
   });

package/src/client/webhooks/asyncHooks.ts

@@ -0,0 +1,38 @@
+import type { AsyncHooks, AsyncHookCtx } from "../types.js";
+import type { AsyncHookName } from "../types/triggers.js";
+/** Route async webhook hooks through the shared public callback contract. */
+export function buildAsyncHookRoutes(hooks: AsyncHooks | undefined) {
+  const routes: Record<
+    AsyncHookName,
+    ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined
+  > = {
+    afterAccountUpdated: hooks?.onAccountUpdated as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterCheckoutCompleted: hooks?.onCheckoutCompleted as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterSubscriptionUpdated: hooks?.onSubscriptionUpdated as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterSubscriptionCanceled: hooks?.onSubscriptionCanceled as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterTrialEnding: hooks?.onTrialEnding as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterInvoicePaid: hooks?.onInvoicePaid as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterInvoicePaymentFailed: hooks?.onInvoicePaymentFailed as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterPaymentSucceeded: hooks?.onPaymentSucceeded as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterPaymentFailed: hooks?.onPaymentFailed as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterPayoutCompleted: hooks?.onPayoutCompleted as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterRefundCreated: hooks?.onRefundCreated as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterDisputeCreated: hooks?.onDisputeCreated as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+    afterDisputeClosed: hooks?.onDisputeClosed as
+      ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
+  };
+
+  return routes;
+}

package/src/client/webhooks/processors.test.ts

@@ -1,8 +1,4 @@
 // @vitest-environment edge-runtime
-/**
- * Drives Stripe event normalization through processEvent and checks the payloads
- * passed to component mutations, including owner, fee, and trial fields.
- */
 import type Stripe from "stripe";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
@@ -12,7 +8,6 @@ import { processEvent } from "./processors.js";
 
 const TO_REF = Symbol.for("toReferencePath");
 
-/** Fake component exposing every query/mutation ref processors.ts resolves. */
 function makeComponent() {
   const refs = (namespace: string, names: string[]) =>
     Object.fromEntries(
@@ -44,12 +39,16 @@ function makeCtx(opts?: { query?: unknown; queryThrows?: boolean }) {
   const runQuery = vi.fn();
   if (opts?.queryThrows) runQuery.mockRejectedValue(new Error("not found"));
   else runQuery.mockResolvedValue(opts?.query ?? null);
-  // `claimReversalSlices` returns the slices the reversal engines execute
-  // (BTS-63). Fake only its storage: the slice math is the REAL shared
-  // computeReversalSlices, applied to this ctx's ledger legs.
+  // Fake claim storage; use the shared reversal sizing math.
   const runMutation = vi.fn(
     async (ref: Record<symbol, string>, args: Record<string, unknown>) => {
       const path = ref?.[TO_REF] ?? "";
+      if (
+        String(path).endsWith(
+          "settlement/mutations/reserveSettlementAllocation",
+        )
+      )
+        return args;
       if (!String(path).endsWith("connect/mutations/claimReversalSlices")) {
         return undefined;
       }
@@ -107,7 +106,9 @@ function makeStripe() {
       update: vi.fn().mockResolvedValue({}),
       retrieve: vi.fn(),
     },
+    charges: { retrieve: vi.fn().mockResolvedValue({ created: 1 }) },
     transfers: {
+      list: vi.fn().mockResolvedValue({ data: [], has_more: false }),
       create: vi.fn(async (_params: unknown) => ({
         id: `tr_${++trCreateSeq}`,
       })),
@@ -146,7 +147,6 @@ function makeStripe() {
       retrieve: vi.fn(),
       update: vi.fn().mockResolvedValue({}),
     },
-    charges: { retrieve: vi.fn() },
   };
 }
 

package/src/client/webhooks/v2.ts

@@ -1,3 +1,4 @@
+import { STRIPE_CUSTOMER_PREVIEW_API_VERSION } from "../apiVersion.js";
 import type Stripe from "stripe";
 
 import { deriveAccountStatus } from "../core/accountStatus.js";
@@ -74,16 +75,19 @@ export async function handleV2Event(
     return null;
   }
 
-  const retrieveParams = {
-    include: [
-      "configuration.merchant",
-      "configuration.recipient",
-      "configuration.customer",
-      "identity",
-      "requirements",
-    ] satisfies NonNullable<
-      Parameters<Stripe["v2"]["core"]["accounts"]["retrieve"]>[1]
-    >["include"],
+  const retrieveParams: NonNullable<
+    Parameters<Stripe["v2"]["core"]["accounts"]["retrieve"]>[1]
+  > = {
+    include:
+      whCtx.config?.stripeApiVersion === STRIPE_CUSTOMER_PREVIEW_API_VERSION
+        ? ["configuration.customer", "identity"]
+        : [
+            "configuration.merchant",
+            "configuration.recipient",
+            "configuration.customer",
+            "identity",
+            "requirements",
+          ],
   };
   // Preserve the verified notification's account/organization context when
   // fetching the latest resource; otherwise organization keys can fetch from

package/src/component/_generated/api.ts

@@ -25,6 +25,8 @@ import type * as lib_stripeFactory from "../lib/stripeFactory.js";
 import type * as products_mutations from "../products/mutations.js";
 import type * as products_queries from "../products/queries.js";
 import type * as products_validators from "../products/validators.js";
+import type * as settlement_mutations from "../settlement/mutations.js";
+import type * as settlement_queries from "../settlement/queries.js";
 import type * as webhooks_mutations from "../webhooks/mutations.js";
 import type * as webhooks_queries from "../webhooks/queries.js";
 import type * as webhooks_validators from "../webhooks/validators.js";
@@ -54,6 +56,8 @@ const fullApi: ApiFromModules<{
   "products/mutations": typeof products_mutations;
   "products/queries": typeof products_queries;
   "products/validators": typeof products_validators;
+  "settlement/mutations": typeof settlement_mutations;
+  "settlement/queries": typeof settlement_queries;
   "webhooks/mutations": typeof webhooks_mutations;
   "webhooks/queries": typeof webhooks_queries;
   "webhooks/validators": typeof webhooks_validators;

package/src/component/_generated/component.ts

@@ -1763,6 +1763,106 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         >;
       };
     };
+    settlement: {
+      mutations: {
+        claimCommissionInvoice: FunctionReference<
+          "mutation",
+          "internal",
+          {
+            affiliateAccountId?: string;
+            firstPaidInvoiceId: string;
+            invoiceId: string;
+            subscriptionId: string;
+            term: "forever" | "one_time";
+          },
+          {
+            claimKey: string;
+            eligible: boolean;
+            firstPaidInvoiceId: string;
+            replay: boolean;
+            term: "forever" | "one_time";
+          },
+          Name
+        >;
+        reserveSettlementAllocation: FunctionReference<
+          "mutation",
+          "internal",
+          {
+            adjustmentAmount?: number;
+            currency: string;
+            gross: number;
+            paymentId?: string;
+            paymentIntentId?: string;
+            platformNet: number;
+            processingFee: number;
+            sourceChargeId: string;
+            sourceInvoiceId?: string;
+            transfers: Array<{
+              amount: number;
+              destinationAccountId: string;
+              role: "store" | "affiliate" | "other";
+            }>;
+          },
+          {
+            _creationTime: number;
+            _id: string;
+            adjustmentAmount?: number;
+            currency: string;
+            gross: number;
+            paymentId?: string;
+            paymentIntentId?: string;
+            platformNet: number;
+            processingFee: number;
+            sourceChargeId: string;
+            sourceInvoiceId?: string;
+            transfers: Array<{
+              amount: number;
+              destinationAccountId: string;
+              role: "store" | "affiliate" | "other";
+            }>;
+          },
+          Name
+        >;
+      };
+      queries: {
+        getCommissionTerm: FunctionReference<
+          "query",
+          "internal",
+          { subscriptionId: string },
+          {
+            affiliateAccountId?: string;
+            firstPaidInvoiceId: string;
+            subscriptionId: string;
+            term: "forever" | "one_time";
+          } | null,
+          Name
+        >;
+        getSettlementAllocation: FunctionReference<
+          "query",
+          "internal",
+          { sourceChargeId: string },
+          {
+            _creationTime: number;
+            _id: string;
+            adjustmentAmount?: number;
+            currency: string;
+            gross: number;
+            paymentId?: string;
+            paymentIntentId?: string;
+            platformNet: number;
+            processingFee: number;
+            sourceChargeId: string;
+            sourceInvoiceId?: string;
+            transfers: Array<{
+              amount: number;
+              destinationAccountId: string;
+              role: "store" | "affiliate" | "other";
+            }>;
+          } | null,
+          Name
+        >;
+      };
+    };
     webhooks: {
       mutations: {
         insertWebhookEvent: FunctionReference<

package/src/component/lib/stripeFactory.ts

@@ -1,6 +1,10 @@
 import Stripe from "stripe";
 
-import { STRIPE_API_VERSION } from "../../client/constants.js";
+import {
+  resolveStripeApiVersion,
+  type SupportedStripeApiVersion,
+} from "../../client/apiVersion.js";
+import type { StripeApiVersion } from "../../client/stripe-types.js";
 
 /**
  * Keyed cache for Stripe SDK instances.
@@ -14,14 +18,18 @@ const _clients = new Map<string, Stripe>();
 
 /**
  * Get or create a Stripe SDK instance for the given API key.
- * Uses the component's pinned API version.
+ * Defaults to GA; an explicitly selected supported preview gets its own cache entry.
  */
-export function getStripe(apiKey: string): Stripe {
-  const cacheKey = `${apiKey}:${STRIPE_API_VERSION}`;
+export function getStripe(
+  apiKey: string,
+  apiVersion?: SupportedStripeApiVersion,
+): Stripe {
+  const version = resolveStripeApiVersion(apiVersion);
+  const cacheKey = `${apiKey}:${version}`;
   let client = _clients.get(cacheKey);
   if (!client) {
     client = new Stripe(apiKey, {
-      apiVersion: STRIPE_API_VERSION,
+      apiVersion: version as StripeApiVersion,
       typescript: true,
     });
     _clients.set(cacheKey, client);

package/src/component/schema.ts

@@ -1,3 +1,8 @@
+import {
+  allocationsTable,
+  commissionTermsTable,
+  commissionDecisionsTable,
+} from "./settlement/schema";
 import { defineSchema } from "convex/server";
 
 import {
@@ -19,6 +24,9 @@ import { pricesTable, productsTable } from "./products/schema";
 import { webhookEventsTable } from "./webhooks/schema";
 
 export default defineSchema({
+  settlementAllocations: allocationsTable,
+  commissionTerms: commissionTermsTable,
+  commissionDecisions: commissionDecisionsTable,
   // Core
   accounts: accountsTable,
 

package/src/component/settlement/mutations.ts

@@ -0,0 +1,119 @@
+import { v } from "convex/values";
+import { mutation } from "../_generated/server.js";
+import { allocationFields, commissionFields, termValidator } from "./schema.js";
+const doc = v.object({
+  ...allocationFields,
+  _id: v.id("settlementAllocations"),
+  _creationTime: v.number(),
+});
+export const reserveSettlementAllocation = mutation({
+  args: allocationFields,
+  returns: doc,
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query("settlementAllocations")
+      .withIndex("by_source_charge", (q) =>
+        q.eq("sourceChargeId", args.sourceChargeId),
+      )
+      .first();
+    if (existing) {
+      if (
+        existing.currency !== args.currency ||
+        existing.paymentIntentId !== args.paymentIntentId ||
+        existing.sourceInvoiceId !== args.sourceInvoiceId
+      )
+        throw new Error("Settlement source identity cannot change.");
+      return existing;
+    }
+    const adjustment = args.adjustmentAmount ?? 0;
+    const amounts = [
+      args.gross,
+      args.processingFee,
+      args.platformNet,
+      ...args.transfers.map((t) => t.amount),
+    ];
+    const keys = args.transfers.map(
+      (t) => `${t.destinationAccountId}:${t.role}`,
+    );
+    if (
+      !Number.isSafeInteger(adjustment) ||
+      args.processingFee + args.platformNet + adjustment < 0 ||
+      amounts.some((n) => !Number.isSafeInteger(n) || n < 0) ||
+      args.gross <= 0 ||
+      !args.currency ||
+      !args.sourceChargeId ||
+      args.transfers.some((t) => !t.destinationAccountId) ||
+      new Set(keys).size !== keys.length ||
+      args.gross !==
+        args.processingFee +
+          args.platformNet +
+          adjustment +
+          args.transfers.reduce((sum, t) => sum + t.amount, 0)
+    )
+      throw new Error(
+        "Settlement allocation must reconcile in integer currency units with unique recipient legs.",
+      );
+    const id = await ctx.db.insert("settlementAllocations", args);
+    return (await ctx.db.get("settlementAllocations", id))!;
+  },
+});
+export const claimCommissionInvoice = mutation({
+  args: { ...commissionFields, invoiceId: v.string() },
+  returns: v.object({
+    eligible: v.boolean(),
+    term: termValidator,
+    firstPaidInvoiceId: v.string(),
+    claimKey: v.string(),
+    replay: v.boolean(),
+  }),
+  handler: async (ctx, args) => {
+    let stored = await ctx.db
+      .query("commissionTerms")
+      .withIndex("by_subscription", (q) =>
+        q.eq("subscriptionId", args.subscriptionId),
+      )
+      .first();
+    if (stored && stored.affiliateAccountId !== args.affiliateAccountId)
+      throw new Error("Subscription affiliate identity cannot change.");
+    if (!stored) {
+      const fields = {
+        subscriptionId: args.subscriptionId,
+        term: args.term,
+        affiliateAccountId: args.affiliateAccountId,
+        firstPaidInvoiceId: args.firstPaidInvoiceId,
+      };
+      const id = await ctx.db.insert("commissionTerms", fields);
+      stored = (await ctx.db.get("commissionTerms", id))!;
+    }
+    const existing = await ctx.db
+      .query("commissionDecisions")
+      .withIndex("by_subscription_invoice", (q) =>
+        q
+          .eq("subscriptionId", args.subscriptionId)
+          .eq("invoiceId", args.invoiceId),
+      )
+      .first();
+    const claimKey =
+      existing?.claimKey ??
+      `commission:${args.subscriptionId}:${args.invoiceId}`;
+    const eligible =
+      existing?.eligible ??
+      (!!stored.affiliateAccountId &&
+        (stored.term === "forever" ||
+          args.invoiceId === stored.firstPaidInvoiceId));
+    if (!existing)
+      await ctx.db.insert("commissionDecisions", {
+        subscriptionId: args.subscriptionId,
+        invoiceId: args.invoiceId,
+        eligible,
+        claimKey,
+      });
+    return {
+      eligible,
+      term: stored.term,
+      firstPaidInvoiceId: stored.firstPaidInvoiceId,
+      claimKey,
+      replay: !!existing,
+    };
+  },
+});

package/src/component/settlement/queries.ts

@@ -0,0 +1,38 @@
+import { v } from "convex/values";
+import { query } from "../_generated/server.js";
+import { allocationFields, commissionFields } from "./schema.js";
+const doc = v.object({
+  ...allocationFields,
+  _id: v.id("settlementAllocations"),
+  _creationTime: v.number(),
+});
+export const getSettlementAllocation = query({
+  args: { sourceChargeId: v.string() },
+  returns: v.union(doc, v.null()),
+  handler: (ctx, args) =>
+    ctx.db
+      .query("settlementAllocations")
+      .withIndex("by_source_charge", (q) =>
+        q.eq("sourceChargeId", args.sourceChargeId),
+      )
+      .first(),
+});
+export const getCommissionTerm = query({
+  args: { subscriptionId: v.string() },
+  returns: v.union(v.object(commissionFields), v.null()),
+  handler: async (ctx, args) => {
+    const row = await ctx.db
+      .query("commissionTerms")
+      .withIndex("by_subscription", (q) =>
+        q.eq("subscriptionId", args.subscriptionId),
+      )
+      .first();
+    if (!row) return null;
+    return {
+      subscriptionId: row.subscriptionId,
+      term: row.term,
+      affiliateAccountId: row.affiliateAccountId,
+      firstPaidInvoiceId: row.firstPaidInvoiceId,
+    };
+  },
+});

package/src/component/settlement/schema.ts

@@ -0,0 +1,45 @@
+import { defineTable } from "convex/server";
+import { v } from "convex/values";
+import { splitRecipientRoleValidator } from "../lib/fees.js";
+export const termValidator = v.union(
+  v.literal("forever"),
+  v.literal("one_time"),
+);
+export const allocationFields = {
+  sourceChargeId: v.string(),
+  paymentIntentId: v.optional(v.string()),
+  sourceInvoiceId: v.optional(v.string()),
+  gross: v.number(),
+  currency: v.string(),
+  processingFee: v.number(),
+  platformNet: v.number(),
+  adjustmentAmount: v.optional(v.number()),
+  paymentId: v.optional(v.string()),
+  transfers: v.array(
+    v.object({
+      destinationAccountId: v.string(),
+      role: splitRecipientRoleValidator,
+      amount: v.number(),
+    }),
+  ),
+};
+export const allocationsTable = defineTable(allocationFields).index(
+  "by_source_charge",
+  ["sourceChargeId"],
+);
+export const commissionFields = {
+  subscriptionId: v.string(),
+  term: termValidator,
+  affiliateAccountId: v.optional(v.string()),
+  firstPaidInvoiceId: v.string(),
+};
+export const commissionTermsTable = defineTable(commissionFields).index(
+  "by_subscription",
+  ["subscriptionId"],
+);
+export const commissionDecisionsTable = defineTable({
+  subscriptionId: v.string(),
+  invoiceId: v.string(),
+  eligible: v.boolean(),
+  claimKey: v.string(),
+}).index("by_subscription_invoice", ["subscriptionId", "invoiceId"]);