@labdigital/commercetools-mock 0.14.0 → 1.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@labdigital/commercetools-mock",
   "author": "Michael van Tellingen",
-  "version": "0.14.0",
+  "version": "1.0.0",
   "license": "MIT",
   "main": "dist/index.js",
   "module": "dist/commercetools--mock.esm.js",
@@ -17,10 +17,10 @@
     }
   },
   "engines": {
-    "node": ">=14",
-    "pnpm": ">=7.13.2"
+    "node": ">=16",
+    "pnpm": ">=8.1.1"
   },
-  "packageManager": "pnpm@7.13.2",
+  "packageManager": "pnpm@8.1.1",
   "publishConfig": {
     "access": "public"
   },
@@ -51,6 +51,7 @@
     "@changesets/cli": "^2.26.0",
     "@changesets/changelog-github": "^0.4.8",
     "@commercetools/platform-sdk": "4.0.0",
+    "@labdigital/eslint-config-node": "0.0.5",
     "@types/basic-auth": "^1.1.3",
     "@types/body-parser": "^1.19.2",
     "@types/deep-equal": "^1.0.1",
@@ -71,7 +72,6 @@
     "got": "^11.8.3",
     "husky": "^7.0.4",
     "jest": "^28.1.3",
-    "nodemon": "^2.0.15",
     "prettier": "^2.7.1",
     "timekeeper": "^2.2.0",
     "ts-node": "^10.4.0",
@@ -84,9 +84,10 @@
     "@commercetools/platform-sdk": "^2.4.1"
   },
   "scripts": {
-    "start": "nodemon --watch src --exec 'node -r esbuild-register' src/server.ts",
+    "start": "tsup src --watch src/server.ts",
     "build": "tsup",
     "build:server": "esbuild src/server.ts --bundle --outfile=dist/server.js --platform=node",
+    "publish:ci": "pnpm build && pnpm changeset publish",
     "check": "eslint src && tsc",
     "test": "jest test --coverage",
     "lint": "eslint src"

package/src/repositories/standalone-price.ts

@@ -1,36 +1,74 @@
 import {
-  Review,
+  ChannelReference,
+  ChannelResourceIdentifier,
+  DiscountedPriceDraft,
   StandalonePrice,
-  StandalonePriceUpdateAction,
+  StandalonePriceChangeActiveAction,
+  StandalonePriceChangeValueAction,
+  StandalonePriceDraft,
+  StandalonePriceSetDiscountedPriceAction,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers'
 import { Writable } from '../types'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
+import { createTypedMoney } from './helpers'
 
 export class StandAlonePriceRepository extends AbstractResourceRepository<'standalone-price'> {
   getTypeId() {
     return 'standalone-price' as const
   }
 
-  create(context: RepositoryContext, draft: StandalonePrice): StandalonePrice {
+  create(context: RepositoryContext, draft: StandalonePriceDraft): StandalonePrice {
     const resource: StandalonePrice = {
       ...getBaseResourceProperties(),
-      active: draft.active,
+      active: draft.active? draft.active : false,
       sku: draft.sku,
-      value: draft.value,
+      value: createTypedMoney(draft.value),
+      country: draft.country,
+      discounted: draft.discounted ? this.transformDiscountDraft(draft.discounted) : undefined,
+      channel: draft.channel?.id ? this.transformChannelReferenceDraft(draft.channel) : undefined,
+      validFrom: draft.validFrom,
+      validUntil: draft.validUntil,
     }
     this.saveNew(context, resource)
     return resource
   }
 
-  actions: Partial<
-    Record<
-      StandalonePriceUpdateAction['action'],
-      (
-        context: RepositoryContext,
-        resource: Writable<Review>,
-        action: any
-      ) => void
-    >
-  > = {}
+  transformChannelReferenceDraft(channel: ChannelResourceIdentifier) : ChannelReference {
+    return {
+      typeId: channel.typeId,
+      id: channel.id as string,
+    }
+  }
+
+  transformDiscountDraft(discounted: DiscountedPriceDraft) {
+    return {
+      value: createTypedMoney(discounted.value),
+      discount: discounted.discount,
+    }
+  }
+
+  actions = {
+    setActive: (
+      context: RepositoryContext,
+      resource: Writable<StandalonePrice>,
+      action: StandalonePriceChangeActiveAction
+    ) => {
+      resource.active = action.active
+    },
+    changeValue: (
+      context: RepositoryContext,
+      resource: Writable<StandalonePrice>,
+      action: StandalonePriceChangeValueAction
+    ) => {
+      resource.value = createTypedMoney(action.value)
+    },
+    setDiscountedPrice: ( 
+      context: RepositoryContext,
+      resource: Writable<StandalonePrice>,
+      action: StandalonePriceSetDiscountedPriceAction
+    ) => {
+      resource.discounted = action.discounted ? this.transformDiscountDraft(action.discounted) : undefined
+    }
+  }
 }

package/src/services/standalone-price.test.ts

@@ -4,34 +4,272 @@ import { CommercetoolsMock } from '../index'
 
 const ctMock = new CommercetoolsMock()
 
-describe('StandalonePrice', () => {
-    test('Create standalone price', async () => {
+describe('Standalone price Query', () => {
+    beforeAll(async () => {
         const draft: StandalonePriceDraft = {
-            sku: 'test-sku',
             value: {
+                centAmount: 100,
                 currencyCode: 'EUR',
-                centAmount: 1000,
             },
+            country: 'DE',
+            sku: 'foo',
             active: true,
+            channel: {
+                typeId: 'channel',
+                id: 'bar',
+            },
+            discounted: {
+                value: {
+                    centAmount: 80,
+                    currencyCode: 'EUR',
+                },
+                discount: {
+                    typeId: 'product-discount',
+                    id: 'baz',
+                },
+            },
         }
+        const createResponse = await supertest(ctMock.app)
+            .post('/dummy/standalone-prices')
+            .send(draft)
+        expect(createResponse.status).toEqual(201)
+    })
 
-        const response = await supertest(ctMock.app).post('/dummy/standalone-prices').send(draft)
-        expect(response.status).toBe(201)
+    afterAll(async () => {
+        ctMock.clear()
     })
 
     test('Get standalone price', async () => {
+        const response = await supertest(ctMock.app).get('/dummy/standalone-prices?sku=foo')
+
+        expect(response.status).toBe(200)
+
+        expect(response.body.results).toEqual([
+            {
+                active: true,
+                channel: {
+                    id: 'bar',
+                    typeId: 'channel',
+                },
+                country: 'DE',
+                createdAt: expect.anything(),
+                discounted: {
+                    discount: {
+                        id: 'baz',
+                        typeId: 'product-discount',
+                    },
+                    value: {
+                        centAmount: 80,
+                        currencyCode: 'EUR',
+                        fractionDigits: 2,
+                        type: 'centPrecision',
+                    },
+                },
+                id: expect.anything(),
+                lastModifiedAt: expect.anything(),
+                sku: 'foo',
+                value: {
+                    centAmount: 100,
+                    currencyCode: 'EUR',
+                    fractionDigits: 2,
+                    type: 'centPrecision',
+                },
+                version: 1,
+            },
+        ])
+    })
+})
+
+describe('Standalone price Actions', () => {
+    let id: string | undefined
+    beforeEach(async () => {
         const draft: StandalonePriceDraft = {
-            sku: 'test-sku',
             value: {
+                centAmount: 100,
                 currencyCode: 'EUR',
-                centAmount: 1000,
             },
+            country: 'DE',
+            sku: 'foo',
             active: true,
+            channel: {
+                typeId: 'channel',
+                id: 'bar',
+            },
         }
+        const createResponse = await supertest(ctMock.app)
+            .post('/dummy/standalone-prices')
+            .send(draft)
+        expect(createResponse.status).toEqual(201)
+        id = createResponse.body.id
+    })
+
+    afterEach(async () => {
+        ctMock.clear()
+    })
+
+    test('changeValue', async () => {
+        const response = await supertest(ctMock.app)
+            .post('/dummy/standalone-prices/' + id)
+            .send({
+                version: 1,
+                actions: [
+                    {
+                        action: 'changeValue',
+                        value: {
+                            centAmount: 200,
+                            currencyCode: 'EUR',
+                        },
+                    },
+                ],
+            })
+
+        expect(response.status).toBe(200)
+
+        expect(response.body).toEqual({
+            active: true,
+            channel: {
+                id: 'bar',
+                typeId: 'channel',
+            },
+            country: 'DE',
+            createdAt: expect.anything(),
+            id: id,
+            lastModifiedAt: expect.anything(),
+            sku: 'foo',
+            value: {
+                centAmount: 200,
+                currencyCode: 'EUR',
+                fractionDigits: 2,
+                type: 'centPrecision',
+            },
+            version: 2,
+        })
+    })
 
-        const createResponse = await supertest(ctMock.app).post('/dummy/standalone-prices').send(draft)
+    test('setActive', async () => {
+        const response = await supertest(ctMock.app)
+            .post('/dummy/standalone-prices/' + id)
+            .send({
+                version: 1,
+                actions: [
+                    {
+                        action: 'setActive',
+                        active: false,
+                    },
+                ],
+            })
 
-        const response = await supertest(ctMock.app).get(`/dummy/standalone-prices/${createResponse.body.id}`)
         expect(response.status).toBe(200)
+
+        expect(response.body).toEqual({
+            active: false,
+            channel: {
+                id: 'bar',
+                typeId: 'channel',
+            },
+            country: 'DE',
+            createdAt: expect.anything(),
+            id: id,
+            lastModifiedAt: expect.anything(),
+            sku: 'foo',
+            value: {
+                centAmount: 100,
+                currencyCode: 'EUR',
+                fractionDigits: 2,
+                type: 'centPrecision',
+            },
+            version: 2,
+        })
+    })
+
+    test('setDiscounted', async () => {
+        const response = await supertest(ctMock.app)
+            .post('/dummy/standalone-prices/' + id)
+            .send({
+                version: 1,
+                actions: [
+                    {
+                        action: 'setDiscountedPrice',
+                        discounted: {
+                            value: {
+                                centAmount: 80,
+                                currencyCode: 'EUR',
+                            },
+                            discount: {
+                                typeId: 'product-discount',
+                                id: 'baz',
+                            },
+                        },
+                    },
+                ],
+            })
+
+        expect(response.status).toBe(200)
+
+        expect(response.body).toEqual({
+            active: true,
+            channel: {
+                id: 'bar',
+                typeId: 'channel',
+            },
+            country: 'DE',
+            createdAt: expect.anything(),
+            discounted: {
+                discount: {
+                    id: 'baz',
+                    typeId: 'product-discount',
+                },
+                value: {
+                    centAmount: 80,
+                    currencyCode: 'EUR',
+                    fractionDigits: 2,
+                    type: 'centPrecision',
+                },
+            },
+            id: id,
+            lastModifiedAt: expect.anything(),
+            sku: 'foo',
+            value: {
+                centAmount: 100,
+                currencyCode: 'EUR',
+                fractionDigits: 2,
+                type: 'centPrecision',
+            },
+            version: 2,
+        })
+
+        const response2 = await supertest(ctMock.app)
+            .post('/dummy/standalone-prices/' + id)
+            .send({
+                version: 2,
+                actions: [
+                    {
+                        action: 'setDiscountedPrice',
+                        discounted: null,
+                    },
+                ],
+            })
+
+        expect(response2.status).toBe(200)
+
+        expect(response2.body).toEqual({
+            active: true,
+            channel: {
+                id: 'bar',
+                typeId: 'channel',
+            },
+            country: 'DE',
+            createdAt: expect.anything(),
+            id: id,
+            lastModifiedAt: expect.anything(),
+            sku: 'foo',
+            value: {
+                centAmount: 100,
+                currencyCode: 'EUR',
+                fractionDigits: 2,
+                type: 'centPrecision',
+            },
+            version: 3,
+        })
     })
 })