@unchainedshop/core-products 4.3.5 → 4.5.0

package/README.md

@@ -1,3 +1,134 @@
-# Products (Unchained Engine)
+[![npm version](https://img.shields.io/npm/v/@unchainedshop/core-products.svg)](https://npmjs.com/package/@unchainedshop/core-products)
+[![License: EUPL-1.2](https://img.shields.io/badge/License-EUPL--1.2-blue.svg)](https://opensource.org/licenses/EUPL-1.2)
 
-This package contains business logic and database abstraction for products in Unchained.
+# @unchainedshop/core-products
+
+Product management module for the Unchained Engine. Handles products, pricing, media, reviews, texts, and variations.
+
+## Installation
+
+```bash
+npm install @unchainedshop/core-products
+```
+
+## Usage
+
+```typescript
+import { configureProductsModule, ProductType } from '@unchainedshop/core-products';
+
+const productsModule = await configureProductsModule({ db });
+
+// Create a product
+const productId = await productsModule.create({
+  type: ProductType.SimpleProduct,
+  slugs: ['my-product'],
+});
+
+// Find products
+const products = await productsModule.findProducts({
+  tags: ['featured'],
+  includeDrafts: false,
+});
+
+// Publish a product
+await productsModule.publish(productId);
+```
+
+## API Overview
+
+### Module Configuration
+
+| Export | Description |
+|--------|-------------|
+| `configureProductsModule` | Configure and return the products module |
+
+### Queries
+
+| Method | Description |
+|--------|-------------|
+| `findProduct` | Find product by ID or slug |
+| `findProducts` | Find products with filtering and pagination |
+| `count` | Count products matching query |
+| `productExists` | Check if product exists |
+
+### Mutations
+
+| Method | Description |
+|--------|-------------|
+| `create` | Create a new product |
+| `update` | Update product data |
+| `delete` | Soft delete a product |
+| `publish` | Publish a draft product |
+| `unpublish` | Unpublish a product |
+| `addAssignment` | Add product proxy assignment |
+| `removeAssignment` | Remove product assignment |
+
+### Submodules
+
+#### Media (`products.media`)
+| Method | Description |
+|--------|-------------|
+| `findProductMedia` | Find media for a product |
+| `createMedia` | Add media to product |
+| `updateMedia` | Update media metadata |
+| `deleteMedia` | Remove media from product |
+| `reorderMedia` | Reorder product media |
+
+#### Prices (`products.prices`)
+| Method | Description |
+|--------|-------------|
+| `findProductPrices` | Get product prices |
+| `createPrice` | Add a price |
+| `updatePrice` | Update a price |
+| `deletePrice` | Remove a price |
+
+#### Reviews (`products.reviews`)
+| Method | Description |
+|--------|-------------|
+| `findProductReviews` | Find reviews for product |
+| `createReview` | Add a review |
+| `updateReview` | Update a review |
+| `deleteReview` | Remove a review |
+
+#### Texts (`products.texts`)
+| Method | Description |
+|--------|-------------|
+| `findProductTexts` | Find localized texts |
+| `updateTexts` | Update product texts |
+
+#### Variations (`products.variations`)
+| Method | Description |
+|--------|-------------|
+| `findProductVariations` | Find product variations |
+| `createVariation` | Add a variation |
+| `updateVariation` | Update a variation |
+| `deleteVariation` | Remove a variation |
+
+### Constants
+
+| Export | Description |
+|--------|-------------|
+| `ProductType` | Product types (SimpleProduct, ConfigurableProduct, BundleProduct, PlanProduct, TokenizedProduct) |
+| `ProductStatus` | Product status values (ACTIVE, DRAFT) |
+
+### Types
+
+| Export | Description |
+|--------|-------------|
+| `Product` | Product document type |
+| `ProductQuery` | Query parameters type |
+| `ProductsModule` | Module interface type |
+
+## Events
+
+| Event | Description |
+|-------|-------------|
+| `PRODUCT_CREATE` | Product created |
+| `PRODUCT_UPDATE` | Product updated |
+| `PRODUCT_REMOVE` | Product deleted |
+| `PRODUCT_PUBLISH` | Product published |
+| `PRODUCT_UNPUBLISH` | Product unpublished |
+
+## License
+
+EUPL-1.2

package/lib/db/ProductMediaCollection.d.ts

@@ -1,4 +1,4 @@
-import { mongodb, TimestampFields } from '@unchainedshop/mongodb';
+import { mongodb, type TimestampFields } from '@unchainedshop/mongodb';
 export type ProductMedia = {
     _id: string;
     mediaId: string;
@@ -18,4 +18,3 @@ export declare const ProductMediaCollection: (db: mongodb.Db) => Promise<{
     ProductMedias: mongodb.Collection<ProductMedia>;
     ProductMediaTexts: mongodb.Collection<ProductMediaText>;
 }>;
-//# sourceMappingURL=ProductMediaCollection.d.ts.map

package/lib/db/ProductMediaCollection.js

@@ -1,19 +1,16 @@
-import { buildDbIndexes } from '@unchainedshop/mongodb';
+import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
 export const ProductMediaCollection = async (db) => {
     const ProductMedias = db.collection('product_media');
     const ProductMediaTexts = db.collection('product_media_texts');
-    // ProductMedia Indexes
     await buildDbIndexes(ProductMedias, [
         { index: { mediaId: 1 } },
         { index: { productId: 1, sortKey: 1 } },
         { index: { tags: 1, sortKey: 1 } },
         { index: { productId: 1, tags: 1, sortKey: 1 } },
     ]);
-    // ProductMediaTexts indexes
     await buildDbIndexes(ProductMediaTexts, [{ index: { productMediaId: 1 } }, { index: { locale: 1 } }]);
     return {
         ProductMedias,
         ProductMediaTexts,
     };
 };
-//# sourceMappingURL=ProductMediaCollection.js.map

package/lib/db/ProductPriceRates.d.ts

@@ -9,4 +9,3 @@ export interface ProductPriceRate {
 export declare const ProductPriceRates: (db: mongodb.Db) => Promise<{
     ProductRates: mongodb.Collection<ProductPriceRate>;
 }>;
-//# sourceMappingURL=ProductPriceRates.d.ts.map

package/lib/db/ProductPriceRates.js

@@ -1,4 +1,4 @@
-import { buildDbIndexes } from '@unchainedshop/mongodb';
+import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
 export const ProductPriceRates = async (db) => {
     const ProductRates = db.collection('product_rates');
     await buildDbIndexes(ProductRates, [
@@ -11,4 +11,3 @@ export const ProductPriceRates = async (db) => {
         ProductRates,
     };
 };
-//# sourceMappingURL=ProductPriceRates.js.map

package/lib/db/ProductReviewsCollection.d.ts

@@ -1,9 +1,10 @@
-import { mongodb, TimestampFields } from '@unchainedshop/mongodb';
-export declare enum ProductReviewVoteType {
-    UPVOTE = "UPVOTE",
-    DOWNVOTE = "DOWNVOTE",
-    REPORT = "REPORT"
-}
+import { mongodb, type TimestampFields } from '@unchainedshop/mongodb';
+export declare const ProductReviewVoteType: {
+    readonly UPVOTE: "UPVOTE";
+    readonly DOWNVOTE: "DOWNVOTE";
+    readonly REPORT: "REPORT";
+};
+export type ProductReviewVoteType = (typeof ProductReviewVoteType)[keyof typeof ProductReviewVoteType];
 export interface ProductVote {
     meta?: any;
     timestamp?: Date;
@@ -23,4 +24,3 @@ export type ProductReview = {
 export declare const ProductReviewsCollection: (db: mongodb.Db) => Promise<{
     ProductReviews: mongodb.Collection<ProductReview>;
 }>;
-//# sourceMappingURL=ProductReviewsCollection.d.ts.map

package/lib/db/ProductReviewsCollection.js

@@ -1,10 +1,9 @@
-import { buildDbIndexes, isDocumentDBCompatModeEnabled, } from '@unchainedshop/mongodb';
-export var ProductReviewVoteType;
-(function (ProductReviewVoteType) {
-    ProductReviewVoteType["UPVOTE"] = "UPVOTE";
-    ProductReviewVoteType["DOWNVOTE"] = "DOWNVOTE";
-    ProductReviewVoteType["REPORT"] = "REPORT";
-})(ProductReviewVoteType || (ProductReviewVoteType = {}));
+import { mongodb, buildDbIndexes, isDocumentDBCompatModeEnabled, } from '@unchainedshop/mongodb';
+export const ProductReviewVoteType = {
+    UPVOTE: 'UPVOTE',
+    DOWNVOTE: 'DOWNVOTE',
+    REPORT: 'REPORT',
+};
 export const ProductReviewsCollection = async (db) => {
     const ProductReviews = db.collection('product_reviews');
     if (!isDocumentDBCompatModeEnabled()) {
@@ -29,4 +28,3 @@ export const ProductReviewsCollection = async (db) => {
         ProductReviews,
     };
 };
-//# sourceMappingURL=ProductReviewsCollection.js.map

package/lib/db/ProductVariationsCollection.d.ts

@@ -1,8 +1,9 @@
-import { mongodb, TimestampFields } from '@unchainedshop/mongodb';
-export declare enum ProductVariationType {
-    COLOR = "COLOR",
-    TEXT = "TEXT"
-}
+import { mongodb, type TimestampFields } from '@unchainedshop/mongodb';
+export declare const ProductVariationType: {
+    readonly COLOR: "COLOR";
+    readonly TEXT: "TEXT";
+};
+export type ProductVariationType = (typeof ProductVariationType)[keyof typeof ProductVariationType];
 export type ProductVariation = {
     _id: string;
     key: string;
@@ -28,4 +29,3 @@ export declare const ProductVariationsCollection: (db: mongodb.Db) => Promise<{
     ProductVariations: mongodb.Collection<ProductVariation>;
     ProductVariationTexts: mongodb.Collection<ProductVariationText>;
 }>;
-//# sourceMappingURL=ProductVariationsCollection.d.ts.map

package/lib/db/ProductVariationsCollection.js

@@ -1,9 +1,8 @@
-import { buildDbIndexes } from '@unchainedshop/mongodb';
-export var ProductVariationType;
-(function (ProductVariationType) {
-    ProductVariationType["COLOR"] = "COLOR";
-    ProductVariationType["TEXT"] = "TEXT";
-})(ProductVariationType || (ProductVariationType = {}));
+import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
+export const ProductVariationType = {
+    COLOR: 'COLOR',
+    TEXT: 'TEXT',
+};
 export const ProductVariationsCollection = async (db) => {
     const ProductVariations = db.collection('product_variations');
     const ProductVariationTexts = db.collection('product_variation_texts');
@@ -17,4 +16,3 @@ export const ProductVariationsCollection = async (db) => {
         ProductVariationTexts,
     };
 };
-//# sourceMappingURL=ProductVariationsCollection.js.map

package/lib/db/ProductsCollection.d.ts

@@ -1,17 +1,19 @@
-import { mongodb, TimestampFields } from '@unchainedshop/mongodb';
-import { Price } from '@unchainedshop/utils';
-export declare enum ProductStatus {
-    DRAFT = "DRAFT",
-    ACTIVE = "ACTIVE",
-    DELETED = "DELETED"
-}
-export declare enum ProductTypes {
-    SimpleProduct = "SIMPLE_PRODUCT",
-    ConfigurableProduct = "CONFIGURABLE_PRODUCT",
-    BundleProduct = "BUNDLE_PRODUCT",
-    PlanProduct = "PLAN_PRODUCT",
-    TokenizedProduct = "TOKENIZED_PRODUCT"
-}
+import { mongodb, type TimestampFields } from '@unchainedshop/mongodb';
+import type { Price } from '@unchainedshop/utils';
+export declare const ProductStatus: {
+    readonly DRAFT: "DRAFT";
+    readonly ACTIVE: "ACTIVE";
+    readonly DELETED: "DELETED";
+};
+export type ProductStatus = (typeof ProductStatus)[keyof typeof ProductStatus];
+export declare const ProductType: {
+    readonly SIMPLE_PRODUCT: "SIMPLE_PRODUCT";
+    readonly CONFIGURABLE_PRODUCT: "CONFIGURABLE_PRODUCT";
+    readonly BUNDLE_PRODUCT: "BUNDLE_PRODUCT";
+    readonly PLAN_PRODUCT: "PLAN_PRODUCT";
+    readonly TOKENIZED_PRODUCT: "TOKENIZED_PRODUCT";
+};
+export type ProductType = (typeof ProductType)[keyof typeof ProductType];
 export interface ProductContractConfiguration {
     tokenId?: string;
     supply?: number;
@@ -30,10 +32,11 @@ export interface ProductSupply {
     lengthInMillimeters?: number;
     widthInMillimeters?: number;
 }
-export declare enum ProductContractStandard {
-    ERC721 = "ERC721",
-    ERC1155 = "ERC1155"
-}
+export declare const ProductContractStandard: {
+    readonly ERC721: "ERC721";
+    readonly ERC1155: "ERC1155";
+};
+export type ProductContractStandard = (typeof ProductContractStandard)[keyof typeof ProductContractStandard];
 export interface ProductConfiguration {
     key: string;
     value: string;
@@ -90,7 +93,7 @@ export type Product = {
     status?: string | null;
     supply?: ProductSupply;
     tags: string[];
-    type: string;
+    type: ProductType;
     warehousing?: ProductWarehousing;
     tokenization?: ProductTokenization;
 } & TimestampFields;
@@ -110,4 +113,3 @@ export declare const ProductsCollection: (db: mongodb.Db) => Promise<{
     Products: mongodb.Collection<Product>;
     ProductTexts: mongodb.Collection<ProductText>;
 }>;
-//# sourceMappingURL=ProductsCollection.d.ts.map

package/lib/db/ProductsCollection.js

@@ -1,23 +1,20 @@
-import { buildDbIndexes, isDocumentDBCompatModeEnabled, } from '@unchainedshop/mongodb';
-export var ProductStatus;
-(function (ProductStatus) {
-    ProductStatus["DRAFT"] = "DRAFT";
-    ProductStatus["ACTIVE"] = "ACTIVE";
-    ProductStatus["DELETED"] = "DELETED";
-})(ProductStatus || (ProductStatus = {}));
-export var ProductTypes;
-(function (ProductTypes) {
-    ProductTypes["SimpleProduct"] = "SIMPLE_PRODUCT";
-    ProductTypes["ConfigurableProduct"] = "CONFIGURABLE_PRODUCT";
-    ProductTypes["BundleProduct"] = "BUNDLE_PRODUCT";
-    ProductTypes["PlanProduct"] = "PLAN_PRODUCT";
-    ProductTypes["TokenizedProduct"] = "TOKENIZED_PRODUCT";
-})(ProductTypes || (ProductTypes = {}));
-export var ProductContractStandard;
-(function (ProductContractStandard) {
-    ProductContractStandard["ERC721"] = "ERC721";
-    ProductContractStandard["ERC1155"] = "ERC1155";
-})(ProductContractStandard || (ProductContractStandard = {}));
+import { mongodb, buildDbIndexes, isDocumentDBCompatModeEnabled, } from '@unchainedshop/mongodb';
+export const ProductStatus = {
+    DRAFT: 'DRAFT',
+    ACTIVE: 'ACTIVE',
+    DELETED: 'DELETED',
+};
+export const ProductType = {
+    SIMPLE_PRODUCT: 'SIMPLE_PRODUCT',
+    CONFIGURABLE_PRODUCT: 'CONFIGURABLE_PRODUCT',
+    BUNDLE_PRODUCT: 'BUNDLE_PRODUCT',
+    PLAN_PRODUCT: 'PLAN_PRODUCT',
+    TOKENIZED_PRODUCT: 'TOKENIZED_PRODUCT',
+};
+export const ProductContractStandard = {
+    ERC721: 'ERC721',
+    ERC1155: 'ERC1155',
+};
 export const ProductsCollection = async (db) => {
     const Products = db.collection('products');
     const ProductTexts = db.collection('product_texts');
@@ -45,7 +42,6 @@ export const ProductsCollection = async (db) => {
             },
         ]);
     }
-    // Product Indexes
     await buildDbIndexes(Products, [
         { index: { sequence: 1 } },
         { index: { slugs: 1 } },
@@ -53,7 +49,6 @@ export const ProductsCollection = async (db) => {
         { index: { tags: 1 } },
         { index: { 'warehousing.sku': 1 } },
     ]);
-    // ProductTexts indexes
     await buildDbIndexes(ProductTexts, [
         { index: { productId: 1 } },
         { index: { locale: 1 } },
@@ -65,4 +60,3 @@ export const ProductsCollection = async (db) => {
         ProductTexts,
     };
 };
-//# sourceMappingURL=ProductsCollection.js.map

package/lib/mock/product.d.ts

@@ -27,4 +27,3 @@ declare const _default: {
     published: Date;
 };
 export default _default;
-//# sourceMappingURL=product.d.ts.map

package/lib/mock/product.js

@@ -45,4 +45,3 @@ export default {
     },
     published: new Date('2022-12-04T13:31:26.406Z'),
 };
-//# sourceMappingURL=product.js.map

package/lib/module/configureProductMediaModule.d.ts

@@ -1,12 +1,13 @@
-import { ModuleInput } from '@unchainedshop/mongodb';
+import type { ModuleInput } from '@unchainedshop/mongodb';
 import { mongodb } from '@unchainedshop/mongodb';
-import { ProductMedia, ProductMediaText } from '../db/ProductMediaCollection.js';
+import { type ProductMedia, type ProductMediaText } from '../db/ProductMediaCollection.ts';
 export declare const configureProductMediaModule: ({ db }: ModuleInput<Record<string, unknown>>) => Promise<{
     findProductMedia: ({ productMediaId }: {
         productMediaId: string;
     }) => Promise<mongodb.WithId<ProductMedia> | null>;
-    findProductMedias: ({ productId, tags, offset, limit, }: {
-        productId?: mongodb.Filter<ProductMedia>["assortmentId"];
+    findProductMedias: ({ productId, productIds, tags, offset, limit, }: {
+        productId?: string;
+        productIds?: string[];
         limit?: number;
         offset?: number;
         tags?: string[];
@@ -26,7 +27,10 @@ export declare const configureProductMediaModule: ({ db }: ModuleInput<Record<st
         }[];
     }) => Promise<ProductMedia[]>;
     texts: {
-        findMediaTexts: ({ productMediaId }: mongodb.Filter<ProductMediaText>, options?: mongodb.FindOptions) => Promise<ProductMediaText[]>;
+        findMediaTexts: (query: {
+            productMediaId?: string;
+            productMediaIds?: string[];
+        }, options?: mongodb.FindOptions) => Promise<ProductMediaText[]>;
         findLocalizedMediaText: ({ productMediaId, locale, }: {
             productMediaId: string;
             locale: Intl.Locale;
@@ -36,4 +40,3 @@ export declare const configureProductMediaModule: ({ db }: ModuleInput<Record<st
         } & Omit<Partial<ProductMediaText>, "productMediaId" | "locale">)[]) => Promise<ProductMediaText[]>;
     };
 }>;
-//# sourceMappingURL=configureProductMediaModule.d.ts.map

package/lib/module/configureProductMediaModule.js

@@ -1,6 +1,6 @@
 import { emit, registerEvents } from '@unchainedshop/events';
-import { findLocalizedText, generateDbFilterById, generateDbObjectId, } from '@unchainedshop/mongodb';
-import { ProductMediaCollection } from '../db/ProductMediaCollection.js';
+import { findLocalizedText, generateDbFilterById, generateDbObjectId, mongodb, } from '@unchainedshop/mongodb';
+import { ProductMediaCollection, } from "../db/ProductMediaCollection.js";
 const PRODUCT_MEDIA_EVENTS = [
     'PRODUCT_ADD_MEDIA',
     'PRODUCT_REMOVE_MEDIA',
@@ -37,12 +37,17 @@ export const configureProductMediaModule = async ({ db }) => {
         return productMediaText;
     };
     return {
-        // Queries
         findProductMedia: async ({ productMediaId }) => {
             return ProductMedias.findOne(generateDbFilterById(productMediaId), {});
         },
-        findProductMedias: async ({ productId, tags, offset, limit, }, options) => {
-            const selector = productId ? { productId } : {};
+        findProductMedias: async ({ productId, productIds, tags, offset, limit, }, options) => {
+            const selector = {};
+            if (productId) {
+                selector.productId = productId;
+            }
+            if (productIds) {
+                selector.productId = { $in: productIds };
+            }
             if (tags?.length && tags?.length > 0) {
                 selector.tags = { $all: tags };
             }
@@ -54,10 +59,8 @@ export const configureProductMediaModule = async ({ db }) => {
             });
             return mediaList.toArray();
         },
-        // Mutations
         create: async ({ sortKey, ...doc }) => {
             if (sortKey === undefined || sortKey === null) {
-                // Get next sort key
                 const lastProductMedia = (await ProductMedias.findOne({
                     productId: doc.productId,
                 }, {
@@ -103,7 +106,6 @@ export const configureProductMediaModule = async ({ db }) => {
             })));
             return deletedResult.deletedCount;
         },
-        // This action is specifically used for the bulk migration scripts in the platform package
         update: async (productMediaId, doc) => {
             const selector = generateDbFilterById(productMediaId);
             const modifier = { $set: doc };
@@ -125,19 +127,21 @@ export const configureProductMediaModule = async ({ db }) => {
             await emit('PRODUCT_REORDER_MEDIA', { productMedias });
             return productMedias;
         },
-        /*
-         * Product Media Texts
-         */
         texts: {
-            // Queries
-            findMediaTexts: async ({ productMediaId }, options) => {
-                return ProductMediaTexts.find({ productMediaId }, options).toArray();
+            findMediaTexts: async (query, options) => {
+                const selector = {};
+                if (query.productMediaId) {
+                    selector.productMediaId = query.productMediaId;
+                }
+                if (query.productMediaIds) {
+                    selector.productMediaId = { $in: query.productMediaIds };
+                }
+                return ProductMediaTexts.find(selector, options).toArray();
             },
             findLocalizedMediaText: async ({ productMediaId, locale, }) => {
                 const text = await findLocalizedText(ProductMediaTexts, { productMediaId }, locale);
                 return text;
             },
-            // Mutations
             updateMediaTexts: async (productMediaId, texts) => {
                 const mediaTexts = (await Promise.all(texts.map(async ({ locale, ...text }) => upsertLocalizedText(productMediaId, new Intl.Locale(locale), text)))).filter(Boolean);
                 return mediaTexts;
@@ -145,4 +149,3 @@ export const configureProductMediaModule = async ({ db }) => {
         },
     };
 };
-//# sourceMappingURL=configureProductMediaModule.js.map

package/lib/module/configureProductPrices.d.ts

@@ -1,5 +1,5 @@
-import { ProductPriceRate } from '../db/ProductPriceRates.js';
-import { Product, ProductConfiguration, ProductPrice, ProductPriceRange } from '../db/ProductsCollection.js';
+import { type ProductPriceRate } from '../db/ProductPriceRates.ts';
+import { type Product, type ProductConfiguration, type ProductPrice, type ProductPriceRange } from '../db/ProductsCollection.ts';
 export declare const getDecimals: (originDecimals: any) => any;
 export declare const normalizeRate: (baseCurrency: {
     decimals?: number;
@@ -63,4 +63,3 @@ export declare const configureProductPricesModule: ({ proxyProducts, db, }: {
         updateRates: (rates: ProductPriceRate[]) => Promise<boolean>;
     };
 };
-//# sourceMappingURL=configureProductPrices.d.ts.map

package/lib/module/configureProductPrices.js

@@ -1,13 +1,12 @@
-import { getPriceLevels } from './utils/getPriceLevels.js';
-import { getPriceRange } from './utils/getPriceRange.js';
-import { ProductPriceRates } from '../db/ProductPriceRates.js';
+import { getPriceLevels } from "./utils/getPriceLevels.js";
+import { getPriceRange } from "./utils/getPriceRange.js";
+import { ProductPriceRates } from "../db/ProductPriceRates.js";
+import {} from "../db/ProductsCollection.js";
 export const getDecimals = (originDecimals) => {
     if (originDecimals === null || originDecimals === undefined) {
         return 2;
     }
     if (originDecimals > 2) {
-        // cryptocurrency, always stored in MAX. 9 decimals
-        // WORKAROUND FOR BIGINT PROBLEM!
         return Math.min(originDecimals, 9);
     }
     return originDecimals;
@@ -172,7 +171,6 @@ export const configureProductPricesModule = ({ proxyProducts, db, }) => {
                                     rate: rate.rate,
                                 },
                             });
-                            // Archive the others that were still valid
                             BulkOp.find({
                                 baseCurrency: rate.baseCurrency,
                                 quoteCurrency: rate.quoteCurrency,
@@ -194,4 +192,3 @@ export const configureProductPricesModule = ({ proxyProducts, db, }) => {
         },
     };
 };
-//# sourceMappingURL=configureProductPrices.js.map

package/lib/module/configureProductReviewsModule.d.ts

@@ -1,7 +1,7 @@
-import { ModuleInput } from '@unchainedshop/mongodb';
+import { type ModuleInput } from '@unchainedshop/mongodb';
 import { mongodb } from '@unchainedshop/mongodb';
-import { SortOption } from '@unchainedshop/utils';
-import { ProductReview, ProductReviewVoteType, ProductVote } from '../db/ProductReviewsCollection.js';
+import { type SortOption } from '@unchainedshop/utils';
+import { type ProductReview, ProductReviewVoteType, type ProductVote } from '../db/ProductReviewsCollection.ts';
 export interface ProductReviewQuery {
     productId?: string;
     authorId?: string;
@@ -31,6 +31,7 @@ export declare const configureProductReviewsModule: ({ db }: ModuleInput<Record<
     create: (doc: Omit<ProductReview, "_id" | "created" | "votes"> & Pick<Partial<ProductReview>, "created" | "_id">) => Promise<ProductReview>;
     delete: (productReviewId: string) => Promise<number>;
     deleteMany: (selector: mongodb.Filter<ProductReview>) => Promise<number>;
+    deleteByAuthorId: (authorId: string) => Promise<number>;
     update: (productReviewId: string, doc: Partial<ProductReview>) => Promise<mongodb.WithId<ProductReview> | null>;
     votes: {
         userIdsThatVoted: (productReview: ProductReview, { type }: {
@@ -47,4 +48,3 @@ export declare const configureProductReviewsModule: ({ db }: ModuleInput<Record<
         removeVote: (productReviewId: string, { userId, type }: ProductVote) => Promise<mongodb.WithId<ProductReview> | null>;
     };
 }>;
-//# sourceMappingURL=configureProductReviewsModule.d.ts.map

package/lib/module/configureProductReviewsModule.js

@@ -1,8 +1,8 @@
 import { assertDocumentDBCompatMode } from '@unchainedshop/mongodb';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { generateDbFilterById, buildSortOptions, generateDbObjectId, } from '@unchainedshop/mongodb';
+import { generateDbFilterById, buildSortOptions, mongodb, generateDbObjectId, } from '@unchainedshop/mongodb';
 import { SortDirection } from '@unchainedshop/utils';
-import { ProductReviewsCollection, ProductReviewVoteType, } from '../db/ProductReviewsCollection.js';
+import { ProductReviewsCollection, ProductReviewVoteType, } from "../db/ProductReviewsCollection.js";
 const PRODUCT_REVIEW_EVENTS = [
     'PRODUCT_REVIEW_CREATE',
     'PRODUCT_REMOVE_REVIEW',
@@ -49,7 +49,6 @@ export const configureProductReviewsModule = async ({ db }) => {
         });
     };
     return {
-        // Queries
         findProductReview: async ({ productReviewId }) => ProductReviews.findOne(generateDbFilterById(productReviewId), {}),
         findProductReviews: async ({ offset, limit, sort, ...query }) => {
             const reviewsList = ProductReviews.find(buildFindSelector(query), {
@@ -66,7 +65,6 @@ export const configureProductReviewsModule = async ({ db }) => {
             const productReviewCount = await ProductReviews.countDocuments(generateDbFilterById(productReviewId, { deleted: null }), { limit: 1 });
             return !!productReviewCount;
         },
-        // Mutations
         create: async (doc) => {
             const { insertedId: productReviewId } = await ProductReviews.insertOne({
                 _id: generateDbObjectId(),
@@ -101,6 +99,14 @@ export const configureProductReviewsModule = async ({ db }) => {
             })));
             return deletionResult.deletedCount;
         },
+        deleteByAuthorId: async (authorId) => {
+            const productReviews = await ProductReviews.find({ authorId }, { projection: { _id: 1 } }).toArray();
+            const deletionResult = await ProductReviews.deleteMany({ authorId });
+            await Promise.all(productReviews.map(async (review) => emit('PRODUCT_REMOVE_REVIEW', {
+                productReviewId: review._id,
+            })));
+            return deletionResult.deletedCount;
+        },
         update: async (productReviewId, doc) => {
             const productReview = await ProductReviews.findOneAndUpdate(generateDbFilterById(productReviewId), {
                 $set: {
@@ -124,14 +130,12 @@ export const configureProductReviewsModule = async ({ db }) => {
                         deleted: null,
                     });
                     if (type === ProductReviewVoteType.UPVOTE) {
-                        // if this is an upvote, remove the downvote first
                         await removeVote(selector, {
                             userId,
                             type: ProductReviewVoteType.DOWNVOTE,
                         });
                     }
                     if (type === ProductReviewVoteType.DOWNVOTE) {
-                        // if this is a downvote, remove the upvote first
                         await removeVote(selector, {
                             userId,
                             type: ProductReviewVoteType.UPVOTE,
@@ -175,4 +179,3 @@ export const configureProductReviewsModule = async ({ db }) => {
         },
     };
 };
-//# sourceMappingURL=configureProductReviewsModule.js.map