feat(medusa): variant creation with prices in productservice.create

.changeset/small-eggs-search.md

@@ -0,0 +1,5 @@
+---
+"@medusajs/medusa": patch
+---
+
+feat(medusa): variant creation with prices in productservice.create

integration-tests/api/__tests__/admin/services/product.ts

@@ -0,0 +1,131 @@
+import path from "path"
+import { initDb, useDb } from "../../../../environment-helpers/use-db"
+import { bootstrapApp } from "../../../../environment-helpers/bootstrap-app"
+
+jest.setTimeout(30000)
+
+describe("/admin/products", () => {
+  let medusaProcess
+  let dbConnection
+  let medusaContainer
+  let productService
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
+    dbConnection = await initDb({ cwd } as any)
+    const { container } = await bootstrapApp({ cwd })
+    medusaContainer = container
+    productService = medusaContainer.resolve("productService")
+  })
+
+  afterAll(async () => {
+    const db = useDb()
+    await db.shutdown()
+
+    medusaProcess.kill()
+  })
+
+  afterEach(async () => {
+    const db = useDb()
+    await db.teardown()
+  })
+
+
+  it("should create variant prices correctly in service creation", async () => {
+    const payload = {
+      title: "test-product",
+      handle: "test-product",
+      options: [{ title: "test-option" }],
+      variants: [
+        {
+          title: "test-variant",
+          inventory_quantity: 10,
+          sku: "test",
+          options: [{ value: "large", title: "test-option" }],
+          prices: [{ amount: "100", currency_code: "usd" }],
+        },
+      ],
+    }
+
+    const { id } = await productService.create(payload)
+
+    const result = await productService.retrieve(id, {
+      relations: ["variants", "variants.prices", "variants.options"],
+    })
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        variants: [
+          expect.objectContaining({
+            options: [expect.objectContaining({ value: "large" })],
+            prices: [
+              expect.objectContaining({ amount: 100, currency_code: "usd" }),
+            ],
+          }),
+        ],
+      })
+    )
+  })
+
+  it("should fail to create a variant without options on for a product with options", async () => {
+    const payload = {
+      title: "test-product",
+      handle: "test-product",
+      options: [{ title: "test-option" }],
+      variants: [
+        {
+          title: "test-variant",
+          inventory_quantity: 10,
+          sku: "test",
+          prices: [{ amount: "100", currency_code: "usd" }],
+        },
+      ],
+    }
+
+    let error
+
+    try { 
+      await productService.create(payload)
+    } catch(err) { 
+      error = err
+    }
+
+    expect(error.message).toEqual(
+      "Product options length does not match variant options length. Product has 1 and variant has 0."
+    )
+  })
+
+  it("should create a product and variant without options", async () => {
+    const payload = {
+      title: "test-product",
+      handle: "test-product",
+      variants: [
+        {
+          title: "test-variant",
+          inventory_quantity: 10,
+          sku: "test",
+          prices: [{ amount: "100", currency_code: "usd" }],
+        },
+      ],
+    }
+
+    const { id } = await productService.create(payload)
+
+    const result = await productService.retrieve(id, {
+      relations: ["variants", "variants.prices", "variants.options"],
+    })
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        options: [], 
+        variants: [
+          expect.objectContaining({
+            prices: [
+              expect.objectContaining({ amount: 100, currency_code: "usd" }),
+            ],
+          }),
+        ],
+      })
+    )
+  })
+})

integration-tests/api/medusa-config.js

@@ -11,7 +11,7 @@ const enableResponseCompression =
 module.exports = {
   plugins: [],
   projectConfig: {
-    redis_url: redisUrl,
+    // redis_url: redisUrl,
     database_url: `postgres://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}`,
     database_type: "postgres",
     jwt_secret: "test",

packages/medusa/src/services/__tests__/product.js

@@ -78,7 +78,7 @@ describe("ProductService", () => {
         title: "Suit",
         options: [],
         collection: { id: IdMap.getId("cat"), title: "Suits" },
-        variants: product.variants,
+        variants: product.variants ?? [],
       }),
       findOneWithRelations: () => ({
         id: IdMap.getId("ironman"),
@@ -117,21 +117,29 @@ describe("ProductService", () => {
         Promise.resolve({ id: IdMap.getId("cat"), title: "Suits" }),
     }
 
+    const productVariantService = {
+      withTransaction: function () {
+        return this
+      },
+      create: (id, data) => Promise.resolve(data),
+    }
+
     const productService = new ProductService({
       manager: MockManager,
       productRepository,
       eventBusService,
       productCollectionService,
       productTagRepository,
       productTypeRepository,
+      productVariantService,
       featureFlagRouter: new FlagRouter({}),
     })
 
     beforeEach(() => {
       jest.clearAllMocks()
     })
 
-    it("successfully create a product", async () => {
+    it.only("should successfully create a product", async () => {
       await productService.create({
         title: "Suit",
         options: [],
@@ -158,16 +166,6 @@ describe("ProductService", () => {
       expect(productRepository.create).toHaveBeenCalledTimes(1)
       expect(productRepository.create).toHaveBeenCalledWith({
         title: "Suit",
-        variants: [
-          {
-            id: "test1",
-            title: "green",
-          },
-          {
-            id: "test2",
-            title: "blue",
-          },
-        ],
       })
 
       expect(productTagRepository.upsertTags).toHaveBeenCalledTimes(1)
@@ -197,10 +195,12 @@ describe("ProductService", () => {
         variants: [
           {
             id: "test1",
+            options: [],
             title: "green",
           },
           {
             id: "test2",
+            options: [],
             title: "blue",
           },
         ],

packages/medusa/src/services/product.ts

@@ -1,26 +1,28 @@
 import {
-    buildRelations,
-    buildSelects, FlagRouter, objectToStringPath
+  buildRelations,
+  buildSelects,
+  FlagRouter,
+  objectToStringPath,
 } from "@medusajs/utils"
 import { isDefined, MedusaError } from "medusa-core-utils"
 import { EntityManager, In } from "typeorm"
 import { ProductVariantService, SearchService } from "."
 import { TransactionBaseService } from "../interfaces"
 import SalesChannelFeatureFlag from "../loaders/feature-flags/sales-channels"
 import {
-    Product,
-    ProductCategory,
-    ProductOption,
-    ProductTag,
-    ProductType,
-    ProductVariant,
-    SalesChannel,
-    ShippingProfile,
+  Product,
+  ProductCategory,
+  ProductOption,
+  ProductTag,
+  ProductType,
+  ProductVariant,
+  SalesChannel,
+  ShippingProfile,
 } from "../models"
 import { ImageRepository } from "../repositories/image"
 import {
-    FindWithoutRelationsOptions,
-    ProductRepository,
+  FindWithoutRelationsOptions,
+  ProductRepository,
 } from "../repositories/product"
 import { ProductCategoryRepository } from "../repositories/product-category"
 import { ProductOptionRepository } from "../repositories/product-option"
@@ -29,15 +31,16 @@ import { ProductTypeRepository } from "../repositories/product-type"
 import { ProductVariantRepository } from "../repositories/product-variant"
 import { Selector } from "../types/common"
 import {
-    CreateProductInput,
-    FilterableProductProps,
-    FindProductConfig,
-    ProductOptionInput,
-    ProductSelector,
-    UpdateProductInput,
+  CreateProductInput,
+  FilterableProductProps,
+  FindProductConfig,
+  ProductOptionInput,
+  ProductSelector,
+  UpdateProductInput,
 } from "../types/product"
 import { buildQuery, isString, setMetadata } from "../utils"
 import EventBusService from "./event-bus"
+import { CreateProductVariantInput } from "../types/product-variant"
 
 type InjectedDependencies = {
   manager: EntityManager
@@ -429,6 +432,7 @@ class ProductService extends TransactionBaseService {
         tags,
         type,
         images,
+        variants,
         sales_channels: salesChannels,
         categories: categories,
         ...rest
@@ -501,6 +505,27 @@ class ProductService extends TransactionBaseService {
         })
       )
 
+      if (variants) {
+        const toCreate = variants.map((variant) => {
+          return {
+            ...variant,
+            options:
+              variant.options?.map((option, index) => {
+                return {
+                  option_id: product.options[index].id,
+                  ...option,
+                }
+              }) ?? [],
+          }
+        })
+        product.variants = await this.productVariantService_
+          .withTransaction(manager)
+          .create(
+            product.id,
+            toCreate as unknown as CreateProductVariantInput[]
+          )
+      }
+
       const result = await this.retrieve(product.id, {
         relations: ["options"],
       })