feat(medusa): integrate pricing module to core (#5304)

* add pricing integraiton feature flag * init * first endpoint * cleanup * remove console.logs * refactor to util and implement across endpoints * add changeset * rename variables * remove mistype * feat(medusa): move price module integration to pricing service (#5322) * initial changes * chore: make product service always internal for pricing module * add notes --------- Co-authored-by: Riqwan Thamir <rmthamir@gmail.com> * nit * cleanup * update to object querying * update cart integration test * remove uppercase currency_code * nit * Feat/admin product pricing module reads (#5354) * initial changes to list prices for admin * working price module implementation of list prices * nit * variant pricing * redo integration test changes * cleanup * cleanup * fix unit tests * [wip] Core <> Pricing - price updates (#5364) * chore: update medusa-app * wip * get links and modules working with migration * wip * chore: make test pass * Feat/rule type utils (#5371) * initial rule type utils * update migration script * chore: cleanup * ensure prices are always decorated * chore: use seed instead * chore: fix oas conflict * region id add to admin price read! --------- Co-authored-by: Philip Korsholm <88927411+pKorsholm@users.noreply.github.com> Co-authored-by: Philip Korsholm <philip.korsholm@hotmail.com> * pr feedback * create remoteQueryFunction type * fix merge * fix loaders issue * Feat(medusa, types, pricing): pricing module migration script (#5409) * add migration script for money amounts in pricing module * add changeset * rename file * cleanup imports * update changeset * add check for pricing module and ff * feat(medusa,workflows,types): update prices on product and variant update (#5412) * wip * chore: update product prices through workflow * chore: cleanup * chore: update product handler updates prices for variants * chore: handle reverts * chore: address pr comments * chore: scope workflow handlers to flag handlers * chore: update return * chore: update db url * chore: remove migration * chore: increase jest timeout * Feat(medusa): update migration and initDb to run link-migrations (#5437) * initial * loader update * more progress on loaders * update integration tests and remote-query loader * remove helper * migrate isolated modules * fix test * fix integration test * update with pr feedback * unregister medusa-app * re-register medusaApp * fix featureflag * set timeout * set timeout * conditionally run link-module migrations * pr feedback 1 * add driver options for db * throw if link is not defined in migration script * pass config module directly * include container in migrate command * chore: increase timeout * rm redis from api integration tests to test * chore: temporarily skip tests * chore: undo skips + add timeout for workflow tests * chore: increase timeout for order edits * re-add redis * include final resolution * add sharedcontainer to medusaapp loader * chore: move migration under run command * try removing redis_url from api tests * chore: cleanup server on process exit * chore: clear container on exit * chore: adjustments * chore: remove consoles * chore: close express app on finish * chore: destroy pg connection on shutdown * chore: skip * chore: unskip test * chore: cleanup container pg connection * chore: skip --------- Co-authored-by: Riqwan Thamir <rmthamir@gmail.com>
2023-10-30 14:42:17 +01:00
parent b69f182571
commit 148f537b47
84 changed files with 2702 additions and 284 deletions
--- a/integration-tests/plugins/tests/cart/store/index.ts
+++ b/integration-tests/plugins/tests/cart/store/index.ts
@@ -1,12 +1,12 @@
 import { MoneyAmount, PriceList, Region } from "@medusajs/medusa"
 import path from "path"

+import { ProductVariantMoneyAmount } from "@medusajs/medusa"
 import { bootstrapApp } from "../../../../environment-helpers/bootstrap-app"
 import setupServer from "../../../../environment-helpers/setup-server"
 import { setPort, useApi } from "../../../../environment-helpers/use-api"
 import { initDb, useDb } from "../../../../environment-helpers/use-db"
 import { simpleProductFactory } from "../../../../factories"
-import { ProductVariantMoneyAmount } from "@medusajs/medusa"

 jest.setTimeout(30000)

@@ -23,7 +23,7 @@ describe("/store/carts", () => {
  beforeAll(async () => {
    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
    dbConnection = await initDb({ cwd })
-    medusaProcess = await setupServer({ cwd, verbose: true })
+    medusaProcess = await setupServer({ cwd })
    const { app, port } = await bootstrapApp({ cwd })
    setPort(port)
    express = app.listen(port, () => {
@@ -134,7 +134,7 @@ describe("/store/carts", () => {
      await dbConnection.manager.save(ma_sale_1)

      await dbConnection.manager.insert(ProductVariantMoneyAmount, {
-        id: 'pvma-test', 
+        id: "pvma-test",
        variant_id: prodSale.variants[0].id,
        money_amount_id: ma_sale_1.id,
      })
--- a/integration-tests/plugins/tests/inventory/inventory-items/ff-many-to-many.js
+++ b/integration-tests/plugins/tests/inventory/inventory-items/ff-many-to-many.js
@@ -32,7 +32,7 @@ describe("Inventory Items endpoints", () => {
    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
    dbConnection = await initDb({ cwd })

-    const { container, app, port } = await bootstrapApp({ cwd, verbose: true })
+    const { container, app, port } = await bootstrapApp({ cwd })
    appContainer = container

    // Set feature flag
--- a/integration-tests/plugins/tests/pricing/get-product.ts
+++ b/integration-tests/plugins/tests/pricing/get-product.ts
@@ -0,0 +1,139 @@
+import { setPort, useApi } from "../../../environment-helpers/use-api"
+import { initDb, useDb } from "../../../environment-helpers/use-db"
+import { simpleCartFactory, simpleRegionFactory } from "../../../factories"
+
+import { ModuleRegistrationName } from "@medusajs/modules-sdk"
+import { AxiosInstance } from "axios"
+import path from "path"
+import { bootstrapApp } from "../../../environment-helpers/bootstrap-app"
+import adminSeeder from "../../../helpers/admin-seeder"
+
+jest.setTimeout(5000000)
+
+const DB_HOST = process.env.DB_HOST
+const DB_USERNAME = process.env.DB_USERNAME
+const DB_PASSWORD = process.env.DB_PASSWORD
+const DB_NAME = process.env.DB_TEMP_NAME
+const DB_URL = `postgres://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}`
+
+const adminHeaders = {
+  headers: {
+    "x-medusa-access-token": "test_token",
+  },
+}
+
+const env = {
+  MEDUSA_FF_ISOLATE_PRICING_DOMAIN: true,
+  MEDUSA_FF_ISOLATE_PRODUCT_DOMAIN: true,
+}
+
+describe("Link Modules", () => {
+  let medusaContainer
+  let dbConnection
+  let express
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", ".."))
+    dbConnection = await initDb({ cwd, env } as any)
+
+    const { container, app, port } = await bootstrapApp({ cwd, env })
+    medusaContainer = container
+    setPort(port)
+
+    express = app.listen(port)
+  })
+
+  afterAll(async () => {
+    const db = useDb()
+    await db.shutdown()
+
+    express.close()
+  })
+
+  beforeEach(async () => {
+    await adminSeeder(dbConnection)
+    await simpleRegionFactory(dbConnection, {
+      id: "region-1",
+      currency_code: "usd",
+    })
+  })
+
+  describe("get product price", () => {
+    let ruleType
+    let priceSet
+    let productId
+    const cartId = "test-cart"
+    beforeEach(async () => {
+      const pricingModuleService = medusaContainer.resolve(
+        ModuleRegistrationName.PRICING
+      )
+      const api = useApi()! as AxiosInstance
+
+      await simpleCartFactory(dbConnection, { id: cartId, region: "region-1" })
+
+      const payload = {
+        title: "Test",
+        description: "test-product-description",
+        images: ["test-image.png", "test-image-2.png"],
+        variants: [
+          {
+            title: "Test variant",
+            prices: [],
+            options: [],
+          },
+        ],
+      }
+
+      const response = await api.post("/admin/products", payload, adminHeaders)
+
+      productId = response.data.product.id
+      const variant = response.data.product.variants[0]
+
+      ruleType = await pricingModuleService.createRuleTypes([
+        { name: "region_id", rule_attribute: "region_id" },
+      ])
+
+      priceSet = await pricingModuleService.create({
+        rules: [{ rule_attribute: "region_id" }],
+        prices: [
+          {
+            amount: 1000,
+            currency_code: "usd",
+            rules: { region_id: "region-1" },
+          },
+          {
+            amount: 900,
+            currency_code: "usd",
+            rules: { region_id: "region-2" },
+          },
+        ],
+      })
+
+      const remoteLink = medusaContainer.resolve("remoteLink") as any
+
+      await remoteLink.create({
+        productService: {
+          variant_id: variant.id,
+        },
+        pricingService: {
+          price_set_id: priceSet.id,
+        },
+      })
+    })
+
+    it("Should get prices declared in pricing module", async () => {
+      const api = useApi()! as AxiosInstance
+
+      const response = await api.get(
+        `/store/products/${productId}?cart_id=${cartId}`
+      )
+
+      expect(response.data.product.variants[0].prices).toEqual([
+        expect.objectContaining({
+          amount: 1000,
+          currency_code: "usd",
+        }),
+      ])
+    })
+  })
+})
--- a/integration-tests/plugins/tests/product/admin/create-product.ts
+++ b/integration-tests/plugins/tests/product/admin/create-product.ts
@@ -0,0 +1,115 @@
+import { initDb, useDb } from "../../../../environment-helpers/use-db"
+
+import { Region } from "@medusajs/medusa"
+import { AxiosInstance } from "axios"
+import path from "path"
+import setupServer from "../../../../environment-helpers/setup-server"
+import { useApi } from "../../../../environment-helpers/use-api"
+import { getContainer } from "../../../../environment-helpers/use-container"
+import adminSeeder from "../../../../helpers/admin-seeder"
+import { createDefaultRuleTypes } from "../../../helpers/create-default-rule-types"
+
+jest.setTimeout(50000)
+
+const adminHeaders = {
+  headers: {
+    "x-medusa-access-token": "test_token",
+  },
+}
+
+const env = {
+  MEDUSA_FF_ISOLATE_PRICING_DOMAIN: true,
+  MEDUSA_FF_ISOLATE_PRODUCT_DOMAIN: true,
+}
+
+describe("[Product & Pricing Module] POST /admin/products", () => {
+  let dbConnection
+  let appContainer
+  let medusaProcess
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
+    dbConnection = await initDb({ cwd, env } as any)
+    medusaProcess = await setupServer({ cwd, env, bootstrapApp: true } as any)
+    appContainer = getContainer()
+  })
+
+  afterAll(async () => {
+    const db = useDb()
+    await db.shutdown()
+    medusaProcess.kill()
+  })
+
+  beforeEach(async () => {
+    const manager = dbConnection.manager
+    await adminSeeder(dbConnection)
+    await createDefaultRuleTypes(appContainer)
+
+    await manager.insert(Region, {
+      id: "test-region",
+      name: "Test Region",
+      currency_code: "usd",
+      tax_rate: 0,
+    })
+  })
+
+  afterEach(async () => {
+    const db = useDb()
+    await db.teardown()
+  })
+
+  it("should create prices with region_id and currency_code context", async () => {
+    const api = useApi()! as AxiosInstance
+
+    const data = {
+      title: "test product",
+      options: [{ title: "test-option" }],
+      variants: [
+        {
+          title: "test variant",
+          prices: [
+            {
+              amount: 66600,
+              region_id: "test-region",
+            },
+            {
+              amount: 55500,
+              currency_code: "usd",
+            },
+          ],
+          options: [{ value: "test-option" }],
+        },
+      ],
+    }
+
+    let response = await api.post(
+      "/admin/products?relations=variants.prices",
+      data,
+      adminHeaders
+    )
+
+    expect(response.status).toEqual(200)
+    expect(response.data).toEqual({
+      product: expect.objectContaining({
+        id: expect.any(String),
+        title: "test product",
+        variants: expect.arrayContaining([
+          expect.objectContaining({
+            id: expect.any(String),
+            title: "test variant",
+            prices: expect.arrayContaining([
+              expect.objectContaining({
+                amount: 66600,
+                currency_code: "usd",
+              }),
+              expect.objectContaining({
+                amount: 55500,
+                currency_code: "usd",
+              }),
+            ]),
+          }),
+        ]),
+      }),
+    })
+  })
+})
--- a/integration-tests/plugins/tests/product/admin/index.ts
+++ b/integration-tests/plugins/tests/product/admin/index.ts
@@ -23,7 +23,6 @@ const adminHeaders = {
 }

 describe("/admin/products", () => {
-  let medusaProcess
  let dbConnection
  let express
  let medusaContainer
@@ -44,7 +43,7 @@ describe("/admin/products", () => {
    const db = useDb()
    await db.shutdown()

-    medusaProcess.kill()
+    express.close()
  })

  it("Should have loaded the product module", function () {
--- a/integration-tests/plugins/tests/product/admin/update-product-variant.spec.ts
+++ b/integration-tests/plugins/tests/product/admin/update-product-variant.spec.ts
@@ -0,0 +1,253 @@
+import setupServer from "../../../../environment-helpers/setup-server"
+import { useApi } from "../../../../environment-helpers/use-api"
+import { getContainer } from "../../../../environment-helpers/use-container"
+import { initDb, useDb } from "../../../../environment-helpers/use-db"
+import {
+  simpleProductFactory,
+  simpleRegionFactory,
+} from "../../../../factories"
+
+import path from "path"
+import adminSeeder from "../../../../helpers/admin-seeder"
+import { createDefaultRuleTypes } from "../../../helpers/create-default-rule-types"
+import { createVariantPriceSet } from "../../../helpers/create-variant-price-set"
+
+jest.setTimeout(50000)
+
+const adminHeaders = {
+  headers: {
+    "x-medusa-access-token": "test_token",
+  },
+}
+
+const env = {
+  MEDUSA_FF_ISOLATE_PRICING_DOMAIN: true,
+  MEDUSA_FF_ISOLATE_PRODUCT_DOMAIN: true,
+}
+
+describe("[Product & Pricing Module] POST /admin/products/:id/variants/:id", () => {
+  let dbConnection
+  let appContainer
+  let medusaProcess
+  let product
+  let variant
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
+    dbConnection = await initDb({ cwd, env } as any)
+    medusaProcess = await setupServer({ cwd, env, bootstrapApp: true } as any)
+    appContainer = getContainer()
+  })
+
+  afterAll(async () => {
+    const db = useDb()
+    await db.shutdown()
+    medusaProcess.kill()
+  })
+
+  beforeEach(async () => {
+    await adminSeeder(dbConnection)
+    await createDefaultRuleTypes(appContainer)
+
+    await simpleRegionFactory(dbConnection, {
+      id: "test-region",
+      name: "Test Region",
+      currency_code: "usd",
+      tax_rate: 0,
+    })
+
+    product = await simpleProductFactory(dbConnection, {
+      id: "test-product-with-variant",
+      variants: [
+        {
+          options: [{ option_id: "test-product-option-1", value: "test" }],
+        },
+      ],
+      options: [
+        {
+          id: "test-product-option-1",
+          title: "Test option 1",
+        },
+      ],
+    })
+
+    variant = product.variants[0]
+  })
+
+  afterEach(async () => {
+    const db = useDb()
+    await db.teardown()
+  })
+
+  it("should create product variant price sets and prices", async () => {
+    const api = useApi()
+    const data = {
+      title: "test variant update",
+      prices: [
+        {
+          amount: 66600,
+          region_id: "test-region",
+        },
+        {
+          amount: 55500,
+          currency_code: "usd",
+          region_id: null,
+        },
+      ],
+    }
+
+    let response = await api.post(
+      `/admin/products/${product.id}/variants/${variant.id}`,
+      data,
+      adminHeaders
+    )
+
+    response = await api.get(`/admin/products/${product.id}`, adminHeaders)
+
+    expect(response.status).toEqual(200)
+    expect(response.data.product).toEqual(
+      expect.objectContaining({
+        id: expect.any(String),
+        variants: expect.arrayContaining([
+          expect.objectContaining({
+            id: variant.id,
+            title: "test variant update",
+            prices: expect.arrayContaining([
+              expect.objectContaining({
+                amount: 66600,
+                currency_code: "usd",
+                region_id: "test-region",
+              }),
+              expect.objectContaining({
+                amount: 55500,
+                currency_code: "usd",
+              }),
+            ]),
+          }),
+        ]),
+      })
+    )
+  })
+
+  it("should update money amounts if money amount id is present in prices", async () => {
+    const priceSet = await createVariantPriceSet({
+      container: appContainer,
+      variantId: variant.id,
+      prices: [
+        {
+          amount: 3000,
+          currency_code: "usd",
+          rules: {},
+        },
+      ],
+    })
+
+    const moneyAmountToUpdate = priceSet.money_amounts?.[0]
+
+    const api = useApi()
+    const data = {
+      title: "test variant update",
+      prices: [
+        {
+          amount: 66600,
+          region_id: "test-region",
+        },
+        {
+          id: moneyAmountToUpdate?.id,
+          amount: 2222,
+          currency_code: "usd",
+          region_id: null,
+        },
+      ],
+    }
+
+    let response = await api.post(
+      `/admin/products/${product.id}/variants/${variant.id}`,
+      data,
+      adminHeaders
+    )
+
+    response = await api.get(`/admin/products/${product.id}`, adminHeaders)
+
+    expect(response.status).toEqual(200)
+    expect(response.data.product).toEqual(
+      expect.objectContaining({
+        id: expect.any(String),
+        variants: expect.arrayContaining([
+          expect.objectContaining({
+            id: variant.id,
+            title: "test variant update",
+            prices: expect.arrayContaining([
+              expect.objectContaining({
+                amount: 66600,
+                currency_code: "usd",
+                region_id: "test-region",
+              }),
+              expect.objectContaining({
+                id: moneyAmountToUpdate?.id,
+                amount: 2222,
+                currency_code: "usd",
+              }),
+            ]),
+          }),
+        ]),
+      })
+    )
+  })
+
+  it("should add prices if price set is already present", async () => {
+    await createVariantPriceSet({
+      container: appContainer,
+      variantId: variant.id,
+      prices: [],
+    })
+
+    const api = useApi()
+    const data = {
+      title: "test variant update",
+      prices: [
+        {
+          amount: 123,
+          region_id: "test-region",
+        },
+        {
+          amount: 456,
+          currency_code: "usd",
+          region_id: null,
+        },
+      ],
+    }
+
+    let response = await api.post(
+      `/admin/products/${product.id}/variants/${variant.id}`,
+      data,
+      adminHeaders
+    )
+
+    response = await api.get(`/admin/products/${product.id}`, adminHeaders)
+
+    expect(response.status).toEqual(200)
+    expect(response.data.product).toEqual(
+      expect.objectContaining({
+        id: expect.any(String),
+        variants: expect.arrayContaining([
+          expect.objectContaining({
+            id: variant.id,
+            title: "test variant update",
+            prices: expect.arrayContaining([
+              expect.objectContaining({
+                amount: 123,
+                currency_code: "usd",
+                region_id: "test-region",
+              }),
+              expect.objectContaining({
+                amount: 456,
+                currency_code: "usd",
+              }),
+            ]),
+          }),
+        ]),
+      })
+    )
+  })
+})
--- a/integration-tests/plugins/tests/product/admin/update-product.spec.ts
+++ b/integration-tests/plugins/tests/product/admin/update-product.spec.ts
@@ -0,0 +1,283 @@
+import setupServer from "../../../../environment-helpers/setup-server"
+import { useApi } from "../../../../environment-helpers/use-api"
+import { getContainer } from "../../../../environment-helpers/use-container"
+import { initDb, useDb } from "../../../../environment-helpers/use-db"
+import { simpleProductFactory } from "../../../../factories"
+
+import { Region } from "@medusajs/medusa"
+import { AxiosInstance } from "axios"
+import path from "path"
+import adminSeeder from "../../../../helpers/admin-seeder"
+import { createDefaultRuleTypes } from "../../../helpers/create-default-rule-types"
+import { createVariantPriceSet } from "../../../helpers/create-variant-price-set"
+
+jest.setTimeout(50000)
+
+const adminHeaders = {
+  headers: {
+    "x-medusa-access-token": "test_token",
+  },
+}
+
+const env = {
+  MEDUSA_FF_ISOLATE_PRICING_DOMAIN: true,
+  MEDUSA_FF_ISOLATE_PRODUCT_DOMAIN: true,
+}
+
+describe.skip("[Product & Pricing Module] POST /admin/products/:id", () => {
+  let dbConnection
+  let appContainer
+  let medusaProcess
+  let product
+  let variant
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
+    dbConnection = await initDb({ cwd, env } as any)
+    medusaProcess = await setupServer({ cwd, env, bootstrapApp: true } as any)
+    appContainer = getContainer()
+  })
+
+  afterAll(async () => {
+    const db = useDb()
+    await db.shutdown()
+    medusaProcess.kill()
+  })
+
+  beforeEach(async () => {
+    const manager = dbConnection.manager
+    await adminSeeder(dbConnection)
+    await createDefaultRuleTypes(appContainer)
+
+    await manager.insert(Region, {
+      id: "test-region",
+      name: "Test Region",
+      currency_code: "usd",
+      tax_rate: 0,
+    })
+
+    product = await simpleProductFactory(dbConnection, {
+      id: "test-product-with-variant",
+      variants: [
+        {
+          options: [{ option_id: "test-product-option-1", value: "test" }],
+        },
+      ],
+      options: [
+        {
+          id: "test-product-option-1",
+          title: "Test option 1",
+        },
+      ],
+    })
+
+    variant = product.variants[0]
+  })
+
+  afterEach(async () => {
+    const db = useDb()
+    await db.teardown()
+  })
+
+  it("should update product variant price sets and prices", async () => {
+    const api = useApi()
+    const data = {
+      title: "test product update",
+      variants: [
+        {
+          id: variant.id,
+          title: "test variant update",
+          prices: [
+            {
+              amount: 66600,
+              region_id: "test-region",
+            },
+            {
+              amount: 55500,
+              currency_code: "usd",
+              region_id: null,
+            },
+          ],
+        },
+      ],
+    }
+
+    let response = await api.post(
+      `/admin/products/${product.id}`,
+      data,
+      adminHeaders
+    )
+
+    response = await api.get(`/admin/products/${product.id}`, adminHeaders)
+
+    expect(response.status).toEqual(200)
+    expect(response.data.product).toEqual(
+      expect.objectContaining({
+        id: expect.any(String),
+        variants: expect.arrayContaining([
+          expect.objectContaining({
+            id: variant.id,
+            title: "test variant update",
+            prices: expect.arrayContaining([
+              expect.objectContaining({
+                amount: 66600,
+                currency_code: "usd",
+                region_id: "test-region",
+              }),
+              expect.objectContaining({
+                amount: 55500,
+                currency_code: "usd",
+              }),
+            ]),
+          }),
+        ]),
+      })
+    )
+  })
+
+  it("should update money amounts if money amount id is present in prices", async () => {
+    const priceSet = await createVariantPriceSet({
+      container: appContainer,
+      variantId: variant.id,
+      prices: [
+        {
+          amount: 3000,
+          currency_code: "usd",
+          rules: {},
+        },
+      ],
+    })
+
+    const moneyAmountToUpdate = priceSet.money_amounts?.[0]
+
+    const api = useApi()
+    const data = {
+      title: "test product update",
+      variants: [
+        {
+          id: variant.id,
+          title: "test variant update",
+          prices: [
+            {
+              amount: 66600,
+              region_id: "test-region",
+            },
+            {
+              id: moneyAmountToUpdate?.id,
+              amount: 2222,
+              currency_code: "usd",
+              region_id: null,
+            },
+          ],
+        },
+      ],
+    }
+
+    let response = await api.post(
+      `/admin/products/${product.id}`,
+      data,
+      adminHeaders
+    )
+
+    response = await api.get(`/admin/products/${product.id}`, adminHeaders)
+
+    expect(response.status).toEqual(200)
+    expect(response.data.product).toEqual(
+      expect.objectContaining({
+        id: expect.any(String),
+        variants: expect.arrayContaining([
+          expect.objectContaining({
+            id: variant.id,
+            title: "test variant update",
+            prices: expect.arrayContaining([
+              expect.objectContaining({
+                amount: 66600,
+                currency_code: "usd",
+                region_id: "test-region",
+              }),
+              expect.objectContaining({
+                id: moneyAmountToUpdate?.id,
+                amount: 2222,
+                currency_code: "usd",
+              }),
+            ]),
+          }),
+        ]),
+      })
+    )
+  })
+
+  it("should add prices if price set is already present", async () => {
+    const remoteLink = appContainer.resolve("remoteLink")
+    const pricingModuleService = appContainer.resolve("pricingModuleService")
+
+    const priceSet = await pricingModuleService.create({
+      rules: [{ rule_attribute: "region_id" }],
+      prices: [],
+    })
+
+    await remoteLink.create({
+      productService: {
+        variant_id: variant.id,
+      },
+      pricingService: {
+        price_set_id: priceSet.id,
+      },
+    })
+
+    const api = useApi()! as AxiosInstance
+
+    const data = {
+      title: "test product update",
+      variants: [
+        {
+          id: variant.id,
+          title: "test variant update",
+          prices: [
+            {
+              amount: 123,
+              region_id: "test-region",
+            },
+            {
+              amount: 456,
+              currency_code: "usd",
+              region_id: null,
+            },
+          ],
+        },
+      ],
+    }
+
+    let response = await api.post(
+      `/admin/products/${product.id}`,
+      data,
+      adminHeaders
+    )
+
+    response = await api.get(`/admin/products/${product.id}`, adminHeaders)
+
+    expect(response.status).toEqual(200)
+    expect(response.data.product).toEqual(
+      expect.objectContaining({
+        id: expect.any(String),
+        variants: expect.arrayContaining([
+          expect.objectContaining({
+            id: variant.id,
+            title: "test variant update",
+            prices: expect.arrayContaining([
+              expect.objectContaining({
+                amount: 123,
+                currency_code: "usd",
+                region_id: "test-region",
+              }),
+              expect.objectContaining({
+                amount: 456,
+                currency_code: "usd",
+              }),
+            ]),
+          }),
+        ]),
+      })
+    )
+  })
+})
--- a/integration-tests/plugins/tests/workflows/product/update-product.ts
+++ b/integration-tests/plugins/tests/workflows/product/update-product.ts
@@ -1,16 +1,18 @@
+import { WorkflowTypes } from "@medusajs/types"
 import {
  Handlers,
  pipe,
  updateProducts,
  UpdateProductsActions,
 } from "@medusajs/workflows"
-import { WorkflowTypes } from "@medusajs/types"
 import path from "path"

-import { initDb, useDb } from "../../../../environment-helpers/use-db"
 import { bootstrapApp } from "../../../../environment-helpers/bootstrap-app"
+import { initDb, useDb } from "../../../../environment-helpers/use-db"
 import { simpleProductFactory } from "../../../../factories"

+jest.setTimeout(30000)
+
 describe("UpdateProduct workflow", function () {
  let medusaProcess
  let dbConnection
--- a/integration-tests/plugins/helpers/create-default-rule-types.ts
+++ b/integration-tests/plugins/helpers/create-default-rule-types.ts
@@ -0,0 +1,14 @@
+import { IPricingModuleService } from "@medusajs/types"
+
+export const createDefaultRuleTypes = async (container) => {
+  const pricingModuleService: IPricingModuleService = container.resolve(
+    "pricingModuleService"
+  )
+
+  return pricingModuleService.createRuleTypes([
+    {
+      name: "region_id",
+      rule_attribute: "region_id",
+    },
+  ])
+}
--- a/integration-tests/plugins/helpers/create-variant-price-set.ts
+++ b/integration-tests/plugins/helpers/create-variant-price-set.ts
@@ -0,0 +1,51 @@
+import { MedusaContainer } from "@medusajs/modules-sdk"
+import {
+  CreatePriceSetDTO,
+  IPricingModuleService,
+  PriceSetDTO,
+} from "@medusajs/types"
+
+const defaultPrices = [
+  {
+    amount: 3000,
+    currency_code: "usd",
+    rules: {},
+  },
+]
+
+const defaultPriceSetRules = [{ rule_attribute: "region_id" }]
+
+export const createVariantPriceSet = async ({
+  container,
+  variantId,
+  prices = defaultPrices,
+  rules = defaultPriceSetRules,
+}: {
+  container: MedusaContainer
+  variantId: string
+  prices?: CreatePriceSetDTO["prices"]
+  rules?: CreatePriceSetDTO["rules"]
+}): Promise<PriceSetDTO> => {
+  const remoteLink = container.resolve("remoteLink")
+  const pricingModuleService: IPricingModuleService = container.resolve(
+    "pricingModuleService"
+  )
+
+  const priceSet = await pricingModuleService.create({
+    rules,
+    prices,
+  })
+
+  await remoteLink.create({
+    productService: {
+      variant_id: variantId,
+    },
+    pricingService: {
+      price_set_id: priceSet.id,
+    },
+  })
+
+  return await pricingModuleService.retrieve(priceSet.id, {
+    relations: ["money_amounts"],
+  })
+}
--- a/integration-tests/plugins/medusa-config.js
+++ b/integration-tests/plugins/medusa-config.js
@@ -5,6 +5,10 @@ const DB_USERNAME = process.env.DB_USERNAME
 const DB_PASSWORD = process.env.DB_PASSWORD
 const DB_NAME = process.env.DB_TEMP_NAME
 const DB_URL = `postgres://${DB_USERNAME}:${DB_PASSWORD}@${DB_HOST}/${DB_NAME}`
+process.env.POSTGRES_URL = DB_URL
+
+const enablePricing = process.env.MEDUSA_FF_ISOLATE_PRICING_DOMAIN == "true"
+const enableProduct = process.env.MEDUSA_FF_ISOLATE_PRODUCT_DOMAIN == "true"

 module.exports = {
  plugins: [
@@ -33,6 +37,8 @@ module.exports = {
    database_extra: { idle_in_transaction_session_timeout: 0 },
  },
  featureFlags: {
+    isolate_product_domain: enableProduct,
+    isolate_pricing_domain: enablePricing,
    workflows: {
      [Workflows.CreateProducts]: true,
      [Workflows.UpdateProducts]: true,
@@ -59,5 +65,10 @@ module.exports = {
      resources: "shared",
      resolve: "@medusajs/product",
    },
+    [Modules.PRICING]: {
+      scope: "internal",
+      resources: "shared",
+      resolve: "@medusajs/pricing",
+    },
  },
 }
--- a/integration-tests/plugins/package.json
+++ b/integration-tests/plugins/package.json
@@ -13,6 +13,8 @@
    "@medusajs/event-bus-local": "workspace:*",
    "@medusajs/inventory": "workspace:^",
    "@medusajs/medusa": "workspace:*",
+    "@medusajs/modules-sdk": "workspace:^",
+    "@medusajs/pricing": "workspace:^",
    "@medusajs/product": "workspace:^",
    "faker": "^5.5.3",
    "medusa-fulfillment-webshipper": "workspace:*",