@deenruv/replicate-plugin 1.0.0

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

@@ -0,0 +1,5 @@
+import { ReplicatePluginOptions } from "./types.js";
+export declare class ReplicatePlugin {
+    private static options;
+    static init(options: ReplicatePluginOptions): typeof ReplicatePlugin;
+}

package/dist/plugin-server/index.js

@@ -0,0 +1,42 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplicatePlugin = void 0;
+const core_1 = require("@deenruv/core");
+const replicate_admin_resolver_js_1 = require("./resolvers/replicate-admin.resolver.js");
+const replicate_service_js_1 = require("./services/replicate.service.js");
+const replicate_js_1 = require("./controllers/replicate.js");
+const constants_js_1 = require("./constants.js");
+const replicate_extension_js_1 = require("./extensions/replicate.extension.js");
+const replicate_entity_js_1 = require("./entites/replicate.entity.js");
+let ReplicatePlugin = class ReplicatePlugin {
+    static init(options) {
+        this.options = options;
+        return this;
+    }
+};
+exports.ReplicatePlugin = ReplicatePlugin;
+exports.ReplicatePlugin = ReplicatePlugin = __decorate([
+    (0, core_1.DeenruvPlugin)({
+        compatibility: "^0.0.20",
+        imports: [core_1.PluginCommonModule],
+        entities: [replicate_entity_js_1.ReplicateEntity],
+        providers: [
+            {
+                provide: constants_js_1.REPLICATE_PLUGIN_OPTIONS,
+                useFactory: () => ReplicatePlugin.options,
+            },
+            replicate_service_js_1.ReplicateService,
+        ],
+        controllers: [replicate_js_1.ReplicateController],
+        adminApiExtensions: {
+            schema: replicate_extension_js_1.AdminExtension,
+            resolvers: [replicate_admin_resolver_js_1.ReplicateAdminResolver],
+        },
+    })
+], ReplicatePlugin);

package/dist/plugin-server/resolvers/replicate-admin.resolver.d.ts

@@ -0,0 +1,35 @@
+import { ReplicateService } from "../services/replicate.service.js";
+import { RequestContext, Customer } from "@deenruv/core";
+import { StartOrderExportToReplicateInput } from "../graphql/generated-admin-types.js";
+export declare class ReplicateAdminResolver {
+    private replicateService;
+    constructor(replicateService: ReplicateService);
+    startModelTraining({ input, }: {
+        input: {
+            numLastOrder: number;
+            startDate: string;
+            endDate: string;
+        };
+    }, ctx: RequestContext): Promise<string>;
+    startOrderExportToReplicate({ input }: {
+        input: StartOrderExportToReplicateInput;
+    }, ctx: RequestContext): Promise<import("@deenruv/core").ID>;
+    getPredictionID(ctx: RequestContext, { input }: {
+        input: {
+            prediction_entity_id: string;
+        };
+    }): Promise<string | undefined>;
+    getReplicatePredictions(ctx: RequestContext, { options }: {
+        options: any;
+    }): Promise<import("@deenruv/core").PaginatedList<import("../entites/replicate.entity.js").ReplicateEntity>>;
+    getPredictionItem(ctx: RequestContext, { id }: {
+        id: string;
+    }): Promise<{
+        status: string;
+        predictions: {
+            id: import("@deenruv/core").ID;
+            score: number;
+            customer: Customer | null;
+        }[];
+    }>;
+}

package/dist/plugin-server/resolvers/replicate-admin.resolver.js

@@ -0,0 +1,84 @@
+"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.ReplicateAdminResolver = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const replicate_service_js_1 = require("../services/replicate.service.js");
+const core_1 = require("@deenruv/core");
+let ReplicateAdminResolver = class ReplicateAdminResolver {
+    constructor(replicateService) {
+        this.replicateService = replicateService;
+    }
+    async startModelTraining({ input, }, ctx) {
+        await this.replicateService.modelTrainingJob(ctx, input);
+        return "model training done";
+    }
+    async startOrderExportToReplicate({ input }, ctx) {
+        return this.replicateService.orderExportJob(ctx, input);
+    }
+    async getPredictionID(ctx, { input }) {
+        return this.replicateService.getPredictionID(ctx, input.prediction_entity_id);
+    }
+    async getReplicatePredictions(ctx, { options }) {
+        return this.replicateService.getPredictionItems(ctx, options);
+    }
+    async getPredictionItem(ctx, { id }) {
+        return this.replicateService.getPredictionItem(ctx, id);
+    }
+};
+exports.ReplicateAdminResolver = ReplicateAdminResolver;
+__decorate([
+    (0, graphql_1.Mutation)(),
+    __param(0, (0, graphql_1.Args)()),
+    __param(1, (0, core_1.Ctx)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, core_1.RequestContext]),
+    __metadata("design:returntype", Promise)
+], ReplicateAdminResolver.prototype, "startModelTraining", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    __param(0, (0, graphql_1.Args)()),
+    __param(1, (0, core_1.Ctx)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, core_1.RequestContext]),
+    __metadata("design:returntype", Promise)
+], ReplicateAdminResolver.prototype, "startOrderExportToReplicate", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], ReplicateAdminResolver.prototype, "getPredictionID", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], ReplicateAdminResolver.prototype, "getReplicatePredictions", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], ReplicateAdminResolver.prototype, "getPredictionItem", null);
+exports.ReplicateAdminResolver = ReplicateAdminResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [replicate_service_js_1.ReplicateService])
+], ReplicateAdminResolver);

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

@@ -0,0 +1,43 @@
+import { OnModuleInit } from "@nestjs/common";
+import { ReplicatePluginOptions, ModelTrainingQueueType, OrderExportQueueType } from "../types.js";
+import { Job, JobQueueService, RequestContext, OrderService, PaginatedList, CustomerService, TransactionalConnection, ID, Customer, ListQueryBuilder, ListQueryOptions } from "@deenruv/core";
+import { StartOrderExportToReplicateInput } from "../graphql/generated-admin-types.js";
+import { ReplicateEntity } from "../entites/replicate.entity.js";
+import { PredictionStatus } from "../zeus/index.js";
+export declare class ReplicateService implements OnModuleInit {
+    private readonly options;
+    private readonly connection;
+    private readonly jobQueueService;
+    private readonly orderService;
+    private readonly customerService;
+    private readonly listQueryBuilder;
+    private modelTrainingQueue;
+    private orderExportQueue;
+    constructor(options: ReplicatePluginOptions, connection: TransactionalConnection, jobQueueService: JobQueueService, orderService: OrderService, customerService: CustomerService, listQueryBuilder: ListQueryBuilder);
+    processModelTrainingJob(job: Job<ModelTrainingQueueType>): Promise<void>;
+    processOrderExportJob(job: Job<OrderExportQueueType>): Promise<void>;
+    modelTrainingJob(ctx: RequestContext, input: any): Promise<void>;
+    getPredictionID(ctx: RequestContext, prediction_id: string): Promise<string | undefined>;
+    orderExportJob(ctx: RequestContext, input: StartOrderExportToReplicateInput): Promise<ID>;
+    onModuleInit(): Promise<void>;
+    startModelTraining(ctx: RequestContext, input: any): Promise<void>;
+    startOrderExportJob(ctx: RequestContext, input: StartOrderExportToReplicateInput & {
+        replicateEntityID: ID;
+    }): Promise<void>;
+    private randomDate;
+    private saveOrdersToCsv;
+    private triggerPredictApi;
+    checkAndUpdatePredictionStatus(ctx: RequestContext, prediction_id: string): Promise<{
+        predictions: never[];
+        status: PredictionStatus;
+    } | undefined>;
+    getPredictionItems(ctx: RequestContext, options?: ListQueryOptions<ReplicateEntity>): Promise<PaginatedList<ReplicateEntity>>;
+    getPredictionItem(ctx: RequestContext, id: string): Promise<{
+        status: string;
+        predictions: {
+            id: ID;
+            score: number;
+            customer: Customer | null;
+        }[];
+    }>;
+}

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

@@ -0,0 +1,389 @@
+"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); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplicateService = void 0;
+const common_1 = require("@nestjs/common");
+const constants_js_1 = require("../constants.js");
+const core_1 = require("@deenruv/core");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const axios_1 = __importDefault(require("axios"));
+const generated_admin_types_js_1 = require("../graphql/generated-admin-types.js");
+const generated_types_js_1 = require("@deenruv/common/lib/generated-types.js");
+const promises_1 = require("fs/promises");
+const replicate_entity_js_1 = require("../entites/replicate.entity.js");
+const index_js_1 = require("../zeus/index.js");
+const typeorm_1 = require("typeorm");
+let ReplicateService = class ReplicateService {
+    constructor(options, connection, jobQueueService, orderService, customerService, listQueryBuilder) {
+        this.options = options;
+        this.connection = connection;
+        this.jobQueueService = jobQueueService;
+        this.orderService = orderService;
+        this.customerService = customerService;
+        this.listQueryBuilder = listQueryBuilder;
+    }
+    async processModelTrainingJob(job) {
+        core_1.Logger.info("initializing model training", constants_js_1.LOGGER_CTX);
+        const { serializedContext, startDate, endDate } = job.data;
+        const ctx = core_1.RequestContext.deserialize(serializedContext);
+        await this.startModelTraining(ctx, { startDate, endDate });
+        this.jobQueueService.start();
+    }
+    async processOrderExportJob(job) {
+        core_1.Logger.info("initializing order export", constants_js_1.LOGGER_CTX);
+        const { replicateEntityID, serializedContext, startDate, endDate, showMetrics, } = job.data;
+        const ctx = core_1.RequestContext.deserialize(serializedContext);
+        await this.startOrderExportJob(ctx, {
+            replicateEntityID,
+            startDate,
+            endDate,
+            showMetrics,
+        });
+        this.jobQueueService.start();
+    }
+    async modelTrainingJob(ctx, input) {
+        var _a, _b, _c;
+        const serializedContext = ctx.serialize();
+        await this.modelTrainingQueue.add({
+            serializedContext,
+            numLastOrder: (_a = input.numLastOrder) !== null && _a !== void 0 ? _a : 30000,
+            startDate: (_b = input.startDate) !== null && _b !== void 0 ? _b : "",
+            endDate: (_c = input.endDate) !== null && _c !== void 0 ? _c : "",
+        });
+    }
+    async getPredictionID(ctx, prediction_id) {
+        const entity = await this.connection
+            .getRepository(ctx, replicate_entity_js_1.ReplicateEntity)
+            .findOne({
+            where: { id: prediction_id },
+        });
+        return entity === null || entity === void 0 ? void 0 : entity.prediction_id;
+    }
+    async orderExportJob(ctx, input) {
+        var _a, _b, _c, _d;
+        const entity = await this.connection
+            .getRepository(ctx, replicate_entity_js_1.ReplicateEntity)
+            .save({});
+        const serializedContext = ctx.serialize();
+        await this.orderExportQueue.add({
+            replicateEntityID: entity.id,
+            serializedContext,
+            startDate: (_a = input.startDate) !== null && _a !== void 0 ? _a : "",
+            endDate: (_b = input.endDate) !== null && _b !== void 0 ? _b : "",
+            predictType: (_c = input.predictType) !== null && _c !== void 0 ? _c : generated_admin_types_js_1.PredictionType.RFM_SCORE,
+            showMetrics: (_d = input.showMetrics) !== null && _d !== void 0 ? _d : false,
+        });
+        return entity.id;
+    }
+    async onModuleInit() {
+        this.modelTrainingQueue = await this.jobQueueService.createQueue({
+            name: "train-model",
+            process: (job) => {
+                return this.processModelTrainingJob(job);
+            },
+        });
+        this.orderExportQueue = await this.jobQueueService.createQueue({
+            name: "order-export",
+            process: (job) => {
+                return this.processOrderExportJob(job);
+            },
+        });
+    }
+    async startModelTraining(ctx, input) {
+        try {
+            const { numLastOrder } = input;
+            const customerService = this.customerService;
+            const orderService = this.orderService;
+            for (let i = 0; i < (numLastOrder !== null && numLastOrder !== void 0 ? numLastOrder : 30000); i++) {
+                const uniqueEmail = `test${i}_${Date.now()}@example.com`;
+                const customer = await customerService.create(ctx, {
+                    emailAddress: uniqueEmail,
+                    firstName: "test",
+                    lastName: "replicatetest",
+                    phoneNumber: "123456789",
+                    title: "Mr",
+                });
+                if ("errorCode" in customer) {
+                    core_1.Logger.error(`Failed to create customer: ${customer.errorCode}`, constants_js_1.LOGGER_CTX);
+                    continue;
+                }
+                const randomNumber = Math.floor(Math.random() * 7) + 1;
+                for (let j = 0; j < randomNumber; j++) {
+                    const order = await orderService.addCustomerToOrder(ctx, await orderService.create(ctx, 1), customer);
+                    const itemsToAdd = Math.floor(Math.random() * 5) + 1;
+                    await orderService.addItemToOrder(ctx, order.id, 1, itemsToAdd);
+                    await orderService.transitionToState(ctx, order.id, "AddingItems");
+                    await orderService.setShippingAddress(ctx, order.id, {
+                        streetLine1: "test",
+                        countryCode: "PL",
+                    });
+                    await orderService.setShippingMethod(ctx, order.id, [1, 2]);
+                    await orderService.transitionToState(ctx, order.id, "ArrangingPayment");
+                    await orderService.addPaymentToOrder(ctx, order.id, {
+                        method: "standard-payment",
+                        metadata: {
+                            transfer_group: "",
+                        },
+                    });
+                    await orderService.transitionToState(ctx, order.id, "PaymentAuthorized");
+                }
+            }
+        }
+        catch (error) {
+            core_1.Logger.error("model training failed", constants_js_1.LOGGER_CTX);
+            console.error("Error:", error);
+        }
+    }
+    async startOrderExportJob(ctx, input) {
+        const { showMetrics, replicateEntityID } = input;
+        let { startDate, endDate, predictType } = input;
+        startDate = startDate || null;
+        endDate = endDate || null;
+        predictType = predictType !== null && predictType !== void 0 ? predictType : generated_admin_types_js_1.PredictionType.RFM_SCORE;
+        core_1.Logger.info("starting order export", constants_js_1.LOGGER_CTX);
+        const columnNames = [
+            "InvoiceNo",
+            "InvoiceDate",
+            "Total",
+            "CustomerId",
+            "Products",
+        ];
+        const csv = [columnNames.join(",")];
+        const LatestOrders = await this.orderService.findAll(ctx, {
+            filter: {
+                orderPlacedAt: startDate && endDate
+                    ? {
+                        between: {
+                            start: new Date(startDate),
+                            end: new Date(endDate),
+                        },
+                    }
+                    : { isNull: false },
+            },
+        });
+        const numLatestOrders = LatestOrders.totalItems;
+        let batch = 1;
+        if (numLatestOrders > 1000) {
+            batch = Math.ceil(numLatestOrders / 1000);
+        }
+        for (let i = 0; i < batch; i++) {
+            const orders = await this.orderService.findAll(ctx, {
+                skip: i * 1000,
+                take: 1000,
+                filter: {
+                    orderPlacedAt: startDate && endDate
+                        ? {
+                            between: {
+                                start: new Date(startDate),
+                                end: new Date(endDate),
+                            },
+                        }
+                        : { isNull: false },
+                },
+                sort: {
+                    orderPlacedAt: generated_types_js_1.SortOrder.DESC,
+                },
+            });
+            if (!orders.items.length)
+                break;
+            await this.saveOrdersToCsv(csv, orders);
+        }
+        const csvString = csv.join("\n");
+        const tmp = await (0, promises_1.mkdtemp)("orders");
+        const filePath = path_1.default.join(tmp, "./orders.csv");
+        fs_1.default.writeFileSync(filePath, csvString);
+        core_1.Logger.info("order export completed", constants_js_1.LOGGER_CTX);
+        const result = await this.triggerPredictApi(filePath, predictType, showMetrics || false);
+        if (!result) {
+            throw new Error("Failed to trigger predict API");
+        }
+        const { prediction_id, status } = result;
+        await this.connection
+            .getRepository(ctx, replicate_entity_js_1.ReplicateEntity)
+            .update({ id: replicateEntityID, status: status }, { prediction_id, status });
+        await (0, promises_1.rm)(tmp, { recursive: true, force: true });
+    }
+    async randomDate(start, end, startHour, endHour) {
+        const date = new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
+        const hour = (startHour + Math.random() * (endHour - startHour)) | 0;
+        date.setHours(hour);
+        return date;
+    }
+    async saveOrdersToCsv(csv, orders) {
+        const orderData = await Promise.all(orders.items.map(async (order) => {
+            var _a;
+            return [
+                order.id,
+                ((_a = order.orderPlacedAt) !== null && _a !== void 0 ? _a : (await this.randomDate(new Date(2024, 1, 1), new Date(2025, 1, 1), 0, 23))).toISOString(),
+                order.totalWithTax,
+                order.customerId,
+                "ALL",
+            ].join(",");
+        }));
+        csv.push(...orderData);
+    }
+    async triggerPredictApi(filePath, predictType, showMetrics) {
+        try {
+            const fileData = await fs_1.default.promises.readFile(filePath);
+            const base64Data = fileData.toString("base64");
+            const fileInput = `data:text/csv;base64,${base64Data}`;
+            let replicatePredictType = "";
+            if (predictType === generated_admin_types_js_1.PredictionType.RFM_SCORE)
+                replicatePredictType = "rfm-score";
+            if (predictType === generated_admin_types_js_1.PredictionType.SEGMENTATION)
+                replicatePredictType = "segmentation";
+            if (!this.options.deploymentName === undefined) {
+                throw new Error("Replicate: deployment name token not set");
+            }
+            if (!this.options.apiToken === undefined) {
+                throw new Error("Replicate: API token not set");
+            }
+            const response = await axios_1.default.post(`https://api.replicate.com/v1/deployments/aexol-studio/${this.options.deploymentName}/predictions`, {
+                input: {
+                    data_path: fileInput,
+                    predict_type: replicatePredictType,
+                    show_metrics: showMetrics,
+                },
+            }, {
+                headers: {
+                    Authorization: `Bearer ${this.options.apiToken}`,
+                    "Content-Type": `application/json`,
+                },
+            });
+            return { prediction_id: response.data.id, status: response.data.status };
+        }
+        catch (error) {
+            core_1.Logger.error("API call to replicate failed", constants_js_1.LOGGER_CTX);
+            console.error("Error:", error);
+        }
+    }
+    async checkAndUpdatePredictionStatus(ctx, prediction_id) {
+        var _a, _b;
+        try {
+            const response = await axios_1.default.get(`https://api.replicate.com/v1/predictions/${prediction_id}`, {
+                headers: {
+                    Authorization: `Bearer ${this.options.apiToken}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            const status = response.data.status;
+            let outputDict = {};
+            if ((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.error) {
+                await this.connection.getRepository(ctx, replicate_entity_js_1.ReplicateEntity).update({ prediction_id }, {
+                    status: index_js_1.PredictionStatus.failed,
+                    finishedAt: response.data.completed_at,
+                });
+                return { predictions: [], status: index_js_1.PredictionStatus.failed };
+            }
+            try {
+                outputDict = JSON.parse(((_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.output) || "{}");
+            }
+            catch (error) {
+                core_1.Logger.error("Failed to parse output", constants_js_1.LOGGER_CTX);
+            }
+            const data = [];
+            for (const key in outputDict) {
+                data.push([key, outputDict[key]]);
+            }
+            data.sort(([_1, ascore], [_2, bscore]) => bscore - ascore);
+            const predictions = [];
+            for (let i = 0; i < data.length; i += 100) {
+                const view = data.slice(i, Math.max(i + 100, data.length));
+                const res = await this.connection.getRepository(ctx, core_1.Customer).find({
+                    where: {
+                        id: (0, typeorm_1.In)(view.map(([id]) => parseInt(id))),
+                    },
+                });
+                predictions.push(...view
+                    .map(([id, score]) => {
+                    const customer = res.find((r) => +r.id === +id);
+                    if (!(customer === null || customer === void 0 ? void 0 : customer.emailAddress)) {
+                        return null;
+                    }
+                    return {
+                        id,
+                        score,
+                        customer: res.find((r) => +r.id === +id),
+                    };
+                })
+                    .filter((x) => !!x));
+            }
+            const output = predictions.map(({ customer, score }) => ({
+                customerId: customer === null || customer === void 0 ? void 0 : customer.id,
+                score,
+                customer,
+            }));
+            if (status !== "starting" && response.data.output) {
+                await this.connection.getRepository(ctx, replicate_entity_js_1.ReplicateEntity).update({ prediction_id }, {
+                    output: output,
+                    status: status,
+                    finishedAt: response.data.completed_at,
+                });
+            }
+        }
+        catch (error) {
+            core_1.Logger.error("API call to check and update prediction status failed", constants_js_1.LOGGER_CTX);
+            console.error("Error:", error);
+        }
+    }
+    async getPredictionItems(ctx, options) {
+        const qb = this.listQueryBuilder.build(replicate_entity_js_1.ReplicateEntity, options, { ctx });
+        const [items, totalItems] = await qb.getManyAndCount();
+        return { items, totalItems };
+    }
+    async getPredictionItem(ctx, id) {
+        const prediction = await this.connection
+            .getRepository(ctx, replicate_entity_js_1.ReplicateEntity)
+            .findOne({ where: { id } });
+        if (!prediction) {
+            throw new Error("Prediction not found");
+        }
+        if (prediction.status === index_js_1.PredictionStatus.starting) {
+            await this.checkAndUpdatePredictionStatus(ctx, prediction.prediction_id.toString());
+        }
+        if (prediction.output) {
+            const output = await Promise.all(prediction.output.map(async ({ customerId, score }) => {
+                const customer = await this.connection
+                    .getRepository(ctx, core_1.Customer)
+                    .findOne({ where: { id: customerId } });
+                return {
+                    id: customerId,
+                    score,
+                    customer,
+                };
+            }));
+            return { status: prediction.status, predictions: output };
+        }
+        return { status: prediction.status, predictions: [] };
+    }
+};
+exports.ReplicateService = ReplicateService;
+exports.ReplicateService = ReplicateService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_js_1.REPLICATE_PLUGIN_OPTIONS)),
+    __param(1, (0, common_1.Inject)(core_1.TransactionalConnection)),
+    __param(2, (0, common_1.Inject)(core_1.JobQueueService)),
+    __param(3, (0, common_1.Inject)(core_1.OrderService)),
+    __param(4, (0, common_1.Inject)(core_1.CustomerService)),
+    __param(5, (0, common_1.Inject)(core_1.ListQueryBuilder)),
+    __metadata("design:paramtypes", [Object, core_1.TransactionalConnection,
+        core_1.JobQueueService,
+        core_1.OrderService,
+        core_1.CustomerService,
+        core_1.ListQueryBuilder])
+], ReplicateService);

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

@@ -0,0 +1,19 @@
+import { ID, SerializedRequestContext } from "@deenruv/core";
+export interface ReplicatePluginOptions {
+    deploymentName: string;
+    apiToken: string;
+}
+export interface ModelTrainingQueueType {
+    serializedContext: SerializedRequestContext;
+    numLastOrder: number;
+    startDate: string;
+    endDate: string;
+}
+export interface OrderExportQueueType {
+    serializedContext: SerializedRequestContext;
+    startDate: string;
+    endDate: string;
+    predictType: string;
+    showMetrics: boolean;
+    replicateEntityID: ID;
+}

package/dist/plugin-server/types.js

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

package/dist/plugin-server/zeus/const.d.ts

@@ -0,0 +1,6 @@
+export declare const AllTypesProps: Record<string, any>;
+export declare const ReturnTypes: Record<string, any>;
+export declare const Ops: {
+    query: "Query";
+    mutation: "Mutation";
+};