@deenruv/merchant-plugin 1.0.15 → 1.0.17-dev.14

package/README.md

@@ -29,10 +29,42 @@ plugins: [
 ]
 ```
 
+### Google Merchant API settings
+
+The Google integration uses the stable Merchant API Products v1 clients. The
+Google settings page requires:
+
+- `merchantId` — the numeric Merchant Center account ID.
+- `dataSource` — the full existing data source resource name in the form
+  `accounts/{merchantId}/dataSources/{id}`. Its account segment must match
+  `merchantId`.
+- `credentials` — Google OAuth credential JSON for a service account or an
+  authorized user. Store and distribute this value as a secret.
+- `brand` — the brand applied to exported product attributes.
+
+Product inputs are written only to the configured data source. Merchant API
+processing is asynchronous, so a processed product might not be readable for
+several minutes after a successful write.
+
+#### Deployment prerequisites (documentation only)
+
+An operator must complete the following outside this plugin and outside the
+application deployment. The plugin does not enable APIs, create or register
+data sources, change Merchant Center configuration, or provision credentials:
+
+1. Enable Merchant API for the Google Cloud project that owns the credentials.
+2. Grant the credential identity the required access to the Merchant Center
+   account.
+3. Create or select an API product data source in Merchant Center and copy its
+   full `accounts/{merchantId}/dataSources/{id}` resource name into the plugin
+   settings.
+4. Ensure the credentials can request the
+   `https://www.googleapis.com/auth/content` OAuth scope.
+
 ## Features
 
 - Strategy-based product export architecture supporting Google and Facebook platforms
-- Google Merchant Center integration via Google Content API
+- Google Merchant Center integration via Merchant API Products v1
 - Facebook Commerce integration via Facebook Business SDK
 - Per-platform settings storage and management
 - Bulk product sync to merchant platforms

package/dist/plugin-server/api/platform-integration-admin-resolver.js

@@ -30,13 +30,23 @@ let PlatformIntegrationAdminResolver = class PlatformIntegrationAdminResolver {
         return this.platformIntegrationService.getBaseSettings(ctx, args.platform);
     }
     async getMerchantPlatformInfo(ctx, args) {
-        var _a, _b;
+        var _a;
         const settings = await this.platformIntegrationService.getBaseSettings(ctx, args.platform);
         if (args.platform === "google") {
+            let isValidConnection = false;
+            if (settings) {
+                try {
+                    this.googlePlatformIntegrationService.validateGoogleSettings(settings);
+                    isValidConnection = true;
+                }
+                catch (_b) {
+                    isValidConnection = false;
+                }
+            }
             return [
                 {
                     productsCount: 0,
-                    isValidConnection: ((_a = settings === null || settings === void 0 ? void 0 : settings.entries.find((entry) => entry.key === "credentials")) === null || _a === void 0 ? void 0 : _a.value) !== "",
+                    isValidConnection,
                 },
             ];
         }
@@ -44,7 +54,7 @@ let PlatformIntegrationAdminResolver = class PlatformIntegrationAdminResolver {
             return [
                 {
                     productsCount: 0,
-                    isValidConnection: ((_b = settings === null || settings === void 0 ? void 0 : settings.entries.find((entry) => entry.key === "accessToken")) === null || _b === void 0 ? void 0 : _b.value) !== "",
+                    isValidConnection: ((_a = settings === null || settings === void 0 ? void 0 : settings.entries.find((entry) => entry.key === "accessToken")) === null || _a === void 0 ? void 0 : _a.value) !== "",
                 },
             ];
         }
@@ -55,6 +65,9 @@ let PlatformIntegrationAdminResolver = class PlatformIntegrationAdminResolver {
             platform: args.input.platform,
             entries: args.input.entries.map((entry) => new platform_integration_setting_entity_js_1.MerchantPlatformSetting(entry)),
         });
+        if (settingsEntity.platform === "google") {
+            this.googlePlatformIntegrationService.validateGoogleSettings(settingsEntity);
+        }
         const settings = await this.platformIntegrationService.savePlatformIntegrationSettings(ctx, settingsEntity);
         return settings;
     }

package/dist/plugin-server/index.d.ts

@@ -1,6 +1,6 @@
 import { OnApplicationBootstrap } from "@nestjs/common";
 import { ModuleRef } from "@nestjs/core";
-import { FacebookProduct, GoogleProduct, MerchantExportStrategy, MerchantPluginOptions } from "./types.js";
+import { FacebookProduct, GoogleProcessedProduct, GoogleProduct, GoogleProductInput, MerchantExportStrategy, MerchantPluginOptions } from "./types.js";
 declare class MerchantPlugin implements OnApplicationBootstrap {
     private moduleRef;
     static options: MerchantPluginOptions;
@@ -11,4 +11,4 @@ declare class MerchantPlugin implements OnApplicationBootstrap {
     private initMerchantStrategy;
     private destroyMerchantStrategy;
 }
-export { FacebookProduct, GoogleProduct, MerchantExportStrategy, MerchantPlugin, };
+export { FacebookProduct, GoogleProcessedProduct, GoogleProduct, GoogleProductInput, MerchantExportStrategy, MerchantPlugin, };

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

@@ -1,11 +1,12 @@
 import { Product, RequestContext, TransactionalConnection } from "@deenruv/core";
 import { MerchantPlatformSettingsEntity } from "../entities/platform-integration-settings.entity.js";
-import { BaseData, BaseProductData } from "../types.js";
+import { BaseData, BaseProductData, RemoteProduct } from "../types.js";
 import { MerchantStrategyService } from "./merchant-strategy.service.js";
-type OpResult = {
+export type FacebookOperationResult = {
     status: "success" | "error";
     message?: string;
 };
+export declare function executeFacebookBatches(batches: readonly BaseProductData<BaseData>[], executeBatch: (batch: BaseProductData<BaseData>) => Promise<FacebookOperationResult>): Promise<FacebookOperationResult>;
 export declare class FacebookPlatformIntegrationService {
     private readonly connection;
     private readonly strategy;
@@ -13,33 +14,30 @@ export declare class FacebookPlatformIntegrationService {
     private log;
     private error;
     constructor(connection: TransactionalConnection, strategy: MerchantStrategyService);
-    removeOrphanItems(ctx: RequestContext, items: BaseData[]): Promise<void>;
-    getAllProducts(ctx: RequestContext): Promise<{
-        communicateID: any;
-        name: any;
-    }[]>;
+    removeOrphanItems(ctx: RequestContext, items: RemoteProduct[]): Promise<void>;
+    getAllProducts(ctx: RequestContext): Promise<RemoteProduct[]>;
     private withCatalog;
     private sendBatch;
     createProduct({ ctx, data, }: {
         ctx: RequestContext;
         data: BaseProductData<BaseData>;
         entity?: Product;
-    }): Promise<OpResult>;
+    }): Promise<FacebookOperationResult>;
     updateProduct({ ctx, data, }: {
         ctx: RequestContext;
         data: BaseProductData<BaseData>;
         entity?: Product;
-    }): Promise<OpResult>;
+    }): Promise<FacebookOperationResult>;
     deleteProduct({ ctx, data, }: {
         ctx: RequestContext;
         data: BaseProductData<BaseData>;
         entity?: Product;
-    }): Promise<OpResult>;
+    }): Promise<FacebookOperationResult>;
     batchProductsAction({ ctx, products, }: {
         ctx: RequestContext;
         products: BaseProductData<BaseData>[];
         entity?: Product;
-    }): Promise<OpResult>;
+    }): Promise<FacebookOperationResult>;
     setFacebookSettings(ctx: RequestContext, rawSettings?: MerchantPlatformSettingsEntity): Promise<{
         autoUpdate: boolean;
         accessToken: string;
@@ -48,4 +46,3 @@ export declare class FacebookPlatformIntegrationService {
     } | null>;
     private prepareFacebookProductPayload;
 }
-export {};

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

@@ -20,13 +20,22 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FacebookPlatformIntegrationService = void 0;
+exports.FacebookPlatformIntegrationService = exports.executeFacebookBatches = void 0;
 const core_1 = require("@deenruv/core");
 const common_1 = require("@nestjs/common");
 const facebook_nodejs_business_sdk_1 = require("facebook-nodejs-business-sdk");
 const platform_integration_settings_entity_js_1 = require("../entities/platform-integration-settings.entity.js");
 const merchant_strategy_service_js_1 = require("./merchant-strategy.service.js");
 const typeorm_1 = require("typeorm");
+async function executeFacebookBatches(batches, executeBatch) {
+    for (const batch of batches) {
+        const result = await executeBatch(batch);
+        if (result.status === "error")
+            return result;
+    }
+    return { status: "success", message: "Products processed successfully" };
+}
+exports.executeFacebookBatches = executeFacebookBatches;
 let FacebookPlatformIntegrationService = class FacebookPlatformIntegrationService {
     constructor(connection, strategy) {
         this.connection = connection;
@@ -160,12 +169,11 @@ let FacebookPlatformIntegrationService = class FacebookPlatformIntegrationServic
     }
     async batchProductsAction({ ctx, products, }) {
         const flatten = products.flat();
-        const batchSize = 500;
-        for (let i = 0; i < flatten.length; i += batchSize) {
-            const batch = flatten.slice(i, i + batchSize);
-            await this.sendBatch({ ctx, method: "UPDATE", data: batch });
+        const batches = [];
+        for (let i = 0; i < flatten.length; i += 500) {
+            batches.push(flatten.slice(i, i + 500));
         }
-        return { status: "success", message: "Products processed successfully" };
+        return executeFacebookBatches(batches, (batch) => this.sendBatch({ ctx, method: "UPDATE", data: batch }));
     }
     async setFacebookSettings(ctx, rawSettings) {
         var _a;

package/dist/plugin-server/services/google-merchant-api.d.ts

@@ -0,0 +1,84 @@
+import { v1 } from "@google-shopping/products";
+import type { protos } from "@google-shopping/products";
+import type { GoogleProcessedProduct, GoogleProduct, GoogleProductInput, RemoteProduct } from "../types.js";
+export declare const GOOGLE_CONTENT_LANGUAGE = "pl";
+export declare const GOOGLE_FEED_LABEL = "PL";
+export declare const DEFAULT_GOOGLE_WRITE_CONCURRENCY = 4;
+type MerchantClientOptions = NonNullable<ConstructorParameters<typeof v1.ProductsServiceClient>[0]>;
+export type GoogleMerchantCredentials = NonNullable<MerchantClientOptions["credentials"]>;
+export type GoogleMerchantSettings = {
+    accountId: string;
+    autoUpdate: boolean;
+    brand: string;
+    credentials: GoogleMerchantCredentials;
+    dataSource: string;
+};
+export type GoogleMerchantClients = {
+    productInputs: v1.ProductInputsServiceClient;
+    products: v1.ProductsServiceClient;
+};
+type InsertProductInputRequest = protos.google.shopping.merchant.products.v1.IInsertProductInputRequest;
+type UpdateProductInputRequest = protos.google.shopping.merchant.products.v1.IUpdateProductInputRequest;
+type DeleteProductInputRequest = protos.google.shopping.merchant.products.v1.IDeleteProductInputRequest;
+type ListProductsRequest = protos.google.shopping.merchant.products.v1.IListProductsRequest;
+export type GoogleWriteOperation = {
+    communicateID: string;
+    method: "insert";
+    request: InsertProductInputRequest;
+} | {
+    communicateID: string;
+    method: "update";
+    request: UpdateProductInputRequest;
+} | {
+    communicateID: string;
+    method: "delete";
+    request: DeleteProductInputRequest;
+};
+export type MerchantOperationResult<T> = {
+    index: number;
+    item: T;
+    status: "success";
+} | {
+    error: unknown;
+    index: number;
+    item: T;
+    status: "error";
+};
+export type MerchantOperationSummary<T> = {
+    failures: Array<Extract<MerchantOperationResult<T>, {
+        status: "error";
+    }>>;
+    results: Array<MerchantOperationResult<T>>;
+    status: "success" | "error";
+};
+export interface GoogleProductInputsWriter {
+    deleteProductInput(request: DeleteProductInputRequest): Promise<unknown>;
+    insertProductInput(request: InsertProductInputRequest): Promise<unknown>;
+    updateProductInput(request: UpdateProductInputRequest): Promise<unknown>;
+}
+export interface GoogleProductsReader {
+    listProductsAsync(request: ListProductsRequest): AsyncIterable<GoogleProcessedProduct>;
+}
+type SettingEntry = {
+    key: string;
+    value: string;
+};
+export declare function parseGoogleCredentials(rawCredentials: string): GoogleMerchantCredentials;
+export declare function normalizeMerchantId(rawMerchantId: string): string;
+export declare function normalizeDataSource(rawDataSource: string, merchantId: string): string;
+export declare function parseGoogleMerchantSettings(entries: readonly SettingEntry[]): GoogleMerchantSettings;
+export declare function createGoogleMerchantClients(credentials: GoogleMerchantCredentials): GoogleMerchantClients;
+export declare function buildGoogleProductIdentifier(offerId: string): string;
+export declare function buildGoogleProductName(accountId: string, offerId: string): string;
+export declare function buildGoogleProductInputName(accountId: string, offerId: string): string;
+export declare function toGoogleProductInput(product: GoogleProduct, brand: string): GoogleProductInput;
+export declare function buildGoogleUpdateMask(productInput: GoogleProductInput): protos.google.protobuf.IFieldMask;
+export declare function createGoogleInsertOperation(product: GoogleProduct, settings: GoogleMerchantSettings): GoogleWriteOperation;
+export declare function createGoogleUpdateOperation(product: GoogleProduct, settings: GoogleMerchantSettings): GoogleWriteOperation;
+export declare function createGoogleDeleteOperation(communicateID: string, settings: GoogleMerchantSettings): GoogleWriteOperation;
+export declare function runBoundedMerchantOperations<T>(items: readonly T[], operation: (item: T, index: number) => Promise<void>, concurrency?: number): Promise<Array<MerchantOperationResult<T>>>;
+export declare function executeGoogleWriteOperations(client: GoogleProductInputsWriter, operations: readonly GoogleWriteOperation[], concurrency?: number): Promise<Array<MerchantOperationResult<GoogleWriteOperation>>>;
+export declare function summarizeMerchantOperations<T>(results: Array<MerchantOperationResult<T>>): MerchantOperationSummary<T>;
+export declare function collectGoogleProductsForDataSource(client: GoogleProductsReader, accountId: string, dataSource: string): Promise<RemoteProduct[]>;
+export declare function selectRemoteOrphanProducts(remoteProducts: readonly RemoteProduct[], localProducts: readonly Pick<GoogleProduct, "communicateID">[]): RemoteProduct[];
+export {};

package/dist/plugin-server/services/google-merchant-api.js

@@ -0,0 +1,310 @@
+"use strict";
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectRemoteOrphanProducts = exports.collectGoogleProductsForDataSource = exports.summarizeMerchantOperations = exports.executeGoogleWriteOperations = exports.runBoundedMerchantOperations = exports.createGoogleDeleteOperation = exports.createGoogleUpdateOperation = exports.createGoogleInsertOperation = exports.buildGoogleUpdateMask = exports.toGoogleProductInput = exports.buildGoogleProductInputName = exports.buildGoogleProductName = exports.buildGoogleProductIdentifier = exports.createGoogleMerchantClients = exports.parseGoogleMerchantSettings = exports.normalizeDataSource = exports.normalizeMerchantId = exports.parseGoogleCredentials = exports.DEFAULT_GOOGLE_WRITE_CONCURRENCY = exports.GOOGLE_FEED_LABEL = exports.GOOGLE_CONTENT_LANGUAGE = void 0;
+const products_1 = require("@google-shopping/products");
+const GOOGLE_OAUTH_SCOPE = "https://www.googleapis.com/auth/content";
+const PLAIN_IDENTIFIER_COMPONENT = /^[A-Za-z0-9_-]+$/;
+const MERCHANT_ID_PATTERN = /^[1-9]\d*$/;
+const DATA_SOURCE_PATTERN = /^accounts\/([1-9]\d*)\/dataSources\/([1-9]\d*)$/;
+exports.GOOGLE_CONTENT_LANGUAGE = "pl";
+exports.GOOGLE_FEED_LABEL = "PL";
+exports.DEFAULT_GOOGLE_WRITE_CONCURRENCY = 4;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString(value, key) {
+    const candidate = value[key];
+    return typeof candidate === "string" && candidate.length > 0
+        ? candidate
+        : undefined;
+}
+function requiredString(value, key) {
+    const candidate = optionalString(value, key);
+    if (!candidate || candidate.trim().length === 0) {
+        throw new Error(`Google credentials field ${key} is required`);
+    }
+    return candidate;
+}
+function parseGoogleCredentials(rawCredentials) {
+    let parsed;
+    try {
+        parsed = JSON.parse(rawCredentials);
+    }
+    catch (_a) {
+        throw new Error("Google credentials must be valid JSON");
+    }
+    if (!isRecord(parsed)) {
+        throw new Error("Google credentials must be a JSON object");
+    }
+    const credentialType = optionalString(parsed, "type");
+    if (credentialType === "authorized_user") {
+        return Object.assign({ type: "authorized_user", client_id: requiredString(parsed, "client_id").trim(), client_secret: requiredString(parsed, "client_secret"), refresh_token: requiredString(parsed, "refresh_token") }, (optionalString(parsed, "quota_project_id") && {
+            quota_project_id: optionalString(parsed, "quota_project_id"),
+        }));
+    }
+    if (credentialType === undefined || credentialType === "service_account") {
+        return Object.assign(Object.assign(Object.assign(Object.assign({ type: "service_account", client_email: requiredString(parsed, "client_email").trim(), private_key: requiredString(parsed, "private_key") }, (optionalString(parsed, "private_key_id") && {
+            private_key_id: optionalString(parsed, "private_key_id"),
+        })), (optionalString(parsed, "project_id") && {
+            project_id: optionalString(parsed, "project_id"),
+        })), (optionalString(parsed, "client_id") && {
+            client_id: optionalString(parsed, "client_id"),
+        })), (optionalString(parsed, "quota_project_id") && {
+            quota_project_id: optionalString(parsed, "quota_project_id"),
+        }));
+    }
+    throw new Error(`Unsupported Google credentials type: ${credentialType !== null && credentialType !== void 0 ? credentialType : "missing"}`);
+}
+exports.parseGoogleCredentials = parseGoogleCredentials;
+function normalizeMerchantId(rawMerchantId) {
+    const merchantId = rawMerchantId.trim();
+    if (!MERCHANT_ID_PATTERN.test(merchantId)) {
+        throw new Error("Merchant ID must be a positive numeric account ID");
+    }
+    return merchantId;
+}
+exports.normalizeMerchantId = normalizeMerchantId;
+function normalizeDataSource(rawDataSource, merchantId) {
+    const dataSource = rawDataSource.trim();
+    const match = DATA_SOURCE_PATTERN.exec(dataSource);
+    if (!match) {
+        throw new Error("Google dataSource must match accounts/{merchantId}/dataSources/{id}");
+    }
+    if (match[1] !== merchantId) {
+        throw new Error("Google dataSource account must match Merchant ID");
+    }
+    return `accounts/${match[1]}/dataSources/${match[2]}`;
+}
+exports.normalizeDataSource = normalizeDataSource;
+function parseGoogleMerchantSettings(entries) {
+    var _a, _b, _c, _d, _e;
+    const getValue = (key) => { var _a; return (_a = entries.find((entry) => entry.key === key)) === null || _a === void 0 ? void 0 : _a.value; };
+    const accountId = normalizeMerchantId((_a = getValue("merchantId")) !== null && _a !== void 0 ? _a : "");
+    const dataSource = normalizeDataSource((_b = getValue("dataSource")) !== null && _b !== void 0 ? _b : "", accountId);
+    const brand = ((_c = getValue("brand")) !== null && _c !== void 0 ? _c : "").trim();
+    if (!brand) {
+        throw new Error("Google brand is required");
+    }
+    const credentials = parseGoogleCredentials((_d = getValue("credentials")) !== null && _d !== void 0 ? _d : "");
+    return {
+        accountId,
+        autoUpdate: ((_e = getValue("autoUpdate")) !== null && _e !== void 0 ? _e : "").toLowerCase() === "true",
+        brand,
+        credentials,
+        dataSource,
+    };
+}
+exports.parseGoogleMerchantSettings = parseGoogleMerchantSettings;
+function createGoogleMerchantClients(credentials) {
+    const options = {
+        credentials,
+        scopes: [GOOGLE_OAUTH_SCOPE],
+    };
+    return {
+        productInputs: new products_1.v1.ProductInputsServiceClient(options),
+        products: new products_1.v1.ProductsServiceClient(options),
+    };
+}
+exports.createGoogleMerchantClients = createGoogleMerchantClients;
+function buildGoogleProductIdentifier(offerId) {
+    if (!offerId) {
+        throw new Error("Google offer ID is required");
+    }
+    const components = [exports.GOOGLE_CONTENT_LANGUAGE, exports.GOOGLE_FEED_LABEL, offerId];
+    const identifier = components.join("~");
+    return components.every((component) => PLAIN_IDENTIFIER_COMPONENT.test(component))
+        ? identifier
+        : Buffer.from(identifier, "utf8").toString("base64url");
+}
+exports.buildGoogleProductIdentifier = buildGoogleProductIdentifier;
+function buildGoogleProductName(accountId, offerId) {
+    return `accounts/${accountId}/products/${buildGoogleProductIdentifier(offerId)}`;
+}
+exports.buildGoogleProductName = buildGoogleProductName;
+function buildGoogleProductInputName(accountId, offerId) {
+    return `accounts/${accountId}/productInputs/${buildGoogleProductIdentifier(offerId)}`;
+}
+exports.buildGoogleProductInputName = buildGoogleProductInputName;
+function toGoogleProductInput(product, brand) {
+    return Object.assign(Object.assign({ offerId: String(product.communicateID), contentLanguage: exports.GOOGLE_CONTENT_LANGUAGE, feedLabel: exports.GOOGLE_FEED_LABEL, productAttributes: Object.assign(Object.assign({}, product.productAttributes), { brand }) }, (product.customAttributes && {
+        customAttributes: product.customAttributes,
+    })), (product.versionNumber !== undefined && {
+        versionNumber: product.versionNumber,
+    }));
+}
+exports.toGoogleProductInput = toGoogleProductInput;
+function camelToSnake(value) {
+    return value.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function buildGoogleUpdateMask(productInput) {
+    var _a, _b;
+    const paths = Object.entries((_a = productInput.productAttributes) !== null && _a !== void 0 ? _a : {})
+        .filter(([, value]) => value !== undefined)
+        .map(([key]) => `product_attributes.${camelToSnake(key)}`);
+    for (const customAttribute of (_b = productInput.customAttributes) !== null && _b !== void 0 ? _b : []) {
+        if (customAttribute.name) {
+            paths.push(`custom_attribute.${customAttribute.name}`);
+        }
+    }
+    if (paths.length === 0) {
+        throw new Error("Google update requires at least one mutable attribute");
+    }
+    return { paths };
+}
+exports.buildGoogleUpdateMask = buildGoogleUpdateMask;
+function createGoogleInsertOperation(product, settings) {
+    const communicateID = String(product.communicateID);
+    return {
+        communicateID,
+        method: "insert",
+        request: {
+            parent: `accounts/${settings.accountId}`,
+            dataSource: settings.dataSource,
+            productInput: toGoogleProductInput(product, settings.brand),
+        },
+    };
+}
+exports.createGoogleInsertOperation = createGoogleInsertOperation;
+function createGoogleUpdateOperation(product, settings) {
+    const communicateID = String(product.communicateID);
+    const input = toGoogleProductInput(product, settings.brand);
+    const productInput = Object.assign({ name: buildGoogleProductInputName(settings.accountId, communicateID), productAttributes: input.productAttributes }, (input.customAttributes && {
+        customAttributes: input.customAttributes,
+    }));
+    return {
+        communicateID,
+        method: "update",
+        request: {
+            dataSource: settings.dataSource,
+            productInput,
+            updateMask: buildGoogleUpdateMask(productInput),
+        },
+    };
+}
+exports.createGoogleUpdateOperation = createGoogleUpdateOperation;
+function createGoogleDeleteOperation(communicateID, settings) {
+    return {
+        communicateID,
+        method: "delete",
+        request: {
+            name: buildGoogleProductInputName(settings.accountId, communicateID),
+            dataSource: settings.dataSource,
+        },
+    };
+}
+exports.createGoogleDeleteOperation = createGoogleDeleteOperation;
+async function runBoundedMerchantOperations(items, operation, concurrency = exports.DEFAULT_GOOGLE_WRITE_CONCURRENCY) {
+    if (!Number.isInteger(concurrency) || concurrency < 1) {
+        throw new Error("Merchant operation concurrency must be a positive integer");
+    }
+    if (items.length === 0)
+        return [];
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(concurrency, items.length);
+    const workers = Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= items.length)
+                return;
+            const item = items[index];
+            try {
+                await operation(item, index);
+                results[index] = { index, item, status: "success" };
+            }
+            catch (error) {
+                results[index] = { error, index, item, status: "error" };
+            }
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
+exports.runBoundedMerchantOperations = runBoundedMerchantOperations;
+function isNotFoundError(error) {
+    if (!isRecord(error))
+        return false;
+    if (error.code === 5 || error.code === 404 || error.code === "404")
+        return true;
+    const response = error.response;
+    return isRecord(response) && response.status === 404;
+}
+async function executeGoogleWriteOperations(client, operations, concurrency = exports.DEFAULT_GOOGLE_WRITE_CONCURRENCY) {
+    return runBoundedMerchantOperations(operations, async (operation) => {
+        try {
+            if (operation.method === "insert") {
+                await client.insertProductInput(operation.request);
+            }
+            else if (operation.method === "update") {
+                await client.updateProductInput(operation.request);
+            }
+            else {
+                await client.deleteProductInput(operation.request);
+            }
+        }
+        catch (error) {
+            if (operation.method === "delete" && isNotFoundError(error))
+                return;
+            throw error;
+        }
+    }, concurrency);
+}
+exports.executeGoogleWriteOperations = executeGoogleWriteOperations;
+function summarizeMerchantOperations(results) {
+    const failures = results.filter((result) => result.status === "error");
+    return {
+        failures,
+        results,
+        status: failures.length === 0 ? "success" : "error",
+    };
+}
+exports.summarizeMerchantOperations = summarizeMerchantOperations;
+async function collectGoogleProductsForDataSource(client, accountId, dataSource) {
+    var _a, e_1, _b, _c;
+    var _d, _e;
+    const products = new Map();
+    try {
+        for (var _f = true, _g = __asyncValues(client.listProductsAsync({
+            parent: `accounts/${accountId}`,
+            pageSize: 1000,
+        })), _h; _h = await _g.next(), _a = _h.done, !_a; _f = true) {
+            _c = _h.value;
+            _f = false;
+            const product = _c;
+            if (product.dataSource !== dataSource || !product.offerId)
+                continue;
+            products.set(product.offerId, {
+                communicateID: product.offerId,
+                name: (_e = (_d = product.productAttributes) === null || _d === void 0 ? void 0 : _d.title) !== null && _e !== void 0 ? _e : undefined,
+            });
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_f && !_a && (_b = _g.return)) await _b.call(_g);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return [...products.values()];
+}
+exports.collectGoogleProductsForDataSource = collectGoogleProductsForDataSource;
+function selectRemoteOrphanProducts(remoteProducts, localProducts) {
+    const localIds = new Set(localProducts.map((product) => String(product.communicateID)));
+    const selected = new Map();
+    for (const remoteProduct of remoteProducts) {
+        if (!localIds.has(remoteProduct.communicateID)) {
+            selected.set(remoteProduct.communicateID, remoteProduct);
+        }
+    }
+    return [...selected.values()];
+}
+exports.selectRemoteOrphanProducts = selectRemoteOrphanProducts;