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

package/.medusa/server/src/modules/faire-sync/models/faire-sync-settings.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@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 = utils_1.model.define("faire_sync_settings", {
+    id: utils_1.model.id().primaryKey(),
+    account_id: utils_1.model.text().nullable(),
+    default_brand_id: utils_1.model.text().nullable(),
+    default_wholesale_markup_percent: utils_1.model.number().nullable(),
+    default_min_order_quantity: utils_1.model.number().default(1),
+    default_lead_time_days: utils_1.model.number().nullable(),
+    default_shipping_policy_id: utils_1.model.text().nullable(),
+    default_category: utils_1.model.text().nullable(),
+    auto_publish: utils_1.model.boolean().default(false),
+    follow_product_status: utils_1.model.boolean().default(true),
+    pending_oauth: utils_1.model.json().nullable(),
+});
+exports.default = FaireSyncSettings;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFpcmUtc3luYy1zZXR0aW5ncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9tb2R1bGVzL2ZhaXJlLXN5bmMvbW9kZWxzL2ZhaXJlLXN5bmMtc2V0dGluZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxxREFBaUQ7QUFFakQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0saUJBQWlCLEdBQUcsYUFBSyxDQUFDLE1BQU0sQ0FBQyxxQkFBcUIsRUFBRTtJQUM1RCxFQUFFLEVBQUUsYUFBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLFVBQVUsRUFBRTtJQUMzQixVQUFVLEVBQUUsYUFBSyxDQUFDLElBQUksRUFBRSxDQUFDLFFBQVEsRUFBRTtJQUNuQyxnQkFBZ0IsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsUUFBUSxFQUFFO0lBQ3pDLGdDQUFnQyxFQUFFLGFBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQyxRQUFRLEVBQUU7SUFDM0QsMEJBQTBCLEVBQUUsYUFBSyxDQUFDLE1BQU0sRUFBRSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDckQsc0JBQXNCLEVBQUUsYUFBSyxDQUFDLE1BQU0sRUFBRSxDQUFDLFFBQVEsRUFBRTtJQUNqRCwwQkFBMEIsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsUUFBUSxFQUFFO0lBQ25ELGdCQUFnQixFQUFFLGFBQUssQ0FBQyxJQUFJLEVBQUUsQ0FBQyxRQUFRLEVBQUU7SUFDekMsWUFBWSxFQUFFLGFBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO0lBQzVDLHFCQUFxQixFQUFFLGFBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDO0lBQ3BELGFBQWEsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsUUFBUSxFQUFFO0NBQ3ZDLENBQUMsQ0FBQTtBQUVGLGtCQUFlLGlCQUFpQixDQUFBIn0=

package/.medusa/server/src/modules/faire-sync/models/faire-webhook-event.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@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 = utils_1.model.define("faire_webhook_event", {
+    id: utils_1.model.id().primaryKey(),
+    webhook_id: utils_1.model.text().unique(),
+    event_type: utils_1.model.text(),
+    brand_id: utils_1.model.text().nullable(),
+    resource_url: utils_1.model.text().nullable(),
+    payload: utils_1.model.json().nullable(),
+    resource: utils_1.model.json().nullable(),
+    processed: utils_1.model.boolean().default(false),
+    error: utils_1.model.text().nullable(),
+    received_at: utils_1.model.dateTime().nullable(),
+});
+exports.default = FaireWebhookEvent;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFpcmUtd2ViaG9vay1ldmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9tb2R1bGVzL2ZhaXJlLXN5bmMvbW9kZWxzL2ZhaXJlLXdlYmhvb2stZXZlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxxREFBaUQ7QUFFakQ7OztHQUdHO0FBQ0gsTUFBTSxpQkFBaUIsR0FBRyxhQUFLLENBQUMsTUFBTSxDQUFDLHFCQUFxQixFQUFFO0lBQzVELEVBQUUsRUFBRSxhQUFLLENBQUMsRUFBRSxFQUFFLENBQUMsVUFBVSxFQUFFO0lBQzNCLFVBQVUsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsTUFBTSxFQUFFO0lBQ2pDLFVBQVUsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFO0lBQ3hCLFFBQVEsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsUUFBUSxFQUFFO0lBQ2pDLFlBQVksRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsUUFBUSxFQUFFO0lBQ3JDLE9BQU8sRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsUUFBUSxFQUFFO0lBQ2hDLFFBQVEsRUFBRSxhQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsUUFBUSxFQUFFO0lBQ2pDLFNBQVMsRUFBRSxhQUFLLENBQUMsT0FBTyxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQztJQUN6QyxLQUFLLEVBQUUsYUFBSyxDQUFDLElBQUksRUFBRSxDQUFDLFFBQVEsRUFBRTtJQUM5QixXQUFXLEVBQUUsYUFBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLFFBQVEsRUFBRTtDQUN6QyxDQUFDLENBQUE7QUFFRixrQkFBZSxpQkFBaUIsQ0FBQSJ9

package/.medusa/server/src/modules/faire-sync/service.js

@@ -0,0 +1,222 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const faire_sync_account_1 = __importDefault(require("./models/faire-sync-account"));
+const faire_sync_record_1 = __importDefault(require("./models/faire-sync-record"));
+const faire_sync_settings_1 = __importDefault(require("./models/faire-sync-settings"));
+const faire_sync_batch_1 = __importDefault(require("./models/faire-sync-batch"));
+const faire_webhook_event_1 = __importDefault(require("./models/faire-webhook-event"));
+const faire_order_1 = __importDefault(require("./models/faire-order"));
+const faire_client_1 = require("../../lib/faire-client");
+function readOption(options, key) {
+    try {
+        const value = options?.[key];
+        return typeof value === "string" ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function toMedusaError(err) {
+    if (err instanceof utils_1.MedusaError)
+        return err;
+    const status = err?.status;
+    const body = err?.body;
+    const message = body?.error_description || body?.error || err?.message || "Faire request failed";
+    if (status === 400 && /invalid_grant|invalid code|already used/i.test(message)) {
+        return new utils_1.MedusaError(utils_1.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 utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, message);
+    }
+    if (status === 401 || status === 403) {
+        return new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, message);
+    }
+    if (status === 404) {
+        return new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, message);
+    }
+    if (status === 400 || status === 422) {
+        return new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, message);
+    }
+    return new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, message);
+}
+function resolveFaireOptions(options) {
+    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") ?? "",
+    };
+}
+class FaireSyncService extends (0, utils_1.MedusaService)({
+    FaireSyncAccount: faire_sync_account_1.default,
+    FaireSyncRecord: faire_sync_record_1.default,
+    FaireSyncSettings: faire_sync_settings_1.default,
+    FaireSyncBatch: faire_sync_batch_1.default,
+    FaireWebhookEvent: faire_webhook_event_1.default,
+    FaireOrder: faire_order_1.default,
+}) {
+    constructor(container, options) {
+        super(...arguments);
+        this.client_ = null;
+        this.options_ = resolveFaireOptions(options);
+    }
+    getClient() {
+        if (!this.client_) {
+            this.client_ = new faire_client_1.FaireClient(this.options_);
+        }
+        return this.client_;
+    }
+    getOptions() {
+        return this.options_;
+    }
+    async getActiveAccount() {
+        const [account] = await this.listFaireSyncAccounts({
+            is_active: true,
+        });
+        return account ?? null;
+    }
+    async saveAccount(token, brand) {
+        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,
+            });
+        }
+        return this.createFaireSyncAccounts(payload);
+    }
+    async disconnect() {
+        const account = await this.getActiveAccount();
+        if (!account)
+            return;
+        await this.updateFaireSyncAccounts({
+            id: account.id,
+            is_active: false,
+            access_token: "",
+            refresh_token: null,
+        });
+    }
+    async ensureFreshToken(account) {
+        const acct = account ?? (await this.getActiveAccount());
+        if (!acct) {
+            throw new utils_1.MedusaError(utils_1.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 utils_1.MedusaError(utils_1.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,
+            });
+        }
+        catch (err) {
+            throw toMedusaError(err);
+        }
+    }
+    async getSettings() {
+        const [settings] = await this.listFaireSyncSettings({}, { take: 1 });
+        if (settings)
+            return settings;
+        return this.createFaireSyncSettings({});
+    }
+    async updateSettings(data) {
+        const settings = await this.getSettings();
+        return this.updateFaireSyncSettings({ id: settings.id, ...data });
+    }
+    async startOAuth() {
+        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, state) {
+        const settings = await this.getSettings();
+        const pending = settings.pending_oauth;
+        if (!pending || pending.state !== state) {
+            throw new utils_1.MedusaError(utils_1.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) {
+        return this.createFaireSyncRecords(data);
+    }
+    async updateSyncRecord(id, data) {
+        return this.updateFaireSyncRecords({ id, ...data });
+    }
+    async listSyncRecords(filters = {}, take = 20, skip = 0) {
+        return this.listAndCountFaireSyncRecords(filters, {
+            take,
+            skip,
+            order: { created_at: "DESC" },
+        });
+    }
+}
+exports.default = FaireSyncService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/faire-sync/service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/subscribers/faire-inventory-sync.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = faireInventorySyncHandler;
+const utils_1 = require("@medusajs/framework/utils");
+const faire_sync_1 = require("../modules/faire-sync");
+/**
+ * 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.
+ */
+async function faireInventorySyncHandler({ event: { data }, container, }) {
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const service = container.resolve(faire_sync_1.FAIRE_SYNC_MODULE);
+    let payload = data?.resource;
+    if (!payload && data?.resource_url) {
+        try {
+            const account = await service.ensureFreshToken();
+            payload = await service
+                .getClient()
+                .fetchResource(account.access_token, data.resource_url);
+        }
+        catch {
+            return;
+        }
+    }
+    if (!payload)
+        return;
+    const levels = Array.isArray(payload?.inventory)
+        ? payload.inventory
+        : Array.isArray(payload)
+            ? payload
+            : payload?.items
+                ? payload.items
+                : [];
+    if (!levels.length)
+        return;
+    try {
+        const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+        const inventory = container.resolve(utils_1.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?.[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) => v.sku === sku);
+            const invItem = (variant?.inventory_items || [])[0];
+            const levels2 = invItem?.inventory?.location_levels || [];
+            const level = [...levels2].sort((a, b) => 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) {
+        logger?.warn?.(`[faire-inventory] sync failed: ${err?.message}`);
+    }
+}
+exports.config = {
+    event: "faire.inventory_updated",
+};
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/subscribers/faire-listing-events.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = faireListingEventsHandler;
+const utils_1 = require("@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 = {
+    "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",
+};
+async function faireListingEventsHandler({ event, container, }) {
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const label = LABELS[event.name] || "changed on Faire";
+    const token = event.data?.product_token;
+    try {
+        const notification = container.resolve(utils_1.Modules.NOTIFICATION);
+        await notification.createNotifications({
+            to: "",
+            channel: "feed",
+            template: "admin-ui",
+            data: {
+                title: "Faire product update",
+                description: `Faire product ${token ?? ""} ${label}.`,
+            },
+        });
+    }
+    catch (err) {
+        logger?.warn?.(`[faire-listing] notify failed for ${event.name}: ${err?.message}`);
+    }
+}
+exports.config = {
+    event: [
+        "faire.product_updated",
+        "faire.product_sold_out",
+        "faire.product_deactivated",
+        "faire.listing.deleted",
+    ],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFpcmUtbGlzdGluZy1ldmVudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc3Vic2NyaWJlcnMvZmFpcmUtbGlzdGluZy1ldmVudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBZ0JBLDRDQXNCQztBQXJDRCxxREFBOEU7QUFFOUU7Ozs7O0dBS0c7QUFDSCxNQUFNLE1BQU0sR0FBMkI7SUFDckMsdUJBQXVCLEVBQUUsc0JBQXNCO0lBQy9DLHdCQUF3QixFQUFFLG1CQUFtQjtJQUM3QywyQkFBMkIsRUFBRSwwQkFBMEI7SUFDdkQsdUJBQXVCLEVBQUUsc0JBQXNCO0NBQ2hELENBQUE7QUFFYyxLQUFLLFVBQVUseUJBQXlCLENBQUMsRUFDdEQsS0FBSyxFQUNMLFNBQVMsR0FDa0Q7SUFDM0QsTUFBTSxNQUFNLEdBQVEsU0FBUyxDQUFDLE9BQU8sQ0FBQyxpQ0FBeUIsQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUN2RSxNQUFNLEtBQUssR0FBRyxNQUFNLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLGtCQUFrQixDQUFBO0lBQ3RELE1BQU0sS0FBSyxHQUFHLEtBQUssQ0FBQyxJQUFJLEVBQUUsYUFBYSxDQUFBO0lBRXZDLElBQUksQ0FBQztRQUNILE1BQU0sWUFBWSxHQUFRLFNBQVMsQ0FBQyxPQUFPLENBQUMsZUFBTyxDQUFDLFlBQVksQ0FBQyxDQUFBO1FBQ2pFLE1BQU0sWUFBWSxDQUFDLG1CQUFtQixDQUFDO1lBQ3JDLEVBQUUsRUFBRSxFQUFFO1lBQ04sT0FBTyxFQUFFLE1BQU07WUFDZixRQUFRLEVBQUUsVUFBVTtZQUNwQixJQUFJLEVBQUU7Z0JBQ0osS0FBSyxFQUFFLHNCQUFzQjtnQkFDN0IsV0FBVyxFQUFFLGlCQUFpQixLQUFLLElBQUksRUFBRSxJQUFJLEtBQUssR0FBRzthQUN0RDtTQUNGLENBQUMsQ0FBQTtJQUNKLENBQUM7SUFBQyxPQUFPLEdBQVEsRUFBRSxDQUFDO1FBQ2xCLE1BQU0sRUFBRSxJQUFJLEVBQUUsQ0FBQyxxQ0FBcUMsS0FBSyxDQUFDLElBQUksS0FBSyxHQUFHLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQTtJQUNwRixDQUFDO0FBQ0gsQ0FBQztBQUVZLFFBQUEsTUFBTSxHQUFxQjtJQUN0QyxLQUFLLEVBQUU7UUFDTCx1QkFBdUI7UUFDdkIsd0JBQXdCO1FBQ3hCLDJCQUEyQjtRQUMzQix1QkFBdUI7S0FDeEI7Q0FDRixDQUFBIn0=

package/.medusa/server/src/subscribers/faire-order-ingest.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = faireOrderIngestHandler;
+const utils_1 = require("@medusajs/framework/utils");
+const faire_sync_1 = require("../modules/faire-sync");
+const ingest_faire_order_1 = require("../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.
+ */
+async function faireOrderIngestHandler({ event: { data }, container, }) {
+    if (process.env.FAIRE_INGEST_ORDERS === "false")
+        return;
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const service = container.resolve(faire_sync_1.FAIRE_SYNC_MODULE);
+    let order = data?.resource;
+    if (!order && data?.resource_url) {
+        try {
+            const account = await service.ensureFreshToken();
+            order = await service
+                .getClient()
+                .fetchResource(account.access_token, data.resource_url);
+        }
+        catch (err) {
+            logger?.warn?.(`[faire-order] could not fetch order: ${err?.message}`);
+            return;
+        }
+    }
+    if (!order)
+        return;
+    try {
+        await (0, ingest_faire_order_1.ingestFaireOrderWorkflow)(container).run({
+            input: {
+                order,
+                order_token: order?.order_token != null ? String(order.order_token) : null,
+            },
+        });
+    }
+    catch (err) {
+        logger?.warn?.(`[faire-order] ingest failed for order ${order?.order_token}: ${err?.message}`);
+    }
+}
+exports.config = {
+    event: ["faire.order_placed", "faire.order_created"],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFpcmUtb3JkZXItaW5nZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3N1YnNjcmliZXJzL2ZhaXJlLW9yZGVyLWluZ2VzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFpQkEsMENBdUNDO0FBdkRELHFEQUFxRTtBQUNyRSxzREFBeUQ7QUFFekQsd0VBQTBFO0FBRTFFOzs7Ozs7Ozs7O0dBVUc7QUFDWSxLQUFLLFVBQVUsdUJBQXVCLENBQUMsRUFDcEQsS0FBSyxFQUFFLEVBQUUsSUFBSSxFQUFFLEVBQ2YsU0FBUyxHQUtUO0lBQ0EsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLG1CQUFtQixLQUFLLE9BQU87UUFBRSxPQUFNO0lBRXZELE1BQU0sTUFBTSxHQUFRLFNBQVMsQ0FBQyxPQUFPLENBQUMsaUNBQXlCLENBQUMsTUFBTSxDQUFDLENBQUE7SUFDdkUsTUFBTSxPQUFPLEdBQXFCLFNBQVMsQ0FBQyxPQUFPLENBQUMsOEJBQWlCLENBQUMsQ0FBQTtJQUV0RSxJQUFJLEtBQUssR0FBUSxJQUFJLEVBQUUsUUFBUSxDQUFBO0lBQy9CLElBQUksQ0FBQyxLQUFLLElBQUksSUFBSSxFQUFFLFlBQVksRUFBRSxDQUFDO1FBQ2pDLElBQUksQ0FBQztZQUNILE1BQU0sT0FBTyxHQUFHLE1BQU0sT0FBTyxDQUFDLGdCQUFnQixFQUFFLENBQUE7WUFDaEQsS0FBSyxHQUFHLE1BQU0sT0FBTztpQkFDbEIsU0FBUyxFQUFFO2lCQUNYLGFBQWEsQ0FBRSxPQUFlLENBQUMsWUFBWSxFQUFFLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQTtRQUNwRSxDQUFDO1FBQUMsT0FBTyxHQUFRLEVBQUUsQ0FBQztZQUNsQixNQUFNLEVBQUUsSUFBSSxFQUFFLENBQUMsd0NBQXdDLEdBQUcsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFBO1lBQ3RFLE9BQU07UUFDUixDQUFDO0lBQ0gsQ0FBQztJQUNELElBQUksQ0FBQyxLQUFLO1FBQUUsT0FBTTtJQUVsQixJQUFJLENBQUM7UUFDSCxNQUFNLElBQUEsNkNBQXdCLEVBQUMsU0FBUyxDQUFDLENBQUMsR0FBRyxDQUFDO1lBQzVDLEtBQUssRUFBRTtnQkFDTCxLQUFLO2dCQUNMLFdBQVcsRUFBRSxLQUFLLEVBQUUsV0FBVyxJQUFJLElBQUksQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSTthQUMzRTtTQUNGLENBQUMsQ0FBQTtJQUNKLENBQUM7SUFBQyxPQUFPLEdBQVEsRUFBRSxDQUFDO1FBQ2xCLE1BQU0sRUFBRSxJQUFJLEVBQUUsQ0FDWix5Q0FBeUMsS0FBSyxFQUFFLFdBQVcsS0FBSyxHQUFHLEVBQUUsT0FBTyxFQUFFLENBQy9FLENBQUE7SUFDSCxDQUFDO0FBQ0gsQ0FBQztBQUVZLFFBQUEsTUFBTSxHQUFxQjtJQUN0QyxLQUFLLEVBQUUsQ0FBQyxvQkFBb0IsRUFBRSxxQkFBcUIsQ0FBQztDQUNyRCxDQUFBIn0=

package/.medusa/server/src/subscribers/faire-order-lifecycle.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = faireOrderLifecycleHandler;
+const utils_1 = require("@medusajs/framework/utils");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const faire_sync_1 = require("../modules/faire-sync");
+/**
+ * Follow a Faire order's lifecycle onto the Medusa order we created for it:
+ *   order.canceled → cancel the Medusa order
+ *   order.shipped  → stamp fulfillment status = shipped
+ *   order.delivered→ stamp fulfillment status = delivered
+ *
+ * The order must already exist (created on order.placed); if it doesn't yet we
+ * simply skip.
+ */
+async function faireOrderLifecycleHandler({ event, container, }) {
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const service = container.resolve(faire_sync_1.FAIRE_SYNC_MODULE);
+    let order = event.data?.resource;
+    if (!order && event.data?.resource_url) {
+        try {
+            const account = await service.ensureFreshToken();
+            order = await service
+                .getClient()
+                .fetchResource(account.access_token, event.data.resource_url);
+        }
+        catch {
+            return;
+        }
+    }
+    const orderToken = order?.order_token != null ? String(order.order_token) : null;
+    if (!orderToken)
+        return;
+    const [mapRow] = await service
+        .listFaireOrders({ order_token: orderToken })
+        .catch(() => []);
+    const orderId = mapRow?.order_id;
+    if (!orderId)
+        return;
+    const orderService = container.resolve(utils_1.Modules.ORDER);
+    try {
+        if (event.name === "faire.order_canceled") {
+            await (0, core_flows_1.cancelOrderWorkflow)(container).run({ input: { order_id: orderId } });
+            await service.updateFaireOrders({ id: mapRow.id, status: "canceled" });
+            logger?.info?.(`[faire-order] canceled Medusa order ${orderId} (Faire ${orderToken})`);
+            return;
+        }
+        const fulfillmentStatus = event.name === "faire.order_delivered" ? "delivered" : "shipped";
+        const existing = await orderService
+            .retrieveOrder(orderId, { select: ["id", "metadata"] })
+            .catch(() => null);
+        const metadata = {
+            ...(existing?.metadata || {}),
+            faire_fulfillment_status: fulfillmentStatus,
+        };
+        await orderService.updateOrders([{ id: orderId, metadata }]);
+        await service.updateFaireOrders({
+            id: mapRow.id,
+            status: fulfillmentStatus,
+        });
+        logger?.info?.(`[faire-order] order ${orderId} fulfillment → ${fulfillmentStatus} (Faire ${orderToken})`);
+    }
+    catch (err) {
+        logger?.warn?.(`[faire-order] lifecycle ${event.name} failed for order ${orderId}: ${err?.message}`);
+    }
+}
+exports.config = {
+    event: ["faire.order_canceled", "faire.order_shipped", "faire.order_delivered"],
+};
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/subscribers/faire-product-status-sync.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = faireProductStatusSyncHandler;
+const utils_1 = require("@medusajs/framework/utils");
+const faire_sync_1 = require("../modules/faire-sync");
+const sync_product_to_faire_1 = require("../workflows/sync-product-to-faire");
+/**
+ * Keep an already-synced Faire product in step with its Medusa product's status
+ * (the draft → published transition the user cares about).
+ *
+ * This is an internal Medusa event (Faire has its own outbound webhooks for
+ * product changes, handled separately). `product.updated` is high-frequency,
+ * so we guard hard to avoid burning Faire's per-second / daily quota:
+ *   - only products that are ALREADY linked (i.e. synced at least once),
+ *   - only when `follow_product_status` is on, and
+ *   - only when the Medusa status ACTUALLY changed since the last sync
+ *     (compared against `product_status` stored on the link metadata).
+ *
+ * The sync workflow does not mutate the Medusa product, so this cannot loop.
+ */
+async function faireProductStatusSyncHandler({ event: { data }, container, }) {
+    if (!data?.id)
+        return;
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const service = container.resolve(faire_sync_1.FAIRE_SYNC_MODULE);
+    const account = await service.getActiveAccount();
+    if (!account)
+        return;
+    const settings = await service.getSettings();
+    if (settings.follow_product_status === false)
+        return;
+    const remoteLink = container.resolve(utils_1.ContainerRegistrationKeys.LINK);
+    let row;
+    try {
+        const rows = await remoteLink.list({
+            [utils_1.Modules.PRODUCT]: { product_id: data.id },
+            [faire_sync_1.FAIRE_SYNC_MODULE]: { faire_sync_account_id: account.id },
+        });
+        row = rows?.[0];
+    }
+    catch {
+        return;
+    }
+    if (!row?.faire_product_token)
+        return;
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data: products } = await query.graph({
+        entity: "product",
+        fields: ["id", "status"],
+        filters: { id: data.id },
+    });
+    const status = products?.[0]?.status;
+    if (!status)
+        return;
+    if (status === row?.metadata?.product_status)
+        return;
+    try {
+        logger?.info?.(`[faire] product ${data.id} status → "${status}" (was "${row?.metadata?.product_status ?? "unknown"}"); re-syncing product ${row.faire_product_token}`);
+        await (0, sync_product_to_faire_1.syncProductToFaireWorkflow)(container).run({
+            input: { product_id: data.id },
+        });
+    }
+    catch (err) {
+        logger?.warn?.(`[faire] auto re-sync failed for product ${data.id}: ${err?.message || err}`);
+    }
+}
+exports.config = {
+    event: "product.updated",
+};
+//# sourceMappingURL=data:application/json;base64,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