@86d-app/reviews 0.0.22 → 0.0.24

package/dist/modules/reviews/src/admin/endpoints/send-review-request.js

@@ -0,0 +1,31 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+export const sendReviewRequest = createAdminEndpoint("/admin/reviews/send-request", {
+    method: "POST",
+    body: z.object({
+        orderId: z.string(),
+        orderNumber: z.string(),
+        email: z.string().email(),
+        customerName: z.string(),
+        items: z.array(z.object({
+            productId: z.string(),
+            name: z.string(),
+        })),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers.reviews;
+    const existing = await controller.getReviewRequest(ctx.body.orderId);
+    if (existing) {
+        return {
+            error: "Review request already sent for this order",
+            status: 409,
+        };
+    }
+    const request = await controller.createReviewRequest({
+        orderId: ctx.body.orderId,
+        orderNumber: ctx.body.orderNumber,
+        email: ctx.body.email,
+        customerName: ctx.body.customerName,
+        items: ctx.body.items,
+    });
+    return { request };
+});

package/dist/modules/reviews/src/admin/endpoints/update-report.js

@@ -0,0 +1,14 @@
+import { createAdminEndpoint, z } from "@86d-app/core";
+export const updateReport = createAdminEndpoint("/admin/reviews/reports/:id/update", {
+    method: "PUT",
+    params: z.object({ id: z.string() }),
+    body: z.object({
+        status: z.enum(["resolved", "dismissed"]),
+    }),
+}, async (ctx) => {
+    const controller = ctx.context.controllers.reviews;
+    const report = await controller.updateReportStatus(ctx.params.id, ctx.body.status);
+    if (!report)
+        return { error: "Report not found", status: 404 };
+    return { report };
+});

package/dist/modules/reviews/src/index.js

@@ -0,0 +1,57 @@
+import { adminEndpoints } from "./admin/endpoints";
+import { reviewsSchema } from "./schema";
+import { createReviewController } from "./service-impl";
+import { storeEndpoints } from "./store/endpoints";
+export default function reviews(options) {
+    return {
+        id: "reviews",
+        version: "0.0.2",
+        schema: reviewsSchema,
+        exports: {
+            read: ["productRating", "reviewCount"],
+        },
+        events: {
+            emits: [
+                "review.submitted",
+                "review.approved",
+                "review.rejected",
+                "review.responded",
+                "review.requested",
+                "review.reported",
+            ],
+        },
+        init: async (ctx) => {
+            const controller = createReviewController(ctx.data, {
+                autoApprove: options?.autoApprove === "true",
+            });
+            return { controllers: { reviews: controller } };
+        },
+        endpoints: {
+            store: storeEndpoints,
+            admin: adminEndpoints,
+        },
+        admin: {
+            pages: [
+                {
+                    path: "/admin/reviews",
+                    component: "ReviewList",
+                    label: "Reviews",
+                    icon: "Star",
+                    group: "Marketing",
+                },
+                {
+                    path: "/admin/reviews/analytics",
+                    component: "ReviewAnalytics",
+                    label: "Review Analytics",
+                    icon: "ChartBar",
+                    group: "Marketing",
+                },
+                {
+                    path: "/admin/reviews/:id",
+                    component: "ReviewModeration",
+                },
+            ],
+        },
+        options,
+    };
+}

package/dist/modules/reviews/src/schema.js

@@ -0,0 +1,63 @@
+export const reviewsSchema = {
+    review: {
+        fields: {
+            id: { type: "string", required: true },
+            productId: { type: "string", required: true },
+            customerId: { type: "string", required: false },
+            authorName: { type: "string", required: true },
+            authorEmail: { type: "string", required: true },
+            rating: { type: "number", required: true },
+            title: { type: "string", required: false },
+            body: { type: "string", required: true },
+            status: { type: "string", required: true, defaultValue: "pending" },
+            isVerifiedPurchase: {
+                type: "boolean",
+                required: true,
+                defaultValue: false,
+            },
+            helpfulCount: { type: "number", required: true, defaultValue: 0 },
+            images: { type: "json", required: false },
+            merchantResponse: { type: "string", required: false },
+            merchantResponseAt: { type: "date", required: false },
+            moderationNote: { type: "string", required: false },
+            createdAt: {
+                type: "date",
+                required: true,
+                defaultValue: () => new Date(),
+            },
+            updatedAt: {
+                type: "date",
+                required: true,
+                defaultValue: () => new Date(),
+                onUpdate: () => new Date(),
+            },
+        },
+    },
+    reviewVote: {
+        fields: {
+            id: { type: "string", required: true },
+            reviewId: { type: "string", required: true },
+            voterId: { type: "string", required: true },
+            createdAt: {
+                type: "date",
+                required: true,
+                defaultValue: () => new Date(),
+            },
+        },
+    },
+    reviewReport: {
+        fields: {
+            id: { type: "string", required: true },
+            reviewId: { type: "string", required: true },
+            reporterId: { type: "string", required: false },
+            reason: { type: "string", required: true },
+            details: { type: "string", required: false },
+            status: { type: "string", required: true, defaultValue: "pending" },
+            createdAt: {
+                type: "date",
+                required: true,
+                defaultValue: () => new Date(),
+            },
+        },
+    },
+};

package/dist/modules/reviews/src/service-impl.js

@@ -0,0 +1,349 @@
+function sortReviews(reviews, sortBy) {
+    const sorted = [...reviews];
+    switch (sortBy) {
+        case "recent":
+            return sorted.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        case "oldest":
+            return sorted.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+        case "highest":
+            return sorted.sort((a, b) => b.rating - a.rating);
+        case "lowest":
+            return sorted.sort((a, b) => a.rating - b.rating);
+        case "helpful":
+            return sorted.sort((a, b) => b.helpfulCount - a.helpfulCount);
+        default:
+            return sorted;
+    }
+}
+export function createReviewController(data, options) {
+    return {
+        async createReview(params) {
+            const id = crypto.randomUUID();
+            const now = new Date();
+            const status = options?.autoApprove === true ? "approved" : "pending";
+            const review = {
+                id,
+                productId: params.productId,
+                customerId: params.customerId,
+                authorName: params.authorName,
+                authorEmail: params.authorEmail,
+                rating: params.rating,
+                title: params.title,
+                body: params.body,
+                status,
+                isVerifiedPurchase: params.isVerifiedPurchase ?? false,
+                helpfulCount: 0,
+                ...(params.images && params.images.length > 0
+                    ? { images: params.images }
+                    : {}),
+                createdAt: now,
+                updatedAt: now,
+            };
+            await data.upsert("review", id, review);
+            return review;
+        },
+        async getReview(id) {
+            const raw = await data.get("review", id);
+            if (!raw)
+                return null;
+            return raw;
+        },
+        async listReviewsByProduct(productId, params) {
+            const where = { productId };
+            if (params?.approvedOnly)
+                where.status = "approved";
+            const all = await data.findMany("review", {
+                where,
+            });
+            let reviews = all;
+            if (params?.sortBy) {
+                reviews = sortReviews(reviews, params.sortBy);
+            }
+            const skip = params?.skip ?? 0;
+            const take = params?.take;
+            if (skip > 0 || take !== undefined) {
+                reviews = reviews.slice(skip, take !== undefined ? skip + take : undefined);
+            }
+            return reviews;
+        },
+        async listReviews(params) {
+            const where = {};
+            if (params?.productId)
+                where.productId = params.productId;
+            if (params?.status)
+                where.status = params.status;
+            const all = await data.findMany("review", {
+                ...(Object.keys(where).length > 0 ? { where } : {}),
+                ...(params?.take !== undefined ? { take: params.take } : {}),
+                ...(params?.skip !== undefined ? { skip: params.skip } : {}),
+            });
+            return all;
+        },
+        async updateReviewStatus(id, status, moderationNote) {
+            const existing = await data.get("review", id);
+            if (!existing)
+                return null;
+            const review = existing;
+            const updated = {
+                ...review,
+                status,
+                updatedAt: new Date(),
+                ...(moderationNote !== undefined ? { moderationNote } : {}),
+            };
+            await data.upsert("review", id, updated);
+            return updated;
+        },
+        async deleteReview(id) {
+            const existing = await data.get("review", id);
+            if (!existing)
+                return false;
+            await data.delete("review", id);
+            return true;
+        },
+        async addMerchantResponse(id, response) {
+            const existing = await data.get("review", id);
+            if (!existing)
+                return null;
+            const review = existing;
+            const updated = {
+                ...review,
+                merchantResponse: response,
+                merchantResponseAt: new Date(),
+                updatedAt: new Date(),
+            };
+            await data.upsert("review", id, updated);
+            return updated;
+        },
+        async markHelpful(id) {
+            const existing = await data.get("review", id);
+            if (!existing)
+                return null;
+            const review = existing;
+            const updated = {
+                ...review,
+                helpfulCount: review.helpfulCount + 1,
+                updatedAt: new Date(),
+            };
+            await data.upsert("review", id, updated);
+            return updated;
+        },
+        async voteHelpful(reviewId, voterId) {
+            const existing = await data.get("review", reviewId);
+            if (!existing)
+                return null;
+            const review = existing;
+            // Check if voter already voted
+            const existingVotes = await data.findMany("reviewVote", {
+                where: { reviewId, voterId },
+                take: 1,
+            });
+            const votes = existingVotes;
+            if (votes.length > 0) {
+                return { review, alreadyVoted: true };
+            }
+            // Record the vote
+            const voteId = crypto.randomUUID();
+            const vote = {
+                id: voteId,
+                reviewId,
+                voterId,
+                createdAt: new Date(),
+            };
+            await data.upsert("reviewVote", voteId, vote);
+            // Increment helpful count
+            const updated = {
+                ...review,
+                helpfulCount: review.helpfulCount + 1,
+                updatedAt: new Date(),
+            };
+            await data.upsert("review", reviewId, updated);
+            return { review: updated, alreadyVoted: false };
+        },
+        async getReviewAnalytics() {
+            const all = await data.findMany("review", {});
+            const reviews = all;
+            const distribution = {
+                "1": 0,
+                "2": 0,
+                "3": 0,
+                "4": 0,
+                "5": 0,
+            };
+            let pendingCount = 0;
+            let approvedCount = 0;
+            let rejectedCount = 0;
+            let ratingTotal = 0;
+            let withMerchantResponse = 0;
+            for (const r of reviews) {
+                if (r.status === "pending")
+                    pendingCount++;
+                else if (r.status === "approved")
+                    approvedCount++;
+                else if (r.status === "rejected")
+                    rejectedCount++;
+                ratingTotal += r.rating;
+                const key = String(r.rating);
+                if (key in distribution) {
+                    distribution[key] = (distribution[key] ?? 0) + 1;
+                }
+                if (r.merchantResponse)
+                    withMerchantResponse++;
+            }
+            // Count reported reviews
+            const allReports = await data.findMany("reviewReport", {
+                where: { status: "pending" },
+            });
+            const reports = allReports;
+            const reportedReviewIds = new Set(reports.map((r) => r.reviewId));
+            return {
+                totalReviews: reviews.length,
+                pendingCount,
+                approvedCount,
+                rejectedCount,
+                averageRating: reviews.length > 0
+                    ? Math.round((ratingTotal / reviews.length) * 10) / 10
+                    : 0,
+                ratingsDistribution: distribution,
+                withMerchantResponse,
+                reportedCount: reportedReviewIds.size,
+            };
+        },
+        async getProductRatingSummary(productId) {
+            const all = await data.findMany("review", {
+                where: { productId, status: "approved" },
+            });
+            const reviews = all;
+            if (reviews.length === 0) {
+                return {
+                    average: 0,
+                    count: 0,
+                    distribution: { "1": 0, "2": 0, "3": 0, "4": 0, "5": 0 },
+                };
+            }
+            const distribution = {
+                "1": 0,
+                "2": 0,
+                "3": 0,
+                "4": 0,
+                "5": 0,
+            };
+            let total = 0;
+            for (const r of reviews) {
+                total += r.rating;
+                const key = String(r.rating);
+                if (key in distribution) {
+                    distribution[key] = (distribution[key] ?? 0) + 1;
+                }
+            }
+            const average = Math.round((total / reviews.length) * 10) / 10;
+            return { average, count: reviews.length, distribution };
+        },
+        async createReviewRequest(params) {
+            const id = crypto.randomUUID();
+            const request = {
+                id,
+                orderId: params.orderId,
+                orderNumber: params.orderNumber,
+                email: params.email,
+                customerName: params.customerName,
+                items: params.items,
+                sentAt: new Date(),
+            };
+            await data.upsert("reviewRequest", id, request);
+            return request;
+        },
+        async getReviewRequest(orderId) {
+            const all = await data.findMany("reviewRequest", {
+                where: { orderId },
+                take: 1,
+            });
+            const requests = all;
+            return requests.length > 0 ? requests[0] : null;
+        },
+        async listReviewRequests(params) {
+            const all = await data.findMany("reviewRequest", {
+                ...(params?.take !== undefined ? { take: params.take } : {}),
+                ...(params?.skip !== undefined ? { skip: params.skip } : {}),
+            });
+            return all;
+        },
+        async listReviewsByCustomer(customerId, params) {
+            const where = { customerId };
+            if (params?.status)
+                where.status = params.status;
+            const all = await data.findMany("review", {
+                where,
+            });
+            const reviews = all;
+            const filtered = reviews.slice(params?.skip ?? 0, params?.skip !== undefined && params?.take !== undefined
+                ? params.skip + params.take
+                : params?.take !== undefined
+                    ? params.take
+                    : undefined);
+            return { reviews: filtered, total: reviews.length };
+        },
+        async hasReviewedProduct(customerId, productId) {
+            const all = await data.findMany("review", {
+                where: { customerId, productId },
+                take: 1,
+            });
+            const reviews = all;
+            return reviews.length > 0;
+        },
+        async reportReview(params) {
+            const id = crypto.randomUUID();
+            const report = {
+                id,
+                reviewId: params.reviewId,
+                reporterId: params.reporterId,
+                reason: params.reason,
+                details: params.details,
+                status: "pending",
+                createdAt: new Date(),
+            };
+            await data.upsert("reviewReport", id, report);
+            return report;
+        },
+        async listReports(params) {
+            const where = {};
+            if (params?.status)
+                where.status = params.status;
+            if (params?.reviewId)
+                where.reviewId = params.reviewId;
+            const all = await data.findMany("reviewReport", {
+                ...(Object.keys(where).length > 0 ? { where } : {}),
+                ...(params?.take !== undefined ? { take: params.take } : {}),
+                ...(params?.skip !== undefined ? { skip: params.skip } : {}),
+            });
+            return all;
+        },
+        async updateReportStatus(id, status) {
+            const existing = await data.get("reviewReport", id);
+            if (!existing)
+                return null;
+            const report = existing;
+            const updated = {
+                ...report,
+                status,
+            };
+            await data.upsert("reviewReport", id, updated);
+            return updated;
+        },
+        async getReportCount(reviewId) {
+            const all = await data.findMany("reviewReport", {
+                where: { reviewId, status: "pending" },
+            });
+            const reports = all;
+            return reports.length;
+        },
+        async getReviewRequestStats() {
+            const all = await data.findMany("reviewRequest", {});
+            const requests = all;
+            const uniqueOrders = new Set(requests.map((r) => r.orderId));
+            return {
+                totalSent: requests.length,
+                uniqueOrders: uniqueOrders.size,
+            };
+        },
+    };
+}

package/dist/modules/reviews/src/service.js

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

package/dist/modules/reviews/src/store/components/_hooks.js

@@ -0,0 +1,10 @@
+"use client";
+import { useModuleClient } from "@86d-app/core/client";
+export function useReviewsApi() {
+    const client = useModuleClient();
+    return {
+        submitReview: client.module("reviews").store["/reviews"],
+        listProductReviews: client.module("reviews").store["/reviews/products/:productId"],
+        markHelpful: client.module("reviews").store["/reviews/:id/helpful"],
+    };
+}

package/dist/modules/reviews/src/store/components/_utils.js

@@ -0,0 +1,17 @@
+export function formatDate(iso) {
+    return new Intl.DateTimeFormat("en-US", {
+        month: "short",
+        day: "numeric",
+        year: "numeric",
+    }).format(new Date(iso));
+}
+export function extractError(error, fallback) {
+    if (!error)
+        return fallback;
+    const body = error.body;
+    if (typeof body?.error === "string")
+        return body.error;
+    if (typeof body?.error?.message === "string")
+        return body.error.message;
+    return fallback;
+}

package/dist/modules/reviews/src/store/components/distribution-bars.jsx

@@ -0,0 +1,5 @@
+"use client";
+import DistributionBarsTemplate from "./distribution-bars.mdx";
+export function DistributionBars({ distribution, total, }) {
+    return <DistributionBarsTemplate distribution={distribution} total={total}/>;
+}

package/dist/modules/reviews/src/store/components/index.jsx

@@ -0,0 +1,17 @@
+"use client";
+import { DistributionBars } from "./distribution-bars";
+import { ProductReviews } from "./product-reviews";
+import { ReviewCard } from "./review-card";
+import { ReviewForm } from "./review-form";
+import { ReviewsSummary } from "./reviews-summary";
+import { StarDisplay } from "./star-display";
+import { StarPicker } from "./star-picker";
+export default {
+    ReviewsSummary,
+    ProductReviews,
+    StarDisplay,
+    StarPicker,
+    ReviewCard,
+    ReviewForm,
+    DistributionBars,
+};

package/dist/modules/reviews/src/store/components/product-reviews.jsx

@@ -0,0 +1,94 @@
+"use client";
+import { useCallback, useState } from "react";
+import { useReviewsApi } from "./_hooks";
+import { DistributionBars } from "./distribution-bars";
+import ProductReviewsTemplate from "./product-reviews.mdx";
+import { ReviewCard } from "./review-card";
+import { ReviewForm } from "./review-form";
+import { StarDisplay } from "./star-display";
+const PAGE_SIZE = 10;
+export function ProductReviews({ productId, title = "Customer Reviews", }) {
+    const api = useReviewsApi();
+    // Initial page via useQuery — eliminates the fetch-on-mount useEffect
+    const { data: initialData, isLoading: loading, isError: queryError, refetch, } = api.listProductReviews.useQuery({
+        params: { productId },
+        take: String(PAGE_SIZE),
+        skip: "0",
+    });
+    // Extra reviews loaded via "Load more"
+    const [extraReviews, setExtraReviews] = useState([]);
+    const [loadingMore, setLoadingMore] = useState(false);
+    const [skip, setSkip] = useState(0);
+    const [loadedAll, setLoadedAll] = useState(false);
+    const [showForm, setShowForm] = useState(false);
+    const allReviews = [...(initialData?.reviews ?? []), ...extraReviews];
+    const hasMore = !loadedAll &&
+        initialData !== undefined &&
+        (initialData.reviews.length === PAGE_SIZE || extraReviews.length > 0);
+    const handleLoadMore = useCallback(async () => {
+        const nextSkip = skip === 0 ? PAGE_SIZE : skip + PAGE_SIZE;
+        setLoadingMore(true);
+        try {
+            const fresh = (await api.listProductReviews.fetch({
+                params: { productId },
+                take: String(PAGE_SIZE),
+                skip: String(nextSkip),
+            }));
+            setExtraReviews((prev) => [...prev, ...fresh.reviews]);
+            setSkip(nextSkip);
+            if (fresh.reviews.length < PAGE_SIZE)
+                setLoadedAll(true);
+        }
+        catch {
+            // silently ignore
+        }
+        finally {
+            setLoadingMore(false);
+        }
+    }, [api.listProductReviews, productId, skip]);
+    const handleMarkHelpful = useCallback(async (id) => {
+        await api.markHelpful.mutate({ params: { id } });
+    }, [api.markHelpful]);
+    const handleReviewSubmitted = useCallback(() => {
+        setShowForm(false);
+        // Invalidate the query to refetch from scratch
+        void api.listProductReviews.invalidate();
+        setExtraReviews([]);
+        setSkip(0);
+        setLoadedAll(false);
+    }, [api.listProductReviews]);
+    if (loading) {
+        return (<section className="py-8">
+				<div className="mb-6 h-7 w-40 animate-pulse rounded-lg bg-muted"/>
+				<div className="space-y-4">
+					{[1, 2, 3].map((n) => (<div key={n} className="space-y-2 border-border border-b pb-4">
+							<div className="h-4 w-24 animate-pulse rounded bg-muted"/>
+							<div className="h-4 w-full animate-pulse rounded bg-muted"/>
+							<div className="h-4 w-3/4 animate-pulse rounded bg-muted"/>
+						</div>))}
+				</div>
+			</section>);
+    }
+    if (queryError) {
+        return (<section className="py-8">
+				<h2 className="mb-4 font-semibold text-foreground text-lg">{title}</h2>
+				<div className="rounded-xl border border-destructive/20 bg-destructive/5 px-4 py-6 text-center" role="alert">
+					<p className="font-medium text-destructive text-sm">
+						Failed to load reviews
+					</p>
+					<button type="button" onClick={() => refetch()} className="mt-2 font-medium text-destructive text-sm underline underline-offset-4">
+						Try again
+					</button>
+				</div>
+			</section>);
+    }
+    const summary = initialData?.summary;
+    const noReviews = !summary || summary.count === 0;
+    const reviewListContent = allReviews.length === 0 ? (<p className="text-muted-foreground text-sm">No approved reviews yet.</p>) : (<div>
+				{allReviews.map((review) => (<ReviewCard key={review.id} review={review} onMarkHelpful={handleMarkHelpful}/>))}
+				{hasMore && (<button type="button" onClick={() => void handleLoadMore()} disabled={loadingMore} className="mt-4 text-primary text-sm underline-offset-4 hover:underline disabled:opacity-60">
+						{loadingMore ? "Loading…" : "Load more reviews"}
+					</button>)}
+			</div>);
+    return (<ProductReviewsTemplate title={title} summary={summary ?? undefined} noReviews={noReviews} showForm={showForm} onToggleForm={() => setShowForm((v) => !v)} formContent={<ReviewForm productId={productId} onSuccess={handleReviewSubmitted}/>} distributionBars={summary ? (<DistributionBars distribution={summary.distribution} total={summary.count}/>) : null} reviewListContent={reviewListContent} starDisplay={summary ? <StarDisplay rating={summary.average} size="lg"/> : null}/>);
+}