@jytextiles/medusa-plugin-faire-store-sync 0.1.0

package/src/modules/faire-sync/migrations/Migration20260707211346.ts

@@ -0,0 +1,43 @@
+import { Migration } from "@medusajs/framework/mikro-orm/migrations";
+
+export class Migration20260707211346 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`alter table if exists "faire_webhook_event" drop constraint if exists "faire_webhook_event_webhook_id_unique";`);
+    this.addSql(`alter table if exists "faire_order" drop constraint if exists "faire_order_order_token_unique";`);
+    this.addSql(`create table if not exists "faire_order" ("id" text not null, "order_token" text not null, "order_id" text null, "status" text not null default 'created', "currency" text null, "total" text null, "buyer_name" text null, "raw" jsonb null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "faire_order_pkey" primary key ("id"));`);
+    this.addSql(`CREATE UNIQUE INDEX IF NOT EXISTS "IDX_faire_order_order_token_unique" ON "faire_order" ("order_token") WHERE deleted_at IS NULL;`);
+    this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_faire_order_deleted_at" ON "faire_order" ("deleted_at") WHERE deleted_at IS NULL;`);
+
+    this.addSql(`create table if not exists "faire_sync_account" ("id" text not null, "brand_id" text not null, "brand_name" text not null, "currency" text null, "country" text null, "access_token" text not null, "refresh_token" text null, "token_expires_at" timestamptz null, "brand_info" jsonb null, "is_active" boolean not null default true, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "faire_sync_account_pkey" primary key ("id"));`);
+    this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_faire_sync_account_deleted_at" ON "faire_sync_account" ("deleted_at") WHERE deleted_at IS NULL;`);
+
+    this.addSql(`create table if not exists "faire_sync_batch" ("id" text not null, "transaction_id" text null, "status" text check ("status" in ('pending', 'processing', 'completed', 'failed')) not null default 'pending', "total_products" integer not null default 0, "synced_count" integer not null default 0, "failed_count" integer not null default 0, "error_log" jsonb null, "started_at" timestamptz null, "completed_at" timestamptz null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "faire_sync_batch_pkey" primary key ("id"));`);
+    this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_faire_sync_batch_deleted_at" ON "faire_sync_batch" ("deleted_at") WHERE deleted_at IS NULL;`);
+
+    this.addSql(`create table if not exists "faire_sync_record" ("id" text not null, "product_id" text not null, "account_id" text not null, "product_token" text null, "product_url" text null, "product_state" text null, "action" text check ("action" in ('create', 'update', 'delete')) not null default 'create', "status" text check ("status" in ('pending', 'syncing', 'success', 'failed', 'draft')) not null default 'pending', "published" boolean not null default false, "error_message" text null, "warnings" jsonb null, "metadata" jsonb null, "synced_at" timestamptz null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "faire_sync_record_pkey" primary key ("id"));`);
+    this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_faire_sync_record_deleted_at" ON "faire_sync_record" ("deleted_at") WHERE deleted_at IS NULL;`);
+
+    this.addSql(`create table if not exists "faire_sync_settings" ("id" text not null, "account_id" text null, "default_brand_id" text null, "default_wholesale_markup_percent" integer null, "default_min_order_quantity" integer not null default 1, "default_lead_time_days" integer null, "default_shipping_policy_id" text null, "default_category" text null, "auto_publish" boolean not null default false, "follow_product_status" boolean not null default true, "pending_oauth" jsonb null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "faire_sync_settings_pkey" primary key ("id"));`);
+    this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_faire_sync_settings_deleted_at" ON "faire_sync_settings" ("deleted_at") WHERE deleted_at IS NULL;`);
+
+    this.addSql(`create table if not exists "faire_webhook_event" ("id" text not null, "webhook_id" text not null, "event_type" text not null, "brand_id" text null, "resource_url" text null, "payload" jsonb null, "resource" jsonb null, "processed" boolean not null default false, "error" text null, "received_at" timestamptz null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "faire_webhook_event_pkey" primary key ("id"));`);
+    this.addSql(`CREATE UNIQUE INDEX IF NOT EXISTS "IDX_faire_webhook_event_webhook_id_unique" ON "faire_webhook_event" ("webhook_id") WHERE deleted_at IS NULL;`);
+    this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_faire_webhook_event_deleted_at" ON "faire_webhook_event" ("deleted_at") WHERE deleted_at IS NULL;`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`drop table if exists "faire_order" cascade;`);
+
+    this.addSql(`drop table if exists "faire_sync_account" cascade;`);
+
+    this.addSql(`drop table if exists "faire_sync_batch" cascade;`);
+
+    this.addSql(`drop table if exists "faire_sync_record" cascade;`);
+
+    this.addSql(`drop table if exists "faire_sync_settings" cascade;`);
+
+    this.addSql(`drop table if exists "faire_webhook_event" cascade;`);
+  }
+
+}

package/src/modules/faire-sync/models/faire-order.ts

@@ -0,0 +1,20 @@
+import { model } from "@medusajs/framework/utils"
+
+/**
+ * Maps a Faire order to the Medusa order created from it. `order_token` is
+ * unique — the idempotency key so a Faire webhook retry (or a later
+ * order.canceled/shipped event for the same order) never re-creates the
+ * Medusa order.
+ */
+const FaireOrder = model.define("faire_order", {
+  id: model.id().primaryKey(),
+  order_token: model.text().unique(),
+  order_id: model.text().nullable(), // Medusa order id
+  status: model.text().default("created"),
+  currency: model.text().nullable(),
+  total: model.text().nullable(), // decimal string (cents as integer string)
+  buyer_name: model.text().nullable(),
+  raw: model.json().nullable(),
+})
+
+export default FaireOrder

package/src/modules/faire-sync/models/faire-sync-account.ts

@@ -0,0 +1,16 @@
+import { model } from "@medusajs/framework/utils"
+
+const FaireSyncAccount = model.define("faire_sync_account", {
+  id: model.id().primaryKey(),
+  brand_id: model.text(),
+  brand_name: model.text(),
+  currency: model.text().nullable(),
+  country: model.text().nullable(),
+  access_token: model.text(),
+  refresh_token: model.text().nullable(),
+  token_expires_at: model.dateTime().nullable(),
+  brand_info: model.json().nullable(),
+  is_active: model.boolean().default(true),
+})
+
+export default FaireSyncAccount

package/src/modules/faire-sync/models/faire-sync-batch.ts

@@ -0,0 +1,17 @@
+import { model } from "@medusajs/framework/utils"
+
+const FaireSyncBatch = model.define("faire_sync_batch", {
+  id: model.id().primaryKey(),
+  transaction_id: model.text().nullable(),
+  status: model
+    .enum(["pending", "processing", "completed", "failed"])
+    .default("pending"),
+  total_products: model.number().default(0),
+  synced_count: model.number().default(0),
+  failed_count: model.number().default(0),
+  error_log: model.json().nullable(),
+  started_at: model.dateTime().nullable(),
+  completed_at: model.dateTime().nullable(),
+})
+
+export default FaireSyncBatch

package/src/modules/faire-sync/models/faire-sync-record.ts

@@ -0,0 +1,21 @@
+import { model } from "@medusajs/framework/utils"
+
+const FaireSyncRecord = model.define("faire_sync_record", {
+  id: model.id().primaryKey(),
+  product_id: model.text(),
+  account_id: model.text(),
+  product_token: model.text().nullable(),
+  product_url: model.text().nullable(),
+  product_state: model.text().nullable(),
+  action: model.enum(["create", "update", "delete"]).default("create"),
+  status: model
+    .enum(["pending", "syncing", "success", "failed", "draft"])
+    .default("pending"),
+  published: model.boolean().default(false),
+  error_message: model.text().nullable(),
+  warnings: model.json().nullable(),
+  metadata: model.json().nullable(),
+  synced_at: model.dateTime().nullable(),
+})
+
+export default FaireSyncRecord

package/src/modules/faire-sync/models/faire-sync-settings.ts

@@ -0,0 +1,25 @@
+import { model } from "@medusajs/framework/utils"
+
+/**
+ * Singleton settings row. Holds publish-readiness defaults plus the in-flight
+ * OAuth `state` (keyed by it) so the callback can verify the round-trip.
+ *
+ * Faire-flavored readiness: connection, brand id, wholesale pricing strategy,
+ * and shipping policy. Missing fields sync products as drafts rather than
+ * publishing them.
+ */
+const FaireSyncSettings = model.define("faire_sync_settings", {
+  id: model.id().primaryKey(),
+  account_id: model.text().nullable(),
+  default_brand_id: model.text().nullable(),
+  default_wholesale_markup_percent: model.number().nullable(),
+  default_min_order_quantity: model.number().default(1),
+  default_lead_time_days: model.number().nullable(),
+  default_shipping_policy_id: model.text().nullable(),
+  default_category: model.text().nullable(),
+  auto_publish: model.boolean().default(false),
+  follow_product_status: model.boolean().default(true),
+  pending_oauth: model.json().nullable(),
+})
+
+export default FaireSyncSettings

package/src/modules/faire-sync/models/faire-webhook-event.ts

@@ -0,0 +1,20 @@
+import { model } from "@medusajs/framework/utils"
+
+/**
+ * Durable record of an inbound Faire webhook delivery. `webhook_id` is the
+ * delivery id Faire sends (unique) so retries are idempotent.
+ */
+const FaireWebhookEvent = model.define("faire_webhook_event", {
+  id: model.id().primaryKey(),
+  webhook_id: model.text().unique(),
+  event_type: model.text(),
+  brand_id: model.text().nullable(),
+  resource_url: model.text().nullable(),
+  payload: model.json().nullable(),
+  resource: model.json().nullable(),
+  processed: model.boolean().default(false),
+  error: model.text().nullable(),
+  received_at: model.dateTime().nullable(),
+})
+
+export default FaireWebhookEvent

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

@@ -0,0 +1,252 @@
+import { MedusaError, MedusaService } from "@medusajs/framework/utils"
+import FaireSyncAccount from "./models/faire-sync-account"
+import FaireSyncRecord from "./models/faire-sync-record"
+import FaireSyncSettings from "./models/faire-sync-settings"
+import FaireSyncBatch from "./models/faire-sync-batch"
+import FaireWebhookEvent from "./models/faire-webhook-event"
+import FaireOrder from "./models/faire-order"
+import { FaireClient } from "../../lib/faire-client"
+import { FairePluginOptions, BrandInfo, TokenData } from "../../lib/types"
+
+type ModuleOptions = FairePluginOptions & Record<string, any>
+
+function readOption(options: any, key: string): string | undefined {
+  try {
+    const value = options?.[key]
+    return typeof value === "string" ? value : undefined
+  } catch {
+    return undefined
+  }
+}
+
+function toMedusaError(err: any): MedusaError {
+  if (err instanceof MedusaError) return err
+
+  const status: number | undefined = err?.status
+  const body: any = err?.body
+  const message: string =
+    body?.error_description || body?.error || err?.message || "Faire request failed"
+
+  if (status === 400 && /invalid_grant|invalid code|already used/i.test(message)) {
+    return new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Faire authorization expired or was already used. Please reconnect."
+    )
+  }
+  if (/brand/i.test(message) && /(no|not|own)/i.test(message)) {
+    return new MedusaError(MedusaError.Types.NOT_FOUND, message)
+  }
+  if (status === 401 || status === 403) {
+    return new MedusaError(MedusaError.Types.NOT_ALLOWED, message)
+  }
+  if (status === 404) {
+    return new MedusaError(MedusaError.Types.NOT_FOUND, message)
+  }
+  if (status === 400 || status === 422) {
+    return new MedusaError(MedusaError.Types.INVALID_DATA, message)
+  }
+  return new MedusaError(MedusaError.Types.UNEXPECTED_STATE, message)
+}
+
+function resolveFaireOptions(options?: ModuleOptions): ModuleOptions {
+  return {
+    clientId: process.env.FAIRE_CLIENT_ID ?? readOption(options, "clientId") ?? "",
+    clientSecret:
+      process.env.FAIRE_CLIENT_SECRET ?? readOption(options, "clientSecret") ?? "",
+    redirectUri:
+      process.env.FAIRE_REDIRECT_URI ??
+      readOption(options, "redirectUri") ??
+      "http://localhost:9000/app/settings/oauth/faire/callback",
+    apiBase: process.env.FAIRE_API_BASE ?? readOption(options, "apiBase"),
+    authUrl: process.env.FAIRE_AUTH_URL ?? readOption(options, "authUrl"),
+    tokenUrl: process.env.FAIRE_TOKEN_URL ?? readOption(options, "tokenUrl"),
+    scope: process.env.FAIRE_SCOPE ?? readOption(options, "scope") ?? "",
+    webhookSecret:
+      process.env.FAIRE_WEBHOOK_SECRET ?? readOption(options, "webhookSecret") ?? "",
+  } as ModuleOptions
+}
+
+class FaireSyncService extends MedusaService({
+  FaireSyncAccount,
+  FaireSyncRecord,
+  FaireSyncSettings,
+  FaireSyncBatch,
+  FaireWebhookEvent,
+  FaireOrder,
+}) {
+  protected options_: ModuleOptions
+  protected client_: FaireClient | null = null
+
+  constructor(container: any, options?: ModuleOptions) {
+    super(...arguments)
+    this.options_ = resolveFaireOptions(options)
+  }
+
+  getClient(): FaireClient {
+    if (!this.client_) {
+      this.client_ = new FaireClient(this.options_)
+    }
+    return this.client_
+  }
+
+  getOptions(): ModuleOptions {
+    return this.options_
+  }
+
+  async getActiveAccount() {
+    const [account] = await this.listFaireSyncAccounts({
+      is_active: true,
+    } as any)
+    return account ?? null
+  }
+
+  async saveAccount(token: TokenData, brand: BrandInfo) {
+    const existing = await this.getActiveAccount()
+    const expiresAt =
+      token.expires_in != null
+        ? new Date(token.retrieved_at + token.expires_in * 1000)
+        : null
+    const payload = {
+      brand_id: brand.brand_id,
+      brand_name: brand.brand_name,
+      currency: brand.currency ?? null,
+      country: brand.country ?? null,
+      access_token: token.access_token,
+      refresh_token: token.refresh_token ?? null,
+      token_expires_at: expiresAt,
+      brand_info: brand.raw,
+      is_active: true,
+    }
+    if (existing) {
+      return this.updateFaireSyncAccounts({
+        id: existing.id,
+        ...payload,
+      } as any)
+    }
+    return this.createFaireSyncAccounts(payload as any)
+  }
+
+  async disconnect() {
+    const account = await this.getActiveAccount()
+    if (!account) return
+    await this.updateFaireSyncAccounts({
+      id: account.id,
+      is_active: false,
+      access_token: "",
+      refresh_token: null,
+    } as any)
+  }
+
+  async ensureFreshToken(account?: any) {
+    const acct = account ?? (await this.getActiveAccount())
+    if (!acct) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_FOUND,
+        "Faire account is not connected"
+      )
+    }
+    if (!acct.token_expires_at) {
+      return acct
+    }
+    const now = Date.now()
+    const expiresAt = new Date(acct.token_expires_at).getTime()
+    const fiveMinutes = 5 * 60 * 1000
+    if (expiresAt - now > fiveMinutes) {
+      return acct
+    }
+    if (!acct.refresh_token) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_ALLOWED,
+        "Faire access token has expired. Please reconnect your Faire account."
+      )
+    }
+    try {
+      const client = this.getClient()
+      const token = await client.refreshAccessToken(acct.refresh_token)
+      return this.updateFaireSyncAccounts({
+        id: acct.id,
+        access_token: token.access_token,
+        refresh_token: token.refresh_token ?? acct.refresh_token,
+        token_expires_at:
+          token.expires_in != null
+            ? new Date(token.retrieved_at + token.expires_in * 1000)
+            : null,
+      } as any)
+    } catch (err) {
+      throw toMedusaError(err)
+    }
+  }
+
+  async getSettings() {
+    const [settings] = await this.listFaireSyncSettings({}, { take: 1 } as any)
+    if (settings) return settings
+    return this.createFaireSyncSettings({} as any)
+  }
+
+  async updateSettings(data: any) {
+    const settings = await this.getSettings()
+    return this.updateFaireSyncSettings({ id: settings.id, ...data } as any)
+  }
+
+  async startOAuth(): Promise<{ authorization_url: string; state: string }> {
+    try {
+      const state = crypto.randomUUID()
+      await this.updateSettings({
+        pending_oauth: {
+          state,
+          created_at: Date.now(),
+        },
+      })
+      const client = this.getClient()
+      return {
+        authorization_url: client.getAuthorizationUrl(state),
+        state,
+      }
+    } catch (err) {
+      throw toMedusaError(err)
+    }
+  }
+
+  async completeOAuth(code: string, state: string) {
+    const settings = await this.getSettings()
+    const pending: any = settings.pending_oauth
+    if (!pending || pending.state !== state) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Invalid or expired OAuth state. Please start the Faire connection again."
+      )
+    }
+    try {
+      const client = this.getClient()
+      const token = await client.exchangeCodeForToken(code)
+      const brand = await client.getBrand(token.access_token)
+      const account = await this.saveAccount(token, brand)
+      await this.updateSettings({
+        account_id: account.id,
+        default_brand_id: brand.brand_id,
+        pending_oauth: null,
+      })
+      return { account, brand }
+    } catch (err) {
+      throw toMedusaError(err)
+    }
+  }
+
+  async createSyncRecord(data: any) {
+    return this.createFaireSyncRecords(data as any)
+  }
+
+  async updateSyncRecord(id: string, data: any) {
+    return this.updateFaireSyncRecords({ id, ...data } as any)
+  }
+
+  async listSyncRecords(filters: any = {}, take = 20, skip = 0) {
+    return this.listAndCountFaireSyncRecords(filters, {
+      take,
+      skip,
+      order: { created_at: "DESC" },
+    } as any)
+  }
+}
+
+export default FaireSyncService

package/src/subscribers/faire-inventory-sync.ts

@@ -0,0 +1,97 @@
+import { SubscriberArgs, type SubscriberConfig } from "@medusajs/framework"
+import { ContainerRegistrationKeys, Modules } from "@medusajs/framework/utils"
+import { FAIRE_SYNC_MODULE } from "../modules/faire-sync"
+import FaireSyncService from "../modules/faire-sync/service"
+
+/**
+ * React to inventory updates Faire pushes (e.g. a retailer placed an order and
+ * Faire decremented stock). We mirror the remote count back onto the linked
+ * Medusa variant's inventory so the two systems stay consistent. Best-effort —
+ * never throws.
+ */
+export default async function faireInventorySyncHandler({
+  event: { data },
+  container,
+}: SubscriberArgs<{ resource?: any; resource_url?: string }>) {
+  const logger: any = container.resolve(ContainerRegistrationKeys.LOGGER)
+  const service: FaireSyncService = container.resolve(FAIRE_SYNC_MODULE)
+
+  let payload: any = data?.resource
+  if (!payload && data?.resource_url) {
+    try {
+      const account = await service.ensureFreshToken()
+      payload = await service
+        .getClient()
+        .fetchResource((account as any).access_token, data.resource_url)
+    } catch {
+      return
+    }
+  }
+  if (!payload) return
+
+  const levels: any[] = Array.isArray(payload?.inventory)
+    ? payload.inventory
+    : Array.isArray(payload)
+      ? payload
+      : payload?.items
+        ? payload.items
+        : []
+  if (!levels.length) return
+
+  try {
+    const query: any = container.resolve(ContainerRegistrationKeys.QUERY)
+    const inventory: any = container.resolve(Modules.INVENTORY)
+
+    for (const lvl of levels) {
+      const sku = String(lvl.sku ?? "")
+      const count = Number(lvl.current_count ?? lvl.inventory_count)
+      if (!sku || !Number.isFinite(count)) continue
+
+      // Find the linked Medusa product via sync record matching this SKU's
+      // product token, then resolve its inventory item and set the level.
+      const productToken = lvl.product_token ? String(lvl.product_token) : null
+      if (!productToken) continue
+      const [records] = await service.listSyncRecords({ product_token: productToken }, 1, 0)
+      const productId = (records as any[])?.[0]?.product_id
+      if (!productId) continue
+
+      const { data: products } = await query.graph({
+        entity: "product",
+        fields: [
+          "id",
+          "variants.sku",
+          "variants.inventory_items.inventory_item_id",
+          "variants.inventory_items.inventory.location_levels.location_id",
+          "variants.inventory_items.inventory.location_levels.stocked_quantity",
+        ],
+        filters: { id: productId },
+      })
+
+      const variant = (products?.[0]?.variants || []).find((v: any) => v.sku === sku)
+      const invItem = (variant?.inventory_items || [])[0]
+      const levels2 = invItem?.inventory?.location_levels || []
+      const level = [...levels2].sort(
+        (a: any, b: any) => Number(b.stocked_quantity) - Number(a.stocked_quantity)
+      )[0]
+      if (!invItem?.inventory_item_id || !level?.location_id) continue
+
+      const delta = count - Number(level.stocked_quantity || 0)
+      if (delta !== 0) {
+        await inventory.adjustInventory(
+          invItem.inventory_item_id,
+          level.location_id,
+          delta
+        )
+        logger?.info?.(
+          `[faire-inventory] ${sku} adjusted by ${delta} → ${count}`
+        )
+      }
+    }
+  } catch (err: any) {
+    logger?.warn?.(`[faire-inventory] sync failed: ${err?.message}`)
+  }
+}
+
+export const config: SubscriberConfig = {
+  event: "faire.inventory_updated",
+}

package/src/subscribers/faire-listing-events.ts

@@ -0,0 +1,48 @@
+import { SubscriberArgs, type SubscriberConfig } from "@medusajs/framework"
+import { ContainerRegistrationKeys, Modules } from "@medusajs/framework/utils"
+
+/**
+ * Surface notable Faire product/listing changes to the admin feed. Faire emits
+ * outbound webhooks for product updates; the webhook receiver re-emits internal
+ * `faire.product.*` / `faire.listing.*` events that this subscriber turns into
+ * admin feed notifications. Extend here to auto-restock or re-list.
+ */
+const LABELS: Record<string, string> = {
+  "faire.product_updated": "was updated on Faire",
+  "faire.product_sold_out": "sold out on Faire",
+  "faire.product_deactivated": "was deactivated on Faire",
+  "faire.listing.deleted": "was removed on Faire",
+}
+
+export default async function faireListingEventsHandler({
+  event,
+  container,
+}: SubscriberArgs<{ product_token?: string; resource?: any }>) {
+  const logger: any = container.resolve(ContainerRegistrationKeys.LOGGER)
+  const label = LABELS[event.name] || "changed on Faire"
+  const token = event.data?.product_token
+
+  try {
+    const notification: any = container.resolve(Modules.NOTIFICATION)
+    await notification.createNotifications({
+      to: "",
+      channel: "feed",
+      template: "admin-ui",
+      data: {
+        title: "Faire product update",
+        description: `Faire product ${token ?? ""} ${label}.`,
+      },
+    })
+  } catch (err: any) {
+    logger?.warn?.(`[faire-listing] notify failed for ${event.name}: ${err?.message}`)
+  }
+}
+
+export const config: SubscriberConfig = {
+  event: [
+    "faire.product_updated",
+    "faire.product_sold_out",
+    "faire.product_deactivated",
+    "faire.listing.deleted",
+  ],
+}

package/src/subscribers/faire-order-ingest.ts

@@ -0,0 +1,61 @@
+import { SubscriberArgs, type SubscriberConfig } from "@medusajs/framework"
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils"
+import { FAIRE_SYNC_MODULE } from "../modules/faire-sync"
+import FaireSyncService from "../modules/faire-sync/service"
+import { ingestFaireOrderWorkflow } from "../workflows/ingest-faire-order"
+
+/**
+ * Create a Medusa order from a placed Faire order.
+ *
+ * Fired by the `faire.order_placed` (or `faire.order_created`) event the webhook
+ * receiver emits, kept off the webhook request path so the 200 stays fast. The
+ * Faire order is carried on the event; if it wasn't fetched at webhook time we
+ * refetch from resource_url.
+ *
+ * Kill switch: set FAIRE_INGEST_ORDERS=false to disable order creation while
+ * still recording webhook deliveries.
+ */
+export default async function faireOrderIngestHandler({
+  event: { data },
+  container,
+}: SubscriberArgs<{
+  resource?: any
+  resource_url?: string
+  webhook_id?: string
+}>) {
+  if (process.env.FAIRE_INGEST_ORDERS === "false") return
+
+  const logger: any = container.resolve(ContainerRegistrationKeys.LOGGER)
+  const service: FaireSyncService = container.resolve(FAIRE_SYNC_MODULE)
+
+  let order: any = data?.resource
+  if (!order && data?.resource_url) {
+    try {
+      const account = await service.ensureFreshToken()
+      order = await service
+        .getClient()
+        .fetchResource((account as any).access_token, data.resource_url)
+    } catch (err: any) {
+      logger?.warn?.(`[faire-order] could not fetch order: ${err?.message}`)
+      return
+    }
+  }
+  if (!order) return
+
+  try {
+    await ingestFaireOrderWorkflow(container).run({
+      input: {
+        order,
+        order_token: order?.order_token != null ? String(order.order_token) : null,
+      },
+    })
+  } catch (err: any) {
+    logger?.warn?.(
+      `[faire-order] ingest failed for order ${order?.order_token}: ${err?.message}`
+    )
+  }
+}
+
+export const config: SubscriberConfig = {
+  event: ["faire.order_placed", "faire.order_created"],
+}