@etohq/review 0.0.0-stage → 2.1.0

package/dist/services/review-module-service.js

@@ -0,0 +1,784 @@
+"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 });
+const utils_1 = require("@etohq/framework/utils");
+const review_1 = require("@etohq/utils/review");
+const _models_1 = require("../models");
+const generateMethodForModels = { Review: _models_1.Review, ReviewRevision: _models_1.ReviewRevision, ReviewFlag: _models_1.ReviewFlag, ReviewSummary: _models_1.ReviewSummary };
+/** A clock skew allowance for `occurred_at` from a phone. */
+const FUTURE_SKEW_MS = 5 * 60 * 1000;
+const LIVE_STATUSES = ["pending", "published", "hidden"];
+/**
+ * The review engine.
+ *
+ * Every invariant in DESIGN.md is enforced here or by an index. Eligibility —
+ * whether the reviewer really took part — is the consumer's, attested on the
+ * input (`verified`, `eligible_until`) and composed by the consumer's flow ahead
+ * of the canonical workflows.
+ */
+class ReviewModuleService extends utils_1.ModulesSdkUtils.EtoService(generateMethodForModels) {
+    constructor(dependencies) {
+        // @ts-ignore
+        super(...arguments);
+        this.baseRepository_ = dependencies.baseRepository;
+        this.reviewService_ = dependencies.reviewService;
+        this.reviewRevisionService_ = dependencies.reviewRevisionService;
+        this.reviewFlagService_ = dependencies.reviewFlagService;
+        this.reviewSummaryService_ = dependencies.reviewSummaryService;
+    }
+    // ===== SUBMIT =====
+    async submitReview(data, sharedContext = {}) {
+        const { review, replayed, revealed_ids, events } = await this.submitReview_(data, sharedContext);
+        this.emit_(events, sharedContext);
+        return {
+            review: await this.baseRepository_.serialize(review),
+            replayed,
+            revealed_ids,
+        };
+    }
+    async submitReview_(data, sharedContext = {}) {
+        requireText(data.space_id, "space_id");
+        requireRef(data.subject, "subject");
+        requireRef(data.reviewer, "reviewer");
+        requireRef(data.context, "context");
+        if (sameRef(data.reviewer, data.subject)) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_ALLOWED, "Nobody may review themselves");
+        }
+        if (data.subject_owner_id && data.subject_owner_id === data.reviewer.id) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_ALLOWED, "Nobody may review something they own");
+        }
+        const problems = (0, review_1.reviewContentProblems)(data);
+        const display = (0, review_1.cleanReviewText)(data.reviewer_display);
+        if (display && display.length > review_1.REVIEW_LIMITS.display) {
+            problems.push(`reviewer name is longer than ${review_1.REVIEW_LIMITS.display} characters`);
+        }
+        if (problems.length) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, problems.join("; "));
+        }
+        const now = new Date();
+        const occurred = actTime(data.occurred_at, now);
+        const eligibleUntil = toDate(data.eligible_until, "eligible_until");
+        if (eligibleUntil && occurred > eligibleUntil) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_ALLOWED, "The time to review this has passed");
+        }
+        const content = {
+            rating: data.rating,
+            dimensions: data.dimensions ?? null,
+            tags: data.tags?.length ? data.tags : null,
+            title: (0, review_1.cleanReviewText)(data.title),
+            body: (0, review_1.cleanReviewText)(data.body),
+            media: data.media?.length ? data.media : null,
+        };
+        // The same tap arriving twice (offline replay) returns the original.
+        const key = (0, review_1.cleanReviewText)(data.idempotency_key);
+        if (key) {
+            const [existing] = await this.reviewService_.list({ space_id: data.space_id, idempotency_key: key }, { take: 1 }, sharedContext);
+            if (existing) {
+                if (sameSubmission(existing, data, content)) {
+                    return { review: existing, replayed: true, revealed_ids: [], events: [] };
+                }
+                throw new utils_1.EtoError(utils_1.EtoError.Types.CONFLICT, "This idempotency key was already used for a different review");
+            }
+        }
+        const [live] = await this.reviewService_.list({
+            space_id: data.space_id,
+            reviewer_type: data.reviewer.type,
+            reviewer_id: data.reviewer.id,
+            subject_type: data.subject.type,
+            subject_id: data.subject.id,
+            context_type: data.context.type,
+            context_id: data.context.id,
+            status: LIVE_STATUSES,
+        }, { take: 1 }, sharedContext);
+        if (live) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.CONFLICT, `You already reviewed this (${live.id}); edit that review instead`);
+        }
+        // Two-sided reviews: if the counterpart already reviewed back in this
+        // context, both reveal now; otherwise a sealed review waits for them or for
+        // its seal to lapse.
+        const [counterpart] = await this.reviewService_.list({
+            space_id: data.space_id,
+            context_type: data.context.type,
+            context_id: data.context.id,
+            reviewer_type: data.subject.type,
+            reviewer_id: data.subject.id,
+            subject_type: data.reviewer.type,
+            subject_id: data.reviewer.id,
+            status: LIVE_STATUSES,
+        }, { take: 1 }, sharedContext);
+        const sealUntil = toDate(data.seal_until, "seal_until");
+        const sealed = !!sealUntil && sealUntil > occurred && !counterpart;
+        const revealCounterpart = !!counterpart && !counterpart.revealed_at;
+        const status = data.moderation === "pre" ? "pending" : "published";
+        let review;
+        try {
+            review = await this.reviewService_.create({
+                space_id: data.space_id,
+                subject_type: data.subject.type,
+                subject_id: data.subject.id,
+                subject_owner_id: data.subject_owner_id ?? null,
+                reviewer_type: data.reviewer.type,
+                reviewer_id: data.reviewer.id,
+                reviewer_display: display,
+                anonymous: !!data.anonymous,
+                context_type: data.context.type,
+                context_id: data.context.id,
+                scope: (0, review_1.cleanReviewText)(data.scope),
+                ...content,
+                locale: (0, review_1.cleanReviewText)(data.locale),
+                verified: !!data.verified,
+                status,
+                revealed_at: sealed ? null : now,
+                reveal_after: sealed ? sealUntil : null,
+                eligible_until: eligibleUntil,
+                occurred_at: occurred,
+                idempotency_key: key,
+                metadata: data.metadata ?? null,
+            }, sharedContext);
+        }
+        catch (e) {
+            throw asConflict(e);
+        }
+        await this.reviewRevisionService_.create({ review_id: review.id, revision: 1, ...content }, sharedContext);
+        const revealed_ids = [];
+        const keys = [...keysOf(review)];
+        if (revealCounterpart) {
+            await this.reviewService_.update({ selector: { id: counterpart.id }, data: { revealed_at: now } }, sharedContext);
+            revealed_ids.push(counterpart.id);
+            keys.push(...keysOf(counterpart));
+        }
+        const events = [
+            { name: review_1.ReviewEvents.SUBMITTED, data: refOf(review) },
+            ...revealed_ids.map((id) => ({ name: review_1.ReviewEvents.REVEALED, data: { id } })),
+            ...(await this.recomputeSummaries_(keys, sharedContext)),
+        ];
+        return { review, replayed: false, revealed_ids, events };
+    }
+    // ===== EDIT / WITHDRAW =====
+    async editReview(data, sharedContext = {}) {
+        const { review, events } = await this.editReview_(data, sharedContext);
+        this.emit_(events, sharedContext);
+        return await this.baseRepository_.serialize(review);
+    }
+    async editReview_(data, sharedContext = {}) {
+        const existing = await this.ownReview_(data.review_id, data.reviewer, sharedContext);
+        if (existing.status === "withdrawn" || existing.status === "hidden") {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_ALLOWED, `This review is ${existing.status} and cannot be edited`);
+        }
+        const occurred = actTime(data.occurred_at, new Date());
+        if (existing.eligible_until && occurred > new Date(existing.eligible_until)) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_ALLOWED, "The time to change this review has passed");
+        }
+        const problems = (0, review_1.reviewContentProblems)(data, { partial: true });
+        if (problems.length) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, problems.join("; "));
+        }
+        const has = (k) => data[k] !== undefined;
+        const next = {
+            rating: has("rating") ? data.rating : existing.rating,
+            dimensions: has("dimensions") ? data.dimensions ?? null : existing.dimensions,
+            tags: has("tags") ? (data.tags?.length ? data.tags : null) : existing.tags,
+            title: has("title") ? (0, review_1.cleanReviewText)(data.title) : existing.title,
+            body: has("body") ? (0, review_1.cleanReviewText)(data.body) : existing.body,
+            media: has("media") ? (data.media?.length ? data.media : null) : existing.media,
+        };
+        const revisions = await this.reviewRevisionService_.list({ review_id: existing.id }, { select: ["revision"], order: { revision: "DESC" }, take: 1 }, sharedContext);
+        await this.reviewRevisionService_.create({ review_id: existing.id, revision: (revisions[0]?.revision ?? 0) + 1, ...next }, sharedContext);
+        const review = firstOf(await this.reviewService_.update({
+            selector: { id: existing.id },
+            data: {
+                ...next,
+                edited_at: new Date(),
+                ...(data.moderation === "pre" ? { status: "pending" } : {}),
+            },
+        }, sharedContext));
+        const events = [
+            { name: review_1.ReviewEvents.EDITED, data: refOf(review) },
+            ...(await this.recomputeSummaries_(keysOf(review), sharedContext)),
+        ];
+        return { review, events };
+    }
+    async withdrawReview(data, sharedContext = {}) {
+        const { review, events } = await this.withdrawReview_(data, sharedContext);
+        this.emit_(events, sharedContext);
+        return await this.baseRepository_.serialize(review);
+    }
+    async withdrawReview_(data, sharedContext = {}) {
+        const existing = await this.ownReview_(data.review_id, data.reviewer, sharedContext);
+        if (existing.status === "withdrawn") {
+            return { review: existing, events: [] };
+        }
+        const review = firstOf(await this.reviewService_.update({ selector: { id: existing.id }, data: { status: "withdrawn" } }, sharedContext));
+        const events = [
+            { name: review_1.ReviewEvents.WITHDRAWN, data: refOf(review) },
+            ...(await this.recomputeSummaries_(keysOf(review), sharedContext)),
+        ];
+        return { review, events };
+    }
+    // ===== RESPOND =====
+    async respondToReview(data, sharedContext = {}) {
+        const review = await this.respondToReview_(data, sharedContext);
+        this.emit_([{ name: review_1.ReviewEvents.RESPONDED, data: refOf(review) }], sharedContext);
+        return await this.baseRepository_.serialize(review);
+    }
+    async respondToReview_(data, sharedContext = {}) {
+        requireRef(data.responder, "responder");
+        const existing = await this.reviewService_.retrieve(data.review_id, {}, sharedContext);
+        const isSubject = sameRef(data.responder, { type: existing.subject_type, id: existing.subject_id });
+        const isOwner = !!existing.subject_owner_id && existing.subject_owner_id === data.responder.id;
+        if (!isSubject && !isOwner) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_ALLOWED, "Only who was reviewed, or its owner, may respond");
+        }
+        // A sealed review is not yet seen by its subject; answering it would
+        // reveal it by the back door.
+        if (existing.status !== "published" || !existing.revealed_at) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_ALLOWED, "Only a published review can be answered");
+        }
+        const body = (0, review_1.cleanReviewText)(data.body);
+        if (!body) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, "A response needs some words");
+        }
+        if (body.length > review_1.REVIEW_LIMITS.response) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `A response is at most ${review_1.REVIEW_LIMITS.response} characters`);
+        }
+        const review = firstOf(await this.reviewService_.update({
+            selector: { id: existing.id },
+            data: { response_body: body, responder_id: data.responder.id, responded_at: new Date() },
+        }, sharedContext));
+        return review;
+    }
+    // ===== MODERATE / FLAG =====
+    async moderateReview(data, sharedContext = {}) {
+        const { review, events } = await this.moderateReview_(data, sharedContext);
+        this.emit_(events, sharedContext);
+        return await this.baseRepository_.serialize(review);
+    }
+    async moderateReview_(data, sharedContext = {}) {
+        requireText(data.moderator_id, "moderator_id");
+        if (data.decision !== "publish" && data.decision !== "hide") {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, "decision is publish or hide");
+        }
+        const existing = await this.reviewService_.retrieve(data.review_id, {}, sharedContext);
+        if (existing.status === "withdrawn") {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_ALLOWED, "A withdrawn review cannot be moderated");
+        }
+        const reason = (0, review_1.cleanReviewText)(data.reason);
+        if (data.decision === "hide" && !reason) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, "Say why a review is hidden");
+        }
+        const now = new Date();
+        const review = firstOf(await this.reviewService_.update({
+            selector: { id: existing.id },
+            data: {
+                status: data.decision === "publish" ? "published" : "hidden",
+                moderated_by: data.moderator_id,
+                moderated_at: now,
+                moderation_reason: reason,
+                open_flag_count: 0,
+            },
+        }, sharedContext));
+        // A moderator's decision answers every open report on it.
+        await this.reviewFlagService_.update({
+            selector: { review_id: existing.id, status: "open" },
+            data: { status: "resolved", resolved_by: data.moderator_id, resolved_at: now },
+        }, sharedContext);
+        const events = [
+            {
+                name: data.decision === "publish" ? review_1.ReviewEvents.PUBLISHED : review_1.ReviewEvents.HIDDEN,
+                data: refOf(review),
+            },
+            ...(await this.recomputeSummaries_(keysOf(review), sharedContext)),
+        ];
+        return { review, events };
+    }
+    async flagReview(data, sharedContext = {}) {
+        const flag = await this.flagReview_(data, sharedContext);
+        this.emit_([{ name: review_1.ReviewEvents.FLAGGED, data: { id: flag.review_id, flag_id: flag.id } }], sharedContext);
+        return await this.baseRepository_.serialize(flag);
+    }
+    async flagReview_(data, sharedContext = {}) {
+        requireRef(data.reporter, "reporter");
+        const reason = (0, review_1.cleanReviewText)(data.reason);
+        if (!reason) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, "Say why this review is being reported");
+        }
+        const review = await this.reviewService_.retrieve(data.review_id, {}, sharedContext);
+        if (review.status === "withdrawn") {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_ALLOWED, "This review was withdrawn");
+        }
+        // Reporting twice changes nothing: the first report stands.
+        const [existing] = await this.reviewFlagService_.list({ review_id: review.id, reporter_type: data.reporter.type, reporter_id: data.reporter.id }, { take: 1 }, sharedContext);
+        if (existing) {
+            return existing;
+        }
+        let flag;
+        try {
+            flag = await this.reviewFlagService_.create({
+                review_id: review.id,
+                space_id: review.space_id,
+                reporter_type: data.reporter.type,
+                reporter_id: data.reporter.id,
+                reason,
+                note: (0, review_1.cleanReviewText)(data.note),
+            }, sharedContext);
+        }
+        catch (e) {
+            throw asConflict(e);
+        }
+        const open = await this.reviewFlagService_.list({ review_id: review.id, status: "open" }, { select: ["id"] }, sharedContext);
+        await this.reviewService_.update({ selector: { id: review.id }, data: { open_flag_count: open.length } }, sharedContext);
+        return flag;
+    }
+    // ===== REVEAL / ERASE =====
+    async revealDueReviews(data = {}, sharedContext = {}) {
+        const { revealed_ids, events } = await this.revealDueReviews_(data, sharedContext);
+        this.emit_(events, sharedContext);
+        return { revealed_ids };
+    }
+    async revealDueReviews_(data, sharedContext = {}) {
+        const now = toDate(data.now, "now") ?? new Date();
+        const due = await this.reviewService_.list({ revealed_at: null, reveal_after: { $lte: now } }, { take: 500 }, sharedContext);
+        if (!due.length) {
+            return { revealed_ids: [], events: [] };
+        }
+        await this.reviewService_.update({ selector: { id: due.map((r) => r.id) }, data: { revealed_at: now } }, sharedContext);
+        const events = [
+            ...due.map((r) => ({ name: review_1.ReviewEvents.REVEALED, data: { id: r.id } })),
+            ...(await this.recomputeSummaries_(due.flatMap(keysOf), sharedContext)),
+        ];
+        return { revealed_ids: due.map((r) => r.id), events };
+    }
+    async anonymizeReviewer(data, sharedContext = {}) {
+        return await this.anonymizeReviewer_(data, sharedContext);
+    }
+    async anonymizeReviewer_(data, sharedContext = {}) {
+        requireRef(data.reviewer, "reviewer");
+        const reviews = await this.reviewService_.list({ reviewer_type: data.reviewer.type, reviewer_id: data.reviewer.id }, { select: ["id"] }, sharedContext);
+        // Each review gets its own placeholder so the one-per-interaction index
+        // still holds; scores stay, so summaries do not move.
+        for (const r of reviews) {
+            await this.reviewService_.update({
+                selector: { id: r.id },
+                data: {
+                    reviewer_id: `anonymized_${r.id}`,
+                    reviewer_display: null,
+                    anonymous: true,
+                    idempotency_key: null,
+                    metadata: null,
+                },
+            }, sharedContext);
+        }
+        return { anonymized: reviews.length };
+    }
+    // ===== READS =====
+    async getReviewSummary(query, sharedContext = {}) {
+        const [summary] = await this.getReviewSummaries({ ...query, subject_ids: [query.subject_id] }, sharedContext);
+        return summary;
+    }
+    async getReviewSummaries(query, sharedContext = {}) {
+        requireText(query.space_id, "space_id");
+        requireText(query.subject_type, "subject_type");
+        const scope = (0, review_1.cleanReviewText)(query.scope) ?? "";
+        const ids = [...new Set(query.subject_ids)];
+        if (!ids.length) {
+            return [];
+        }
+        const rows = await this.reviewSummaryService_.list({ space_id: query.space_id, subject_type: query.subject_type, subject_id: ids, scope }, {}, sharedContext);
+        const byId = new Map(rows.map((r) => [r.subject_id, r]));
+        return ids.map((subject_id) => {
+            const row = byId.get(subject_id);
+            return row
+                ? toSummaryDTO(row)
+                : emptySummary({ space_id: query.space_id, subject_type: query.subject_type, subject_id, scope });
+        });
+    }
+    async listPublicReviews(query, sharedContext = {}) {
+        requireText(query.space_id, "space_id");
+        const filters = {
+            space_id: query.space_id,
+            subject_type: query.subject_type,
+            subject_id: query.subject_id,
+            status: "published",
+            revealed_at: { $ne: null },
+        };
+        const scope = (0, review_1.cleanReviewText)(query.scope);
+        if (scope)
+            filters.scope = scope;
+        if (query.rating)
+            filters.rating = query.rating;
+        if (query.verified_only)
+            filters.verified = true;
+        if (query.tag) {
+            // jsonb containment; the ORM has no portable operator for it.
+            const em = this.baseRepository_.getActiveManager(sharedContext);
+            const rows = await em.execute(`select id from review where deleted_at is null and space_id = ? and subject_type = ?
+           and subject_id = ? and tags @> ?::jsonb`, [query.space_id, query.subject_type, query.subject_id, JSON.stringify([query.tag])]);
+            filters.id = rows.map((r) => r.id);
+        }
+        const [rows, count] = await this.reviewService_.listAndCount(filters, {
+            order: { occurred_at: "DESC" },
+            take: Math.min(Math.max(query.limit ?? 20, 1), 100),
+            skip: Math.max(query.offset ?? 0, 0),
+        }, sharedContext);
+        const reviews = await this.baseRepository_.serialize(rows);
+        return { reviews: reviews.map(toPublic), count };
+    }
+    // ===== INTERNALS =====
+    async ownReview_(id, reviewer, sharedContext) {
+        requireRef(reviewer, "reviewer");
+        const review = await this.reviewService_.retrieve(id, {}, sharedContext);
+        if (!sameRef(reviewer, { type: review.reviewer_type, id: review.reviewer_id })) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.NOT_ALLOWED, "Only who wrote a review may change it");
+        }
+        return review;
+    }
+    /**
+     * Recompute summaries from the rows, in SQL, under a per-subject advisory
+     * lock held to the end of the transaction. Two reviews of one subject at once
+     * serialise here, so the second recompute sees the first's row.
+     */
+    async recomputeSummaries_(keys, sharedContext) {
+        const em = this.baseRepository_.getActiveManager(sharedContext);
+        if (!em?.execute) {
+            throw new utils_1.EtoError(utils_1.EtoError.Types.UNEXPECTED_STATE, "No transaction to recompute summaries in");
+        }
+        // The aggregates are SQL over the table, so this transaction's own pending
+        // changes must reach it first.
+        await em.flush?.();
+        const unique = new Map(keys.map((k) => [summaryKey(k), k]));
+        const subjects = new Map([...unique.values()].map((k) => [`${k.space_id}|${k.subject_type}|${k.subject_id}`, k]));
+        // Lock in a stable order so two transactions never wait on each other in a cycle.
+        for (const lockKey of [...subjects.keys()].sort()) {
+            await em.execute("select pg_advisory_xact_lock(hashtext(?))", [`review:${lockKey}`]);
+        }
+        const events = [];
+        for (const key of unique.values()) {
+            const where = `deleted_at is null and status = 'published' and revealed_at is not null
+        and space_id = ? and subject_type = ? and subject_id = ?${key.scope ? " and scope = ?" : ""}`;
+            const params = [key.space_id, key.subject_type, key.subject_id, ...(key.scope ? [key.scope] : [])];
+            const stars = await em.execute(`select rating, count(*)::int as n, sum(case when verified then 1 else 0 end)::int as v,
+                max(occurred_at) as last
+           from review where ${where} group by rating`, params);
+            const dims = await em.execute(`select d.key as key, count(*)::int as n, avg((d.value)::numeric)::float as mean
+           from review r cross join lateral jsonb_each_text(coalesce(r.dimensions, '{}'::jsonb)) d
+          where ${where.replace(/\b(deleted_at|status|revealed_at|space_id|subject_type|subject_id|scope)\b/g, "r.$1")}
+          group by d.key`, params);
+            const tags = await em.execute(`select t.value as tag, count(*)::int as n
+           from review r cross join lateral jsonb_array_elements_text(coalesce(r.tags, '[]'::jsonb)) t
+          where ${where.replace(/\b(deleted_at|status|revealed_at|space_id|subject_type|subject_id|scope)\b/g, "r.$1")}
+          group by t.value`, params);
+            const distribution = { "1": 0, "2": 0, "3": 0, "4": 0, "5": 0 };
+            let count = 0;
+            let verified = 0;
+            let sum = 0;
+            let last = null;
+            for (const row of stars) {
+                distribution[String(row.rating)] = row.n;
+                count += row.n;
+                verified += row.v;
+                sum += row.rating * row.n;
+                const at = row.last ? new Date(row.last) : null;
+                if (at && (!last || at > last))
+                    last = at;
+            }
+            const dimensions = Object.fromEntries(dims.map((d) => [d.key, { count: d.n, mean: round2(d.mean) }]));
+            const tagCounts = Object.fromEntries(tags.map((t) => [t.tag, t.n]));
+            const mean = count ? round2(sum / count) : null;
+            await em.execute(`insert into review_summary
+           (id, space_id, subject_type, subject_id, scope, count, verified_count, rating_sum, mean,
+            distribution, dimensions, tags, last_reviewed_at)
+         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?::jsonb, ?::jsonb, ?::jsonb, ?)
+         on conflict (space_id, subject_type, subject_id, scope) where deleted_at is null
+         do update set count = excluded.count, verified_count = excluded.verified_count,
+           rating_sum = excluded.rating_sum, mean = excluded.mean,
+           distribution = excluded.distribution, dimensions = excluded.dimensions,
+           tags = excluded.tags, last_reviewed_at = excluded.last_reviewed_at, updated_at = now()`, [
+                (0, utils_1.generateEntityId)(undefined, "rvws"),
+                key.space_id,
+                key.subject_type,
+                key.subject_id,
+                key.scope,
+                count,
+                verified,
+                sum,
+                mean,
+                JSON.stringify(distribution),
+                JSON.stringify(dimensions),
+                JSON.stringify(tagCounts),
+                last,
+            ]);
+            events.push({
+                name: review_1.ReviewEvents.SUMMARY_CHANGED,
+                data: { ...key, count, mean },
+            });
+        }
+        return events;
+    }
+    emit_(events, sharedContext) {
+        if (!events.length || !sharedContext.messageAggregator) {
+            return;
+        }
+        const messages = events.map((e) => ({
+            source: utils_1.Modules.REVIEW,
+            action: e.name.split(".").pop(),
+            object: e.name.split(".")[1],
+            eventName: e.name,
+            context: sharedContext,
+            data: e.data,
+        }));
+        sharedContext.messageAggregator.saveRawMessageData(messages);
+    }
+}
+exports.default = ReviewModuleService;
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "submitReview", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "submitReview_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "editReview", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "editReview_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "withdrawReview", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "withdrawReview_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "respondToReview", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "respondToReview_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "moderateReview", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "moderateReview_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "flagReview", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "flagReview_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "revealDueReviews", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "revealDueReviews_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "anonymizeReviewer", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "anonymizeReviewer_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "getReviewSummary", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "getReviewSummaries", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.EtoContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ReviewModuleService.prototype, "listPublicReviews", null);
+// ===== pure helpers =====
+function firstOf(value) {
+    return Array.isArray(value) ? value[0] : value;
+}
+function requireText(value, name) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `${name} is required`);
+    }
+}
+function requireRef(ref, name) {
+    if (!ref || typeof ref.type !== "string" || !ref.type.trim() || typeof ref.id !== "string" || !ref.id.trim()) {
+        throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `${name} needs a type and an id`);
+    }
+}
+function sameRef(a, b) {
+    return a.type === b.type && a.id === b.id;
+}
+function toDate(value, name) {
+    if (value == null || value === "")
+        return null;
+    const d = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(d.getTime())) {
+        throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, `${name} is not a date`);
+    }
+    return d;
+}
+/** When the person acted. A phone's clock may run a little fast; never far. */
+function actTime(value, now) {
+    const at = toDate(value, "occurred_at") ?? now;
+    if (at.getTime() > now.getTime() + FUTURE_SKEW_MS) {
+        throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_DATA, "occurred_at is in the future");
+    }
+    return at;
+}
+function sameSubmission(existing, data, content) {
+    const same = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+    return (existing.subject_type === data.subject.type &&
+        existing.subject_id === data.subject.id &&
+        existing.reviewer_type === data.reviewer.type &&
+        existing.reviewer_id === data.reviewer.id &&
+        existing.context_type === data.context.type &&
+        existing.context_id === data.context.id &&
+        Object.keys(content).every((k) => same(existing[k], content[k])));
+}
+function asConflict(e) {
+    const message = e instanceof Error ? e.message : String(e);
+    if (/IDX_review_one_per_interaction|duplicate key|already exists/i.test(message)) {
+        return new utils_1.EtoError(utils_1.EtoError.Types.CONFLICT, "You already reviewed this; edit that review instead");
+    }
+    if (/IDX_review_flag_one_per_reporter/.test(message)) {
+        return new utils_1.EtoError(utils_1.EtoError.Types.CONFLICT, "You already reported this review");
+    }
+    return e;
+}
+function keysOf(review) {
+    const base = {
+        space_id: review.space_id,
+        subject_type: review.subject_type,
+        subject_id: review.subject_id,
+    };
+    return review.scope ? [{ ...base, scope: "" }, { ...base, scope: review.scope }] : [{ ...base, scope: "" }];
+}
+function summaryKey(k) {
+    return `${k.space_id}|${k.subject_type}|${k.subject_id}|${k.scope}`;
+}
+function refOf(review) {
+    return {
+        id: review.id,
+        space_id: review.space_id,
+        subject_type: review.subject_type,
+        subject_id: review.subject_id,
+        context_type: review.context_type,
+        context_id: review.context_id,
+    };
+}
+function round2(n) {
+    return Math.round(n * 100) / 100;
+}
+function toSummaryDTO(row) {
+    return {
+        space_id: row.space_id,
+        subject_type: row.subject_type,
+        subject_id: row.subject_id,
+        scope: row.scope ?? "",
+        count: row.count ?? 0,
+        verified_count: row.verified_count ?? 0,
+        mean: row.mean ?? null,
+        distribution: row.distribution ?? { "1": 0, "2": 0, "3": 0, "4": 0, "5": 0 },
+        dimensions: row.dimensions ?? {},
+        tags: row.tags ?? {},
+        last_reviewed_at: row.last_reviewed_at ?? null,
+    };
+}
+function emptySummary(key) {
+    return toSummaryDTO({ ...key });
+}
+function toPublic(review) {
+    const { reviewer_id: _id, idempotency_key: _key, moderated_by: _by, moderation_reason: _reason, open_flag_count: _flags, metadata: _meta, ...rest } = review;
+    return review.anonymous ? { ...rest, reviewer_display: null } : rest;
+}
+//# sourceMappingURL=review-module-service.js.map