@labdigital/commercetools-mock 0.10.0 → 0.10.1

package/src/repositories/extension.ts

@@ -6,19 +6,18 @@ import {
   ExtensionSetKeyAction,
   ExtensionSetTimeoutInMsAction,
   ExtensionUpdateAction,
-  ReferenceTypeId,
 } from '@commercetools/platform-sdk'
-import { Resource, Writable } from '../types'
 import { getBaseResourceProperties } from '../helpers'
-import { AbstractResourceRepository, RepositoryContext } from './abstract'
 import { maskSecretValue } from '../lib/masking'
+import { Writable } from '../types'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
 
-export class ExtensionRepository extends AbstractResourceRepository {
-  getTypeId(): ReferenceTypeId {
-    return 'extension'
+export class ExtensionRepository extends AbstractResourceRepository<'extension'> {
+  getTypeId() {
+    return 'extension' as const
   }
 
-  postProcessResource<T extends Resource>(resource: T): T {
+  postProcessResource(resource: Extension): Extension {
     if (resource) {
       const extension = resource as Extension
       if (
@@ -28,7 +27,7 @@ export class ExtensionRepository extends AbstractResourceRepository {
         return maskSecretValue(
           extension,
           'destination.authentication.headerValue'
-        ) as T
+        )
       } else if (extension.destination.type == 'AWSLambda') {
         return maskSecretValue(resource, 'destination.accessSecret')
       }

package/src/repositories/helpers.ts

@@ -1,4 +1,3 @@
-import { v4 as uuidv4 } from 'uuid'
 import {
   Address,
   BaseAddress,
@@ -18,9 +17,10 @@ import {
   TypedMoney,
 } from '@commercetools/platform-sdk'
 import { Request } from 'express'
+import { v4 as uuidv4 } from 'uuid'
+import { CommercetoolsError } from '../exceptions'
 import { AbstractStorage } from '../storage'
 import { RepositoryContext } from './abstract'
-import { CommercetoolsError } from '../exceptions'
 
 export const createAddress = (
   base: BaseAddress | undefined,

package/src/repositories/index.ts

@@ -11,14 +11,21 @@ import { ExtensionRepository } from './extension'
 import { InventoryEntryRepository } from './inventory-entry'
 import { MyOrderRepository } from './my-order'
 import { OrderRepository } from './order'
+import { OrderEditRepository } from './order-edit'
 import { PaymentRepository } from './payment'
 import { ProductRepository } from './product'
 import { ProductDiscountRepository } from './product-discount'
 import { ProductProjectionRepository } from './product-projection'
+import { ProductSelectionRepository } from './product-selection'
 import { ProductTypeRepository } from './product-type'
 import { ProjectRepository } from './project'
+import { QuoteRepository } from './quote'
+import { QuoteRequestRepository } from './quote-request'
+import { ReviewRepository } from './review'
 import { ShippingMethodRepository } from './shipping-method'
 import { ShoppingListRepository } from './shopping-list'
+import { StagedQuoteRepository } from './staged-quote'
+import { StandAlonePriceRepository } from './standalone-price'
 import { StateRepository } from './state'
 import { StoreRepository } from './store'
 import { SubscriptionRepository } from './subscription'
@@ -26,6 +33,8 @@ import { TaxCategoryRepository } from './tax-category'
 import { TypeRepository } from './type'
 import { ZoneRepository } from './zone'
 
+export type RepositoryMap = ReturnType<typeof createRepositories>
+
 export const createRepositories = (storage: AbstractStorage) => ({
   category: new CategoryRepository(storage),
   cart: new CartRepository(storage),
@@ -38,18 +47,25 @@ export const createRepositories = (storage: AbstractStorage) => ({
   'inventory-entry': new InventoryEntryRepository(storage),
   'key-value-document': new CustomObjectRepository(storage),
   order: new OrderRepository(storage),
+  'order-edit': new OrderEditRepository(storage),
   payment: new PaymentRepository(storage),
   'my-cart': new CartRepository(storage),
   'my-order': new MyOrderRepository(storage),
   'my-customer': new CustomerRepository(storage),
   'my-payment': new PaymentRepository(storage),
-  'shipping-method': new ShippingMethodRepository(storage),
-  'product-type': new ProductTypeRepository(storage),
   product: new ProductRepository(storage),
-  project: new ProjectRepository(storage),
+  'product-type': new ProductTypeRepository(storage),
   'product-discount': new ProductDiscountRepository(storage),
   'product-projection': new ProductProjectionRepository(storage),
+  'product-selection': new ProductSelectionRepository(storage),
+  project: new ProjectRepository(storage),
+  review: new ReviewRepository(storage),
+  quote: new QuoteRepository(storage),
+  'quote-request': new QuoteRequestRepository(storage),
+  'shipping-method': new ShippingMethodRepository(storage),
   'shopping-list': new ShoppingListRepository(storage),
+  'staged-quote': new StagedQuoteRepository(storage),
+  'standalone-price': new StandAlonePriceRepository(storage),
   state: new StateRepository(storage),
   store: new StoreRepository(storage),
   subscription: new SubscriptionRepository(storage),

package/src/repositories/inventory-entry.ts

@@ -6,16 +6,15 @@ import {
   InventoryEntrySetCustomTypeAction,
   InventoryEntrySetExpectedDeliveryAction,
   InventoryEntrySetRestockableInDaysAction,
-  ReferenceTypeId,
 } from '@commercetools/platform-sdk'
 import { getBaseResourceProperties } from '../helpers'
+import { Writable } from '../types'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
 import { createCustomFields } from './helpers'
-import { Writable } from '../types'
 
-export class InventoryEntryRepository extends AbstractResourceRepository {
-  getTypeId(): ReferenceTypeId {
-    return 'inventory-entry'
+export class InventoryEntryRepository extends AbstractResourceRepository<'inventory-entry'> {
+  getTypeId() {
+    return 'inventory-entry' as const
   }
 
   create(

package/src/repositories/my-order.ts

@@ -1,11 +1,11 @@
-import assert from 'assert'
 import {
   CartReference,
   MyOrderFromCartDraft,
   Order,
 } from '@commercetools/platform-sdk'
-import { OrderRepository } from './order'
+import assert from 'assert'
 import { RepositoryContext } from './abstract'
+import { OrderRepository } from './order'
 
 export class MyOrderRepository extends OrderRepository {
   create(context: RepositoryContext, draft: MyOrderFromCartDraft): Order {

package/src/repositories/order-edit.ts

@@ -0,0 +1,39 @@
+import {
+  OrderEdit,
+  OrderEditDraft,
+  OrderEditResult,
+  OrderEditUpdateAction,
+} from '@commercetools/platform-sdk'
+import { getBaseResourceProperties } from '../helpers'
+import { Writable } from '../types'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
+
+export class OrderEditRepository extends AbstractResourceRepository<'order-edit'> {
+  getTypeId() {
+    return 'order-edit' as const
+  }
+
+  create(context: RepositoryContext, draft: OrderEditDraft): OrderEdit {
+    const resource: OrderEdit = {
+      ...getBaseResourceProperties(),
+      stagedActions: draft.stagedActions ?? [],
+      resource: draft.resource,
+      result: {
+        type: 'NotProcessed',
+      } as OrderEditResult,
+    }
+    this.saveNew(context, resource)
+    return resource
+  }
+
+  actions: Partial<
+    Record<
+      OrderEditUpdateAction['action'],
+      (
+        context: RepositoryContext,
+        resource: Writable<OrderEdit>,
+        action: any
+      ) => void
+    >
+  > = {}
+}

package/src/repositories/order.test.ts

@@ -1,6 +1,6 @@
 import { Cart, OrderImportDraft } from '@commercetools/platform-sdk'
-import { OrderRepository } from './order'
 import { InMemoryStorage } from '../storage'
+import { OrderRepository } from './order'
 
 describe('Order repository', () => {
   const storage = new InMemoryStorage()
@@ -21,6 +21,8 @@ describe('Order repository', () => {
         fractionDigits: 2,
       },
       cartState: 'Active',
+      shippingMode: 'Single',
+      shipping: [],
       taxMode: 'Platform',
       taxRoundingMode: 'HalfEven',
       taxCalculationMode: 'UnitPriceLevel',
@@ -29,18 +31,19 @@ describe('Order repository', () => {
     }
 
     storage.add('dummy', 'cart', cart)
+    const ctx = { projectKey: 'dummy' }
 
-    const result = repository.create(
-      { projectKey: 'dummy' },
-      {
-        cart: {
-          id: cart.id,
-          typeId: 'cart',
-        },
-        version: cart.version,
-      }
-    )
+    const result = repository.create(ctx, {
+      cart: {
+        id: cart.id,
+        typeId: 'cart',
+      },
+      version: cart.version,
+    })
     expect(result.cart?.id).toBe(cart.id)
+
+    const items = repository.query(ctx)
+    expect(items.count).toBe(1)
   })
 
   test('create from cart - in store', async () => {
@@ -58,6 +61,8 @@ describe('Order repository', () => {
         fractionDigits: 2,
       },
       cartState: 'Active',
+      shippingMode: 'Single',
+      shipping: [],
       taxMode: 'Platform',
       taxRoundingMode: 'HalfEven',
       taxCalculationMode: 'UnitPriceLevel',

package/src/repositories/order.ts

@@ -1,4 +1,3 @@
-import assert from 'assert'
 import {
   Cart,
   CartReference,
@@ -25,10 +24,13 @@ import {
   Product,
   ProductPagedQueryResponse,
   ProductVariant,
-  ReferenceTypeId,
   State,
   Store,
 } from '@commercetools/platform-sdk'
+import assert from 'assert'
+import { CommercetoolsError } from '../exceptions'
+import { getBaseResourceProperties } from '../helpers'
+import { Writable } from '../types'
 import {
   AbstractResourceRepository,
   QueryParams,
@@ -40,13 +42,10 @@ import {
   createTypedMoney,
   resolveStoreReference,
 } from './helpers'
-import { Writable } from '../types'
-import { getBaseResourceProperties } from '../helpers'
-import { CommercetoolsError } from '../exceptions'
 
-export class OrderRepository extends AbstractResourceRepository {
-  getTypeId(): ReferenceTypeId {
-    return 'order'
+export class OrderRepository extends AbstractResourceRepository<'order'> {
+  getTypeId() {
+    return 'order' as const
   }
 
   create(context: RepositoryContext, draft: OrderFromCartDraft): Order {
@@ -85,6 +84,8 @@ export class OrderRepository extends AbstractResourceRepository {
       refusedGifts: [],
       origin: 'Customer',
       syncInfo: [],
+      shippingMode: cart.shippingMode,
+      shipping: cart.shipping,
       store: context.storeKey
         ? {
             key: context.storeKey,
@@ -118,6 +119,9 @@ export class OrderRepository extends AbstractResourceRepository {
       origin: draft.origin || 'Customer',
       paymentState: draft.paymentState,
       refusedGifts: [],
+      shippingMode: 'Single',
+      shipping: [],
+
       store: resolveStoreReference(
         draft.store,
         context.projectKey,
@@ -202,6 +206,8 @@ export class OrderRepository extends AbstractResourceRepository {
       quantity: draft.quantity,
       state: draft.state || [],
       taxRate: draft.taxRate,
+      taxedPricePortions: [],
+      perMethodTaxRate: [],
       totalPrice: createTypedMoney(draft.price.value),
       variant: {
         id: variant.id,
@@ -228,6 +234,7 @@ export class OrderRepository extends AbstractResourceRepository {
       money: createTypedMoney(draft.money),
       name: draft.name,
       quantity: draft.quantity,
+      priceMode: draft.priceMode,
       slug: draft.slug,
       state: [],
       totalPrice: createTypedMoney(draft.money),

package/src/repositories/payment.ts

@@ -6,25 +6,24 @@ import {
   PaymentSetCustomFieldAction,
   PaymentSetCustomTypeAction,
   PaymentTransitionStateAction,
-  ReferenceTypeId,
   State,
   StateReference,
   Transaction,
   TransactionDraft,
 } from '@commercetools/platform-sdk'
+import { v4 as uuidv4 } from 'uuid'
+import { getBaseResourceProperties } from '../helpers'
+import { Writable } from '../types'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
 import {
   createCustomFields,
   createTypedMoney,
   getReferenceFromResourceIdentifier,
 } from './helpers'
-import { getBaseResourceProperties } from '../helpers'
-import { v4 as uuidv4 } from 'uuid'
-import { Writable } from '../types'
 
-export class PaymentRepository extends AbstractResourceRepository {
-  getTypeId(): ReferenceTypeId {
-    return 'payment'
+export class PaymentRepository extends AbstractResourceRepository<'payment'> {
+  getTypeId() {
+    return 'payment' as const
   }
 
   create(context: RepositoryContext, draft: PaymentDraft): Payment {

package/src/repositories/product-discount.ts

@@ -17,16 +17,15 @@ import {
   ProductDiscountValueDraft,
   ProductDiscountValueExternal,
   ProductDiscountValueRelative,
-  ReferenceTypeId,
 } from '@commercetools/platform-sdk'
-import { Writable } from 'types'
 import { getBaseResourceProperties } from '../helpers'
+import { Writable } from '../types'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
 import { createTypedMoney } from './helpers'
 
-export class ProductDiscountRepository extends AbstractResourceRepository {
-  getTypeId(): ReferenceTypeId {
-    return 'product-discount'
+export class ProductDiscountRepository extends AbstractResourceRepository<'product-discount'> {
+  getTypeId() {
+    return 'product-discount' as const
   }
 
   create(
@@ -73,25 +72,6 @@ export class ProductDiscountRepository extends AbstractResourceRepository {
     }
   }
 
-  getWithKey(
-    context: RepositoryContext,
-    key: string
-  ): ProductDiscount | undefined {
-    const result = this._storage.query(context.projectKey, this.getTypeId(), {
-      where: [`key="${key}"`],
-    })
-    if (result.count === 1) {
-      return result.results[0] as ProductDiscount
-    }
-
-    // Catch this for now, should be checked when creating/updating
-    if (result.count > 1) {
-      throw new Error('Duplicate product discount key')
-    }
-
-    return
-  }
-
   actions: Partial<
     Record<
       ProductDiscountUpdateAction['action'],

package/src/repositories/product-projection.ts

@@ -5,12 +5,11 @@ import {
   QueryParams,
   RepositoryContext,
 } from './abstract'
-import { RepositoryTypes } from '../types'
 import { AbstractStorage } from '../storage'
 import { ProductProjectionSearch } from '../product-projection-search'
 import { QueryParamsAsArray } from '../helpers'
 
-export class ProductProjectionRepository extends AbstractResourceRepository {
+export class ProductProjectionRepository extends AbstractResourceRepository<'product-projection'> {
   protected _searchService: ProductProjectionSearch
 
   constructor(storage: AbstractStorage) {
@@ -18,8 +17,8 @@ export class ProductProjectionRepository extends AbstractResourceRepository {
     this._searchService = new ProductProjectionSearch(storage)
   }
 
-  getTypeId(): RepositoryTypes {
-    return 'product-projection'
+  getTypeId() {
+    return 'product-projection' as const
   }
 
   create(context: RepositoryContext, draft: ProductDraft): ProductProjection {
@@ -27,12 +26,19 @@ export class ProductProjectionRepository extends AbstractResourceRepository {
   }
 
   query(context: RepositoryContext, params: QueryParams = {}) {
-    return this._storage.query(context.projectKey, 'product', {
+    const response = this._storage.query(context.projectKey, 'product', {
       expand: params.expand,
       where: params.where,
       offset: params.offset,
       limit: params.limit,
     })
+
+    return {
+      ...response,
+      results: response.results.map((r) =>
+        this._searchService.transform(r, false)
+      ),
+    }
   }
 
   search(context: RepositoryContext, query: ParsedQs) {

package/src/repositories/product-selection.ts

@@ -0,0 +1,40 @@
+import {
+  ProductSelection,
+  ProductSelectionDraft,
+  Review,
+  ReviewUpdateAction,
+} from '@commercetools/platform-sdk'
+import { getBaseResourceProperties } from '../helpers'
+import { Writable } from '../types'
+import { AbstractResourceRepository, RepositoryContext } from './abstract'
+
+export class ProductSelectionRepository extends AbstractResourceRepository<'product-selection'> {
+  getTypeId() {
+    return 'product-selection' as const
+  }
+
+  create(
+    context: RepositoryContext,
+    draft: ProductSelectionDraft
+  ): ProductSelection {
+    const resource: ProductSelection = {
+      ...getBaseResourceProperties(),
+      productCount: 0,
+      name: draft.name,
+      type: 'individual',
+    }
+    this.saveNew(context, resource)
+    return resource
+  }
+
+  actions: Partial<
+    Record<
+      ReviewUpdateAction['action'],
+      (
+        context: RepositoryContext,
+        resource: Writable<Review>,
+        action: any
+      ) => void
+    >
+  > = {}
+}

package/src/repositories/product-type.ts

@@ -1,25 +1,24 @@
-import { getBaseResourceProperties } from '../helpers'
 import {
   AttributeDefinition,
   AttributeDefinitionDraft,
   AttributeType,
   ProductType,
   ProductTypeAddAttributeDefinitionAction,
-  ProductTypeChangeAttributeOrderAction,
+  ProductTypeChangeAttributeOrderByNameAction,
   ProductTypeChangeLabelAction,
   ProductTypeChangeLocalizedEnumValueLabelAction,
   ProductTypeDraft,
   ProductTypeRemoveAttributeDefinitionAction,
   ProductTypeRemoveEnumValuesAction,
   ProductTypeUpdateAction,
-  ReferenceTypeId,
 } from '@commercetools/platform-sdk'
+import { getBaseResourceProperties } from '../helpers'
+import { Writable } from '../types'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
-import { Writable } from 'types'
 
-export class ProductTypeRepository extends AbstractResourceRepository {
-  getTypeId(): ReferenceTypeId {
-    return 'product-type'
+export class ProductTypeRepository extends AbstractResourceRepository<'product-type'> {
+  getTypeId() {
+    return 'product-type' as const
   }
 
   create(context: RepositoryContext, draft: ProductTypeDraft): ProductType {
@@ -51,22 +50,6 @@ export class ProductTypeRepository extends AbstractResourceRepository {
     isSearchable: draft.isSearchable ?? true,
   })
 
-  getWithKey(context: RepositoryContext, key: string): ProductType | undefined {
-    const result = this._storage.query(context.projectKey, this.getTypeId(), {
-      where: [`key="${key}"`],
-    })
-    if (result.count === 1) {
-      return result.results[0] as ProductType
-    }
-
-    // Catch this for now, should be checked when creating/updating
-    if (result.count > 1) {
-      throw new Error('Duplicate product type key')
-    }
-
-    return
-  }
-
   actions: Partial<
     Record<
       ProductTypeUpdateAction['action'],
@@ -126,10 +109,10 @@ export class ProductTypeRepository extends AbstractResourceRepository {
         this.attributeDefinitionFromAttributeDefinitionDraft(context, attribute)
       )
     },
-    changeAttributeOrder: (
+    changeAttributeOrderByName: (
       context: RepositoryContext,
       resource: Writable<ProductType>,
-      { attributes }: ProductTypeChangeAttributeOrderAction
+      { attributeNames }: ProductTypeChangeAttributeOrderByNameAction
     ) => {
       const attrs = new Map(
         resource.attributes?.map((item) => [item.name, item])
@@ -137,15 +120,15 @@ export class ProductTypeRepository extends AbstractResourceRepository {
       const result: AttributeDefinition[] = []
       let current = resource.attributes
 
-      attributes.forEach((iAttr) => {
-        const attr = attrs.get(iAttr.name)
+      attributeNames.forEach((attrName) => {
+        const attr = attrs.get(attrName)
         if (attr === undefined) {
           throw new Error('New attr')
         }
         result.push(attr)
 
         // Remove from current items
-        current = current?.filter((f) => f.name !== iAttr.name)
+        current = current?.filter((f) => f.name !== attrName)
       })
 
       resource.attributes = result

package/src/repositories/product.ts

@@ -12,18 +12,17 @@ import {
   ProductUpdateAction,
   ProductVariant,
   ProductVariantDraft,
-  ReferenceTypeId,
 } from '@commercetools/platform-sdk'
 import { v4 as uuidv4 } from 'uuid'
+import { Writable } from '../types'
 import { getBaseResourceProperties } from '../helpers'
 import { AbstractResourceRepository, RepositoryContext } from './abstract'
-import { Writable } from '../types'
 import { getReferenceFromResourceIdentifier } from './helpers'
 import deepEqual from 'deep-equal'
 
-export class ProductRepository extends AbstractResourceRepository {
-  getTypeId(): ReferenceTypeId {
-    return 'product'
+export class ProductRepository extends AbstractResourceRepository<'product'> {
+  getTypeId() {
+    return 'product' as const
   }
 
   create(context: RepositoryContext, draft: ProductDraft): Product {
@@ -100,7 +99,7 @@ export class ProductRepository extends AbstractResourceRepository {
     },
     unpublish: (
       context: RepositoryContext,
-      resource: Writable<Product>,
+      resource: Writable<Product>
       // { action }: ProductUnpublishAction
     ) => {
       resource.masterData.published = false
@@ -162,7 +161,7 @@ export class ProductRepository extends AbstractResourceRepository {
 
       return resource
     },
-    'setDescription': (
+    setDescription: (
       context: RepositoryContext,
       resource: Writable<Product>,
       { description, staged }: ProductSetDescriptionAction
@@ -176,7 +175,7 @@ export class ProductRepository extends AbstractResourceRepository {
       checkForStagedChanges(resource)
       return resource
     },
-    'setKey': (
+    setKey: (
       context: RepositoryContext,
       resource: Writable<Product>,
       { key }: ProductSetKeyAction

package/src/repositories/project.ts

@@ -5,7 +5,7 @@ import {
   ProjectChangeCountryTaxRateFallbackEnabledAction,
   ProjectChangeCurrenciesAction,
   ProjectChangeLanguagesAction,
-  ProjectChangeMessagesEnabledAction,
+  ProjectChangeMessagesConfigurationAction,
   ProjectChangeNameAction,
   ProjectChangeOrderSearchStatusAction,
   ProjectChangeProductSearchIndexingEnabledAction,
@@ -13,17 +13,17 @@ import {
   ProjectSetShippingRateInputTypeAction,
   ProjectUpdateAction,
 } from '@commercetools/platform-sdk'
-import { Resource, Writable } from 'types'
-import { AbstractRepository, RepositoryContext } from './abstract'
 import { maskSecretValue } from '../lib/masking'
+import { Writable } from '../types'
+import { AbstractRepository, RepositoryContext } from './abstract'
 
-export class ProjectRepository extends AbstractRepository {
+export class ProjectRepository extends AbstractRepository<Project> {
   get(context: RepositoryContext): Project | null {
     const resource = this._storage.getProject(context.projectKey)
     return this.postProcessResource(resource)
   }
 
-  postProcessResource<T extends Resource>(resource: T): T {
+  postProcessResource(resource: Project): Project {
     if (resource) {
       return maskSecretValue(resource, 'externalOAuth.authorizationHeader')
     }
@@ -77,12 +77,12 @@ export class ProjectRepository extends AbstractRepository {
     ) => {
       resource.languages = languages
     },
-    changeMessagesEnabled: (
+    changeMessagesConfiguration: (
       context: RepositoryContext,
       resource: Writable<Project>,
-      { messagesEnabled }: ProjectChangeMessagesEnabledAction
+      { messagesConfiguration }: ProjectChangeMessagesConfigurationAction
     ) => {
-      resource.messages.enabled = messagesEnabled
+      resource.messages.enabled = messagesConfiguration.enabled
     },
     changeProductSearchIndexingEnabled: (
       context: RepositoryContext,