@tinloof/medusa-sanity-sync 0.1.0

package/.medusa/server/src/modules/sanity/service.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@sanity/client");
+const core_1 = require("../../core");
+const event_batcher_1 = require("../../event-batcher");
+class SanityModuleService {
+    constructor({ logger }, options) {
+        this.client = (0, client_1.createClient)({
+            projectId: options.project_id,
+            apiVersion: options.api_version,
+            dataset: options.dataset,
+            token: options.api_token,
+        });
+        this.logger = logger;
+        this.syncHandlers = options.syncHandlers;
+        // Initialize entity registry with configured entities or defaults
+        const entities = options.entities?.length
+            ? options.entities
+            : core_1.defaultEntities;
+        this.entityRegistry = (0, core_1.createEntityRegistry)(entities);
+        // Initialize transformer with plugin-level transformer function
+        this.transformer = (0, core_1.createTransformer)({
+            logger,
+            transformer: options.transformer,
+        });
+        // Initialize batcher with flush handler
+        this.batcher = new event_batcher_1.EventBatcher(this.handleBatchFlush.bind(this), options.batching);
+        this.logger.info(`Sanity module initialized with ${this.entityRegistry.size} entity type(s), batching ${this.batcher.isEnabled ? "enabled" : "disabled"}`);
+    }
+    /**
+     * Get the entity registry for external access.
+     */
+    getEntityRegistry() {
+        return this.entityRegistry;
+    }
+    /**
+     * Get the transformer for external access.
+     */
+    getTransformer() {
+        return this.transformer;
+    }
+    /**
+     * Get the batcher for external access (used by subscribers).
+     */
+    getBatcher() {
+        return this.batcher;
+    }
+    /**
+     * Create sync context for custom handlers.
+     */
+    createSyncContext() {
+        return {
+            sanityClient: this.client,
+            logger: this.logger,
+        };
+    }
+    /**
+     * Handle batch flush - called by batcher when ready.
+     * Uses Sanity's transaction API for batch operations across all entity types.
+     */
+    async handleBatchFlush(batches) {
+        const ctx = this.createSyncContext();
+        // If custom handlers are provided, fall back to individual calls
+        if (this.syncHandlers) {
+            await this.handleBatchFlushWithHandlers(batches, ctx);
+            return;
+        }
+        // Use single Sanity transaction for all entity types
+        const transaction = this.client.transaction();
+        let createCount = 0;
+        let updateCount = 0;
+        let deleteCount = 0;
+        for (const [entityType, batch] of batches.entries()) {
+            const entity = this.entityRegistry.get(entityType);
+            if (!entity) {
+                this.logger.warn(`Entity type "${entityType}" not registered, skipping`);
+                continue;
+            }
+            // Process creates - use createIfNotExists
+            for (const { id, data } of batch.creates) {
+                try {
+                    const result = this.transformer.transformForCreate(entity, data, id);
+                    transaction.createIfNotExists(result.data);
+                    createCount += 1;
+                }
+                catch (error) {
+                    this.logger.error(`Failed to prepare create for ${entityType} ${id}: ${error}`);
+                }
+            }
+            // Process updates - resolve draft IDs, then patch to preserve Sanity-managed fields
+            if (batch.updates.length > 0) {
+                const updateIds = batch.updates.map(({ id }) => id);
+                const targetIds = await this.getTargetIds(updateIds);
+                for (const { id, data } of batch.updates) {
+                    try {
+                        const result = this.transformer.transformForUpdate(entity, data);
+                        const targetId = targetIds.get(id) ?? id;
+                        transaction.createIfNotExists({
+                            _id: targetId,
+                            _type: entity.sanityType,
+                        });
+                        transaction.patch(targetId, { set: result.data });
+                        updateCount += 1;
+                    }
+                    catch (error) {
+                        this.logger.error(`Failed to prepare update for ${entityType} ${id}: ${error}`);
+                    }
+                }
+            }
+            // Process deletes - delete both published and draft
+            for (const { id } of batch.deletes) {
+                transaction.delete(id);
+                transaction.delete(`drafts.${id}`);
+                deleteCount += 1;
+            }
+        }
+        // Commit transaction if there are any operations
+        const totalOps = createCount + updateCount + deleteCount;
+        if (totalOps > 0) {
+            try {
+                await transaction.commit();
+                this.logger.info(`Batch committed: ${createCount} creates, ${updateCount} updates, ${deleteCount} deletes`);
+            }
+            catch (error) {
+                this.logger.error(`Failed to commit batch: ${error}`);
+            }
+        }
+    }
+    /**
+     * Handle batch flush with custom handlers (individual calls).
+     */
+    async handleBatchFlushWithHandlers(batches, ctx) {
+        for (const [entityType, batch] of batches.entries()) {
+            // Process creates
+            for (const { id, data } of batch.creates) {
+                try {
+                    if (this.syncHandlers?.onCreate) {
+                        await this.syncHandlers.onCreate(entityType, id, data, ctx);
+                    }
+                    else {
+                        await this.createSyncDocument(entityType, data);
+                    }
+                }
+                catch (error) {
+                    this.logger.error(`Failed to create ${entityType} ${id}: ${error}`);
+                }
+            }
+            // Process updates
+            for (const { id, data } of batch.updates) {
+                try {
+                    if (this.syncHandlers?.onUpdate) {
+                        await this.syncHandlers.onUpdate(entityType, id, data, ctx);
+                    }
+                    else {
+                        await this.updateSyncDocument(entityType, data);
+                    }
+                }
+                catch (error) {
+                    this.logger.error(`Failed to update ${entityType} ${id}: ${error}`);
+                }
+            }
+            // Process deletes
+            for (const { id } of batch.deletes) {
+                try {
+                    if (this.syncHandlers?.onDelete) {
+                        await this.syncHandlers.onDelete(entityType, id, ctx);
+                    }
+                    else {
+                        await this.delete(id);
+                    }
+                }
+                catch (error) {
+                    this.logger.error(`Failed to delete ${entityType} ${id}: ${error}`);
+                }
+            }
+            this.logger.info(`Batch flush for ${entityType}: ${batch.creates.length} creates, ${batch.updates.length} updates, ${batch.deletes.length} deletes`);
+        }
+    }
+    /**
+     * Upsert a document to Sanity (create if not exists, update if exists).
+     */
+    async upsertSyncDocument(entityType, data) {
+        const entity = this.entityRegistry.get(entityType);
+        if (!entity) {
+            throw new Error(`Entity type "${entityType}" is not registered`);
+        }
+        const [published, draft] = await this.client.getDocuments([
+            data.id,
+            `drafts.${data.id}`,
+        ]);
+        if (published || draft) {
+            return this.updateSyncDocument(entityType, data);
+        }
+        return this.createSyncDocument(entityType, data);
+    }
+    /**
+     * Create a new document in Sanity.
+     */
+    async createSyncDocument(entityType, data, options) {
+        const entity = this.entityRegistry.get(entityType);
+        if (!entity) {
+            throw new Error(`Entity type "${entityType}" is not registered`);
+        }
+        const result = this.transformer.transformForCreate(entity, data, data.id);
+        // @ts-expect-error
+        const document = await this.client.create(result.data, options);
+        return { document, isCreate: true };
+    }
+    /**
+     * Update an existing document in Sanity.
+     */
+    async updateSyncDocument(entityType, data) {
+        const entity = this.entityRegistry.get(entityType);
+        if (!entity) {
+            throw new Error(`Entity type "${entityType}" is not registered`);
+        }
+        const result = this.transformer.transformForUpdate(entity, data);
+        const targetId = await this.getTargetId(data.id);
+        const document = await this.client
+            .patch(targetId)
+            .set(result.data)
+            .commit();
+        return { document, isCreate: false };
+    }
+    /**
+     * Get the document ID to patch: prefers the draft if it exists, otherwise the published ID.
+     */
+    async getTargetId(id) {
+        const draftId = `drafts.${id}`;
+        const draft = await this.client.getDocument(draftId);
+        return draft ? draftId : id;
+    }
+    /**
+     * Get target IDs for a batch of document IDs.
+     * Returns a map of original ID → target ID (draft or published).
+     */
+    async getTargetIds(ids) {
+        const draftIds = ids.map((id) => `drafts.${id}`);
+        const drafts = await this.client.getDocuments(draftIds);
+        const targetMap = new Map();
+        for (let i = 0; i < ids.length; i++) {
+            targetMap.set(ids[i], drafts[i] ? draftIds[i] : ids[i]);
+        }
+        return targetMap;
+    }
+    /**
+     * Retrieve a document from Sanity by ID.
+     */
+    retrieve(id) {
+        return this.client.getDocument(id);
+    }
+    /**
+     * Delete a document from Sanity by ID (both published and draft).
+     */
+    delete(id) {
+        const tx = this.client.transaction();
+        tx.delete(id);
+        tx.delete(`drafts.${id}`);
+        return tx.commit();
+    }
+    /**
+     * Update a document in Sanity with raw data.
+     * Targets the draft if one exists, otherwise the published document.
+     */
+    async update(id, data) {
+        const targetId = await this.getTargetId(id);
+        return await this.client.patch(targetId, { set: data }).commit();
+    }
+    /**
+     * List documents from Sanity by IDs.
+     */
+    async list(filter) {
+        const data = await this.client.getDocuments(Array.isArray(filter.id) ? filter.id : [filter.id]);
+        return data.map((doc) => ({
+            id: doc?._id,
+            ...doc,
+        }));
+    }
+    /**
+     * Compensate for failed sync operations (rollback).
+     */
+    async compensate(upsertMap) {
+        await Promise.all(upsertMap.map(({ id, before, after, isCreate }) => {
+            if (isCreate) {
+                // Document was created, delete it
+                return this.delete(after._id);
+            }
+            // Document was updated, restore previous state
+            const { _id, _rev, _type, _createdAt, _updatedAt, ...oldData } = before;
+            return this.update(id, oldData);
+        }));
+    }
+    /**
+     * Get the Sanity client for advanced operations.
+     */
+    getClient() {
+        return this.client;
+    }
+}
+exports.default = SanityModuleService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/sanity/service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/subscribers/factory.d.ts

@@ -0,0 +1,43 @@
+import type { SubscriberArgs, SubscriberConfig } from "@medusajs/framework";
+/**
+ * Options for creating an entity subscriber.
+ */
+export type EntitySubscriberOptions = {
+    /**
+     * The Medusa entity type to sync (e.g., "product", "product_category")
+     */
+    entityType: string;
+    /**
+     * The events that trigger the sync
+     */
+    events: string[];
+};
+/**
+ * Factory function to create a subscriber for syncing entities to Sanity.
+ * Use this to create subscribers for custom entity types.
+ *
+ * @example
+ * ```typescript
+ * // src/subscribers/my-custom-entity-sync.ts
+ * import { createEntitySubscriber } from "@tinloof/medusa-sanity-sync/subscribers";
+ *
+ * const { handler, config } = createEntitySubscriber({
+ *   entityType: "my_custom_entity",
+ *   events: [
+ *     "my-custom-entity.created",
+ *     "my-custom-entity.updated",
+ *     "my-custom-entity.deleted",
+ *   ],
+ * });
+ *
+ * export default handler;
+ * export { config };
+ * ```
+ */
+export declare function createEntitySubscriber(options: EntitySubscriberOptions): {
+    handler: (args: SubscriberArgs<{
+        id: string;
+    }>) => Promise<void>;
+    config: SubscriberConfig;
+};
+//# sourceMappingURL=factory.d.ts.map

package/.medusa/server/src/subscribers/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../src/subscribers/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAM5E;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAYF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,uBAAuB,GAAG;IACxE,OAAO,EAAE,CAAC,IAAI,EAAE,cAAc,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjE,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAuCA"}

package/.medusa/server/src/subscribers/factory.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEntitySubscriber = createEntitySubscriber;
+const utils_1 = require("@medusajs/framework/utils");
+const sanity_1 = require("../modules/sanity");
+function getOperationType(eventName) {
+    if (eventName.endsWith(".created")) {
+        return "create";
+    }
+    if (eventName.endsWith(".deleted")) {
+        return "delete";
+    }
+    return "update";
+}
+/**
+ * Factory function to create a subscriber for syncing entities to Sanity.
+ * Use this to create subscribers for custom entity types.
+ *
+ * @example
+ * ```typescript
+ * // src/subscribers/my-custom-entity-sync.ts
+ * import { createEntitySubscriber } from "@tinloof/medusa-sanity-sync/subscribers";
+ *
+ * const { handler, config } = createEntitySubscriber({
+ *   entityType: "my_custom_entity",
+ *   events: [
+ *     "my-custom-entity.created",
+ *     "my-custom-entity.updated",
+ *     "my-custom-entity.deleted",
+ *   ],
+ * });
+ *
+ * export default handler;
+ * export { config };
+ * ```
+ */
+function createEntitySubscriber(options) {
+    const handler = async ({ event: { name: eventName, data }, container, }) => {
+        const sanityModule = container.resolve(sanity_1.SANITY_MODULE);
+        const batcher = sanityModule.getBatcher();
+        const operation = getOperationType(eventName);
+        // For delete, we don't need entity data
+        if (operation === "delete") {
+            await batcher.add(options.entityType, data.id, operation);
+            return;
+        }
+        // Fetch entity data for create/update
+        const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+        const entityRegistry = sanityModule.getEntityRegistry();
+        const entity = entityRegistry.get(options.entityType);
+        const queryFields = entity?.queryFields?.length
+            ? entity.queryFields
+            : ["*"];
+        const { data: entities } = await query.graph({
+            entity: entity?.medusaEntity ?? options.entityType,
+            fields: queryFields,
+            filters: { id: [data.id] },
+        });
+        if (entities.length > 0) {
+            await batcher.add(options.entityType, data.id, operation, entities[0]);
+        }
+    };
+    const config = {
+        event: options.events,
+    };
+    return { handler, config };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/subscribers/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This module exports subscriber utilities for creating custom entity sync subscribers.
+ *
+ * The default subscribers (product, category, collection) are automatically registered
+ * when the plugin is installed. For custom entities, you can use the createEntitySubscriber
+ * factory to create your own subscribers.
+ */
+export { createEntitySubscriber } from "./factory";
+//# sourceMappingURL=index.d.ts.map

package/.medusa/server/src/subscribers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/subscribers/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC"}

package/.medusa/server/src/subscribers/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * This module exports subscriber utilities for creating custom entity sync subscribers.
+ *
+ * The default subscribers (product, category, collection) are automatically registered
+ * when the plugin is installed. For custom entities, you can use the createEntitySubscriber
+ * factory to create your own subscribers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEntitySubscriber = void 0;
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "createEntitySubscriber", { enumerable: true, get: function () { return factory_1.createEntitySubscriber; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc3Vic2NyaWJlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7O0FBRUgscUNBQW1EO0FBQTFDLGlIQUFBLHNCQUFzQixPQUFBIn0=

package/.medusa/server/src/subscribers/sanity-sync.d.ts

@@ -0,0 +1,10 @@
+import type { SubscriberArgs, SubscriberConfig } from "@medusajs/framework";
+/**
+ * Unified subscriber for syncing all entities to Sanity.
+ * Handles products, categories, and collections.
+ */
+export default function syncToSanity({ event: { name: eventName, data }, container, }: SubscriberArgs<{
+    id: string;
+}>): Promise<void>;
+export declare const config: SubscriberConfig;
+//# sourceMappingURL=sanity-sync.d.ts.map

package/.medusa/server/src/subscribers/sanity-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanity-sync.d.ts","sourceRoot":"","sources":["../../../../src/subscribers/sanity-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AA+B5E;;;GAGG;AACH,wBAA8B,YAAY,CAAC,EACzC,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,EAChC,SAAS,GACV,EAAE,cAAc,CAAC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,iBAsChC;AAED,eAAO,MAAM,MAAM,EAAE,gBAepB,CAAC"}

package/.medusa/server/src/subscribers/sanity-sync.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = syncToSanity;
+const utils_1 = require("@medusajs/framework/utils");
+const sanity_1 = require("../modules/sanity");
+/**
+ * Map event prefix to entity type
+ */
+const EVENT_TO_ENTITY = {
+    product: "product",
+    "product-category": "product_category",
+    "product-collection": "product_collection",
+};
+function getOperationType(eventName) {
+    if (eventName.endsWith(".created")) {
+        return "create";
+    }
+    if (eventName.endsWith(".deleted")) {
+        return "delete";
+    }
+    return "update";
+}
+function getEntityType(eventName) {
+    // Event format: "prefix.action" (e.g., "product.created", "product-category.updated")
+    const prefix = eventName.split(".")[0];
+    return EVENT_TO_ENTITY[prefix] ?? null;
+}
+/**
+ * Unified subscriber for syncing all entities to Sanity.
+ * Handles products, categories, and collections.
+ */
+async function syncToSanity({ event: { name: eventName, data }, container, }) {
+    const sanityModule = container.resolve(sanity_1.SANITY_MODULE);
+    const batcher = sanityModule.getBatcher();
+    const entityRegistry = sanityModule.getEntityRegistry();
+    const entityType = getEntityType(eventName);
+    if (!entityType) {
+        return;
+    }
+    const entity = entityRegistry.get(entityType);
+    if (!entity) {
+        return;
+    }
+    const operation = getOperationType(eventName);
+    // For delete, we don't need entity data
+    if (operation === "delete") {
+        await batcher.add(entityType, data.id, operation);
+        return;
+    }
+    // Fetch entity data for create/update
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const queryFields = entity.queryFields?.length
+        ? entity.queryFields
+        : ["*"];
+    const { data: entities } = await query.graph({
+        entity: entity.medusaEntity,
+        fields: queryFields,
+        filters: { id: [data.id] },
+    });
+    if (entities.length > 0) {
+        await batcher.add(entityType, data.id, operation, entities[0]);
+    }
+}
+exports.config = {
+    event: [
+        // Products
+        "product.created",
+        "product.updated",
+        "product.deleted",
+        // Categories
+        "product-category.created",
+        "product-category.updated",
+        "product-category.deleted",
+        // Collections
+        "product-collection.created",
+        "product-collection.updated",
+        "product-collection.deleted",
+    ],
+};
+//# sourceMappingURL=data:application/json;base64,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