@deenruv/merchant-plugin 1.0.17-dev.17 → 1.0.17-dev.20

package/dist/plugin-server/services/merchant-sync-history.service.js

@@ -0,0 +1,97 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerchantSyncHistoryService = exports.summarizeGoogleSyncRun = void 0;
+const core_1 = require("@deenruv/core");
+const common_1 = require("@nestjs/common");
+const merchant_sync_item_entity_js_1 = require("../entities/merchant-sync-item.entity.js");
+const merchant_sync_run_entity_js_1 = require("../entities/merchant-sync-run.entity.js");
+const google_merchant_api_js_1 = require("./google-merchant-api.js");
+function summarizeGoogleSyncRun(input) {
+    const resultFailures = input.results.filter((result) => result.status === "error").length;
+    const total = input.results.length || input.requestedTotal;
+    const failed = input.results.length === 0 && input.fallbackError
+        ? input.requestedTotal
+        : resultFailures;
+    const succeeded = Math.max(0, total - failed);
+    const status = failed === 0 && !input.fallbackError
+        ? "SUCCESS"
+        : succeeded > 0
+            ? "PARTIAL"
+            : "FAILED";
+    return { failed, status, succeeded, total };
+}
+exports.summarizeGoogleSyncRun = summarizeGoogleSyncRun;
+let MerchantSyncHistoryService = class MerchantSyncHistoryService {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    async start(ctx, input) {
+        var _a, _b;
+        return this.connection.getRepository(ctx, merchant_sync_run_entity_js_1.MerchantSyncRun).save(new merchant_sync_run_entity_js_1.MerchantSyncRun({
+            errorSummary: null,
+            failed: 0,
+            finishedAt: null,
+            items: [],
+            jobId: (_a = input.jobId) !== null && _a !== void 0 ? _a : null,
+            platform: input.platform,
+            startedAt: new Date(),
+            status: "RUNNING",
+            succeeded: 0,
+            total: (_b = input.total) !== null && _b !== void 0 ? _b : 0,
+            trigger: input.trigger,
+        }));
+    }
+    async finishGoogleRun(ctx, run, results, fallbackError) {
+        var _a, _b;
+        const itemRepository = this.connection.getRepository(ctx, merchant_sync_item_entity_js_1.MerchantSyncItem);
+        const items = results.map((result) => {
+            var _a, _b;
+            const normalized = result.status === "error"
+                ? (0, google_merchant_api_js_1.normalizeGoogleMerchantError)(result.error)
+                : undefined;
+            return new merchant_sync_item_entity_js_1.MerchantSyncItem({
+                attempts: result.attempts,
+                errorCode: (_a = normalized === null || normalized === void 0 ? void 0 : normalized.code) !== null && _a !== void 0 ? _a : null,
+                errorMessage: (_b = normalized === null || normalized === void 0 ? void 0 : normalized.message) !== null && _b !== void 0 ? _b : null,
+                offerId: result.item.communicateID,
+                operation: result.item.method,
+                run,
+                status: result.status === "success" ? "SUCCESS" : "FAILED",
+            });
+        });
+        if (items.length > 0)
+            await itemRepository.save(items, { chunk: 100 });
+        const summary = summarizeGoogleSyncRun({
+            fallbackError,
+            requestedTotal: run.total,
+            results,
+        });
+        const fallback = fallbackError
+            ? (0, google_merchant_api_js_1.normalizeGoogleMerchantError)(fallbackError)
+            : undefined;
+        const firstItemError = items.find((item) => item.errorMessage);
+        return this.connection.getRepository(ctx, merchant_sync_run_entity_js_1.MerchantSyncRun).save(Object.assign(Object.assign({}, run), { errorSummary: (_b = (_a = fallback === null || fallback === void 0 ? void 0 : fallback.message) !== null && _a !== void 0 ? _a : firstItemError === null || firstItemError === void 0 ? void 0 : firstItemError.errorMessage) !== null && _b !== void 0 ? _b : null, failed: summary.failed, finishedAt: new Date(), status: summary.status, succeeded: summary.succeeded, total: summary.total }));
+    }
+    async findLatest(ctx, platform, take = 20) {
+        return this.connection.getRepository(ctx, merchant_sync_run_entity_js_1.MerchantSyncRun).find({
+            order: { createdAt: "DESC" },
+            relations: ["items"],
+            take: Math.min(Math.max(take, 1), 100),
+            where: { platform },
+        });
+    }
+};
+exports.MerchantSyncHistoryService = MerchantSyncHistoryService;
+exports.MerchantSyncHistoryService = MerchantSyncHistoryService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.TransactionalConnection])
+], MerchantSyncHistoryService);

package/dist/plugin-server/services/platform-integration.service.d.ts

@@ -4,6 +4,7 @@ import { MerchantPlatformSettingsEntity } from "../entities/platform-integration
 import { FacebookPlatformIntegrationService } from "./facebook-platform-integration.service.js";
 import { GooglePlatformIntegrationService } from "./google-platform-integration.service.js";
 import { MerchantStrategyService } from "./merchant-strategy.service.js";
+import { MerchantSyncHistoryService } from "./merchant-sync-history.service.js";
 type JOB_PAYLOAD = {
     platform: string;
     action: "SEND_ALL_PRODUCTS";
@@ -15,6 +16,7 @@ export declare class PlatformIntegrationService implements OnModuleInit {
     private readonly facebookService;
     private readonly productService;
     private readonly strategy;
+    private readonly syncHistory;
     MerchantPlatformQueue: JobQueue<{
         payload: JOB_PAYLOAD;
         worker: number;
@@ -24,7 +26,7 @@ export declare class PlatformIntegrationService implements OnModuleInit {
     }>;
     private readonly logger;
     private log;
-    constructor(connection: TransactionalConnection, jobQueueService: JobQueueService, googleService: GooglePlatformIntegrationService, facebookService: FacebookPlatformIntegrationService, productService: ProductService, strategy: MerchantStrategyService);
+    constructor(connection: TransactionalConnection, jobQueueService: JobQueueService, googleService: GooglePlatformIntegrationService, facebookService: FacebookPlatformIntegrationService, productService: ProductService, strategy: MerchantStrategyService, syncHistory: MerchantSyncHistoryService);
     removeOrphanItems(ctx: RequestContext, platform: string): Promise<boolean>;
     fetchProducts(input: {
         ctx: RequestContext;
@@ -32,8 +34,10 @@ export declare class PlatformIntegrationService implements OnModuleInit {
     }, callback?: (progress: number) => void): AsyncGenerator<import("../types.js").BaseProductData<import("../types.js").BaseData>, void, unknown>;
     onModuleInit(): Promise<void>;
     createContext(): Promise<RequestContext>;
-    savePlatformIntegrationSettings(ctx: RequestContext, settings: MerchantPlatformSettingsEntity): Promise<MerchantPlatformSettingsEntity | undefined>;
+    savePlatformIntegrationSettings(ctx: RequestContext, settings: MerchantPlatformSettingsEntity): Promise<MerchantPlatformSettingsEntity>;
     getBaseSettings(ctx: RequestContext, platform: string): Promise<MerchantPlatformSettingsEntity | null>;
+    enqueueFullSync(ctx: RequestContext, platform: string): Promise<boolean>;
+    getSyncHistory(ctx: RequestContext, platform: string, take?: number): Promise<import("../entities/merchant-sync-run.entity.js").MerchantSyncRun[]>;
     getPlatformAutoUpdateSettings(ctx: RequestContext): Promise<{
         googleAutoUpdate: boolean;
         facebookAutoUpdate: boolean;

package/dist/plugin-server/services/platform-integration.service.js

@@ -38,22 +38,24 @@ const facebook_platform_integration_service_js_1 = require("./facebook-platform-
 const google_merchant_api_js_1 = require("./google-merchant-api.js");
 const google_platform_integration_service_js_1 = require("./google-platform-integration.service.js");
 const merchant_strategy_service_js_1 = require("./merchant-strategy.service.js");
+const merchant_sync_history_service_js_1 = require("./merchant-sync-history.service.js");
 const BATCH_SIZE = 200;
 const WORKER_THRESHOLD = 5000;
 let PlatformIntegrationService = class PlatformIntegrationService {
-    constructor(connection, jobQueueService, googleService, facebookService, productService, strategy) {
+    constructor(connection, jobQueueService, googleService, facebookService, productService, strategy, syncHistory) {
         this.connection = connection;
         this.jobQueueService = jobQueueService;
         this.googleService = googleService;
         this.facebookService = facebookService;
         this.productService = productService;
         this.strategy = strategy;
+        this.syncHistory = syncHistory;
         this.logger = new core_1.Logger();
         this.log = (message) => this.logger.log(message, "Merchant Platform Service");
     }
     async removeOrphanItems(ctx, platform) {
         if (["facebook", "google"].includes(platform)) {
-            await this.OrphanItemsQueue.add({ platform });
+            await this.OrphanItemsQueue.add({ platform }, { retries: 3 });
             return true;
         }
         return false;
@@ -65,13 +67,17 @@ let PlatformIntegrationService = class PlatformIntegrationService {
             const start = worker * WORKER_THRESHOLD;
             for (let i = start; i < totalToFetch; i += BATCH_SIZE) {
                 const { items } = yield __await(this.productService.findAll(ctx, {
+                    sort: { id: admin_types_1.SortOrder.ASC },
                     take: BATCH_SIZE,
                     skip: i,
                 }));
+                if (items.length === 0)
+                    break;
                 for (const product of items) {
                     const baseProduct = yield __await(this.strategy.getBaseData(ctx, product));
                     if (callback) {
-                        const progress = Math.floor((i / totalToFetch) * 100);
+                        const progress = Math.min(100, Math.floor(((i - start + items.indexOf(product) + 1) / WORKER_THRESHOLD) *
+                            100));
                         callback(progress);
                     }
                     if (!baseProduct)
@@ -117,10 +123,17 @@ let PlatformIntegrationService = class PlatformIntegrationService {
                         let googleResponse = false;
                         let facebookResponse = false;
                         if (platform === "google") {
+                            const run = await this.syncHistory.start(ctx, {
+                                jobId: job.id == null ? undefined : String(job.id),
+                                platform,
+                                total: products.length,
+                                trigger: "FULL_SYNC",
+                            });
                             const response = await this.googleService.batchProductsAction({
                                 ctx,
                                 products,
                             });
+                            await this.syncHistory.finishGoogleRun(ctx, run, response.results, response.error);
                             if (response.status === "success") {
                                 this.log("Products sent to google");
                                 googleResponse = true;
@@ -229,36 +242,24 @@ let PlatformIntegrationService = class PlatformIntegrationService {
         });
     }
     async savePlatformIntegrationSettings(ctx, settings) {
-        const repository = this.connection.getRepository(ctx, platform_integration_settings_entity_js_1.MerchantPlatformSettingsEntity);
-        const existing = await repository.findOne({
-            where: { platform: settings.platform },
-        });
-        if (existing)
-            await repository.delete(existing.id);
-        let response = await repository.save(settings);
-        if (!response.id)
-            return;
         const [isFirstSync, isAutoUpdate] = [
             this.lookup(settings, "firstSync") === "true",
             this.lookup(settings, "autoUpdate") === "true",
         ];
-        if (isFirstSync && isAutoUpdate) {
-            const products = await this.productService.findAll(ctx, {
-                take: 1,
-                skip: 0,
+        const shouldStartFullSync = isFirstSync && isAutoUpdate;
+        const settingsToSave = new platform_integration_settings_entity_js_1.MerchantPlatformSettingsEntity(Object.assign(Object.assign({}, settings), { entries: settings.entries.map((entry) => shouldStartFullSync && entry.key === "firstSync"
+                ? Object.assign(Object.assign({}, entry), { value: "false" }) : entry) }));
+        const response = await this.connection.withTransaction(ctx, async (transactionCtx) => {
+            const repository = this.connection.getRepository(transactionCtx, platform_integration_settings_entity_js_1.MerchantPlatformSettingsEntity);
+            const existing = await repository.findOne({
+                where: { platform: settings.platform },
             });
-            const total = products.totalItems;
-            const workers = Math.ceil(total / WORKER_THRESHOLD);
-            for (let worker = 0; worker < workers; worker++) {
-                await this.MerchantPlatformQueue.add({
-                    worker,
-                    payload: {
-                        platform: response.platform,
-                        action: "SEND_ALL_PRODUCTS",
-                    },
-                });
-            }
-            response = await repository.save(Object.assign(Object.assign({}, settings), { entries: settings.entries.map((entry) => entry.key === "firstSync" ? Object.assign(Object.assign({}, entry), { value: "false" }) : entry) }));
+            if (existing)
+                await repository.delete(existing.id);
+            return repository.save(settingsToSave);
+        });
+        if (response.id && shouldStartFullSync) {
+            await this.enqueueFullSync(ctx, response.platform);
         }
         return response;
     }
@@ -267,6 +268,28 @@ let PlatformIntegrationService = class PlatformIntegrationService {
             .getRepository(ctx, platform_integration_settings_entity_js_1.MerchantPlatformSettingsEntity)
             .findOne({ relations: ["entries"], where: { platform } });
     }
+    async enqueueFullSync(ctx, platform) {
+        if (!["google", "facebook"].includes(platform))
+            return false;
+        const { totalItems } = await this.productService.findAll(ctx, {
+            take: 1,
+            skip: 0,
+        });
+        const workers = Math.max(1, Math.ceil(totalItems / WORKER_THRESHOLD));
+        for (let worker = 0; worker < workers; worker += 1) {
+            await this.MerchantPlatformQueue.add({
+                worker,
+                payload: {
+                    platform,
+                    action: "SEND_ALL_PRODUCTS",
+                },
+            }, { retries: 3 });
+        }
+        return true;
+    }
+    getSyncHistory(ctx, platform, take) {
+        return this.syncHistory.findLatest(ctx, platform, take);
+    }
     async getPlatformAutoUpdateSettings(ctx) {
         const [googlePlatformSettings, facebookPlatformSettings] = await Promise.all([
             this.getBaseSettings(ctx, "google"),
@@ -290,5 +313,6 @@ exports.PlatformIntegrationService = PlatformIntegrationService = __decorate([
         google_platform_integration_service_js_1.GooglePlatformIntegrationService,
         facebook_platform_integration_service_js_1.FacebookPlatformIntegrationService,
         core_1.ProductService,
-        merchant_strategy_service_js_1.MerchantStrategyService])
+        merchant_strategy_service_js_1.MerchantStrategyService,
+        merchant_sync_history_service_js_1.MerchantSyncHistoryService])
 ], PlatformIntegrationService);

package/dist/plugin-server/services/subscriber.service.d.ts

@@ -1,13 +1,34 @@
 import { CreateProductInput, CreateProductVariantInput, UpdateProductInput, UpdateProductVariantInput } from "@deenruv/common/lib/generated-types.js";
-import { EventBus, ID, Product, ProductService, RequestContext } from "@deenruv/core";
+import { EventBus, ID, JobQueueService, Product, ProductService, RequestContext, TransactionalConnection } from "@deenruv/core";
 import { OnApplicationBootstrap } from "@nestjs/common";
 import { MerchantPluginOptions } from "../types.js";
 import { FacebookPlatformIntegrationService } from "./facebook-platform-integration.service.js";
 import { GooglePlatformIntegrationService } from "./google-platform-integration.service.js";
 import { MerchantStrategyService } from "./merchant-strategy.service.js";
+import { MerchantSyncHistoryService } from "./merchant-sync-history.service.js";
 import { PlatformIntegrationService } from "./platform-integration.service.js";
 type ProductInputTypes = CreateProductInput | UpdateProductInput | ID;
 type ProductVariantInputTypes = CreateProductVariantInput[] | UpdateProductVariantInput[] | ID | ID[];
+export declare function getMerchantOperationsForEvent(type: "created" | "updated" | "deleted"): {
+    readonly google: "insertProduct";
+    readonly facebook: "createProduct";
+} | {
+    readonly google: "insertProduct";
+    readonly facebook: "updateProduct";
+} | {
+    readonly google: "deleteProduct";
+    readonly facebook: "deleteProduct";
+};
+export declare function getGoogleDeleteIds(product: {
+    variants?: Array<{
+        customFields?: {
+            communicateID?: string | null;
+        };
+        sku?: string;
+    }>;
+}, data?: Array<{
+    communicateID: string;
+}>): string[];
 export declare class SubscriberService implements OnApplicationBootstrap {
     private readonly options;
     private readonly eventBus;
@@ -16,15 +37,22 @@ export declare class SubscriberService implements OnApplicationBootstrap {
     private readonly facebookService;
     private readonly strategy;
     private readonly productService;
-    constructor(options: MerchantPluginOptions, eventBus: EventBus, integrationService: PlatformIntegrationService, googleService: GooglePlatformIntegrationService, facebookService: FacebookPlatformIntegrationService, strategy: MerchantStrategyService, productService: ProductService);
+    private readonly jobQueueService;
+    private readonly syncHistory;
+    private readonly connection;
+    private readonly logger;
+    private productEventQueue;
+    constructor(options: MerchantPluginOptions, eventBus: EventBus, integrationService: PlatformIntegrationService, googleService: GooglePlatformIntegrationService, facebookService: FacebookPlatformIntegrationService, strategy: MerchantStrategyService, productService: ProductService, jobQueueService: JobQueueService, syncHistory: MerchantSyncHistoryService, connection: TransactionalConnection);
     onApplicationBootstrap(): Promise<void>;
-    event({ ctx, entity, type, input, }: {
+    event({ ctx, entity, type, input, deleteIds, }: {
         ctx: RequestContext;
         entity: Product;
         type: "created" | "updated" | "deleted";
         input?: ProductInputTypes | ProductVariantInputTypes;
+        deleteIds?: string[];
     }): Promise<void>;
+    private processEvent;
     private isValidEventData;
-    private getOperationsForType;
+    private observeOperations;
 }
 export {};

package/dist/plugin-server/services/subscriber.service.js

@@ -12,16 +12,41 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubscriberService = void 0;
+exports.SubscriberService = exports.getGoogleDeleteIds = exports.getMerchantOperationsForEvent = void 0;
 const core_1 = require("@deenruv/core");
 const common_1 = require("@nestjs/common");
 const constants_js_1 = require("../constants.js");
 const facebook_platform_integration_service_js_1 = require("./facebook-platform-integration.service.js");
 const google_platform_integration_service_js_1 = require("./google-platform-integration.service.js");
 const merchant_strategy_service_js_1 = require("./merchant-strategy.service.js");
+const merchant_sync_history_service_js_1 = require("./merchant-sync-history.service.js");
 const platform_integration_service_js_1 = require("./platform-integration.service.js");
+function getMerchantOperationsForEvent(type) {
+    const operationMap = {
+        created: { google: "insertProduct", facebook: "createProduct" },
+        updated: { google: "insertProduct", facebook: "updateProduct" },
+        deleted: { google: "deleteProduct", facebook: "deleteProduct" },
+    };
+    return operationMap[type];
+}
+exports.getMerchantOperationsForEvent = getMerchantOperationsForEvent;
+function getGoogleDeleteIds(product, data) {
+    var _a, _b, _c;
+    const ids = new Set();
+    for (const variant of (_a = product.variants) !== null && _a !== void 0 ? _a : []) {
+        const id = (_c = (_b = variant.customFields) === null || _b === void 0 ? void 0 : _b.communicateID) !== null && _c !== void 0 ? _c : variant.sku;
+        if (id)
+            ids.add(String(id));
+    }
+    for (const item of data !== null && data !== void 0 ? data : []) {
+        if (item.communicateID)
+            ids.add(String(item.communicateID));
+    }
+    return [...ids];
+}
+exports.getGoogleDeleteIds = getGoogleDeleteIds;
 let SubscriberService = class SubscriberService {
-    constructor(options, eventBus, integrationService, googleService, facebookService, strategy, productService) {
+    constructor(options, eventBus, integrationService, googleService, facebookService, strategy, productService, jobQueueService, syncHistory, connection) {
         this.options = options;
         this.eventBus = eventBus;
         this.integrationService = integrationService;
@@ -29,8 +54,20 @@ let SubscriberService = class SubscriberService {
         this.facebookService = facebookService;
         this.strategy = strategy;
         this.productService = productService;
+        this.jobQueueService = jobQueueService;
+        this.syncHistory = syncHistory;
+        this.connection = connection;
+        this.logger = new core_1.Logger();
     }
     async onApplicationBootstrap() {
+        this.productEventQueue = await this.jobQueueService.createQueue({
+            name: "MerchantProductEventQueue",
+            process: async (job) => {
+                const ctx = core_1.RequestContext.deserialize(job.data.ctx);
+                const product = await this.productService.findOne(ctx, job.data.productId);
+                await this.processEvent(ctx, product !== null && product !== void 0 ? product : undefined, job.data.type, job.data.deleteIds, job.id == null ? undefined : String(job.id));
+            },
+        });
         this.eventBus.ofType(core_1.ProductEvent).subscribe(async (props) => {
             await this.event(props);
         });
@@ -42,39 +79,117 @@ let SubscriberService = class SubscriberService {
             const product = await this.productService.findOne(ctx, entity[0].productId);
             if (!product)
                 return;
-            await this.event({ ctx, entity: product, type, input });
+            await this.event({
+                ctx,
+                deleteIds: getGoogleDeleteIds({ variants: entity }),
+                entity: product,
+                type,
+                input,
+            });
         });
     }
-    async event({ ctx, entity, type, input, }) {
+    async event({ ctx, entity, type, input, deleteIds, }) {
         if (!this.isValidEventData(ctx, entity))
             return;
+        const resolvedDeleteIds = new Set(deleteIds !== null && deleteIds !== void 0 ? deleteIds : getGoogleDeleteIds(entity));
+        if (type === "deleted" || resolvedDeleteIds.size === 0) {
+            const variants = await this.connection
+                .getRepository(ctx, core_1.ProductVariant)
+                .find({
+                relations: { product: true },
+                where: { product: { id: entity.id } },
+                withDeleted: true,
+            });
+            for (const id of getGoogleDeleteIds({ variants })) {
+                resolvedDeleteIds.add(id);
+            }
+        }
+        await this.productEventQueue.add({
+            ctx: ctx.serialize(),
+            deleteIds: [...resolvedDeleteIds],
+            productId: entity.id,
+            type,
+        }, { retries: 3 });
+    }
+    async processEvent(ctx, entity, type, persistedDeleteIds, jobId) {
         const { googleAutoUpdate, facebookAutoUpdate } = await this.integrationService.getPlatformAutoUpdateSettings(ctx);
         if (!googleAutoUpdate && !facebookAutoUpdate)
             return;
-        const data = await this.strategy.getBaseData(ctx, entity);
-        if (!data)
+        const data = entity && type !== "deleted"
+            ? await this.strategy.getBaseData(ctx, entity)
+            : undefined;
+        const hasExportableData = Boolean(data === null || data === void 0 ? void 0 : data.length);
+        if (type === "deleted" || !hasExportableData) {
+            if (googleAutoUpdate) {
+                const deleteIds = [
+                    ...new Set([
+                        ...persistedDeleteIds,
+                        ...(entity ? getGoogleDeleteIds(entity, data) : []),
+                    ]),
+                ];
+                const run = await this.syncHistory.start(ctx, {
+                    jobId,
+                    platform: "google",
+                    total: deleteIds.length,
+                    trigger: "PRODUCT_EVENT",
+                });
+                const response = await this.googleService.deleteProductsByCommunicationIds(ctx, deleteIds);
+                await this.syncHistory.finishGoogleRun(ctx, run, response.results, response.error);
+                if (response.status === "error") {
+                    throw response.error instanceof Error
+                        ? response.error
+                        : new Error("Google product deletion failed");
+                }
+            }
+            if (facebookAutoUpdate && (data === null || data === void 0 ? void 0 : data.length) && entity) {
+                await this.facebookService.deleteProduct({ ctx, data, entity });
+            }
+            return;
+        }
+        if (!data || !entity)
             return;
-        const operations = this.getOperationsForType(type);
+        const operations = getMerchantOperationsForEvent(type);
         const eventPayload = { ctx, data, entity };
-        await Promise.allSettled([
-            ...(googleAutoUpdate
-                ? [this.googleService[operations.google](eventPayload)]
-                : []),
-            ...(facebookAutoUpdate
-                ? [this.facebookService[operations.facebook](eventPayload)]
-                : []),
-        ]);
+        if (googleAutoUpdate) {
+            const run = await this.syncHistory.start(ctx, {
+                jobId,
+                platform: "google",
+                total: data.length,
+                trigger: "PRODUCT_EVENT",
+            });
+            const response = await this.googleService[operations.google](eventPayload);
+            await this.syncHistory.finishGoogleRun(ctx, run, response.results, response.error);
+            if (response.status === "error") {
+                throw response.error instanceof Error
+                    ? response.error
+                    : new Error("Google product synchronization failed");
+            }
+        }
+        if (facebookAutoUpdate) {
+            await this.observeOperations([this.facebookService[operations.facebook](eventPayload)], type);
+        }
     }
     isValidEventData(ctx, entity) {
         return Boolean(ctx && entity && entity instanceof core_1.Product);
     }
-    getOperationsForType(type) {
-        const operationMap = {
-            created: { google: "insertProduct", facebook: "createProduct" },
-            updated: { google: "updateProduct", facebook: "updateProduct" },
-            deleted: { google: "deleteProduct", facebook: "deleteProduct" },
-        };
-        return operationMap[type];
+    async observeOperations(operations, eventType) {
+        const results = await Promise.allSettled(operations);
+        for (const result of results) {
+            if (result.status === "rejected") {
+                this.logger.error(`Merchant ${eventType} operation rejected`, result.reason instanceof Error
+                    ? result.reason.stack
+                    : String(result.reason), "Merchant Product Subscriber");
+                continue;
+            }
+            const value = result.value;
+            if (typeof value === "object" &&
+                value !== null &&
+                "status" in value &&
+                value.status === "error") {
+                const error = "error" in value ? value.error : undefined;
+                this.logger.error(`Merchant ${eventType} operation failed`, error instanceof Error ? error.stack : String(error), "Merchant Product Subscriber");
+            }
+        }
     }
 };
 exports.SubscriberService = SubscriberService;
@@ -86,5 +201,8 @@ exports.SubscriberService = SubscriberService = __decorate([
         google_platform_integration_service_js_1.GooglePlatformIntegrationService,
         facebook_platform_integration_service_js_1.FacebookPlatformIntegrationService,
         merchant_strategy_service_js_1.MerchantStrategyService,
-        core_1.ProductService])
+        core_1.ProductService,
+        core_1.JobQueueService,
+        merchant_sync_history_service_js_1.MerchantSyncHistoryService,
+        core_1.TransactionalConnection])
 ], SubscriberService);

package/dist/plugin-server/ui/graphql/mutations.ts

@@ -21,3 +21,10 @@ export const saveMerchantPlatformSettings = mutation({
 export const removeOrphanItems = mutation({
   removeOrphanItems: [{ platform: $("platform", "String!") }, true],
 });
+
+export const sendAllProductsToMerchantPlatform = mutation({
+  sendAllProductsToMerchantPlatform: [
+    { platform: $("platform", "String!") },
+    true,
+  ],
+});