@jytextiles/medusa-plugin-faire-store-sync 0.2.5 → 0.2.7

package/src/lib/types.ts

@@ -28,7 +28,11 @@ export interface FairePluginOptions {
   tokenUrl?: string
 }
 
-export const DEFAULT_API_BASE = "https://faire.com/external-api/v2"
+// MUST be the canonical www host. Bare `faire.com` 301-redirects to www, and a
+// 301 on a POST/PUT strips the request body (fetch/curl replay it without the
+// payload) — so writes (createProduct/updateProduct) silently no-op'd, coming
+// back as if they were `GET /products` (a product LIST). Verified live 2026-07-09.
+export const DEFAULT_API_BASE = "https://www.faire.com/external-api/v2"
 export const DEFAULT_AUTH_URL = "https://faire.com/oauth2/authorize"
 export const DEFAULT_TOKEN_URL = "https://www.faire.com/api/external-api-oauth2/token"
 // Faire OAuth scopes are coarse tokens like READ_ORDERS, WRITE_PRODUCTS. The
@@ -69,27 +73,59 @@ export interface ProductImage {
   url: string
 }
 
+/**
+ * Faire External API v2 create/update product contract (verified live
+ * 2026-07-09 against `POST https://www.faire.com/external-api/v2/products`).
+ *
+ * Money is `amount_minor` (integer minor units = cents) + `currency`. Each
+ * variant price is scoped to a geo (`country` ISO-2 OR a `country_group` enum
+ * like EUROPEAN_UNION). `taxonomy_type.id` (a `tt_…` id from GET /products/types)
+ * and per-entity `idempotence_token`s are REQUIRED — omitting either 400s.
+ */
+export type FaireLifecycleState = "DRAFT" | "PUBLISHED"
+
+export interface FaireGeoConstraint {
+  country?: string
+  country_group?: string
+}
+
+export interface FaireMoneyMinor {
+  amount_minor: number
+  currency: string
+}
+
+export interface FaireVariantPrice {
+  geo_constraint: FaireGeoConstraint
+  wholesale_price: FaireMoneyMinor
+  retail_price: FaireMoneyMinor
+}
+
+export interface FaireVariantOption {
+  name: string
+  value: string
+}
+
 export interface ProductVariantInput {
   sku: string
-  name?: string
-  wholesale_price_cents?: number
-  retail_price_cents?: number
-  inventory_count?: number
+  name: string
+  idempotence_token: string
+  options?: FaireVariantOption[]
+  available_quantity?: number
+  prices?: FaireVariantPrice[]
   images?: ProductImage[]
 }
 
 export interface CreateProductInput {
-  brand_id: string
   name: string
+  idempotence_token: string
+  lifecycle_state: FaireLifecycleState
+  taxonomy_type: { id: string }
   description?: string
-  wholesale_price_cents?: number
-  retail_price_cents?: number
-  images?: ProductImage[]
-  variants?: ProductVariantInput[]
-  tags?: string[]
-  shipping?: Record<string, any>
-  metadata?: Record<string, any>
   short_description?: string
+  variants: ProductVariantInput[]
+  images?: ProductImage[]
+  unit_multiplier?: number
+  minimum_order_quantity?: number
 }
 
 export type UpdateProductInput = Partial<CreateProductInput>
@@ -101,8 +137,6 @@ export interface ProductResponse {
   description?: string
   state?: ProductState
   url?: string
-  wholesale_price_cents?: number
-  retail_price_cents?: number
   variants?: any[]
   images?: ProductImage[]
   raw: Record<string, any>
@@ -116,12 +150,17 @@ export interface InventoryLevel {
 }
 
 /**
- * Payload for `PATCH /product-inventory/by-skus`. Faire ingests an array of
- * per-SKU overrides; each row carries the SKU and the new on-hand count.
+ * Payload row for `PATCH /product-inventory/by-skus`. Faire ingests an array
+ * under `inventories`; each row carries the SKU and the new on-hand count.
+ * The writable quantity field is `on_hand_quantity` (integer) — verified live
+ * 2026-07-09 against the docs (there is NO `current_count`/`available_quantity`
+ * on this endpoint; those belong to other inventory endpoints). `product_variant_id`
+ * is optional — Faire resolves the row by SKU when it's omitted.
  */
 export interface InventoryOverrideBySku {
   sku: string
-  current_count: number
+  on_hand_quantity: number
+  product_variant_id?: string
 }
 
 export interface FaireOrder {

package/src/modules/faire-sync/service.ts

@@ -253,6 +253,13 @@ class FaireSyncService extends MedusaService({
     return this.updateFaireSyncSettings({ id: settings.id, ...data } as any)
   }
 
+  async getTaxonomyTypes(): Promise<Array<{ id: string; name: string }>> {
+    const account = await this.getActiveAccount()
+    if (!account) return []
+    const client = this.getClient(account.auth_mode as "oauth" | "apiKey")
+    return client.getTaxonomyTypes(account.access_token)
+  }
+
   /**
    * High-water mark for incremental order polling. Returns the last successful
    * sync timestamp, or null if orders have never been polled (full backfill).
@@ -324,15 +331,23 @@ class FaireSyncService extends MedusaService({
   async completeOAuth(code: string, state: string) {
     const settings = await this.getSettings()
     const pending: any = settings.pending_oauth
+    // eslint-disable-next-line no-console
+    console.info(
+      `[faire-sync] completeOAuth: received code=${code ? code.slice(0, 6) + "…" : "<none>"} ` +
+        `state=${state ? state.slice(0, 8) + "…" : "<none>"} ` +
+        `pending=${pending ? "state:" + String(pending.state).slice(0, 8) + "…" : "<none>"} ` +
+        `match=${!!pending && pending.state === state}`
+    )
     if (!pending || pending.state !== state) {
       throw new MedusaError(
         MedusaError.Types.INVALID_DATA,
-        "Invalid or expired OAuth state. Please start the Faire connection again."
+        `Invalid or expired OAuth state (received "${state}", ` +
+          `pending ${pending ? `"${pending.state}"` : "<none>"}). Please start the Faire connection again.`
       )
     }
     let token: TokenData | undefined
     try {
-      const client = this.getClient()
+      const client = this.getClient("oauth")
       token = await client.exchangeCodeForToken(code)
       const brand = await client.getBrand(token.access_token)
       const account = await this.saveAccount(token, brand, "oauth")
@@ -343,6 +358,12 @@ class FaireSyncService extends MedusaService({
       })
       return { account, brand }
     } catch (err) {
+      // eslint-disable-next-line no-console
+      console.error(
+        "[faire-sync] completeOAuth failed during exchange/brand/save:",
+        (err as any)?.message || err,
+        (err as any)?.body ? `| faire body: ${JSON.stringify((err as any).body)}` : ""
+      )
       // Self-heal a dropped OAuth so the next attempt starts clean:
       //  1. clear the pending state (otherwise it sticks and confuses retries), and
       //  2. if the code exchange succeeded but a later step failed, REVOKE the

package/src/workflows/ingest-faire-order-support.ts

@@ -18,6 +18,31 @@ const splitName = (name?: string): { first: string; last: string } => {
   return { first: parts[0], last: parts.slice(1).join(" ") }
 }
 
+// Faire ExternalMoneyV2 = { amount_minor, currency }. Returns integer minor
+// units + ISO currency, or null when the field is absent/not a money object.
+const moneyOf = (m: any): { minor: number; currency: string } | null =>
+  m && typeof m === "object" && m.amount_minor != null
+    ? { minor: Number(m.amount_minor) || 0, currency: String(m.currency || "") }
+    : null
+
+// Faire order addresses carry ISO-3 `country_code` ("CAN") + a full `country`
+// name ("Canada"); Medusa wants a lowercase ISO-2. Map the ISO-3 codes for the
+// regions Faire operates in; pass through anything already 2-letter.
+const ISO3_TO_ISO2: Record<string, string> = {
+  USA: "us", CAN: "ca", GBR: "gb", AUS: "au", NZL: "nz", DEU: "de", FRA: "fr",
+  ITA: "it", ESP: "es", PRT: "pt", NLD: "nl", BEL: "be", LUX: "lu", AUT: "at",
+  IRL: "ie", CHE: "ch", SWE: "se", DNK: "dk", FIN: "fi", NOR: "no", POL: "pl",
+  CZE: "cz", GRC: "gr", HUN: "hu", ROU: "ro", BGR: "bg", HRV: "hr", SVK: "sk",
+  SVN: "si", EST: "ee", LVA: "lv", LTU: "lt", CYP: "cy", MLT: "mt",
+}
+const faireCountryToIso2 = (raw?: string): string | undefined => {
+  const s = String(raw ?? "").trim()
+  if (!s) return undefined
+  if (s.length === 2) return s.toLowerCase()
+  const iso2 = ISO3_TO_ISO2[s.toUpperCase()]
+  return iso2 ?? undefined // full country names ("Canada") can't be mapped safely
+}
+
 export type MappedFaireOrder = {
   order_token: string
   email: string
@@ -37,12 +62,31 @@ export function mapFaireOrderToOrder(order: any): MappedFaireOrder {
   const orderToken = String(order?.order_token ?? order?.id ?? order?.token ?? "")
 
   const address = order?.address ?? order?.shipping_address ?? {}
-  const currency = String(order?.currency ?? order?.currency_code ?? "usd").toLowerCase()
+  const items: any[] = Array.isArray(order?.items) ? order.items : []
 
+  // ExternalOrderV2 has NO top-level currency/total. Currency comes off any
+  // item's ExternalMoneyV2 `price` (fall back to the payout currency, then the
+  // legacy top-level fields for back-compat). See docs verified 2026-07-09.
+  const itemMoney = items.map((it) => moneyOf(it?.price)).find(Boolean)
+  const currency = String(
+    itemMoney?.currency ||
+      moneyOf(order?.payout_costs?.total_payout)?.currency ||
+      order?.currency ||
+      order?.currency_code ||
+      "usd"
+  ).toLowerCase()
+
+  // Buyer name: ExternalOrderV2.customer { first_name, last_name }, else the
+  // recipient name on the address. (`address.company_name`/`retailer_id` is the
+  // wholesale store, not the person.) Legacy fields kept as fallbacks.
+  const customer = order?.customer ?? {}
   const buyerName =
-    order?.buyer_name ??
-    order?.customer_name ??
-    [address?.first_name, address?.last_name].filter(Boolean).join(" ")
+    [customer?.first_name, customer?.last_name].filter(Boolean).join(" ") ||
+    address?.name ||
+    order?.buyer_name ||
+    order?.customer_name ||
+    [address?.first_name, address?.last_name].filter(Boolean).join(" ") ||
+    ""
   const { first, last } = splitName(buyerName)
 
   // Faire usually does NOT expose the retailer's email via API — fall back to a
@@ -53,35 +97,58 @@ export function mapFaireOrderToOrder(order: any): MappedFaireOrder {
     (typeof order?.email === "string" && order.email) ||
     `faire+${orderToken}@marketplace.invalid`
 
-  const items: any[] = Array.isArray(order?.items) ? order.items : []
-  const mappedItems = items.map((it) => {
-    const unitCents = Number(it?.wholesale_price_cents ?? it?.unit_price_cents ?? 0)
-    return {
-      title: String(it?.product_name ?? it?.name ?? it?.title ?? "Faire item").slice(0, 250),
-      quantity: Math.max(1, Number(it?.quantity ?? it?.qty) || 1),
-      unit_price: faireMoney(unitCents),
-      metadata: {
-        faire_order_token: orderToken,
-        faire_item_id: it?.id != null ? String(it.id) : null,
-        faire_product_token:
-          it?.product_token != null ? String(it.product_token) : null,
-        faire_sku: it?.sku ?? null,
-        faire_variant_id:
-          it?.variant_id != null ? String(it.variant_id) : null,
-      },
-    }
-  })
+  const unitMinorOf = (it: any): number => {
+    const m = moneyOf(it?.price)
+    return m
+      ? m.minor
+      : Number(it?.price_cents ?? it?.wholesale_price_cents ?? it?.unit_price_cents ?? 0)
+  }
+
+  const mappedItems = items.map((it) => ({
+    title: String(it?.product_name ?? it?.name ?? it?.title ?? "Faire item").slice(0, 250),
+    quantity: Math.max(1, Number(it?.quantity ?? it?.qty) || 1),
+    unit_price: faireMoney(unitMinorOf(it)),
+    metadata: {
+      faire_order_token: orderToken,
+      faire_item_id: it?.id != null ? String(it.id) : null,
+      faire_product_token:
+        it?.product_id != null
+          ? String(it.product_id)
+          : it?.product_token != null
+            ? String(it.product_token)
+            : null,
+      faire_sku: it?.sku ?? null,
+      faire_variant_id: it?.variant_id != null ? String(it.variant_id) : null,
+    },
+  }))
+
+  // No order-level total exists — sum line values (unit price × qty). Honour an
+  // explicit total_cents/grand_total_cents if a caller ever supplies one.
+  const explicitTotalCents = order?.total_cents ?? order?.grand_total_cents
+  const total =
+    explicitTotalCents != null
+      ? faireMoney(explicitTotalCents)
+      : faireMoney(
+          items.reduce(
+            (sum, it) =>
+              sum + unitMinorOf(it) * Math.max(1, Number(it?.quantity ?? it?.qty) || 1),
+            0
+          )
+        )
 
   const shipping_address = {
     first_name: address?.first_name ?? first,
     last_name: address?.last_name ?? last,
-    address_1: address?.street1 ?? address?.address1 ?? address?.address_1 ?? "",
-    address_2: address?.street2 ?? address?.address2 ?? address?.address_2 ?? "",
+    company: address?.company_name ?? undefined,
+    address_1:
+      address?.address1 ?? address?.address_1 ?? address?.street1 ?? "",
+    address_2:
+      address?.address2 ?? address?.address_2 ?? address?.street2 ?? "",
     city: address?.city ?? "",
-    province: address?.state ?? address?.province ?? "",
-    postal_code: address?.zip ?? address?.postal_code ?? "",
-    country_code: String(address?.country ?? address?.country_code ?? "").toLowerCase() || undefined,
-    phone: address?.phone ?? undefined,
+    province: address?.state_code ?? address?.state ?? address?.province ?? "",
+    postal_code: address?.postal_code ?? address?.zip ?? "",
+    country_code: faireCountryToIso2(address?.country_code ?? address?.country),
+    phone: address?.phone_number ?? address?.phone ?? undefined,
   }
 
   return {
@@ -89,7 +156,7 @@ export function mapFaireOrderToOrder(order: any): MappedFaireOrder {
     email,
     buyer_name: buyerName || null,
     currency_code: currency,
-    total: faireMoney(order?.total_cents ?? order?.grand_total_cents),
+    total,
     shipping_address,
     items: mappedItems,
   }

package/src/workflows/sync-product-to-faire.ts

@@ -6,7 +6,7 @@ import {
   WorkflowData,
   transform,
 } from "@medusajs/framework/workflows-sdk"
-import { ContainerRegistrationKeys, Modules } from "@medusajs/framework/utils"
+import { ContainerRegistrationKeys, MedusaError, Modules } from "@medusajs/framework/utils"
 import type { Link } from "@medusajs/modules-sdk"
 import type { RemoteQueryFunction } from "@medusajs/types"
 import { FAIRE_SYNC_MODULE } from "../modules/faire-sync"
@@ -28,6 +28,7 @@ type ResolvedConfig = {
   access_token: string
   auth_mode: "oauth" | "apiKey"
   currency: string | null
+  country: string | null
   settings: any
 }
 
@@ -55,6 +56,31 @@ const productDisplayUrl = (product: ProductResponse): string | null => {
   return `https://www.faire.com/brand/products/${product.product_token}`
 }
 
+/**
+ * Faire variant prices are geo-scoped (`geo_constraint`). Derive a sensible
+ * default from the brand's currency (and country when known). Eurozone brands
+ * map to the EUROPEAN_UNION country_group; otherwise scope to a single country.
+ */
+const geoForCurrency = (
+  currency: string,
+  country: string | null
+): { country?: string; country_group?: string } => {
+  switch (currency) {
+    case "EUR":
+      return { country_group: "EUROPEAN_UNION" }
+    case "GBP":
+      return { country: "GB" }
+    case "USD":
+      return { country: "US" }
+    case "CAD":
+      return { country: "CA" }
+    case "AUD":
+      return { country: "AU" }
+    default:
+      return country ? { country } : { country_group: "EUROPEAN_UNION" }
+  }
+}
+
 // ── Step 1: resolve account (fresh token) + settings ─────────────────────
 
 const resolveFaireConfigStep = createStep(
@@ -69,6 +95,7 @@ const resolveFaireConfigStep = createStep(
       access_token: account.access_token,
       auth_mode: (account.auth_mode as "oauth" | "apiKey") ?? "oauth",
       currency: account.currency ?? null,
+      country: account.country ?? null,
       settings,
     })
   }
@@ -79,7 +106,15 @@ const resolveFaireConfigStep = createStep(
 const prepareProductStep = createStep(
   "faire-prepare-product-step",
   async (
-    input: { product_id: string; settings: any; brand_id: string },
+    input: {
+      product_id: string
+      settings: any
+      brand_id: string
+      currency: string | null
+      country: string | null
+      access_token: string
+      auth_mode: "oauth" | "apiKey"
+    },
     { container }
   ): Promise<StepResponse<PreparedProduct>> => {
     const query = container.resolve(
@@ -99,6 +134,8 @@ const prepareProductStep = createStep(
         "tags.*",
         "variants.*",
         "variants.prices.*",
+        "variants.options.*",
+        "variants.options.option.*",
         "variants.inventory_items.*",
         "images.*",
         "variants.sku",
@@ -108,7 +145,10 @@ const prepareProductStep = createStep(
 
     const product: any = products?.[0]
     if (!product) {
-      throw new Error(`Product ${input.product_id} not found`)
+      throw new MedusaError(
+        MedusaError.Types.NOT_FOUND,
+        `Product ${input.product_id} not found`
+      )
     }
 
     // Resolve existing Faire product (from link)
@@ -131,64 +171,122 @@ const prepareProductStep = createStep(
     const metadata = product.metadata || {}
     const variants: any[] = product.variants || []
 
-    // Medusa v2 stores money as a whole decimal in the price's currency (NOT
-    // minor units). Faire wants integer cents, so round to cents.
-    const toCents = (amount: any): number => Math.round(Number(amount || 0) * 100)
+    // ── Currency + geo constraint (Faire prices are geo-scoped) ────────────
+    // Prefer the brand's own currency; fall back to the price currency Medusa
+    // stored, then EUR. Currency picks the price row + drives the geo default.
+    const currency = String(
+      metadata.faire_currency ||
+        input.currency ||
+        (variants.flatMap((v) => v.prices || [])[0]?.currency_code ?? "EUR")
+    ).toUpperCase()
+    const geoConstraint: { country?: string; country_group?: string } =
+      metadata.faire_geo_constraint && typeof metadata.faire_geo_constraint === "object"
+        ? metadata.faire_geo_constraint
+        : geoForCurrency(currency, input.country)
+
+    // Medusa v2 stores money as a whole decimal in the price's currency; Faire
+    // wants integer minor units (cents), so round.
+    const toMinor = (amount: any): number => Math.round(Number(amount || 0) * 100)
 
     const markupPercent =
       Number(metadata.faire_wholesale_markup_percent ?? settings.default_wholesale_markup_percent) ||
       0
 
-    const buildVariant = (v: any) => {
-      const prices: any[] = v.prices || []
-      const retail = prices[0] ?? prices.find(Boolean)
-      const retailCents = retail ? toCents(retail.amount) : 0
-      const wholesaleCents =
+    // Pick the price row matching the chosen currency (fall back to first).
+    const pickPrice = (prices: any[]): any =>
+      prices.find((p) => String(p.currency_code || "").toUpperCase() === currency) ??
+      prices[0] ??
+      null
+
+    const buildVariant = (v: any, idx: number) => {
+      const retail = pickPrice(v.prices || [])
+      const retailMinor = retail ? toMinor(retail.amount) : 0
+      const wholesaleMinor =
         markupPercent > 0
-          ? Math.round((retailCents * (100 - markupPercent)) / 100)
-          : retailCents
+          ? Math.round((retailMinor * (100 - markupPercent)) / 100)
+          : retailMinor
+      const sku = v.sku || v.id
+      const options =
+        (v.options || [])
+          .map((o: any) => ({
+            name: String(o.option?.title || o.title || "Option"),
+            value: String(o.value ?? ""),
+          }))
+          .filter((o: any) => o.value) || []
       return {
-        sku: v.sku || v.id,
-        name: v.title || undefined,
-        retail_price_cents: retailCents || undefined,
-        wholesale_price_cents: wholesaleCents || undefined,
-        inventory_count: Number(v.inventory_quantity) || 0,
+        sku,
+        name: v.title || sku,
+        idempotence_token: `${product.id}:${v.id || sku}`,
+        options: options.length ? options : undefined,
+        available_quantity: Number(v.inventory_quantity) || 0,
+        prices:
+          retailMinor > 0
+            ? [
+                {
+                  geo_constraint: geoConstraint,
+                  wholesale_price: { amount_minor: wholesaleMinor, currency },
+                  retail_price: { amount_minor: retailMinor, currency },
+                },
+              ]
+            : undefined,
       }
     }
 
-    // Aggregate retail/wholesale from min-variant for the product-level price.
-    const allPrices = variants.flatMap((v) => v.prices || [])
-    const minRetail =
-      allPrices
-        .map((p) => toCents(p.amount))
-        .filter((a) => a > 0)
-        .sort((a, b) => a - b)[0] ?? 0
-    const minWholesale =
-      markupPercent > 0
-        ? Math.round((minRetail * (100 - markupPercent)) / 100)
-        : minRetail
-
-    const tags = (product.tags || [])
-      .map((t: any) => t.value)
-      .filter(Boolean)
-
     const images = (product.images || [])
       .map((img: any) => ({ url: img.url }))
       .filter((i: any) => i.url)
 
+    // Resolve taxonomy_type.id — REQUIRED by Faire create. Priority:
+    //   product.metadata.faire_taxonomy_type_id (tt_… or a category name)
+    //   → settings.default_category (id or name) → error.
+    const client = service.getClient(input.auth_mode)
+    const categoryHint =
+      metadata.faire_taxonomy_type_id ||
+      metadata.faire_category ||
+      settings.default_category ||
+      ""
+    const taxonomyTypeId = await client.resolveTaxonomyTypeId(
+      input.access_token,
+      String(categoryHint)
+    )
+    if (!taxonomyTypeId) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Faire requires a product category (taxonomy_type). Set a Faire " +
+          "category in sync settings (default_category) or on the product " +
+          "(metadata.faire_taxonomy_type_id — a `tt_…` id or a category name)."
+      )
+    }
+
+    const lifecycle_state: "DRAFT" | "PUBLISHED" =
+      settings.follow_product_status !== false && product.status === "published"
+        ? "PUBLISHED"
+        : "DRAFT"
+
+    const builtVariants = (variants.length ? variants : [null]).map((v, i) =>
+      v
+        ? buildVariant(v, i)
+        : {
+            // Single-variant fallback for products with no explicit variants.
+            sku: product.id,
+            name: product.title || "Default",
+            idempotence_token: `${product.id}:default`,
+            available_quantity: 0,
+          }
+    )
+
     const product_input: CreateProductInput = {
-      brand_id: input.brand_id,
       name: (product.title || "Untitled Product").slice(0, 140),
+      idempotence_token: product.id,
+      lifecycle_state,
+      taxonomy_type: { id: taxonomyTypeId },
       description: product.description || "",
-      wholesale_price_cents: minWholesale || undefined,
-      retail_price_cents: minRetail || undefined,
-      images,
-      variants: variants.length ? variants.map(buildVariant) : undefined,
-      tags,
       short_description:
         typeof metadata.faire_short_description === "string"
           ? metadata.faire_short_description
           : undefined,
+      images,
+      variants: builtVariants,
     }
 
     return new StepResponse({
@@ -226,9 +324,11 @@ const syncProductStep = createStep(
         product = await client.updateProduct(access_token, existing_product_token, {
           name: product_input.name,
           description: product_input.description,
+          short_description: product_input.short_description,
+          lifecycle_state: product_input.lifecycle_state,
+          taxonomy_type: product_input.taxonomy_type,
           images: product_input.images,
           variants: product_input.variants,
-          tags: product_input.tags,
         })
       } else {
         product = await client.createProduct(access_token, product_input)
@@ -244,7 +344,7 @@ const syncProductStep = createStep(
       try {
         const levels = product_input.variants.map((v) => ({
           sku: v.sku,
-          current_count: v.inventory_count ?? 0,
+          on_hand_quantity: v.available_quantity ?? 0,
         }))
         await client.updateInventory(access_token, levels)
       } catch (err: any) {
@@ -348,6 +448,10 @@ export const syncProductToFaireWorkflow = createWorkflow(
         product_id: data.input.product_id,
         settings: data.config.settings,
         brand_id: data.config.brand_id,
+        currency: data.config.currency,
+        country: data.config.country,
+        access_token: data.config.access_token,
+        auth_mode: data.config.auth_mode,
       }))
     )