@unchainedshop/core-products 4.4.0 → 4.6.0

package/lib/db/ProductsCollection.js

@@ -43,6 +43,7 @@ export const ProductsCollection = async (db) => {
         ]);
     }
     await buildDbIndexes(Products, [
+        { index: { deleted: 1 } },
         { index: { sequence: 1 } },
         { index: { slugs: 1 } },
         { index: { status: 1 } },

package/lib/module/configureProductMediaModule.d.ts

@@ -5,8 +5,9 @@ export declare const configureProductMediaModule: ({ db }: ModuleInput<Record<st
     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,3 +40,4 @@ export declare const configureProductMediaModule: ({ db }: ModuleInput<Record<st
         } & Omit<Partial<ProductMediaText>, "productMediaId" | "locale">)[]) => Promise<ProductMediaText[]>;
     };
 }>;
+export type ProductMediaModule = Awaited<ReturnType<typeof configureProductMediaModule>>;

package/lib/module/configureProductMediaModule.js

@@ -40,8 +40,14 @@ export const configureProductMediaModule = async ({ db }) => {
         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 };
             }
@@ -122,8 +128,15 @@ export const configureProductMediaModule = async ({ db }) => {
             return productMedias;
         },
         texts: {
-            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);

package/lib/module/configureProductPrices.d.ts

@@ -63,3 +63,4 @@ export declare const configureProductPricesModule: ({ proxyProducts, db, }: {
         updateRates: (rates: ProductPriceRate[]) => Promise<boolean>;
     };
 };
+export type ProductPricesModule = ReturnType<typeof configureProductPricesModule>;

package/lib/module/configureProductReviewsModule.d.ts

@@ -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,3 +48,4 @@ export declare const configureProductReviewsModule: ({ db }: ModuleInput<Record<
         removeVote: (productReviewId: string, { userId, type }: ProductVote) => Promise<mongodb.WithId<ProductReview> | null>;
     };
 }>;
+export type ProductReviewsModule = Awaited<ReturnType<typeof configureProductReviewsModule>>;

package/lib/module/configureProductReviewsModule.js

@@ -99,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: {

package/lib/module/configureProductTextsModule.d.ts

@@ -4,7 +4,11 @@ export declare const configureProductTextsModule: ({ Products, ProductTexts, }:
     Products: mongodb.Collection<Product>;
     ProductTexts: mongodb.Collection<ProductText>;
 }) => {
-    findTexts: (query: mongodb.Filter<ProductText>, options?: mongodb.FindOptions) => Promise<ProductText[]>;
+    findTexts: (query: {
+        productId?: string;
+        productIds?: string[];
+        queryString?: string;
+    }, options?: mongodb.FindOptions) => Promise<ProductText[]>;
     findLocalizedText: ({ productId, locale, }: {
         productId: string;
         locale: Intl.Locale;
@@ -22,3 +26,4 @@ export declare const configureProductTextsModule: ({ Products, ProductTexts, }:
         excludedProductIds?: string[];
     }) => Promise<number>;
 };
+export type ProductTextsModule = ReturnType<typeof configureProductTextsModule>;

package/lib/module/configureProductTextsModule.js

@@ -75,7 +75,17 @@ export const configureProductTextsModule = ({ Products, ProductTexts, }) => {
     };
     return {
         findTexts: async (query, options) => {
-            const texts = ProductTexts.find(query, options);
+            const selector = {};
+            if (query.productId) {
+                selector.productId = query.productId;
+            }
+            if (query.productIds) {
+                selector.productId = { $in: query.productIds };
+            }
+            if (query.queryString) {
+                selector.$text = { $search: query.queryString };
+            }
+            const texts = ProductTexts.find(selector, options);
             return texts.toArray();
         },
         findLocalizedText: async ({ productId, locale, }) => {

package/lib/module/configureProductVariationsModule.d.ts

@@ -9,8 +9,10 @@ export declare const configureProductVariationsModule: ({ db }: ModuleInput<Reco
     findProductVariation: ({ productVariationId }: {
         productVariationId: string;
     }) => Promise<mongodb.WithId<ProductVariation> | null>;
-    findProductVariations: (query: mongodb.Filter<ProductVariation> & {
-        productId?: string | mongodb.Filter<string>;
+    findProductVariations: (query: {
+        productId?: string;
+        productIds?: string[];
+        productVariationIds?: string[];
         tags?: string[];
         limit?: number;
         offset?: number;
@@ -30,7 +32,11 @@ export declare const configureProductVariationsModule: ({ db }: ModuleInput<Reco
     }) => Promise<mongodb.WithId<ProductVariation> | null>;
     removeVariationOption: (productVariationId: string, productVariationOptionValue: string) => Promise<void>;
     texts: {
-        findVariationTexts: (query: mongodb.Filter<ProductVariationText>, options?: mongodb.FindOptions) => Promise<ProductVariationText[]>;
+        findVariationTexts: (query: {
+            productVariationId?: string;
+            productVariationIds?: string[];
+            productVariationOptionValue?: string | null;
+        }, options?: mongodb.FindOptions) => Promise<ProductVariationText[]>;
         findLocalizedVariationText: ({ productVariationId, productVariationOptionValue, locale, }: {
             locale: Intl.Locale;
             productVariationId: string;
@@ -41,3 +47,4 @@ export declare const configureProductVariationsModule: ({ db }: ModuleInput<Reco
         } & Omit<Partial<ProductVariationText>, "locale" | "productVariationId" | "productVariationOptionValue">)[], productVariationOptionValue?: string) => Promise<ProductVariationText[]>;
     };
 }>;
+export type ProductVariationsModule = Awaited<ReturnType<typeof configureProductVariationsModule>>;

package/lib/module/configureProductVariationsModule.js

@@ -53,11 +53,17 @@ export const configureProductVariationsModule = async ({ db }) => {
             return ProductVariations.findOne(generateDbFilterById(productVariationId), {});
         },
         findProductVariations: async (query, options) => {
-            const { productId, tags, offset, limit, ...rest } = query;
-            const selector = { ...rest };
+            const { productId, productIds, productVariationIds, tags, offset, limit } = query;
+            const selector = {};
             if (productId) {
                 selector.productId = productId;
             }
+            if (productIds) {
+                selector.productId = { $in: productIds };
+            }
+            if (productVariationIds) {
+                selector._id = { $in: productVariationIds };
+            }
             if (tags && tags.length > 0) {
                 selector.tags = { $all: tags };
             }
@@ -142,7 +148,17 @@ export const configureProductVariationsModule = async ({ db }) => {
         },
         texts: {
             findVariationTexts: async (query, options) => {
-                return ProductVariationTexts.find(query, options).toArray();
+                const selector = {};
+                if (query.productVariationId) {
+                    selector.productVariationId = query.productVariationId;
+                }
+                if (query.productVariationIds) {
+                    selector.productVariationId = { $in: query.productVariationIds };
+                }
+                if (query.productVariationOptionValue !== undefined) {
+                    selector.productVariationOptionValue = query.productVariationOptionValue || { $eq: null };
+                }
+                return ProductVariationTexts.find(selector, options).toArray();
             },
             findLocalizedVariationText: async ({ productVariationId, productVariationOptionValue, locale, }) => {
                 const selector = { productVariationId };

package/lib/module/configureProductsModule.d.ts

@@ -5,10 +5,14 @@ import { type ProductsSettingsOptions } from '../products-settings.ts';
 export interface ProductQuery {
     queryString?: string;
     includeDrafts?: boolean;
+    includeDeleted?: boolean;
     productIds?: string[];
     productSelector?: mongodb.Filter<Product>;
     slugs?: string[];
     tags?: string[];
+    skus?: string[];
+    bundleItemProductIds?: string[];
+    proxyAssignmentProductIds?: string[];
 }
 export interface ProductDiscount {
     _id: string;
@@ -18,7 +22,7 @@ export interface ProductDiscount {
     discountKey: string;
     context?: any;
 }
-export declare const buildFindSelector: ({ slugs, tags, includeDrafts, productIds, productSelector, queryString, ...query }: ProductQuery) => mongodb.Filter<Product>;
+export declare const buildFindSelector: ({ slugs, tags, includeDrafts, includeDeleted, productIds, productSelector, queryString, skus, bundleItemProductIds, proxyAssignmentProductIds, }: ProductQuery) => mongodb.Filter<Product>;
 export declare const configureProductsModule: (moduleInput: ModuleInput<ProductsSettingsOptions>) => Promise<{
     findProduct: (params: {
         productId: string;
@@ -134,8 +138,9 @@ export declare const configureProductsModule: (moduleInput: ModuleInput<Products
         findProductMedia: ({ productMediaId }: {
             productMediaId: string;
         }) => Promise<mongodb.WithId<import("../products-index.ts").ProductMedia> | null>;
-        findProductMedias: ({ productId, tags, offset, limit, }: {
-            productId?: mongodb.Filter<import("../products-index.ts").ProductMedia>["assortmentId"];
+        findProductMedias: ({ productId, productIds, tags, offset, limit, }: {
+            productId?: string;
+            productIds?: string[];
             limit?: number;
             offset?: number;
             tags?: string[];
@@ -155,7 +160,10 @@ export declare const configureProductsModule: (moduleInput: ModuleInput<Products
             }[];
         }) => Promise<import("../products-index.ts").ProductMedia[]>;
         texts: {
-            findMediaTexts: ({ productMediaId }: mongodb.Filter<import("../products-index.ts").ProductMediaText>, options?: mongodb.FindOptions) => Promise<import("../products-index.ts").ProductMediaText[]>;
+            findMediaTexts: (query: {
+                productMediaId?: string;
+                productMediaIds?: string[];
+            }, options?: mongodb.FindOptions) => Promise<import("../products-index.ts").ProductMediaText[]>;
             findLocalizedMediaText: ({ productMediaId, locale, }: {
                 productMediaId: string;
                 locale: Intl.Locale;
@@ -181,6 +189,7 @@ export declare const configureProductsModule: (moduleInput: ModuleInput<Products
         create: (doc: Omit<import("../products-index.ts").ProductReview, "_id" | "created" | "votes"> & Pick<Partial<import("../products-index.ts").ProductReview>, "created" | "_id">) => Promise<import("../products-index.ts").ProductReview>;
         delete: (productReviewId: string) => Promise<number>;
         deleteMany: (selector: mongodb.Filter<import("../products-index.ts").ProductReview>) => Promise<number>;
+        deleteByAuthorId: (authorId: string) => Promise<number>;
         update: (productReviewId: string, doc: Partial<import("../products-index.ts").ProductReview>) => Promise<mongodb.WithId<import("../products-index.ts").ProductReview> | null>;
         votes: {
             userIdsThatVoted: (productReview: import("../products-index.ts").ProductReview, { type }: {
@@ -205,8 +214,10 @@ export declare const configureProductsModule: (moduleInput: ModuleInput<Products
         findProductVariation: ({ productVariationId }: {
             productVariationId: string;
         }) => Promise<mongodb.WithId<import("../products-index.ts").ProductVariation> | null>;
-        findProductVariations: (query: mongodb.Filter<import("../products-index.ts").ProductVariation> & {
-            productId?: string | mongodb.Filter<string>;
+        findProductVariations: (query: {
+            productId?: string;
+            productIds?: string[];
+            productVariationIds?: string[];
             tags?: string[];
             limit?: number;
             offset?: number;
@@ -226,7 +237,11 @@ export declare const configureProductsModule: (moduleInput: ModuleInput<Products
         }) => Promise<mongodb.WithId<import("../products-index.ts").ProductVariation> | null>;
         removeVariationOption: (productVariationId: string, productVariationOptionValue: string) => Promise<void>;
         texts: {
-            findVariationTexts: (query: mongodb.Filter<import("../products-index.ts").ProductVariationText>, options?: mongodb.FindOptions) => Promise<import("../products-index.ts").ProductVariationText[]>;
+            findVariationTexts: (query: {
+                productVariationId?: string;
+                productVariationIds?: string[];
+                productVariationOptionValue?: string | null;
+            }, options?: mongodb.FindOptions) => Promise<import("../products-index.ts").ProductVariationText[]>;
             findLocalizedVariationText: ({ productVariationId, productVariationOptionValue, locale, }: {
                 locale: Intl.Locale;
                 productVariationId: string;
@@ -253,7 +268,11 @@ export declare const configureProductsModule: (moduleInput: ModuleInput<Products
         }) => Promise<Product[]>;
     };
     texts: {
-        findTexts: (query: mongodb.Filter<import("../db/ProductsCollection.ts").ProductText>, options?: mongodb.FindOptions) => Promise<import("../db/ProductsCollection.ts").ProductText[]>;
+        findTexts: (query: {
+            productId?: string;
+            productIds?: string[];
+            queryString?: string;
+        }, options?: mongodb.FindOptions) => Promise<import("../db/ProductsCollection.ts").ProductText[]>;
         findLocalizedText: ({ productId, locale, }: {
             productId: string;
             locale: Intl.Locale;

package/lib/module/configureProductsModule.js

@@ -23,8 +23,8 @@ const PRODUCT_EVENTS = [
 const InternalProductStatus = {
     DRAFT: null,
 };
-export const buildFindSelector = ({ slugs, tags, includeDrafts = false, productIds, productSelector, queryString, ...query }) => {
-    const selector = productSelector ? { ...productSelector, ...query } : query;
+export const buildFindSelector = ({ slugs, tags, includeDrafts = false, includeDeleted = false, productIds, productSelector, queryString, skus, bundleItemProductIds, proxyAssignmentProductIds, }) => {
+    const selector = productSelector ? { ...productSelector } : {};
     if (productIds && !selector._id) {
         selector._id = { $in: productIds };
     }
@@ -39,16 +39,33 @@ export const buildFindSelector = ({ slugs, tags, includeDrafts = false, productI
             selector.tags = tags;
         }
     }
+    if (skus) {
+        selector['warehousing.sku'] = { $in: skus };
+    }
+    if (bundleItemProductIds || proxyAssignmentProductIds) {
+        const orConditions = [];
+        if (bundleItemProductIds) {
+            orConditions.push({ 'bundleItems.productId': { $in: bundleItemProductIds } });
+        }
+        if (proxyAssignmentProductIds) {
+            orConditions.push({ 'proxy.assignments.productId': { $in: proxyAssignmentProductIds } });
+        }
+        selector.$or = orConditions;
+    }
     if (queryString && !selector.$text) {
         assertDocumentDBCompatMode();
         selector.$text = { $search: queryString };
     }
     if (!selector.status) {
-        selector.status = !includeDrafts
-            ? { $eq: ProductStatus.ACTIVE }
-            : {
-                $in: [ProductStatus.ACTIVE, InternalProductStatus.DRAFT],
-            };
+        if (includeDeleted) {
+            selector.status = { $exists: true };
+        }
+        else if (includeDrafts) {
+            selector.status = { $in: [ProductStatus.ACTIVE, InternalProductStatus.DRAFT] };
+        }
+        else {
+            selector.status = { $eq: ProductStatus.ACTIVE };
+        }
     }
     return selector;
 };

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@unchainedshop/core-products",
-  "version": "4.4.0",
+  "description": "Product catalog management module for the Unchained Engine",
+  "version": "4.6.0",
   "main": "lib/products-index.js",
   "types": "lib/products-index.d.ts",
   "type": "module",
+  "sideEffects": false,
   "scripts": {
     "clean": "tsc -b --clean",
     "build": "tsc -b",
@@ -33,9 +35,9 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@unchainedshop/events": "^4.4.0",
-    "@unchainedshop/file-upload": "^4.4.0",
-    "@unchainedshop/utils": "^4.4.0"
+    "@unchainedshop/events": "^4.6.0",
+    "@unchainedshop/file-upload": "^4.6.0",
+    "@unchainedshop/utils": "^4.6.0"
   },
   "devDependencies": {
     "@types/node": "^25.0.0",