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

package/src/api/admin/faire/settings/route.ts

@@ -0,0 +1,17 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { FAIRE_SYNC_MODULE } from "../../../../modules/faire-sync"
+import FaireSyncService from "../../../../modules/faire-sync/service"
+
+// GET /admin/faire/settings
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const service: FaireSyncService = req.scope.resolve(FAIRE_SYNC_MODULE)
+  const settings = await service.getSettings()
+  res.json({ settings })
+}
+
+// POST /admin/faire/settings
+export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
+  const service: FaireSyncService = req.scope.resolve(FAIRE_SYNC_MODULE)
+  const settings = await service.updateSettings(req.body || {})
+  res.json({ settings })
+}

package/src/api/admin/faire/status/product/[id]/route.ts

@@ -0,0 +1,30 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { FAIRE_SYNC_MODULE } from "../../../../../../modules/faire-sync"
+import FaireSyncService from "../../../../../../modules/faire-sync/service"
+
+// GET /admin/faire/status/product/:id — latest sync state for a single product.
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const { id } = req.params
+  const service: FaireSyncService = req.scope.resolve(FAIRE_SYNC_MODULE)
+
+  const connected = !!(await service.getActiveAccount())
+  const [records] = await service.listSyncRecords({ product_id: id }, 1, 0)
+  const latest: any = records?.[0] ?? null
+
+  res.json({
+    connected,
+    synced: !!latest,
+    latest: latest
+      ? {
+          id: latest.id,
+          status: latest.status,
+          product_token: latest.product_token,
+          product_url: latest.product_url,
+          product_state: latest.product_state,
+          published: latest.published,
+          error_message: latest.error_message,
+          synced_at: latest.synced_at,
+        }
+      : null,
+  })
+}

package/src/api/admin/faire/status/route.ts

@@ -0,0 +1,47 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { FAIRE_SYNC_MODULE } from "../../../../modules/faire-sync"
+import FaireSyncService from "../../../../modules/faire-sync/service"
+
+// GET /admin/faire/status — connection status + readiness checklist
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const service: FaireSyncService = req.scope.resolve(FAIRE_SYNC_MODULE)
+  const account = await service.getActiveAccount()
+  const settings = await service.getSettings()
+
+  const connected = !!account && account.is_active
+  const hasBrand = !!settings.default_brand_id
+  const hasMarkup =
+    settings.default_wholesale_markup_percent != null &&
+    settings.default_wholesale_markup_percent > 0
+  const hasShipping = !!settings.default_shipping_policy_id
+
+  res.json({
+    connected,
+    account: account
+      ? {
+          id: account.id,
+          brand_id: account.brand_id,
+          brand_name: account.brand_name,
+          currency: account.currency,
+          token_expires_at: account.token_expires_at,
+        }
+      : null,
+    settings: {
+      default_brand_id: settings.default_brand_id,
+      default_wholesale_markup_percent: settings.default_wholesale_markup_percent,
+      default_min_order_quantity: settings.default_min_order_quantity,
+      default_lead_time_days: settings.default_lead_time_days,
+      default_shipping_policy_id: settings.default_shipping_policy_id,
+      default_category: settings.default_category,
+      auto_publish: settings.auto_publish,
+      follow_product_status: settings.follow_product_status,
+    },
+    readiness: {
+      connected,
+      brand: hasBrand,
+      wholesale_pricing: hasMarkup,
+      shipping_policy: hasShipping,
+      ready_to_publish: connected && hasBrand,
+    },
+  })
+}

package/src/api/admin/faire/sync/bulk/[batchId]/route.ts

@@ -0,0 +1,33 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { MedusaError } from "@medusajs/framework/utils"
+import { FAIRE_SYNC_MODULE } from "../../../../../../modules/faire-sync"
+import FaireSyncService from "../../../../../../modules/faire-sync/service"
+
+// GET /admin/faire/sync/bulk/:batchId — poll the progress of a background batch
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const { batchId } = req.params
+  const service: FaireSyncService = req.scope.resolve(FAIRE_SYNC_MODULE)
+
+  const batch = await service
+    .retrieveFaireSyncBatch(batchId)
+    .catch(() => null)
+
+  if (!batch) {
+    throw new MedusaError(MedusaError.Types.NOT_FOUND, "Batch not found")
+  }
+
+  const total = (batch as any).total_products || 0
+  const done =
+    ((batch as any).synced_count || 0) + ((batch as any).failed_count || 0)
+
+  res.json({
+    batch,
+    progress: {
+      total,
+      done,
+      pct: total ? Math.round((done / total) * 100) : 0,
+      finished:
+        (batch as any).status === "completed" || (batch as any).status === "failed",
+    },
+  })
+}

package/src/api/admin/faire/sync/bulk/route.ts

@@ -0,0 +1,27 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { MedusaError } from "@medusajs/framework/utils"
+import { syncProductsToFaireWorkflow } from "../../../../../workflows/sync-products-to-faire"
+
+type BulkSyncBody = {
+  product_ids?: string[]
+}
+
+// POST /admin/faire/sync/bulk — sync many products (long-running background workflow)
+export const POST = async (req: MedusaRequest<BulkSyncBody>, res: MedusaResponse) => {
+  const { product_ids } = req.body || {}
+
+  if (!product_ids?.length) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "product_ids array is required"
+    )
+  }
+
+  const { result } = await syncProductsToFaireWorkflow(req.scope).run({
+    input: { product_ids },
+  })
+
+  // The workflow runs the per-product sync in the background; we return the
+  // batch id immediately so the client can poll GET /admin/faire/sync/bulk/:id.
+  res.status(202).json({ batch_id: (result as any).batch_id, status: "processing" })
+}

package/src/api/admin/faire/sync/product/[id]/route.ts

@@ -0,0 +1,13 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { syncProductToFaireWorkflow } from "../../../../../../workflows/sync-product-to-faire"
+
+// POST /admin/faire/sync/product/:id — sync a single product to Faire
+export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
+  const { id } = req.params
+
+  const { result } = await syncProductToFaireWorkflow(req.scope).run({
+    input: { product_id: id },
+  })
+
+  res.json({ result })
+}

package/src/api/admin/faire/syncs/[id]/route.ts

@@ -0,0 +1,32 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { MedusaError } from "@medusajs/framework/utils"
+import { FAIRE_SYNC_MODULE } from "../../../../../modules/faire-sync"
+import FaireSyncService from "../../../../../modules/faire-sync/service"
+import { syncProductToFaireWorkflow } from "../../../../../workflows/sync-product-to-faire"
+
+// GET /admin/faire/syncs/:id — fetch a single sync record
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const service: FaireSyncService = req.scope.resolve(FAIRE_SYNC_MODULE)
+  const { id } = req.params
+  const [record] = await service.listFaireSyncRecords({ id } as any, { take: 1 } as any)
+  if (!record) {
+    throw new MedusaError(MedusaError.Types.NOT_FOUND, "Sync record not found")
+  }
+  res.json({ sync: record })
+}
+
+// POST /admin/faire/syncs/:id/retry — re-sync the product referenced by this record
+export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
+  const service: FaireSyncService = req.scope.resolve(FAIRE_SYNC_MODULE)
+  const { id } = req.params
+  const [record] = await service.listFaireSyncRecords({ id } as any, { take: 1 } as any)
+  if (!record) {
+    throw new MedusaError(MedusaError.Types.NOT_FOUND, "Sync record not found")
+  }
+
+  const { result } = await syncProductToFaireWorkflow(req.scope).run({
+    input: { product_id: (record as any).product_id },
+  })
+
+  res.json({ result })
+}

package/src/api/admin/faire/syncs/route.ts

@@ -0,0 +1,17 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { FAIRE_SYNC_MODULE } from "../../../../modules/faire-sync"
+import FaireSyncService from "../../../../modules/faire-sync/service"
+
+// GET /admin/faire/syncs — list recent sync records (paginated)
+export const GET = async (req: MedusaRequest, res: MedusaResponse) => {
+  const service: FaireSyncService = req.scope.resolve(FAIRE_SYNC_MODULE)
+  const take = Number(req.query.take) || 20
+  const skip = Number(req.query.skip) || 0
+  const status = req.query.status as string | undefined
+
+  const filters: any = {}
+  if (status) filters.status = status
+
+  const [records, count] = await service.listSyncRecords(filters, take, skip)
+  res.json({ syncs: records, count, take, skip })
+}

package/src/api/webhooks/faire/route.ts

@@ -0,0 +1,133 @@
+import crypto from "crypto"
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { ContainerRegistrationKeys, Modules } from "@medusajs/framework/utils"
+import { FAIRE_SYNC_MODULE } from "../../../modules/faire-sync"
+import FaireSyncService from "../../../modules/faire-sync/service"
+import { verifyFaireWebhook } from "../../../lib/webhook"
+
+/**
+ * POST /webhooks/faire — inbound Faire webhook receiver.
+ *
+ * Faire signs each delivery with an HMAC-SHA256 of the raw body using the
+ * webhook secret shared at registration time, sent in the
+ * `X-Faire-Webhook-Signature` header. This route:
+ *   1. verifies the signature over the raw body,
+ *   2. records the delivery idempotently (unique delivery id),
+ *   3. best-effort fetches the resource referenced and re-emits a Medusa event
+ *      `faire.<event_type>` so subscribers / visual flows can act on it,
+ *   4. always returns 200 once verified+recorded (Faire retries on non-2xx).
+ *
+ * Raw body is available because the host's middlewares.ts sets preserveRawBody
+ * for this path. Register the endpoint URL + copy the signing secret
+ * (FAIRE_WEBHOOK_SECRET) when you create the webhook via the Faire API.
+ *
+ * Faire emits events such as ORDER_PLACED, ORDER_CANCELED, ORDER_SHIPPED,
+ * INVENTORY_UPDATED, PRODUCT_UPDATED (verify against your Faire app's
+ * configuration). We normalize the event_type to lowercase for the emitted
+ * Medusa event name.
+ */
+export const POST = async (req: MedusaRequest, res: MedusaResponse) => {
+  const logger = req.scope.resolve(ContainerRegistrationKeys.LOGGER) as any
+  const service: FaireSyncService = req.scope.resolve(FAIRE_SYNC_MODULE)
+  const secret = (service.getOptions() as any).webhookSecret as string
+
+  const rawBody = (req as any).rawBody as Buffer | undefined
+  const rawStr = rawBody?.length ? rawBody.toString("utf8") : JSON.stringify(req.body ?? {})
+
+  const headers = {
+    signature: req.headers["x-faire-webhook-signature"] as string | undefined,
+    timestamp: req.headers["x-faire-webhook-timestamp"] as string | undefined,
+  }
+
+  const { valid, reason } = verifyFaireWebhook({ secret, headers, rawBody: rawStr })
+  if (!valid) {
+    logger?.warn?.(`[faire-webhook] rejected: ${reason}`)
+    return res.status(401).json({ error: "invalid signature" })
+  }
+
+  const payload: any = req.body ?? safeParse(rawStr)
+  const eventType: string = String(
+    payload?.event_type || payload?.type || "unknown"
+  ).toLowerCase()
+
+  // Delivery id — Faire sends a unique id per delivery; fall back to a hash of
+  // the body + type so we still dedupe if absent.
+  const webhookId =
+    (req.headers["x-faire-webhook-id"] as string | undefined) ||
+    (payload?.webhook_id as string | undefined) ||
+    `${eventType}:${crypto.createHash("sha256").update(rawStr).digest("hex")}`
+
+  // Idempotency — Faire retries with backoff; a verified duplicate is a no-op.
+  const existing = await service
+    .listFaireWebhookEvents({ webhook_id: webhookId } as any)
+    .catch(() => [])
+  if ((existing as any[])?.length) {
+    return res.status(200).json({ ok: true, duplicate: true })
+  }
+
+  let record: any
+  try {
+    record = await service.createFaireWebhookEvents({
+      webhook_id: webhookId,
+      event_type: eventType,
+      brand_id: payload?.brand_id != null ? String(payload.brand_id) : null,
+      resource_url: payload?.resource_url ?? null,
+      payload,
+      received_at: new Date(),
+    } as any)
+  } catch {
+    // Unique-constraint race → treat as duplicate.
+    return res.status(200).json({ ok: true, duplicate: true })
+  }
+
+  // Best-effort processing — never fail the webhook once it's verified+recorded.
+  try {
+    let resource: any = null
+    if (payload?.resource_url) {
+      const account = await service.getActiveAccount()
+      if (account) {
+        resource = await service
+          .getClient()
+          .fetchResource(account.access_token, payload.resource_url)
+          .catch(() => null)
+      }
+    } else if (payload?.data) {
+      resource = payload.data
+    }
+
+    const eventBus: any = req.scope.resolve(Modules.EVENT_BUS)
+    await eventBus.emit({
+      name: `faire.${eventType}`,
+      data: {
+        webhook_id: webhookId,
+        event_type: eventType,
+        brand_id: payload?.brand_id ?? null,
+        resource_url: payload?.resource_url ?? null,
+        resource,
+      },
+    })
+
+    await service.updateFaireWebhookEvents({
+      id: record.id,
+      resource,
+      processed: true,
+    } as any)
+  } catch (err: any) {
+    logger?.warn?.(
+      `[faire-webhook] processing failed for ${webhookId}: ${err?.message || err}`
+    )
+    await service
+      .updateFaireWebhookEvents({ id: record.id, error: String(err?.message || err) } as any)
+      .catch(() => {})
+  }
+
+  return res.status(200).json({ ok: true })
+}
+
+function safeParse(s: string): any {
+  try {
+    return JSON.parse(s)
+  } catch {
+    return {}
+  }
+}

package/src/jobs/pull-faire-orders.ts

@@ -0,0 +1,30 @@
+import { MedusaContainer } from "@medusajs/framework/types"
+import { FAIRE_SYNC_MODULE } from "../modules/faire-sync"
+import FaireSyncService from "../modules/faire-sync/service"
+import { ingestFaireOrdersBulkWorkflow } from "../workflows/ingest-faire-orders-bulk"
+
+/**
+ * Scheduled pull of new Faire orders. Runs the bulk order-ingestion workflow
+ * (a long-running background workflow) so new wholesale orders placed on Faire
+ * are mirrored into Medusa without a seller having to trigger it manually.
+ *
+ * Disable by setting FAIRE_AUTO_INGEST_ORDERS=false.
+ */
+export default async function pullFaireOrdersJob(container: MedusaContainer) {
+  if (process.env.FAIRE_AUTO_INGEST_ORDERS === "false") return
+
+  const service: FaireSyncService = container.resolve(FAIRE_SYNC_MODULE)
+  const account = await service.getActiveAccount()
+  if (!account) return
+
+  try {
+    await ingestFaireOrdersBulkWorkflow(container).run({ input: {} })
+  } catch (err: any) {
+    console.error("[faire-sync] scheduled order pull failed:", err.message)
+  }
+}
+
+export const config = {
+  name: "faire-pull-orders",
+  schedule: "*/30 * * * *", // every 30 minutes
+}

package/src/jobs/refresh-faire-token.ts

@@ -0,0 +1,23 @@
+import { MedusaContainer } from "@medusajs/framework/types"
+import { FAIRE_SYNC_MODULE } from "../modules/faire-sync"
+import FaireSyncService from "../modules/faire-sync/service"
+
+// Refreshes the Faire access token if it is set to expire (Faire tokens
+// historically do not expire, but this keeps the OAuth2 path correct if yours do).
+export default async function refreshFaireTokenJob(container: MedusaContainer) {
+  const service: FaireSyncService = container.resolve(FAIRE_SYNC_MODULE)
+  const account = await service.getActiveAccount()
+  if (!account) {
+    return
+  }
+  try {
+    await service.ensureFreshToken(account)
+  } catch (err: any) {
+    console.error("[faire-sync] token refresh failed:", err.message)
+  }
+}
+
+export const config = {
+  name: "faire-refresh-token",
+  schedule: "*/10 * * * *",
+}