@deenruv/merchant-plugin 1.0.0

package/dist/plugin-server/services/merchant-strategy.service.js

@@ -0,0 +1,39 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerchantStrategyService = void 0;
+const common_1 = require("@nestjs/common");
+const constants_js_1 = require("../constants.js");
+const default_merchant_export_strategy_js_1 = require("../strategies/default-merchant-export-strategy.js");
+let MerchantStrategyService = class MerchantStrategyService {
+    constructor(options) {
+        this.options = options;
+        this.strategy = (options === null || options === void 0 ? void 0 : options.strategy) || new default_merchant_export_strategy_js_1.DefaultMerchantExportStrategy();
+    }
+    async getBaseData(ctx, product) {
+        return this.strategy.getBaseData(ctx, product);
+    }
+    async prepareGoogleProductPayload(ctx, product) {
+        return this.strategy.prepareGoogleProductPayload(ctx, product);
+    }
+    async prepareFacebookProductPayload(ctx, product) {
+        return this.strategy.prepareFacebookProductPayload(ctx, product);
+    }
+};
+exports.MerchantStrategyService = MerchantStrategyService;
+exports.MerchantStrategyService = MerchantStrategyService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_js_1.MERCHANT_PLUGIN_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], MerchantStrategyService);

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

@@ -0,0 +1,43 @@
+import { JobQueue, JobQueueService, ProductService, RequestContext, TransactionalConnection } from "@deenruv/core";
+import { OnModuleInit } from "@nestjs/common";
+import { MerchantPlatformSettingsEntity } from "../entities/platform-integration-settings.entity.js";
+import { FacebookPlatformIntegrationService } from "./facebook-platform-integration.service.js";
+import { GooglePlatformIntegrationService } from "./google-platform-integration.service.js";
+import { MerchantStrategyService } from "./merchant-strategy.service.js";
+type JOB_PAYLOAD = {
+    platform: string;
+    action: "SEND_ALL_PRODUCTS";
+};
+export declare class PlatformIntegrationService implements OnModuleInit {
+    private readonly connection;
+    private readonly jobQueueService;
+    private readonly googleService;
+    private readonly facebookService;
+    private readonly productService;
+    private readonly strategy;
+    MerchantPlatformQueue: JobQueue<{
+        payload: JOB_PAYLOAD;
+        worker: number;
+    }>;
+    OrphanItemsQueue: JobQueue<{
+        platform: string;
+    }>;
+    private readonly logger;
+    private log;
+    constructor(connection: TransactionalConnection, jobQueueService: JobQueueService, googleService: GooglePlatformIntegrationService, facebookService: FacebookPlatformIntegrationService, productService: ProductService, strategy: MerchantStrategyService);
+    removeOrphanItems(ctx: RequestContext, platform: string): Promise<boolean>;
+    fetchProducts(input: {
+        ctx: RequestContext;
+        worker: number;
+    }, 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>;
+    getBaseSettings(ctx: RequestContext, platform: string): Promise<MerchantPlatformSettingsEntity | null>;
+    getPlatformAutoUpdateSettings(ctx: RequestContext): Promise<{
+        googleAutoUpdate: boolean;
+        facebookAutoUpdate: boolean;
+    }>;
+    private lookup;
+}
+export {};

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

@@ -0,0 +1,282 @@
+"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);
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+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.PlatformIntegrationService = void 0;
+const admin_types_1 = require("@deenruv/admin-types");
+const core_1 = require("@deenruv/core");
+const common_1 = require("@nestjs/common");
+const platform_integration_settings_entity_js_1 = require("../entities/platform-integration-settings.entity.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 BATCH_SIZE = 200;
+const WORKER_THRESHOLD = 5000;
+let PlatformIntegrationService = class PlatformIntegrationService {
+    constructor(connection, jobQueueService, googleService, facebookService, productService, strategy) {
+        this.connection = connection;
+        this.jobQueueService = jobQueueService;
+        this.googleService = googleService;
+        this.facebookService = facebookService;
+        this.productService = productService;
+        this.strategy = strategy;
+        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 });
+            return true;
+        }
+        return false;
+    }
+    fetchProducts(input, callback) {
+        return __asyncGenerator(this, arguments, function* fetchProducts_1() {
+            const { ctx, worker } = input;
+            const totalToFetch = (worker + 1) * WORKER_THRESHOLD;
+            const start = worker * WORKER_THRESHOLD;
+            for (let i = start; i < totalToFetch; i += BATCH_SIZE) {
+                const { items } = yield __await(this.productService.findAll(ctx, {
+                    take: BATCH_SIZE,
+                    skip: i,
+                }));
+                for (const product of items) {
+                    const baseProduct = yield __await(this.strategy.getBaseData(ctx, product));
+                    if (callback) {
+                        const progress = Math.floor((i / totalToFetch) * 100);
+                        callback(progress);
+                    }
+                    if (!baseProduct)
+                        continue;
+                    yield yield __await(baseProduct);
+                }
+            }
+        });
+    }
+    async onModuleInit() {
+        this.MerchantPlatformQueue = await this.jobQueueService.createQueue({
+            name: "MerchantPlatformEventQueue",
+            process: async (job) => {
+                var _a, e_1, _b, _c;
+                try {
+                    const { payload: { action, platform }, worker, } = job.data;
+                    if (action === "SEND_ALL_PRODUCTS") {
+                        const ctx = await this.createContext();
+                        if (!ctx)
+                            return { status: "CONTEXT_ERROR" };
+                        const products = [];
+                        try {
+                            for (var _d = true, _e = __asyncValues(this.fetchProducts({ ctx, worker }, (progress) => {
+                                if (job.state === admin_types_1.JobState.CANCELLED) {
+                                    throw new Error("Job was cancelled");
+                                }
+                                else
+                                    job.setProgress(progress);
+                            })), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+                                _c = _f.value;
+                                _d = false;
+                                const product = _c;
+                                products.push(product);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        let googleResponse = false;
+                        let facebookResponse = false;
+                        if (platform === "google") {
+                            const response = await this.googleService.batchProductsAction({
+                                ctx,
+                                products,
+                            });
+                            if (response.status === "success") {
+                                this.log("Products sent to google");
+                                googleResponse = true;
+                            }
+                            else {
+                                this.log("Error sending products to google");
+                                googleResponse = false;
+                            }
+                        }
+                        if (platform === "facebook") {
+                            const response = await this.facebookService.batchProductsAction({
+                                ctx,
+                                products,
+                            });
+                            if (response.status === "success") {
+                                this.log("Products sent to facebook");
+                                facebookResponse = true;
+                            }
+                            else {
+                                this.log("Error sending products to facebook");
+                                facebookResponse = false;
+                            }
+                        }
+                        return { status: "SUCCESS", facebookResponse, googleResponse };
+                    }
+                }
+                catch (e) {
+                    const status = e instanceof Error ? e.message : "Unknown error";
+                    this.log(`Error processing job: ${status}`);
+                    throw new Error(status);
+                }
+            },
+        });
+        this.OrphanItemsQueue = await this.jobQueueService.createQueue({
+            name: "MerchantPlatformOrphanItemsQueue",
+            process: async (job) => {
+                var _a, e_2, _b, _c;
+                const { platform } = job.data;
+                const ctx = await this.createContext();
+                const map = {
+                    google: this.googleService,
+                    facebook: this.facebookService,
+                };
+                const service = map[platform];
+                if (!service)
+                    throw new Error("Unknown platform");
+                const results = await service.getAllProducts(ctx);
+                const products = [];
+                try {
+                    for (var _d = true, _e = __asyncValues(this.fetchProducts({ ctx, worker: 0 }, (progress) => {
+                        if (job.state === admin_types_1.JobState.CANCELLED) {
+                            throw new Error("Job was cancelled");
+                        }
+                        else
+                            job.setProgress(progress);
+                    })), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const product = _c;
+                        products.push(...product);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                const missingProducts = products.filter((product) => !results.find((result) => result.communicateID === product.communicateID));
+                if (missingProducts.length > 0) {
+                    this.log(`Found ${missingProducts.length} orphan items for platform ${platform}`);
+                    await service.removeOrphanItems(ctx, missingProducts);
+                }
+                else {
+                    this.log(`No orphan items found for platform ${platform}`);
+                }
+            },
+        });
+    }
+    async createContext() {
+        const channel = await this.connection.rawConnection
+            .getRepository(core_1.Channel)
+            .findOne({
+            where: { token: "pl-channel" }, // TODO: We should take default channel code, and allow to map other channels
+            relations: { defaultTaxZone: true },
+        });
+        if (!channel)
+            throw new Error("Cannot create context, default channel not found");
+        return new core_1.RequestContext({
+            apiType: "admin",
+            channel,
+            isAuthorized: true,
+            authorizedAsOwnerOnly: true,
+        });
+    }
+    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 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) }));
+        }
+        return response;
+    }
+    async getBaseSettings(ctx, platform) {
+        return this.connection
+            .getRepository(ctx, platform_integration_settings_entity_js_1.MerchantPlatformSettingsEntity)
+            .findOne({ relations: ["entries"], where: { platform } });
+    }
+    async getPlatformAutoUpdateSettings(ctx) {
+        const [googlePlatformSettings, facebookPlatformSettings] = await Promise.all([
+            this.getBaseSettings(ctx, "google"),
+            this.getBaseSettings(ctx, "facebook"),
+        ]);
+        return {
+            googleAutoUpdate: this.lookup(googlePlatformSettings, "autoUpdate") === "true",
+            facebookAutoUpdate: this.lookup(facebookPlatformSettings, "autoUpdate") === "true",
+        };
+    }
+    lookup(settings, key) {
+        var _a;
+        return (_a = settings === null || settings === void 0 ? void 0 : settings.entries.find((entry) => entry.key === key)) === null || _a === void 0 ? void 0 : _a.value;
+    }
+};
+exports.PlatformIntegrationService = PlatformIntegrationService;
+exports.PlatformIntegrationService = PlatformIntegrationService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.TransactionalConnection,
+        core_1.JobQueueService,
+        google_platform_integration_service_js_1.GooglePlatformIntegrationService,
+        facebook_platform_integration_service_js_1.FacebookPlatformIntegrationService,
+        core_1.ProductService,
+        merchant_strategy_service_js_1.MerchantStrategyService])
+], PlatformIntegrationService);

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

@@ -0,0 +1,30 @@
+import { CreateProductInput, CreateProductVariantInput, UpdateProductInput, UpdateProductVariantInput } from "@deenruv/common/lib/generated-types.js";
+import { EventBus, ID, Product, ProductService, RequestContext } 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 { PlatformIntegrationService } from "./platform-integration.service.js";
+type ProductInputTypes = CreateProductInput | UpdateProductInput | ID;
+type ProductVariantInputTypes = CreateProductVariantInput[] | UpdateProductVariantInput[] | ID | ID[];
+export declare class SubscriberService implements OnApplicationBootstrap {
+    private readonly options;
+    private readonly eventBus;
+    private readonly integrationService;
+    private readonly googleService;
+    private readonly facebookService;
+    private readonly strategy;
+    private readonly productService;
+    constructor(options: MerchantPluginOptions, eventBus: EventBus, integrationService: PlatformIntegrationService, googleService: GooglePlatformIntegrationService, facebookService: FacebookPlatformIntegrationService, strategy: MerchantStrategyService, productService: ProductService);
+    onApplicationBootstrap(): Promise<void>;
+    event({ ctx, entity, type, input, }: {
+        ctx: RequestContext;
+        entity: Product;
+        type: "created" | "updated" | "deleted";
+        input?: ProductInputTypes | ProductVariantInputTypes;
+    }): Promise<void>;
+    private isValidEventData;
+    private getOperationsForType;
+}
+export {};

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

@@ -0,0 +1,90 @@
+"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);
+};
+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;
+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 platform_integration_service_js_1 = require("./platform-integration.service.js");
+let SubscriberService = class SubscriberService {
+    constructor(options, eventBus, integrationService, googleService, facebookService, strategy, productService) {
+        this.options = options;
+        this.eventBus = eventBus;
+        this.integrationService = integrationService;
+        this.googleService = googleService;
+        this.facebookService = facebookService;
+        this.strategy = strategy;
+        this.productService = productService;
+    }
+    async onApplicationBootstrap() {
+        this.eventBus.ofType(core_1.ProductEvent).subscribe(async (props) => {
+            await this.event(props);
+        });
+        this.eventBus
+            .ofType(core_1.ProductVariantEvent)
+            .subscribe(async ({ ctx, entity, type, input }) => {
+            if (!entity || !entity.length)
+                return;
+            const product = await this.productService.findOne(ctx, entity[0].productId);
+            if (!product)
+                return;
+            await this.event({ ctx, entity: product, type, input });
+        });
+    }
+    async event({ ctx, entity, type, input, }) {
+        if (!this.isValidEventData(ctx, entity))
+            return;
+        const { googleAutoUpdate, facebookAutoUpdate } = await this.integrationService.getPlatformAutoUpdateSettings(ctx);
+        if (!googleAutoUpdate && !facebookAutoUpdate)
+            return;
+        const data = await this.strategy.getBaseData(ctx, entity);
+        if (!data)
+            return;
+        const operations = this.getOperationsForType(type);
+        const eventPayload = { ctx, data, entity };
+        await Promise.allSettled([
+            ...(googleAutoUpdate
+                ? [this.googleService[operations.google](eventPayload)]
+                : []),
+            ...(facebookAutoUpdate
+                ? [this.facebookService[operations.facebook](eventPayload)]
+                : []),
+        ]);
+    }
+    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];
+    }
+};
+exports.SubscriberService = SubscriberService;
+exports.SubscriberService = SubscriberService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_js_1.MERCHANT_PLUGIN_OPTIONS)),
+    __metadata("design:paramtypes", [Object, core_1.EventBus,
+        platform_integration_service_js_1.PlatformIntegrationService,
+        google_platform_integration_service_js_1.GooglePlatformIntegrationService,
+        facebook_platform_integration_service_js_1.FacebookPlatformIntegrationService,
+        merchant_strategy_service_js_1.MerchantStrategyService,
+        core_1.ProductService])
+], SubscriberService);

package/dist/plugin-server/strategies/default-merchant-export-strategy.d.ts

@@ -0,0 +1,21 @@
+import { Product, RequestContext } from "@deenruv/core";
+import { BaseData, BaseProductData, MerchantExportStrategy } from "../types.js";
+export declare class DefaultMerchantExportStrategy implements MerchantExportStrategy<BaseProductData<BaseData>> {
+    prepareFacebookProductPayload(ctx: RequestContext, product: BaseProductData<BaseData>): Promise<undefined>;
+    prepareGoogleProductPayload(ctx: RequestContext, product: BaseProductData<BaseData>): Promise<undefined>;
+    getBaseData(ctx: RequestContext, product: Product): Promise<{
+        communicateID: string;
+        variantID: import("@deenruv/core").ID;
+        customFields: import("@deenruv/core").CustomProductFields;
+        variants: undefined;
+        title: import("@deenruv/core").LocaleString;
+        description: import("@deenruv/core").LocaleString;
+        slug: import("@deenruv/core").LocaleString;
+        asset: string;
+        price: number;
+        currencyCode: import("@deenruv/core").CurrencyCode;
+        availability: string;
+        colors: never[];
+        mpn: string;
+    }[]>;
+}

package/dist/plugin-server/strategies/default-merchant-export-strategy.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMerchantExportStrategy = void 0;
+class DefaultMerchantExportStrategy {
+    async prepareFacebookProductPayload(ctx, product) {
+        return undefined;
+    }
+    async prepareGoogleProductPayload(ctx, product) {
+        return undefined;
+    }
+    async getBaseData(ctx, product) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        return [
+            {
+                communicateID: product.id,
+                variantID: (_b = (_a = product.variants) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.id,
+                customFields: product.customFields,
+                variants: undefined,
+                title: product.name,
+                description: product.description,
+                slug: product.slug,
+                asset: (_d = (_c = product.featuredAsset) === null || _c === void 0 ? void 0 : _c.preview) !== null && _d !== void 0 ? _d : (_g = (_f = (_e = product.assets) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.asset) === null || _g === void 0 ? void 0 : _g.preview,
+                price: (_j = (_h = product.variants) === null || _h === void 0 ? void 0 : _h[0]) === null || _j === void 0 ? void 0 : _j.priceWithTax,
+                currencyCode: (_l = (_k = product.variants) === null || _k === void 0 ? void 0 : _k[0]) === null || _l === void 0 ? void 0 : _l.currencyCode,
+                availability: ((_p = (_o = (_m = product.variants) === null || _m === void 0 ? void 0 : _m[0]) === null || _o === void 0 ? void 0 : _o.stockLevels) === null || _p === void 0 ? void 0 : _p[0].stockOnHand) > 0
+                    ? "in stock"
+                    : "out of stock",
+                colors: [],
+                mpn: (_r = (_q = product.variants) === null || _q === void 0 ? void 0 : _q[0]) === null || _r === void 0 ? void 0 : _r.sku,
+            },
+        ];
+    }
+}
+exports.DefaultMerchantExportStrategy = DefaultMerchantExportStrategy;

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

@@ -0,0 +1,29 @@
+import { InjectableStrategy, Product, RequestContext } from "@deenruv/core";
+import { content_v2_1 } from "googleapis";
+export type BaseData = {
+    communicateID: string;
+    variantID: string | number;
+};
+export type BaseProductData<T extends BaseData> = Array<T>;
+export type MerchantPluginOptions = {
+    strategy?: MerchantExportStrategy<BaseProductData<any>>;
+};
+export type GoogleProduct = Omit<content_v2_1.Schema$Product, "brand"> & BaseData;
+export type FacebookProduct = Record<string, unknown> & {
+    communicateID: string;
+    variantID: string | number;
+};
+export interface MerchantExportStrategy<T extends BaseProductData<any>> extends InjectableStrategy {
+    getBaseData: (ctx: RequestContext, product: Product) => Promise<T | undefined>;
+    prepareGoogleProductPayload: (ctx: RequestContext, data: T) => Promise<Array<GoogleProduct> | undefined>;
+    prepareFacebookProductPayload: (ctx: RequestContext, data: T) => Promise<Array<FacebookProduct> | undefined>;
+}
+declare module "@deenruv/core" {
+    interface CustomProductFields {
+        seoTitle: string | null;
+        seoDescription: string | null;
+    }
+    interface CustomProductVariantFields {
+        communicateID: string | null;
+    }
+}

package/dist/plugin-server/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,23 @@
+import { $, Selector } from "../zeus/index";
+import { typedGql } from "../zeus/typedDocumentNode";
+import { scalars } from "./scalars";
+
+const mutation = typedGql("mutation", { scalars });
+
+export const merchantPlatformSettingsSelector = Selector(
+  "MerchantPlatformSettingsEntity",
+)({
+  platform: true,
+  entries: { key: true, value: true },
+});
+
+export const saveMerchantPlatformSettings = mutation({
+  saveMerchantPlatformSettings: [
+    { input: $("input", "SaveMerchantPlatformSettingInput!") },
+    merchantPlatformSettingsSelector,
+  ],
+});
+
+export const removeOrphanItems = mutation({
+  removeOrphanItems: [{ platform: $("platform", "String!") }, true],
+});

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

@@ -0,0 +1,18 @@
+import { typedGql } from "../zeus/typedDocumentNode";
+import { scalars } from "./scalars";
+import { merchantPlatformSettingsSelector } from "./mutations";
+import { $ } from "../zeus/index";
+
+const query = typedGql("query", { scalars });
+export const getMerchantPlatformSettings = query({
+  getMerchantPlatformSettings: [
+    { platform: $("platform", "String!") },
+    merchantPlatformSettingsSelector,
+  ],
+});
+export const getMerchantPlatformInfo = query({
+  getMerchantPlatformInfo: [
+    { platform: $("platform", "String!") },
+    { isValidConnection: true, productsCount: true },
+  ],
+});

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

@@ -0,0 +1,12 @@
+import { ZeusScalars } from "../zeus/index";
+
+export const scalars = ZeusScalars({
+  DateTime: {
+    decode: (e: unknown) => new Date(e as string).toISOString(),
+    encode: (e: unknown) => (e as Date).toISOString(),
+  },
+  JSON: {
+    decode: (e: unknown) => JSON.parse(e as string),
+    encode: (e: unknown) => JSON.stringify(e),
+  },
+});