@medusajs/pricing 0.1.13-snapshot-20240701122250 → 0.1.13-snapshot-20240703074611

package/dist/services/pricing-module.d.ts

@@ -43,6 +43,7 @@ export default class PricingModuleService extends PricingModuleService_base impl
     constructor({ baseRepository, pricingRepository, priceSetService, priceRuleService, priceService, priceListService, priceListRuleService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
     __joinerConfig(): ModuleJoinerConfig;
     private setupCalculatedPriceConfig_;
+    retrievePriceSet(id: string, config?: FindConfig<PriceSetDTO> | undefined, sharedContext?: Context | undefined): Promise<PriceSetDTO>;
     listPriceSets(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<PriceSetDTO[]>;
     listAndCountPriceSets(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<[PriceSetDTO[], number]>;
     calculatePrices(pricingFilters: PricingFilters, pricingContext?: PricingContext, sharedContext?: Context): Promise<PricingTypes.CalculatedPriceSet[]>;
@@ -73,5 +74,17 @@ export default class PricingModuleService extends PricingModuleService_base impl
     protected setPriceListRules_(data: PricingTypes.SetPriceListRulesDTO[], sharedContext?: Context): Promise<PriceList[]>;
     protected removePriceListRules_(data: PricingTypes.RemovePriceListRulesDTO[], sharedContext?: Context): Promise<PriceList[]>;
     protected normalizePriceListDate(data: (ServiceTypes.UpdatePriceListDTO | ServiceTypes.CreatePriceListDTO | CreatePriceListDTO)[]): any[];
+    protected normalizePriceSetConfig(config: FindConfig<PricingTypes.PriceSetDTO> | undefined): {
+        select?: string[] | undefined;
+        skip?: number | null | undefined;
+        take?: number | null | undefined;
+        relations?: string[] | undefined;
+        order?: {
+            [K: string]: "ASC" | "DESC";
+        } | undefined;
+        withDeleted?: boolean | undefined;
+        filters?: Record<string, any> | undefined;
+        options: Record<string, any>;
+    };
 }
 export {};

package/dist/services/pricing-module.js

@@ -53,53 +53,60 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         return pricingContext;
     }
     // @ts-expect-error
+    async retrievePriceSet(id, config, sharedContext) {
+        const priceSet = await this.priceSetService_.retrieve(id, this.normalizePriceSetConfig(config), sharedContext);
+        return await this.baseRepository_.serialize(priceSet);
+    }
+    // @ts-expect-error
     async listPriceSets(filters = {}, config = {}, sharedContext = {}) {
-        const pricingContext = this.setupCalculatedPriceConfig_(filters, config);
-        const priceSets = await super.listPriceSets(filters, config, sharedContext);
+        const normalizedConfig = this.normalizePriceSetConfig(config);
+        const pricingContext = this.setupCalculatedPriceConfig_(filters, normalizedConfig);
+        const priceSets = await super.listPriceSets(filters, normalizedConfig, sharedContext);
         if (!pricingContext || !priceSets.length) {
             return priceSets;
         }
-        const priceSetIds = [];
-        const priceSetMap = new Map();
-        for (const priceSet of priceSets) {
-            priceSetIds.push(priceSet.id);
-            priceSetMap.set(priceSet.id, priceSet);
-        }
-        const calculatedPrices = await this.calculatePrices({ id: priceSetIds }, { context: pricingContext }, sharedContext);
+        const calculatedPrices = await this.calculatePrices({ id: priceSets.map((p) => p.id) }, { context: pricingContext }, sharedContext);
+        const calculatedPricesMap = new Map();
         for (const calculatedPrice of calculatedPrices) {
-            const priceSet = priceSetMap.get(calculatedPrice.id);
-            priceSet.calculated_price = calculatedPrice;
+            calculatedPricesMap.set(calculatedPrice.id, calculatedPrice);
+        }
+        for (const priceSet of priceSets) {
+            const calculatedPrice = calculatedPricesMap.get(priceSet.id);
+            priceSet.calculated_price = calculatedPrice ?? null;
         }
         return priceSets;
     }
     // @ts-expect-error
     async listAndCountPriceSets(filters = {}, config = {}, sharedContext = {}) {
-        const pricingContext = this.setupCalculatedPriceConfig_(filters, config);
-        const [priceSets, count] = await super.listAndCountPriceSets(filters, config, sharedContext);
+        const normalizedConfig = this.normalizePriceSetConfig(config);
+        const pricingContext = this.setupCalculatedPriceConfig_(filters, normalizedConfig);
+        const [priceSets, count] = await super.listAndCountPriceSets(filters, normalizedConfig, sharedContext);
         if (!pricingContext || !priceSets.length) {
             return [priceSets, count];
         }
-        const priceSetIds = [];
-        const priceSetMap = new Map();
-        for (const priceSet of priceSets) {
-            priceSetIds.push(priceSet.id);
-            priceSetMap.set(priceSet.id, priceSet);
-        }
-        const calculatedPrices = await this.calculatePrices({ id: priceSetIds }, { context: pricingContext }, sharedContext);
+        const calculatedPrices = await this.calculatePrices({ id: priceSets.map((p) => p.id) }, { context: pricingContext }, sharedContext);
+        const calculatedPricesMap = new Map();
         for (const calculatedPrice of calculatedPrices) {
-            const priceSet = priceSetMap.get(calculatedPrice.id);
-            priceSet.calculated_price = calculatedPrice;
+            calculatedPricesMap.set(calculatedPrice.id, calculatedPrice);
+        }
+        for (const priceSet of priceSets) {
+            const calculatedPrice = calculatedPricesMap.get(priceSet.id);
+            priceSet.calculated_price = calculatedPrice ?? null;
         }
         return [priceSets, count];
     }
     async calculatePrices(pricingFilters, pricingContext = { context: {} }, sharedContext = {}) {
         const results = await this.pricingRepository_.calculatePrices(pricingFilters, pricingContext, sharedContext);
         const pricesSetPricesMap = (0, utils_1.groupBy)(results, "price_set_id");
-        const calculatedPrices = pricingFilters.id.map((priceSetId) => {
+        const calculatedPrices = pricingFilters.id
+            .map((priceSetId) => {
             // This is where we select prices, for now we just do a first match based on the database results
             // which is prioritized by rules_count first for exact match and then deafult_priority of the rule_type
             // TODO: inject custom price selection here
             const prices = pricesSetPricesMap.get(priceSetId) || [];
+            if (!prices.length) {
+                return null;
+            }
             const priceListPrice = prices.find((p) => p.price_list_id);
             const defaultPrice = prices?.find((p) => !p.price_list_id);
             let calculatedPrice = defaultPrice;
@@ -132,16 +139,17 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                     max_quantity: parseInt(originalPrice?.max_quantity || "") || null,
                 },
             };
-        });
+        })
+            .filter(Boolean);
         return JSON.parse(JSON.stringify(calculatedPrices));
     }
     async createPriceSets(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const priceSets = await this.createPriceSets_(input, sharedContext);
         // TODO: Remove the need to refetch the data here
-        const dbPriceSets = await this.listPriceSets({ id: priceSets.map((p) => p.id) }, {
+        const dbPriceSets = await this.listPriceSets({ id: priceSets.map((p) => p.id) }, this.normalizePriceSetConfig({
             relations: ["prices", "prices.price_rules"],
-        }, sharedContext);
+        }), sharedContext);
         // Ensure the output to be in the same order as the input
         const results = priceSets.map((priceSet) => {
             return dbPriceSets.find((p) => p.id === priceSet.id);
@@ -719,8 +727,24 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             return priceListData;
         });
     }
+    normalizePriceSetConfig(config) {
+        return {
+            options: {
+                populateWhere: { prices: { price_list_id: null } },
+            },
+            ...config,
+        };
+    }
 }
 exports.default = PricingModuleService;
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_")
+    // @ts-expect-error
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "retrievePriceSet", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_")
     // @ts-expect-error

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medusajs/pricing",
-  "version": "0.1.13-snapshot-20240701122250",
+  "version": "0.1.13-snapshot-20240703074611",
   "description": "Medusa Pricing module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,7 +37,7 @@
     "@mikro-orm/cli": "5.9.7",
     "cross-env": "^5.2.1",
     "jest": "^29.7.0",
-    "medusa-test-utils": "1.1.45-snapshot-20240701122250",
+    "medusa-test-utils": "1.1.45-snapshot-20240703074611",
     "rimraf": "^3.0.2",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",
@@ -45,9 +45,9 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "@medusajs/modules-sdk": "1.13.0-snapshot-20240701122250",
-    "@medusajs/types": "1.12.0-snapshot-20240701122250",
-    "@medusajs/utils": "1.12.0-snapshot-20240701122250",
+    "@medusajs/modules-sdk": "1.13.0-snapshot-20240703074611",
+    "@medusajs/types": "1.12.0-snapshot-20240703074611",
+    "@medusajs/utils": "1.12.0-snapshot-20240703074611",
     "@mikro-orm/core": "5.9.7",
     "@mikro-orm/migrations": "5.9.7",
     "@mikro-orm/postgresql": "5.9.7",