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

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

@@ -1,39 +1,30 @@
 import { Product, RequestContext, TransactionalConnection } from "@deenruv/core";
-import { content_v2_1 } from "googleapis";
 import { MerchantPlatformSettingsEntity } from "../entities/platform-integration-settings.entity.js";
-import { BaseData, BaseProductData } from "../types.js";
+import { BaseData, BaseProductData, GoogleProcessedProduct, RemoteProduct } from "../types.js";
+import { GoogleMerchantSettings, GoogleWriteOperation, MerchantOperationResult } from "./google-merchant-api.js";
 import { MerchantStrategyService } from "./merchant-strategy.service.js";
+type GoogleWriteResult = MerchantOperationResult<GoogleWriteOperation>;
 type OpResult = {
-    status: "success";
-} | {
-    status: "error";
     error?: unknown;
+    results: GoogleWriteResult[];
+    status: "success" | "error";
 };
 export declare class GooglePlatformIntegrationService {
     private readonly connection;
     private readonly strategy;
-    private readonly SCOPES;
-    private readonly google_content_api_version;
     private readonly logger;
     private log;
     private error;
-    private googleContext;
-    private googleContextString;
     constructor(connection: TransactionalConnection, strategy: MerchantStrategyService);
-    removeOrphanItems(ctx: RequestContext, items: BaseData[]): Promise<void>;
-    getAllProducts(ctx: RequestContext): Promise<Array<{
+    removeOrphanItems(ctx: RequestContext, items: RemoteProduct[]): Promise<void>;
+    getAllProducts(ctx: RequestContext): Promise<RemoteProduct[]>;
+    getGoogleProduct(ctx: RequestContext, { communicateID }: {
         communicateID: string;
-        name?: string;
-    }>>;
-    private getAuthorization;
-    getGoogleProduct({ communicateID }: {
-        communicateID: string;
-    }): Promise<content_v2_1.Schema$Product | null>;
+    }): Promise<GoogleProcessedProduct | null>;
     insertProduct<T extends BaseData>(opts: {
         ctx: RequestContext;
         data: BaseProductData<T>;
         entity: Product;
-        skipCheck?: boolean;
     }): Promise<OpResult>;
     updateProduct(opts: {
         ctx: RequestContext;
@@ -49,15 +40,15 @@ export declare class GooglePlatformIntegrationService {
         ctx: RequestContext;
         products: BaseProductData<BaseData>[];
     }): Promise<OpResult>;
-    private sendBatch;
+    private sendProducts;
+    private sendPreparedProducts;
+    private createOperations;
+    private persistCommunicationIds;
     private buildPayload;
-    private mapInsertProducts;
-    private mapUpdateProducts;
-    setGoogleSettings(rawSettings?: MerchantPlatformSettingsEntity): Promise<{
-        autoUpdate: boolean;
-        accountId: string;
-        credentials: any;
-        brand: string;
-    } | null>;
+    validateGoogleSettings(rawSettings: MerchantPlatformSettingsEntity): GoogleMerchantSettings;
+    setGoogleSettings(ctx: RequestContext, rawSettings?: MerchantPlatformSettingsEntity): Promise<GoogleMerchantSettings | null>;
+    private getAuthorization;
+    private closeClients;
+    private isNotFoundError;
 }
 export {};

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

@@ -8,341 +8,233 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GooglePlatformIntegrationService = void 0;
 const core_1 = require("@deenruv/core");
 const common_1 = require("@nestjs/common");
-const googleapis_1 = require("googleapis");
+const typeorm_1 = require("typeorm");
 const platform_integration_settings_entity_js_1 = require("../entities/platform-integration-settings.entity.js");
+const google_merchant_api_js_1 = require("./google-merchant-api.js");
 const merchant_strategy_service_js_1 = require("./merchant-strategy.service.js");
-const typeorm_1 = require("typeorm");
+class GoogleMerchantOperationError extends Error {
+    constructor(method, results) {
+        const failedIds = results
+            .filter((result) => result.status === "error")
+            .map((result) => result.item.communicateID)
+            .join(", ");
+        super(`Google ${method} failed for: ${failedIds || "unknown product"}`);
+        this.name = "GoogleMerchantOperationError";
+    }
+}
 let GooglePlatformIntegrationService = class GooglePlatformIntegrationService {
     constructor(connection, strategy) {
         this.connection = connection;
         this.strategy = strategy;
-        this.SCOPES = ["https://www.googleapis.com/auth/content"];
-        this.google_content_api_version = "v2.1";
         this.logger = new core_1.Logger();
         this.log = (message) => this.logger.log(message, "Merchant Platform Service");
         this.error = (message, err) => this.logger.error(message, err instanceof Error ? err.stack : String(err), "Merchant Platform Service");
-        this.googleContext = {
-            channel: "online",
-            contentLanguage: "pl",
-            feedLabel: "PL",
-        };
-        this.googleContextString = (id) => Object.values(this.googleContext).join(":") + `:${id}`;
     }
     async removeOrphanItems(ctx, items) {
-        const { accountId, client } = await this.getAuthorization();
-        const payload = items.map((item) => ({
-            merchantId: accountId,
-            productId: this.googleContextString(item.communicateID),
-        }));
-        if (payload.length > 0) {
-            await client.products.custombatch({
-                requestBody: {
-                    entries: payload.map((p) => (Object.assign(Object.assign({}, p), { method: "delete" }))),
-                },
-            });
+        if (items.length === 0)
+            return;
+        const authorization = await this.getAuthorization(ctx);
+        try {
+            const operations = items.map((item) => (0, google_merchant_api_js_1.createGoogleDeleteOperation)(item.communicateID, authorization.settings));
+            const results = await (0, google_merchant_api_js_1.executeGoogleWriteOperations)(authorization.clients.productInputs, operations);
+            const summary = (0, google_merchant_api_js_1.summarizeMerchantOperations)(results);
+            if (summary.status === "error") {
+                throw new GoogleMerchantOperationError("delete", results);
+            }
+        }
+        finally {
+            await this.closeClients(authorization.clients);
         }
     }
     async getAllProducts(ctx) {
-        var _a, _b, _c;
-        const { accountId, client } = await this.getAuthorization();
-        const collected = [];
-        let pageToken;
-        let page = 0;
+        const authorization = await this.getAuthorization(ctx);
         try {
-            do {
-                const { data } = await client.products.list({
-                    merchantId: accountId,
-                    pageToken,
-                    maxResults: 250,
-                });
-                const resources = (_a = data.resources) !== null && _a !== void 0 ? _a : [];
-                for (const p of resources) {
-                    if (p.offerId) {
-                        collected.push({
-                            communicateID: p.offerId,
-                            name: (_b = p.title) !== null && _b !== void 0 ? _b : undefined,
-                        });
-                    }
-                }
-                pageToken = (_c = data.nextPageToken) !== null && _c !== void 0 ? _c : undefined;
-                page++;
-                if (page > 500) {
-                    this.error("Aborting products pagination: too many pages");
-                    break;
-                }
-            } while (pageToken);
-            return collected;
+            return await (0, google_merchant_api_js_1.collectGoogleProductsForDataSource)(authorization.clients.products, authorization.settings.accountId, authorization.settings.dataSource);
         }
-        catch (e) {
-            this.error("Failed to retrieve products from Google", e);
-            return [];
+        catch (error) {
+            this.error("Failed to retrieve products from Google", error);
+            throw error;
+        }
+        finally {
+            await this.closeClients(authorization.clients);
         }
     }
-    async getAuthorization() {
-        const settings = await this.setGoogleSettings();
-        if (!settings)
-            throw new Error("Google platform settings not found");
-        const { accountId, credentials } = settings;
-        const auth = new googleapis_1.google.auth.GoogleAuth({
-            credentials,
-            scopes: this.SCOPES,
-        });
-        const client = googleapis_1.google.content({
-            version: this.google_content_api_version,
-            auth,
-        });
-        if (!client)
-            throw new Error("Content API client not found");
-        if (!accountId)
-            throw new Error("Merchant ID not found");
-        return Object.assign({ client }, settings);
-    }
-    async getGoogleProduct({ communicateID }) {
-        var _a, _b;
-        const { accountId, client } = await this.getAuthorization();
+    async getGoogleProduct(ctx, { communicateID }) {
+        const authorization = await this.getAuthorization(ctx);
         try {
-            const response = await client.products.get({
-                merchantId: accountId,
-                productId: this.googleContextString(communicateID),
+            const [product] = await authorization.clients.products.getProduct({
+                name: (0, google_merchant_api_js_1.buildGoogleProductName)(authorization.settings.accountId, communicateID),
             });
-            return (_a = response.data) !== null && _a !== void 0 ? _a : null;
+            return product !== null && product !== void 0 ? product : null;
         }
-        catch (e) {
-            const err = e;
-            if (((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) === 404)
+        catch (error) {
+            if (this.isNotFoundError(error))
                 return null;
-            throw e;
+            throw error;
+        }
+        finally {
+            await this.closeClients(authorization.clients);
         }
     }
     async insertProduct(opts) {
-        return this.sendBatch(Object.assign(Object.assign({}, opts), { method: "insert" }));
+        return this.sendProducts(Object.assign(Object.assign({}, opts), { method: "insert" }));
     }
     async updateProduct(opts) {
-        return this.sendBatch(Object.assign(Object.assign({}, opts), { method: "update" }));
+        return this.sendProducts(Object.assign(Object.assign({}, opts), { method: "update" }));
     }
     async deleteProduct(opts) {
-        return this.sendBatch(Object.assign(Object.assign({}, opts), { method: "delete" }));
+        return this.sendProducts(Object.assign(Object.assign({}, opts), { method: "delete" }));
     }
     async batchProductsAction(opts) {
-        var _a, _b, _c, _d, _e;
         const { ctx, products } = opts;
         try {
-            const { accountId, brand, client } = await this.getAuthorization();
-            const allPayloads = await Promise.all(products.map((p) => this.buildPayload(ctx, p))).then((arr) => arr.flat());
-            if (allPayloads.length === 0)
-                return { status: "success" };
-            const insertProducts = this.mapInsertProducts(allPayloads, brand);
-            const entries = insertProducts.map((product, i) => ({
-                batchId: i + 1,
-                merchantId: accountId,
-                method: "insert",
-                product,
-            }));
-            const resp = await client.products.custombatch({
-                requestBody: { entries },
-            });
-            if (resp.status !== 200)
-                throw new Error("Batch insert failed");
-            const hasErrors = (_b = (_a = resp.data) === null || _a === void 0 ? void 0 : _a.entries) === null || _b === void 0 ? void 0 : _b.some((e) => e.errors);
-            if (hasErrors)
-                throw new Error("Per-item insert errors");
-            this.log(`Batch inserted ${(_e = (_d = (_c = resp.data) === null || _c === void 0 ? void 0 : _c.entries) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : insertProducts.length} product(s)`);
+            const payload = [];
             for (const product of products) {
-                for (const item of product) {
-                    await this.connection
-                        .getRepository(ctx, core_1.ProductVariant)
-                        .update({ id: item.variantID }, { customFields: { communicateID: item.communicateID } });
-                }
+                payload.push(...(await this.buildPayload(ctx, product)));
             }
-            return { status: "success" };
+            return await this.sendPreparedProducts(ctx, "insert", payload);
         }
-        catch (e) {
-            this.error("Batch products action failed", e);
-            return { status: "error", error: e };
+        catch (error) {
+            this.error("Google bulk insert failed", error);
+            return { error, results: [], status: "error" };
         }
     }
-    async sendBatch(opts) {
-        var _a, _b, _c, _d, _e, _f;
-        const { ctx, method, data, skipCheck } = opts;
+    async sendProducts(opts) {
+        const { ctx, method, data } = opts;
         try {
-            const basePayload = await this.buildPayload(ctx, data);
-            if (basePayload.length === 0)
-                return { status: "success" };
-            const { accountId, brand, client } = await this.getAuthorization();
-            let working = basePayload;
-            if (method === "insert" && !skipCheck) {
-                const filtered = [];
-                for (const item of working) {
-                    if (!item.communicateID)
-                        continue;
-                    try {
-                        const exists = await this.getGoogleProduct({
-                            communicateID: item.communicateID,
-                        });
-                        if (!exists)
-                            filtered.push(item);
-                    }
-                    catch (e) {
-                        this.log(`Lookup failed for ${item.communicateID}, attempting insert. ${e}`);
-                        filtered.push(item);
-                    }
+            const payload = await this.buildPayload(ctx, data);
+            return await this.sendPreparedProducts(ctx, method, payload);
+        }
+        catch (error) {
+            this.error(`Google ${method} failed`, error);
+            return { error, results: [], status: "error" };
+        }
+    }
+    async sendPreparedProducts(ctx, method, payload) {
+        if (payload.length === 0) {
+            return { results: [], status: "success" };
+        }
+        const authorization = await this.getAuthorization(ctx);
+        let results = [];
+        try {
+            const operations = this.createOperations(method, payload, authorization.settings);
+            results = await (0, google_merchant_api_js_1.executeGoogleWriteOperations)(authorization.clients.productInputs, operations);
+            if (method !== "delete") {
+                const successfulIds = new Set(results
+                    .filter((result) => result.status === "success")
+                    .map((result) => result.item.communicateID));
+                const successfulProducts = payload.filter((product) => successfulIds.has(String(product.communicateID)));
+                const previousIds = await this.persistCommunicationIds(ctx, successfulProducts, method);
+                if (previousIds.length > 0) {
+                    const cleanupOperations = previousIds.map((communicateID) => (0, google_merchant_api_js_1.createGoogleDeleteOperation)(communicateID, authorization.settings));
+                    const cleanupResults = await (0, google_merchant_api_js_1.executeGoogleWriteOperations)(authorization.clients.productInputs, cleanupOperations);
+                    results.push(...cleanupResults);
                 }
-                working = filtered;
-                if (working.length === 0)
-                    return { status: "success" };
             }
-            let entries = [];
-            if (method === "insert") {
-                const products = this.mapInsertProducts(working, brand);
-                entries = products.map((product, i) => ({
-                    batchId: i + 1,
-                    merchantId: accountId,
-                    method,
-                    product,
-                }));
+            const summary = (0, google_merchant_api_js_1.summarizeMerchantOperations)(results);
+            const succeeded = results.length - summary.failures.length;
+            this.log(`Google ${method} completed (${succeeded}/${results.length} successful)`);
+            if (summary.status === "error") {
+                const error = new GoogleMerchantOperationError(method, results);
+                this.error(error.message, error);
+                return { error, results, status: "error" };
             }
-            else if (method === "update") {
-                const products = this.mapUpdateProducts(working, brand);
-                if (products.length === 0)
-                    return { status: "success" };
-                entries = products.map(({ communicateID, product }, i) => ({
-                    batchId: i + 1,
-                    merchantId: accountId,
-                    method,
-                    productId: communicateID,
-                    product,
-                }));
-            }
-            else if (method === "delete") {
-                entries = working
-                    .filter((p) => !!p.communicateID)
-                    .map((p, i) => ({
-                    batchId: i + 1,
-                    merchantId: accountId,
-                    method,
-                    productId: this.googleContextString(p.communicateID),
-                }));
-            }
-            if (entries.length === 0)
-                return { status: "success" };
-            const resp = await client.products.custombatch({
-                requestBody: { entries },
-            });
-            if (resp.status !== 200)
-                throw new Error(`Batch ${method} HTTP status ${resp.status}`);
-            const perItemErrors = (_b = (_a = resp.data) === null || _a === void 0 ? void 0 : _a.entries) === null || _b === void 0 ? void 0 : _b.filter((e) => e.errors);
-            if (perItemErrors && perItemErrors.length > 0) {
-                this.error(`Google batch ${method} per-item errors`);
-                return { status: "error", error: perItemErrors };
-            }
-            if (method !== "delete") {
-                const repo = this.connection.getRepository(ctx, core_1.ProductVariant);
-                const items = data.filter((d) => d.variantID);
-                const ids = [...new Set(items.map((i) => i.variantID))];
-                if (ids.length) {
-                    const variants = await repo.find({ where: { id: (0, typeorm_1.In)(ids) } });
-                    const variantMap = new Map(variants.map((v) => [v.id, v]));
-                    const toDelete = [];
-                    for (const item of items) {
-                        const variant = variantMap.get(item.variantID);
-                        if (!variant)
-                            continue;
-                        const newCommId = item.communicateID;
-                        const prevCommId = (_c = variant.customFields) === null || _c === void 0 ? void 0 : _c.communicateID;
-                        if (method === "update" && prevCommId && prevCommId !== newCommId) {
-                            toDelete.push({
-                                communicateID: prevCommId,
-                                variantID: variant.id,
-                            });
-                        }
-                        variant.customFields = Object.assign(Object.assign({}, variant.customFields), { communicateID: newCommId });
-                    }
-                    if (toDelete.length)
-                        await this.sendBatch({ ctx, method: "delete", data: toDelete });
-                    if (variants.length)
-                        await repo.save(variants, { chunk: 100 });
-                }
+            return { results, status: "success" };
+        }
+        catch (error) {
+            this.error(`Google ${method} failed`, error);
+            return { error, results, status: "error" };
+        }
+        finally {
+            await this.closeClients(authorization.clients);
+        }
+    }
+    createOperations(method, payload, settings) {
+        if (method === "insert") {
+            return payload.map((product) => (0, google_merchant_api_js_1.createGoogleInsertOperation)(product, settings));
+        }
+        if (method === "update") {
+            return payload.map((product) => (0, google_merchant_api_js_1.createGoogleUpdateOperation)(product, settings));
+        }
+        return payload.map((product) => (0, google_merchant_api_js_1.createGoogleDeleteOperation)(String(product.communicateID), settings));
+    }
+    async persistCommunicationIds(ctx, products, method) {
+        var _a;
+        const items = products.filter((product) => product.variantID !== undefined);
+        const ids = [...new Set(items.map((item) => String(item.variantID)))];
+        if (ids.length === 0)
+            return [];
+        const repository = this.connection.getRepository(ctx, core_1.ProductVariant);
+        const variants = await repository.find({ where: { id: (0, typeorm_1.In)(ids) } });
+        const variantMap = new Map(variants.map((variant) => [String(variant.id), variant]));
+        const previousIds = new Set();
+        for (const item of items) {
+            const variant = variantMap.get(String(item.variantID));
+            if (!variant)
+                continue;
+            const nextId = String(item.communicateID);
+            const previousId = (_a = variant.customFields) === null || _a === void 0 ? void 0 : _a.communicateID;
+            if (method === "update" && previousId && previousId !== nextId) {
+                previousIds.add(previousId);
             }
-            this.log(`Google batch ${method} done (${(_f = (_e = (_d = resp.data) === null || _d === void 0 ? void 0 : _d.entries) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : entries.length} items)`);
-            return { status: "success" };
+            variant.customFields = Object.assign(Object.assign({}, variant.customFields), { communicateID: nextId });
         }
-        catch (e) {
-            this.error(`Google batch ${method} failed`, e);
-            return { status: "error", error: e };
+        if (variants.length > 0) {
+            await repository.save(variants, { chunk: 100 });
         }
+        return [...previousIds];
     }
     async buildPayload(ctx, data) {
         const payload = await this.strategy.prepareGoogleProductPayload(ctx, data);
-        return (payload !== null && payload !== void 0 ? payload : []).filter((p) => !!p && !!p.communicateID);
-    }
-    mapInsertProducts(payload, brand) {
-        return payload.map((_a) => {
-            var { communicateID, variantID } = _a, rest = __rest(_a, ["communicateID", "variantID"]);
-            return (Object.assign(Object.assign(Object.assign({ offerId: communicateID.toString() }, rest), this.googleContext), { brand }));
-        });
+        return (payload !== null && payload !== void 0 ? payload : []).filter((product) => Boolean(product &&
+            String(product.communicateID).length > 0 &&
+            product.productAttributes));
     }
-    mapUpdateProducts(payload, brand) {
-        return payload
-            .filter((p) => !!p.communicateID)
-            .map((_a) => {
-            var { communicateID, variantID } = _a, rest = __rest(_a, ["communicateID", "variantID"]);
-            delete rest.offerId;
-            delete rest.feedLabel;
-            delete rest.contentLanguage;
-            delete rest.channel;
-            const product = Object.assign(Object.assign({}, rest), { brand });
-            return {
-                communicateID: this.googleContextString(communicateID),
-                product,
-            };
-        });
+    validateGoogleSettings(rawSettings) {
+        return (0, google_merchant_api_js_1.parseGoogleMerchantSettings)(rawSettings.entries);
     }
-    async setGoogleSettings(rawSettings) {
-        var _a, _b;
+    async setGoogleSettings(ctx, rawSettings) {
         let settings = rawSettings;
         if (!settings) {
             settings = await this.connection
-                .getRepository(core_1.RequestContext.empty(), platform_integration_settings_entity_js_1.MerchantPlatformSettingsEntity)
+                .getRepository(ctx, platform_integration_settings_entity_js_1.MerchantPlatformSettingsEntity)
                 .findOne({ relations: ["entries"], where: { platform: "google" } });
         }
+        return settings ? this.validateGoogleSettings(settings) : null;
+    }
+    async getAuthorization(ctx) {
+        const settings = await this.setGoogleSettings(ctx);
         if (!settings)
-            return null;
-        const getVal = (k) => { var _a; return (_a = settings.entries.find((e) => e.key === k)) === null || _a === void 0 ? void 0 : _a.value; };
-        const autoUpdate = getVal("autoUpdate");
-        const accountId = getVal("merchantId");
-        const brand = (_a = getVal("brand")) !== null && _a !== void 0 ? _a : "";
-        let credentials = null;
-        try {
-            credentials = JSON.parse((_b = getVal("credentials")) !== null && _b !== void 0 ? _b : "null");
-        }
-        catch (_c) {
-            this.log("Error parsing credentials");
-            return null;
-        }
-        if (!accountId || !credentials || !brand)
-            return null;
+            throw new Error("Google platform settings not found");
         return {
-            autoUpdate: String(autoUpdate).toLowerCase() === "true",
-            accountId,
-            credentials,
-            brand,
+            clients: (0, google_merchant_api_js_1.createGoogleMerchantClients)(settings.credentials),
+            settings,
         };
     }
+    async closeClients(clients) {
+        for (const client of [clients.products, clients.productInputs]) {
+            try {
+                await client.close();
+            }
+            catch (error) {
+                this.error("Failed to close Google Merchant API client", error);
+            }
+        }
+    }
+    isNotFoundError(error) {
+        var _a;
+        if (typeof error !== "object" || error === null)
+            return false;
+        const candidate = error;
+        return (candidate.code === 5 ||
+            candidate.code === 404 ||
+            candidate.code === "404" ||
+            ((_a = candidate.response) === null || _a === void 0 ? void 0 : _a.status) === 404);
+    }
 };
 exports.GooglePlatformIntegrationService = GooglePlatformIntegrationService;
 exports.GooglePlatformIntegrationService = GooglePlatformIntegrationService = __decorate([