@labdigital/commercetools-mock 0.9.1 → 0.10.1

package/src/storage/abstract.ts

@@ -0,0 +1,82 @@
+import {
+    BaseResource,
+    Project,
+    QueryParam,
+    ResourceIdentifier
+} from '@commercetools/platform-sdk'
+import { PagedQueryResponseMap, ResourceMap, ResourceType } from '../types'
+
+export type GetParams = {
+  expand?: string[]
+}
+
+export type QueryParams = {
+  expand?: string | string[]
+  sort?: string | string[]
+  limit?: number
+  offset?: number
+  withTotal?: boolean
+  where?: string | string[]
+  [key: string]: QueryParam
+}
+
+export abstract class AbstractStorage {
+  abstract clear(): void
+
+  abstract all<RT extends ResourceType>(
+    projectKey: string,
+    typeId: RT
+  ): Array<ResourceMap[RT]>
+
+  abstract add<RT extends ResourceType>(
+    projectKey: string,
+    typeId: RT,
+    obj: ResourceMap[RT]
+  ): void
+
+  abstract get<RT extends ResourceType>(
+    projectKey: string,
+    typeId: RT,
+    id: string,
+    params?: GetParams
+  ): ResourceMap[RT] | null
+
+  abstract getByKey<RT extends ResourceType>(
+    projectKey: string,
+    typeId: RT,
+    key: string,
+    params: GetParams
+  ): ResourceMap[RT] | null
+
+  abstract addProject(projectKey: string): Project
+  abstract getProject(projectKey: string): Project
+  abstract saveProject(project: Project): Project
+
+  abstract delete<RT extends ResourceType>(
+    projectKey: string,
+    typeId: RT,
+    id: string,
+    params: GetParams
+  ): ResourceMap[RT] | null
+
+  abstract query<RT extends ResourceType>(
+    projectKey: string,
+    typeId: RT,
+    params: QueryParams
+  ): PagedQueryResponseMap[RT]
+
+  abstract getByResourceIdentifier<RT extends ResourceType>(
+    projectKey: string,
+    identifier: ResourceIdentifier
+  ): ResourceMap[RT] | null
+
+  abstract expand<T>(
+    projectKey: string,
+    obj: T,
+    clause: undefined | string | string[]
+  ): T
+}
+
+export type ProjectStorage = {
+  [index in ResourceType]: Map<string, BaseResource>
+}

package/src/{storage.ts → storage/in-memory.ts}

@@ -1,118 +1,54 @@
-import assert from 'assert'
 import {
-  BaseResource,
   Cart,
+  CartDiscount,
   Category,
+  Channel,
   Customer,
+  CustomerGroup,
   CustomObject,
+  DiscountCode,
+  Extension,
+  InvalidInputError,
   InventoryEntry,
   Order,
   PagedQueryResponse,
-  QueryParam,
-  Reference,
-  ResourceIdentifier,
-  Product,
-  Store,
-  Type,
   Payment,
+  Product,
+  ProductDiscount,
+  ProductProjection,
+  ProductType,
   Project,
-  State,
-  TaxCategory,
+  Quote,
+  QuoteRequest,
+  Reference,
+  ResourceIdentifier,
   ShippingMethod,
-  ProductType,
-  InvalidInputError,
-  ProductProjection,
   ShoppingList,
-  Extension,
-  CartDiscount,
-  CustomerGroup,
-  DiscountCode,
-  Zone,
-  Channel,
+  StagedQuote,
+  State,
+  Store,
   Subscription,
-  ProductDiscount,
+  TaxCategory,
+  Type,
+  Zone,
 } from '@commercetools/platform-sdk'
-import { parseExpandClause } from './lib/expandParser'
-import { RepositoryTypes, ResourceMap, Writable } from './types'
-import { parseQueryExpression } from './lib/predicateParser'
-import { CommercetoolsError } from './exceptions'
-
-type GetParams = {
-  expand?: string[]
-}
-
-type QueryParams = {
-  expand?: string | string[]
-  sort?: string | string[]
-  limit?: number
-  offset?: number
-  withTotal?: boolean
-  where?: string | string[]
-  [key: string]: QueryParam
-}
-
-export abstract class AbstractStorage {
-  abstract clear(): void
-
-  abstract assertStorage(typeId: RepositoryTypes): void
-
-  abstract all<RT extends RepositoryTypes>(
-    projectKey: string,
-    typeId: RT
-  ): Array<ResourceMap[RT]>
-
-  abstract add<RT extends RepositoryTypes>(
-    projectKey: string,
-    typeId: RT,
-    obj: ResourceMap[RT]
-  ): void
-
-  abstract get<RT extends RepositoryTypes>(
-    projectKey: string,
-    typeId: RT,
-    id: string,
-    params?: GetParams
-  ): ResourceMap[RT] | null
-
-  abstract getByKey<RT extends RepositoryTypes>(
-    projectKey: string,
-    typeId: RT,
-    key: string,
-    params: GetParams
-  ): ResourceMap[RT] | null
-
-  abstract addProject(projectKey: string): Project
-  abstract getProject(projectKey: string): Project
-  abstract saveProject(project: Project): Project
-
-  abstract delete<RT extends RepositoryTypes>(
-    projectKey: string,
-    typeId: RT,
-    id: string,
-    params: GetParams
-  ): BaseResource | null
-
-  abstract query(
-    projectKey: string,
-    typeId: RepositoryTypes,
-    params: QueryParams
-  ): PagedQueryResponse
-
-  abstract getByResourceIdentifier<RT extends RepositoryTypes>(
-    projectKey: string,
-    identifier: ResourceIdentifier
-  ): ResourceMap[RT] | undefined
-
-  abstract expand<T>(
-    projectKey: string,
-    obj: T,
-    clause: undefined | string | string[]
-  ): T
-}
-
-type ProjectStorage = {
-  [index in RepositoryTypes]: Map<string, BaseResource>
-}
+import assert from 'assert'
+import { CommercetoolsError } from '../exceptions'
+import { cloneObject } from '../helpers'
+import { parseExpandClause } from '../lib/expandParser'
+import { parseQueryExpression } from '../lib/predicateParser'
+import {
+  PagedQueryResponseMap,
+  ResourceMap,
+  ResourceType,
+  Writable,
+} from '../types'
+import {
+  AbstractStorage,
+  GetParams,
+  ProjectStorage,
+  QueryParams,
+} from './abstract'
 
 export class InMemoryStorage extends AbstractStorage {
   protected resources: {
@@ -143,13 +79,15 @@ export class InMemoryStorage extends AbstractStorage {
         'order-edit': new Map<string, any>(),
         payment: new Map<string, Payment>(),
         product: new Map<string, Product>(),
+        quote: new Map<string, Quote>(),
+        'quote-request': new Map<string, QuoteRequest>(),
         'product-discount': new Map<string, ProductDiscount>(),
-        'product-price': new Map<string, any>(),
         'product-selection': new Map<string, any>(),
         'product-type': new Map<string, ProductType>(),
         'product-projection': new Map<string, ProductProjection>(),
         review: new Map<string, any>(),
         'shipping-method': new Map<string, ShippingMethod>(),
+        'staged-quote': new Map<string, StagedQuote>(),
         state: new Map<string, State>(),
         store: new Map<string, Store>(),
         'shopping-list': new Map<string, ShoppingList>(),
@@ -171,20 +109,18 @@ export class InMemoryStorage extends AbstractStorage {
     }
   }
 
-  assertStorage(typeId: RepositoryTypes) {}
-
-  all<RT extends RepositoryTypes>(
+  all<RT extends ResourceType>(
     projectKey: string,
     typeId: RT
   ): ResourceMap[RT][] {
     const store = this.forProjectKey(projectKey)[typeId]
     if (store) {
-      return Array.from(store.values()) as ResourceMap[RT][]
+      return Array.from(store.values()).map(cloneObject) as ResourceMap[RT][]
     }
     return []
   }
 
-  add<RT extends RepositoryTypes>(
+  add<RT extends ResourceType>(
     projectKey: string,
     typeId: RT,
     obj: ResourceMap[RT],
@@ -195,10 +131,10 @@ export class InMemoryStorage extends AbstractStorage {
 
     const resource = this.get(projectKey, typeId, obj.id, params)
     assert(resource, `resource of type ${typeId} with id ${obj.id} not created`)
-    return resource
+    return cloneObject(resource)
   }
 
-  get<RT extends RepositoryTypes>(
+  get<RT extends ResourceType>(
     projectKey: string,
     typeId: RT,
     id: string,
@@ -206,12 +142,13 @@ export class InMemoryStorage extends AbstractStorage {
   ): ResourceMap[RT] | null {
     const resource = this.forProjectKey(projectKey)[typeId]?.get(id)
     if (resource) {
-      return this.expand(projectKey, resource, params.expand) as ResourceMap[RT]
+      const clone = cloneObject(resource)
+      return this.expand(projectKey, clone, params.expand) as ResourceMap[RT]
     }
     return null
   }
 
-  getByKey<RT extends RepositoryTypes>(
+  getByKey<RT extends ResourceType>(
     projectKey: string,
     typeId: RT,
     key: string,
@@ -224,45 +161,46 @@ export class InMemoryStorage extends AbstractStorage {
     }
 
     const resources: any[] = Array.from(resourceStore.values())
-    const resource = resources.find(e => e.key === key)
+    const resource = resources.find((e) => e.key === key)
     if (resource) {
-      return this.expand(projectKey, resource, params.expand) as ResourceMap[RT]
+      const clone = cloneObject(resource)
+      return this.expand(projectKey, clone, params.expand) as ResourceMap[RT]
     }
     return null
   }
 
-  delete<RT extends RepositoryTypes>(
+  delete<RT extends ResourceType>(
     projectKey: string,
     typeId: RT,
     id: string,
     params: GetParams = {}
-  ): BaseResource | null {
+  ): ResourceMap[RT] | null {
     const resource = this.get(projectKey, typeId, id)
 
     if (resource) {
       this.forProjectKey(projectKey)[typeId]?.delete(id)
-      return this.expand(projectKey, resource, params.expand) as ResourceMap[RT]
+      return this.expand(projectKey, resource, params.expand)
     }
     return resource
   }
 
-  query(
+  query<RT extends ResourceType>(
     projectKey: string,
-    typeId: RepositoryTypes,
+    typeId: RT,
     params: QueryParams
-  ): PagedQueryResponse {
+  ): PagedQueryResponseMap[RT] {
     const store = this.forProjectKey(projectKey)[typeId]
     if (!store) {
       throw new Error('No type')
     }
 
-    let resources = Array.from(store.values())
+    let resources = this.all<RT>(projectKey, typeId)
 
     // Apply predicates
     if (params.where) {
       try {
         const filterFunc = parseQueryExpression(params.where)
-        resources = resources.filter(resource => filterFunc(resource, {}))
+        resources = resources.filter((resource) => filterFunc(resource, {}))
       } catch (err) {
         throw new CommercetoolsError<InvalidInputError>(
           {
@@ -284,9 +222,9 @@ export class InMemoryStorage extends AbstractStorage {
 
     // Expand the resources
     if (params.expand !== undefined) {
-      resources = resources.map(resource => {
-        return this.expand(projectKey, resource, params.expand)
-      })
+      resources = resources.map((resource) =>
+        this.expand(projectKey, resource, params.expand)
+      )
     }
 
     return {
@@ -294,27 +232,22 @@ export class InMemoryStorage extends AbstractStorage {
       total: resources.length,
       offset: offset,
       limit: limit,
-      results: resources,
-    }
+      results: resources.map(cloneObject),
+    } as PagedQueryResponseMap[RT]
   }
 
   search(
     projectKey: string,
-    typeId: RepositoryTypes,
+    typeId: ResourceType,
     params: QueryParams
   ): PagedQueryResponse {
-    const store = this.forProjectKey(projectKey)[typeId]
-    if (!store) {
-      throw new Error('No type')
-    }
-
-    let resources = Array.from(store.values())
+    let resources = this.all(projectKey, typeId)
 
     // Apply predicates
     if (params.where) {
       try {
         const filterFunc = parseQueryExpression(params.where)
-        resources = resources.filter(resource => filterFunc(resource, {}))
+        resources = resources.filter((resource) => filterFunc(resource, {}))
       } catch (err) {
         throw new CommercetoolsError<InvalidInputError>(
           {
@@ -336,9 +269,9 @@ export class InMemoryStorage extends AbstractStorage {
 
     // Expand the resources
     if (params.expand !== undefined) {
-      resources = resources.map(resource => {
-        return this.expand(projectKey, resource, params.expand)
-      })
+      resources = resources.map((resource) =>
+        this.expand(projectKey, resource, params.expand)
+      )
     }
 
     return {
@@ -350,10 +283,10 @@ export class InMemoryStorage extends AbstractStorage {
     }
   }
 
-  getByResourceIdentifier<RT extends RepositoryTypes>(
+  getByResourceIdentifier<RT extends ResourceType>(
     projectKey: string,
     identifier: ResourceIdentifier
-  ): ResourceMap[RT] | undefined {
+  ): ResourceMap[RT] | null {
     if (identifier.id) {
       const resource = this.get(projectKey, identifier.typeId, identifier.id)
       if (resource) {
@@ -362,7 +295,7 @@ export class InMemoryStorage extends AbstractStorage {
       console.error(
         `No resource found with typeId=${identifier.typeId}, id=${identifier.id}`
       )
-      return undefined
+      return null
     }
 
     if (identifier.key) {
@@ -373,7 +306,7 @@ export class InMemoryStorage extends AbstractStorage {
         // have them all.
         const resource = Array.from(store.values()).find(
           // @ts-ignore
-          r => r.key === identifier.key
+          (r) => r.key === identifier.key
         )
         if (resource) {
           return resource as ResourceMap[RT]
@@ -384,7 +317,7 @@ export class InMemoryStorage extends AbstractStorage {
         )
       }
     }
-    return undefined
+    return null
   }
 
   addProject = (projectKey: string): Project => {
@@ -423,19 +356,18 @@ export class InMemoryStorage extends AbstractStorage {
     return project
   }
 
-  getProject = (projectKey: string): Project => {
-    return this.addProject(projectKey)
-  }
+  getProject = (projectKey: string): Project => this.addProject(projectKey)
 
+  // Expand resolves a nested reference and injects the object in the given obj
   public expand = <T>(
     projectKey: string,
     obj: T,
     clause: undefined | string | string[]
   ): T => {
     if (!clause) return obj
-    const newObj = JSON.parse(JSON.stringify(obj))
+    const newObj = cloneObject(obj)
     if (Array.isArray(clause)) {
-      clause.forEach(c => {
+      clause.forEach((c) => {
         this._resolveResource(projectKey, newObj, c)
       })
     } else {

package/src/storage/index.ts

@@ -0,0 +1,2 @@
+export { AbstractStorage } from './abstract'
+export { InMemoryStorage } from './in-memory'

package/src/types.ts

@@ -1,64 +1,53 @@
-import { ProductProjectionRepository } from './repositories/product-projection'
-import { ShoppingListRepository } from './repositories/shopping-list'
 import * as ctp from '@commercetools/platform-sdk'
-import { ReferenceTypeId } from '@commercetools/platform-sdk'
+import { RepositoryMap } from './repositories'
 import AbstractService from './services/abstract'
-import { CartRepository } from './repositories/cart'
-import { CustomerRepository } from './repositories/customer'
-import { CustomObjectRepository } from './repositories/custom-object'
-import { InventoryEntryRepository } from './repositories/inventory-entry'
-import { OrderRepository } from './repositories/order'
-import { PaymentRepository } from './repositories/payment'
-import { ProductRepository } from './repositories/product'
-import { ProductTypeRepository } from './repositories/product-type'
-import { ShippingMethodRepository } from './repositories/shipping-method'
-import { StateRepository } from './repositories/state'
-import { TaxCategoryRepository } from './repositories/tax-category'
-import { ProductDiscountRepository } from 'repositories/product-discount'
 
 export type Writable<T> = { -readonly [P in keyof T]: Writable<T[P]> }
+export type ShallowWritable<T> = { -readonly [P in keyof T]: T[P] }
 
-export type RepositoryTypes =
-  | ReferenceTypeId
-  | 'standalone-price'
-  | 'product-projection'
 export type ServiceTypes =
-  | RepositoryTypes
+  | ctp.ReferenceTypeId
+  | 'product-projection'
   | 'my-cart'
   | 'my-order'
   | 'my-payment'
   | 'my-customer'
   | 'product-projection'
 
-export type Services = Partial<
-  {
-    [index in ServiceTypes]: AbstractService
-  }
->
+export type Services = Partial<{
+  [index in ServiceTypes]: AbstractService
+}>
+
+export type ResourceType = keyof ResourceMap & keyof RepositoryMap
 
 export type ResourceMap = {
-  cart: ctp.Cart
   'cart-discount': ctp.CartDiscount
+  cart: ctp.Cart
   category: ctp.Category
   channel: ctp.Channel
-  customer: ctp.Customer
+  'customer-email-token': never
   'customer-group': ctp.CustomerGroup
+  'customer-password-token': never
+  customer: ctp.Customer
   'discount-code': ctp.DiscountCode
   extension: ctp.Extension
   'inventory-entry': ctp.InventoryEntry
   'key-value-document': ctp.CustomObject
-  order: ctp.Order
   'order-edit': ctp.OrderEdit
+  order: ctp.Order
   payment: ctp.Payment
-  product: ctp.Product
   'product-discount': ctp.ProductDiscount
+  'product-price': ctp.StandalonePrice
   'product-projection': ctp.ProductProjection
   'product-selection': ctp.ProductSelection
-  'product-price': ctp.StandalonePrice
   'product-type': ctp.ProductType
+  product: ctp.Product
+  'quote-request': ctp.QuoteRequest
+  quote: ctp.Quote
   review: ctp.Review
   'shipping-method': ctp.ShippingMethod
   'shopping-list': ctp.ShoppingList
+  'staged-quote': ctp.StagedQuote
   'standalone-price': ctp.StandalonePrice
   state: ctp.State
   store: ctp.Store
@@ -66,61 +55,41 @@ export type ResourceMap = {
   'tax-category': ctp.TaxCategory
   type: ctp.Type
   zone: ctp.Zone
-  'customer-email-token': never
-  'customer-password-token': never
-}
-
-export type ResourceIdentifierMap = {
-  cart: ctp.CartDiscountResourceIdentifier
-  // 'cart': ctp.CartResourceIdentifier,
-  // 'category': ctp.CategoryResourceIdentifier,
-  channel: ctp.ChannelResourceIdentifier
-  // 'foobar': ctp.CustomerResourceIdentifier,
-  // 'foobar': ctp.DiscountCodeResourceIdentifier,
-  // 'foobar': ctp.InventoryEntryResourceIdentifier,
-  // 'foobar': ctp.OrderEditResourceIdentifier,
-  // 'foobar': ctp.OrderResourceIdentifier,
-  // 'foobar': ctp.PaymentResourceIdentifier,
-  // 'foobar': ctp.ProductDiscountResourceIdentifier,
-  // 'foobar': ctp.ProductResourceIdentifier,
-  // 'foobar': ctp.ProductTypeResourceIdentifier,
-  // 'foobar': ctp.ReviewResourceIdentifier,
-  // 'foobar': ctp.ShippingMethodResourceIdentifier,
-  // 'foobar': ctp.ShoppingListResourceIdentifier,
-  // 'foobar': ctp.StateResourceIdentifier,
-  // 'foobar': ctp.StoreResourceIdentifier,
-  // 'foobar': ctp.TaxCategoryResourceIdentifier,
-  // 'foobar': ctp.TypeResourceIdentifier,
-  // 'foobar': ctp.ZoneResourceIdentifier,
 }
 
-export type RepositoryMap = {
-  cart: CartRepository
-  'cart-discount': never
-  category: never
-  channel: never
-  customer: CustomerRepository
+export type PagedQueryResponseMap = {
+  'cart-discount': ctp.CartDiscountPagedQueryResponse
+  cart: ctp.CartPagedQueryResponse
+  category: ctp.CategoryPagedQueryResponse
+  channel: ctp.ChannelPagedQueryResponse
   'customer-email-token': never
-  'customer-group': never
+  'customer-group': ctp.CustomerGroupPagedQueryResponse
   'customer-password-token': never
-  'discount-code': never
-  extension: never
-  'inventory-entry': InventoryEntryRepository
-  'key-value-document': CustomObjectRepository
-  order: OrderRepository
-  'order-edit': never
-  payment: PaymentRepository
-  product: ProductRepository
-  'product-projection': ProductProjectionRepository
-  'product-discount': ProductDiscountRepository
-  'product-type': ProductTypeRepository
-  review: never
-  'shipping-method': ShippingMethodRepository
-  'shopping-list': ShoppingListRepository
-  state: StateRepository
-  store: never
-  subscription: never
-  'tax-category': TaxCategoryRepository
-  type: ctp.Type
-  zone: ctp.Zone
+  customer: ctp.CustomerPagedQueryResponse
+  'discount-code': ctp.DiscountCodePagedQueryResponse
+  extension: ctp.ExtensionPagedQueryResponse
+  'inventory-entry': ctp.InventoryPagedQueryResponse
+  'key-value-document': ctp.CustomObjectPagedQueryResponse
+  'order-edit': ctp.OrderEditPagedQueryResponse
+  order: ctp.OrderPagedQueryResponse
+  payment: ctp.PaymentPagedQueryResponse
+  'product-discount': ctp.ProductDiscountPagedQueryResponse
+  'product-price': ctp.StandalonePricePagedQueryResponse
+  'product-projection': ctp.ProductProjectionPagedQueryResponse
+  'product-selection': ctp.ProductSelectionPagedQueryResponse
+  'product-type': ctp.ProductTypePagedQueryResponse
+  product: ctp.ProductPagedQueryResponse
+  'quote-request': ctp.QuoteRequestPagedQueryResponse
+  quote: ctp.QuotePagedQueryResponse
+  review: ctp.ReviewPagedQueryResponse
+  'shipping-method': ctp.ShippingMethodPagedQueryResponse
+  'shopping-list': ctp.ShoppingListPagedQueryResponse
+  'staged-quote': ctp.StagedQuotePagedQueryResponse
+  'standalone-price': ctp.StandalonePricePagedQueryResponse
+  state: ctp.StatePagedQueryResponse
+  store: ctp.StorePagedQueryResponse
+  subscription: ctp.SubscriptionPagedQueryResponse
+  'tax-category': ctp.TaxCategoryPagedQueryResponse
+  type: ctp.TypePagedQueryResponse
+  zone: ctp.ZonePagedQueryResponse
 }