@deenruv/reviews-plugin 1.0.0

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

@@ -0,0 +1,366 @@
+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 __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;
+};
+import { CustomerService, EntityHydrator, EventBus, ListQueryBuilder, OrderService, ProductVariantService, TransactionalConnection, TranslatableSaver, TranslatorService, } from "@deenruv/core";
+import { Inject, Injectable, Logger } from "@nestjs/common";
+import { ReviewStateMachine } from "../state/reviews.state.js";
+import { ReviewEntity } from "../entities/review.entity.js";
+import { REVIEWS_PLUGIN_OPTIONS, ReviewState } from "../constants.js";
+import { ReviewEntityTranslation } from "../entities/review-translation.entity.js";
+import { GetObjectCommand, PutObjectCommand } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import ReviewChangeStateEvent from "../events.js";
+let ReviewsService = class ReviewsService {
+    constructor(options, connection, reviewStateMachine, productVariantService, orderService, translatableSaver, translatorService, customerServicer, listQueryBuilder, eventBus, entityHydrator) {
+        this.options = options;
+        this.connection = connection;
+        this.reviewStateMachine = reviewStateMachine;
+        this.productVariantService = productVariantService;
+        this.orderService = orderService;
+        this.translatableSaver = translatableSaver;
+        this.translatorService = translatorService;
+        this.customerServicer = customerServicer;
+        this.listQueryBuilder = listQueryBuilder;
+        this.eventBus = eventBus;
+        this.entityHydrator = entityHydrator;
+        this.logger = new Logger("ReviewsService");
+        this.error = this.logger.error.bind(this.logger);
+        this.log = this.logger.log.bind(this.logger);
+        this.translateStrategy = options.translateStrategy;
+        if (!this.translateStrategy)
+            this.canTranslate = false;
+        else
+            this.canTranslate = true;
+    }
+    async hasShopReviewCreated(ctx, customer) {
+        const qb = this.connection
+            .getRepository(ctx, ReviewEntity)
+            .createQueryBuilder("review");
+        qb.select("COUNT(review.id)", "count")
+            .where("review.authorId = :authorId", { authorId: customer.id })
+            .andWhere("review.productId IS NULL")
+            .andWhere("review.orderId IS NULL");
+        const result = await qb.getRawOne();
+        if (!result)
+            return false;
+        const count = parseInt(result.count, 10);
+        if (isNaN(count))
+            return false;
+        return count > 0;
+    }
+    async getAverageRatings(ctx) {
+        var _a, _b, _c, _d;
+        const reviewRepo = this.connection.getRepository(ctx, ReviewEntity);
+        const productQb = reviewRepo.createQueryBuilder("review");
+        productQb
+            .select("SUM(review.rating)", "total")
+            .addSelect("COUNT(review.rating)", "count")
+            .where("review.productId IS NOT NULL")
+            .andWhere("review.state = :state", { state: ReviewState.ACCEPTED });
+        const productResult = await productQb.getRawOne();
+        const shopQb = reviewRepo.createQueryBuilder("review");
+        shopQb
+            .select("SUM(review.rating)", "total")
+            .addSelect("COUNT(review.rating)", "count")
+            .where("review.productId IS NULL")
+            .andWhere("review.state = :state", { state: ReviewState.ACCEPTED });
+        const shopResult = await shopQb.getRawOne();
+        const productsAverageRating = {
+            total: parseInt((_a = productResult === null || productResult === void 0 ? void 0 : productResult.total) !== null && _a !== void 0 ? _a : "0", 10),
+            count: parseInt((_b = productResult === null || productResult === void 0 ? void 0 : productResult.count) !== null && _b !== void 0 ? _b : "0", 10),
+        };
+        const shopAverageRating = {
+            total: parseInt((_c = shopResult === null || shopResult === void 0 ? void 0 : shopResult.total) !== null && _c !== void 0 ? _c : "0", 10),
+            count: parseInt((_d = shopResult === null || shopResult === void 0 ? void 0 : shopResult.count) !== null && _d !== void 0 ? _d : "0", 10),
+        };
+        return { shopAverageRating, productsAverageRating };
+    }
+    async getOrderReview(ctx, order, relations) {
+        const review = await this.connection
+            .getRepository(ctx, ReviewEntity)
+            .findOne({ where: { order: { id: order.id } }, relations });
+        if (!review)
+            return null;
+        return this.translatorService.translate(review, ctx);
+    }
+    async isOrderReviewed(ctx, order) {
+        const qb = this.connection
+            .getRepository(ctx, ReviewEntity)
+            .createQueryBuilder("review");
+        qb.select("COUNT(review.id)", "count").where("review.orderId = :orderId", {
+            orderId: order.id,
+        });
+        const result = await qb.getRawOne();
+        if (!result)
+            return false;
+        const count = parseInt(result.count, 10);
+        if (isNaN(count))
+            return false;
+        return count > 0;
+    }
+    async getAverageRating(ctx, product) {
+        var _a;
+        const productId = product.id;
+        const qb = this.connection
+            .getRepository(ctx, ReviewEntity)
+            .createQueryBuilder("review");
+        qb.select("AVG(review.rating)", "averageRating")
+            .where("review.productId = :productId", { productId })
+            .andWhere("review.state = :state", { state: ReviewState.ACCEPTED });
+        const result = await qb.getRawOne();
+        const averageRating = (_a = result === null || result === void 0 ? void 0 : result.averageRating) !== null && _a !== void 0 ? _a : 0;
+        const value = parseFloat(averageRating);
+        return isNaN(value) ? 0 : value;
+    }
+    async translateReviews(ctx, input) {
+        if (!this.canTranslate || !this.translateStrategy) {
+            this.error("ReviewsService.translateReviews called, but translateStrategy is not set");
+            return [];
+        }
+        const { id, languages } = input;
+        const review = await this.connection.getEntityOrThrow(ctx, ReviewEntity, id, { relations: ["translations"] });
+        if (!review) {
+            this.error(`Review with id ${id} not found`);
+            return [];
+        }
+        return this.translateStrategy.translateReviews(ctx, review, languages);
+    }
+    async updateTranslationsReview(ctx, input) {
+        const { id, translations } = input;
+        const review = await this.connection.getEntityOrThrow(ctx, ReviewEntity, id, { relations: ["translations"] });
+        if (!review) {
+            this.error(`Review with id ${id} not found`);
+            return;
+        }
+        const existingTranslations = review.translations || [];
+        const updatedTranslations = existingTranslations.map((translation) => {
+            const newTranslation = translations.find((t) => t.languageCode === translation.languageCode);
+            if (newTranslation) {
+                return Object.assign(Object.assign({}, translation), { body: newTranslation.body });
+            }
+            return translation;
+        });
+        const newTranslations = translations
+            .filter((t) => !existingTranslations.some((et) => et.languageCode === t.languageCode))
+            .map((t) => ({
+            languageCode: t.languageCode,
+            body: t.body,
+        }));
+        const allTranslations = [...updatedTranslations, ...newTranslations];
+        if (allTranslations.length === 0) {
+            this.error(`No translations provided for review with id ${id}`);
+            return;
+        }
+        return this.translatableSaver.update({
+            ctx,
+            entityType: ReviewEntity,
+            translationType: ReviewEntityTranslation,
+            input: { id, translations: allTranslations },
+        });
+    }
+    async getReviewInfoForProduct(ctx, productId) {
+        const qb = this.connection
+            .getRepository(ctx, ReviewEntity)
+            .createQueryBuilder("review");
+        qb.select("AVG(review.rating)", "averageRating")
+            .addSelect("COUNT(review.id)", "totalReviews")
+            .addSelect("SUM(review.rating)", "totalRatings")
+            .where("review.productId = :productId", { productId })
+            .andWhere("review.state = :state", { state: ReviewState.ACCEPTED });
+        const result = await qb.getRawOne();
+        if (!result) {
+            return { averageRating: 0, totalReviews: 0, totalRatings: 0 };
+        }
+        return {
+            averageRating: parseFloat(result.averageRating) || 0,
+            totalReviews: parseInt(result.totalReviews, 10) || 0,
+            totalRatings: parseInt(result.totalRatings, 10) || 0,
+        };
+    }
+    async getReviewsConfig(ctx) {
+        const configFn = this.options.getReviewsConfig;
+        const emptyConfig = {
+            reviewsLanguages: [],
+            canTranslate: this.canTranslate,
+        };
+        if (typeof configFn !== "function") {
+            this.error("ReviewsPluginOptions.getReviewsConfig is not set or not a function, returning empty config");
+            return emptyConfig;
+        }
+        try {
+            const response = await configFn(ctx);
+            return Object.assign(Object.assign({}, response), { canTranslate: this.canTranslate });
+        }
+        catch (e) {
+            this.error(`Error while executing ReviewsPluginOptions.getReviewsConfig: ${e instanceof Error ? e.message : "Unknown error"}`);
+            return emptyConfig;
+        }
+    }
+    async getReview(ctx, id, relations) {
+        const review = await this.connection.getEntityOrThrow(ctx, ReviewEntity, id, { relations });
+        return this.translatorService.translate(review, ctx);
+    }
+    async changeReviewState(ctx, input) {
+        const response = [];
+        for (let _a of input) {
+            const { id } = _a, rest = __rest(_a, ["id"]);
+            const review = await this.connection.getEntityOrThrow(ctx, ReviewEntity, id);
+            const { finalize } = await this.reviewStateMachine.transition(ctx, review, rest);
+            await this.connection.getRepository(ctx, ReviewEntity).save(review);
+            await finalize();
+            await this.eventBus.publish(new ReviewChangeStateEvent(ctx, review, review.state, rest.state, rest.message));
+            response.push({ id, success: true });
+        }
+        return response.length === 1 ? response[0] : response;
+    }
+    async listReviews(ctx, _options, relations, showAll = false) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const options = (_options || {});
+        const where = ctx.apiType !== "admin"
+            ? showAll
+                ? {}
+                : { state: ReviewState.ACCEPTED }
+            : {};
+        const qb = this.listQueryBuilder.build(ReviewEntity, options, {
+            ctx,
+            where,
+            relations,
+            customPropertyMap: {
+                productId: "product.id",
+                orderId: "order.id",
+                customerId: "author.id",
+            },
+        });
+        qb.addOrderBy("reviewentity.createdAt", "DESC");
+        qb.leftJoin("reviewentity.product", "product");
+        qb.leftJoin("product.channels", "productChannel");
+        qb.leftJoin("reviewentity.order", "order");
+        qb.leftJoin("order.channels", "orderChannel");
+        qb.andWhere(`(
+      (product.id IS NOT NULL AND productChannel.id = :channelId)
+      OR
+      (order.id IS NOT NULL AND orderChannel.id = :channelId)
+      OR
+      (product.id IS NULL AND order.id IS NULL)
+    )`, { channelId: ctx.channelId });
+        const [items, totalItems] = await qb.getManyAndCount();
+        const reviews = items.map((item) => this.translatorService.translate(item, ctx));
+        return { items: reviews, totalItems };
+    }
+    async createReview(ctx, input) {
+        const { productVariantId, orderId, rating, uploadedAssets, authorLocation, authorName, authorEmailAddress, keepAnonymous } = input, translations = __rest(input, ["productVariantId", "orderId", "rating", "uploadedAssets", "authorLocation", "authorName", "authorEmailAddress", "keepAnonymous"]);
+        let variant = undefined;
+        if (productVariantId) {
+            variant = await this.productVariantService.findOne(ctx, productVariantId, ["product"]);
+        }
+        return this.translatableSaver.create({
+            ctx,
+            entityType: ReviewEntity,
+            translationType: ReviewEntityTranslation,
+            input: {
+                translations: [Object.assign({ languageCode: ctx.languageCode }, translations)],
+            },
+            beforeSave: async (review) => {
+                review.authorName = authorName || "";
+                review.authorLocation = authorLocation || "";
+                review.authorEmailAddress = authorEmailAddress || "";
+                review.keepAnonymous = keepAnonymous || false;
+                review.rating = rating;
+                if (variant) {
+                    review.productVariant = variant;
+                    if (variant.product)
+                        review.product = variant.product;
+                }
+                if (orderId) {
+                    const order = await this.orderService.findOne(ctx, orderId, []);
+                    if (order) {
+                        review.order = order;
+                        if (order.customer)
+                            review.author = order.customer;
+                    }
+                }
+                if (uploadedAssets) {
+                    const filteredAssets = uploadedAssets.filter((asset) => !!asset && asset.length > 0);
+                    review.assetKeys = filteredAssets;
+                }
+                if (ctx.activeUserId && !review.author) {
+                    // If the review is being created by an authenticated user, we can set the author
+                    const customer = await this.customerServicer.findOneByUserId(ctx, ctx.activeUserId);
+                    if (customer) {
+                        await this.entityHydrator.hydrate(ctx, customer, {
+                            relations: ["addresses"],
+                        });
+                        review.author = customer;
+                    }
+                }
+            },
+        });
+    }
+    async getReviewsStorage(ctx, input) {
+        const { bucket, client, folder } = this.options.s3;
+        const results = [];
+        for (const { filename } of input) {
+            const timestamp = new Date().getTime();
+            const [name, ext] = filename.split(".");
+            const hash = [
+                timestamp,
+                name.replace(/[^a-z0-9]/gi, "_").toLowerCase(),
+                ext,
+            ].join("-");
+            const key = [folder, hash].join("/");
+            const command = new PutObjectCommand({ Bucket: bucket, Key: key });
+            const url = await getSignedUrl(client, command);
+            results.push({ key, url });
+        }
+        return results;
+    }
+    async getReviewAssets(ctx, review) {
+        const keys = review.assetKeys || [];
+        if (keys.length > 0) {
+            const { bucket, client } = this.options.s3;
+            const results = [];
+            for (const key of keys) {
+                const command = new GetObjectCommand({ Bucket: bucket, Key: key });
+                const url = await getSignedUrl(client, command);
+                results.push({ key, url });
+            }
+            return results;
+        }
+        return [];
+    }
+};
+ReviewsService = __decorate([
+    Injectable(),
+    __param(0, Inject(REVIEWS_PLUGIN_OPTIONS)),
+    __metadata("design:paramtypes", [Object, TransactionalConnection,
+        ReviewStateMachine,
+        ProductVariantService,
+        OrderService,
+        TranslatableSaver,
+        TranslatorService,
+        CustomerService,
+        ListQueryBuilder,
+        EventBus,
+        EntityHydrator])
+], ReviewsService);
+export { ReviewsService };

package/dist/plugin-server/state/reviews.state.d.ts

@@ -0,0 +1,16 @@
+import { RequestContext } from "@deenruv/core";
+import { ReviewState } from "../constants.js";
+import { ReviewEntity } from "../entities/review.entity.js";
+type ChangeReviewStateInput = {
+    state: ReviewState;
+    message?: string;
+};
+export declare class ReviewStateMachine {
+    constructor();
+    private readonly config;
+    getNextStates(review: ReviewEntity): readonly ReviewState[];
+    transition(ctx: RequestContext, review: ReviewEntity, { state, ...rest }: ChangeReviewStateInput): Promise<{
+        finalize: () => Promise<any>;
+    }>;
+}
+export {};

package/dist/plugin-server/state/reviews.state.js

@@ -0,0 +1,63 @@
+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 __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;
+};
+import { Injectable } from "@nestjs/common";
+import { FSM, } from "@deenruv/core";
+import { ReviewState } from "../constants.js";
+const transitions = {
+    ACCEPTED: { to: [ReviewState.DECLINED] },
+    DECLINED: { to: [ReviewState.ACCEPTED] },
+    PENDING: { to: [ReviewState.ACCEPTED, ReviewState.DECLINED] },
+};
+let ReviewStateMachine = class ReviewStateMachine {
+    constructor() {
+        this.config = {
+            transitions,
+            onTransitionStart: async (fromState, toState, { ctx, review, message }) => {
+                if ([ReviewState.ACCEPTED, ReviewState.DECLINED].includes(toState)) {
+                    review.responseCreatedAt = new Date();
+                    review.response = message;
+                    if (ctx.activeUserId) {
+                        // we need only id to make proper relation
+                        //eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        review.responseAuthor = { id: ctx.activeUserId };
+                    }
+                }
+            },
+        };
+    }
+    getNextStates(review) {
+        const fsm = new FSM(this.config, review.state);
+        return fsm.getNextStates();
+    }
+    async transition(ctx, review, _a) {
+        var { state } = _a, rest = __rest(_a, ["state"]);
+        const fsm = new FSM(this.config, review.state);
+        const result = await fsm.transitionTo(state, Object.assign({ ctx,
+            review }, rest));
+        review.state = state;
+        return result;
+    }
+};
+ReviewStateMachine = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [])
+], ReviewStateMachine);
+export { ReviewStateMachine };

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

@@ -0,0 +1,33 @@
+import { S3Client } from "@aws-sdk/client-s3";
+import { ID, InjectableStrategy, RequestContext } from "@deenruv/core";
+import { ReviewEntity } from "./entities/review.entity.js";
+import { LanguageCode } from "./zeus/index.js";
+export interface TranslateReviewStrategy extends InjectableStrategy {
+    translateReviews: (ctx: RequestContext, review: ReviewEntity, languageCodes: LanguageCode[]) => Promise<Array<{
+        languageCode: LanguageCode;
+        body: string;
+        summary: string;
+    }>>;
+}
+export type ReviewsPluginOptions = {
+    s3: {
+        bucket: string;
+        client: S3Client;
+        folder: string;
+    };
+    getReviewsConfig: (ctx: RequestContext) => Promise<{
+        reviewsLanguages: string[];
+    }>;
+    translateStrategy?: TranslateReviewStrategy;
+};
+export type CreateReviewInput = {
+    body: string;
+    rating: number;
+    keepAnonymous: boolean;
+    orderId?: ID;
+    productVariantId?: ID;
+    uploadedAssets?: string[];
+    authorName?: string;
+    authorLocation?: string;
+    authorEmailAddress?: string;
+};

package/dist/plugin-server/types.js

@@ -0,0 +1 @@
+export {};

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";
+};