@labdigital/commercetools-mock 0.6.5 → 0.8.0

package/src/storage.ts

@@ -30,6 +30,7 @@ import {
   Zone,
   Channel,
   Subscription,
+  ProductDiscount,
 } from '@commercetools/platform-sdk'
 import { parseExpandClause } from './lib/expandParser'
 import { RepositoryTypes, ResourceMap, Writable } from './types'
@@ -55,35 +56,38 @@ export abstract class AbstractStorage {
 
   abstract assertStorage(typeId: RepositoryTypes): void
 
-  abstract all(projectKey: string, typeId: RepositoryTypes): Array<BaseResource>
+  abstract all<RT extends RepositoryTypes>(
+    projectKey: string,
+    typeId: RT
+  ): Array<ResourceMap[RT]>
 
-  abstract add<RepositoryTypes extends keyof ResourceMap>(
+  abstract add<RT extends RepositoryTypes>(
     projectKey: string,
-    typeId: RepositoryTypes,
-    obj: ResourceMap[RepositoryTypes]
+    typeId: RT,
+    obj: ResourceMap[RT]
   ): void
 
-  abstract get<RepositoryTypes extends keyof ResourceMap>(
+  abstract get<RT extends RepositoryTypes>(
     projectKey: string,
-    typeId: RepositoryTypes,
+    typeId: RT,
     id: string,
     params?: GetParams
-  ): ResourceMap[RepositoryTypes] | null
+  ): ResourceMap[RT] | null
 
-  abstract getByKey<RepositoryTypes extends keyof ResourceMap>(
+  abstract getByKey<RT extends RepositoryTypes>(
     projectKey: string,
-    typeId: RepositoryTypes,
+    typeId: RT,
     key: string,
     params: GetParams
-  ): ResourceMap[RepositoryTypes] | null
+  ): ResourceMap[RT] | null
 
   abstract addProject(projectKey: string): Project
   abstract getProject(projectKey: string): Project
   abstract saveProject(project: Project): Project
 
-  abstract delete(
+  abstract delete<RT extends RepositoryTypes>(
     projectKey: string,
-    typeId: RepositoryTypes,
+    typeId: RT,
     id: string,
     params: GetParams
   ): BaseResource | null
@@ -94,17 +98,21 @@ export abstract class AbstractStorage {
     params: QueryParams
   ): PagedQueryResponse
 
-  abstract getByResourceIdentifier(
+  abstract getByResourceIdentifier<RT extends RepositoryTypes>(
     projectKey: string,
     identifier: ResourceIdentifier
-  ): BaseResource | undefined
+  ): ResourceMap[RT] | undefined
+
+  abstract expand<T>(
+    projectKey: string,
+    obj: T,
+    clause: undefined | string | string[]
+  ): T
 }
 
-type ProjectStorage = Partial<
-  {
-    [index in RepositoryTypes]: Map<string, BaseResource>
-  }
->
+type ProjectStorage = {
+  [index in RepositoryTypes]: Map<string, BaseResource>
+}
 
 export class InMemoryStorage extends AbstractStorage {
   protected resources: {
@@ -115,7 +123,7 @@ export class InMemoryStorage extends AbstractStorage {
     [projectKey: string]: Project
   } = {}
 
-  private forProjectKey(projectKey: string) {
+  private forProjectKey(projectKey: string): ProjectStorage {
     this.addProject(projectKey)
 
     let projectStorage = this.resources[projectKey]
@@ -132,15 +140,20 @@ export class InMemoryStorage extends AbstractStorage {
         'inventory-entry': new Map<string, InventoryEntry>(),
         'key-value-document': new Map<string, CustomObject>(),
         order: new Map<string, Order>(),
+        'order-edit': new Map<string, any>(),
         payment: new Map<string, Payment>(),
-        'product-type': new Map<string, ProductType>(),
         product: new Map<string, Product>(),
+        '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>(),
         state: new Map<string, State>(),
         store: new Map<string, Store>(),
         'shopping-list': new Map<string, ShoppingList>(),
+        'standalone-price': new Map<string, any>(),
         subscription: new Map<string, Subscription>(),
         'tax-category': new Map<string, TaxCategory>(),
         type: new Map<string, Type>(),
@@ -160,70 +173,67 @@ export class InMemoryStorage extends AbstractStorage {
 
   assertStorage(typeId: RepositoryTypes) {}
 
-  all(projectKey: string, typeId: RepositoryTypes) {
+  all<RT extends RepositoryTypes>(
+    projectKey: string,
+    typeId: RT
+  ): ResourceMap[RT][] {
     const store = this.forProjectKey(projectKey)[typeId]
     if (store) {
-      return Array.from(store.values())
+      return Array.from(store.values()) as ResourceMap[RT][]
     }
     return []
   }
 
-  add<RepositoryTypes extends keyof ResourceMap>(
+  add<RT extends RepositoryTypes>(
     projectKey: string,
-    typeId: RepositoryTypes,
-    obj: ResourceMap[RepositoryTypes],
+    typeId: RT,
+    obj: ResourceMap[RT],
     params: GetParams = {}
-  ): ResourceMap[RepositoryTypes] {
-    this.forProjectKey(projectKey)[typeId]?.set(obj.id, obj)
+  ): ResourceMap[RT] {
+    const store = this.forProjectKey(projectKey)
+    store[typeId]?.set(obj.id, obj)
 
     const resource = this.get(projectKey, typeId, obj.id, params)
     assert(resource, `resource of type ${typeId} with id ${obj.id} not created`)
     return resource
   }
 
-  get<RepositoryTypes extends keyof ResourceMap>(
+  get<RT extends RepositoryTypes>(
     projectKey: string,
-    typeId: RepositoryTypes,
+    typeId: RT,
     id: string,
     params: GetParams = {}
-  ): ResourceMap[RepositoryTypes] | null {
+  ): ResourceMap[RT] | null {
     const resource = this.forProjectKey(projectKey)[typeId]?.get(id)
     if (resource) {
-      return this.expand(
-        projectKey,
-        resource,
-        params.expand
-      ) as ResourceMap[RepositoryTypes]
+      return this.expand(projectKey, resource, params.expand) as ResourceMap[RT]
     }
     return null
   }
 
-  getByKey<RepositoryTypes extends keyof ResourceMap>(
+  getByKey<RT extends RepositoryTypes>(
     projectKey: string,
-    typeId: RepositoryTypes,
+    typeId: RT,
     key: string,
     params: GetParams = {}
-  ): ResourceMap[RepositoryTypes] | null {
-    const store = this.forProjectKey(projectKey)[typeId]
+  ): ResourceMap[RT] | null {
+    const store = this.forProjectKey(projectKey)
+    const resourceStore = store[typeId]
     if (!store) {
       throw new Error('No type')
     }
 
-    const resources: any[] = Array.from(store.values())
+    const resources: any[] = Array.from(resourceStore.values())
     const resource = resources.find(e => e.key === key)
     if (resource) {
-      return this.expand(
-        projectKey,
-        resource,
-        params.expand
-      ) as ResourceMap[RepositoryTypes]
+      return this.expand(projectKey, resource, params.expand) as ResourceMap[RT]
     }
     return null
   }
 
-  delete(
+  delete<RT extends RepositoryTypes>(
     projectKey: string,
-    typeId: RepositoryTypes,
+    typeId: RT,
     id: string,
     params: GetParams = {}
   ): BaseResource | null {
@@ -231,11 +241,7 @@ export class InMemoryStorage extends AbstractStorage {
 
     if (resource) {
       this.forProjectKey(projectKey)[typeId]?.delete(id)
-      return this.expand(
-        projectKey,
-        resource,
-        params.expand
-      ) as ResourceMap[RepositoryTypes]
+      return this.expand(projectKey, resource, params.expand) as ResourceMap[RT]
     }
     return resource
   }
@@ -292,14 +298,66 @@ export class InMemoryStorage extends AbstractStorage {
     }
   }
 
-  getByResourceIdentifier<RepositoryTypes extends keyof ResourceMap>(
+  search(
+    projectKey: string,
+    typeId: RepositoryTypes,
+    params: QueryParams
+  ): PagedQueryResponse {
+    const store = this.forProjectKey(projectKey)[typeId]
+    if (!store) {
+      throw new Error('No type')
+    }
+
+    let resources = Array.from(store.values())
+
+    // Apply predicates
+    if (params.where) {
+      try {
+        const filterFunc = parseQueryExpression(params.where)
+        resources = resources.filter(resource => filterFunc(resource, {}))
+      } catch (err) {
+        throw new CommercetoolsError<InvalidInputError>(
+          {
+            code: 'InvalidInput',
+            message: (err as any).message,
+          },
+          400
+        )
+      }
+    }
+
+    // Get the total before slicing the array
+    const totalResources = resources.length
+
+    // Apply offset, limit
+    const offset = params.offset || 0
+    const limit = params.limit || 20
+    resources = resources.slice(offset, offset + limit)
+
+    // Expand the resources
+    if (params.expand !== undefined) {
+      resources = resources.map(resource => {
+        return this.expand(projectKey, resource, params.expand)
+      })
+    }
+
+    return {
+      count: totalResources,
+      total: resources.length,
+      offset: offset,
+      limit: limit,
+      results: resources,
+    }
+  }
+
+  getByResourceIdentifier<RT extends RepositoryTypes>(
     projectKey: string,
     identifier: ResourceIdentifier
-  ): ResourceMap[RepositoryTypes] | undefined {
+  ): ResourceMap[RT] | undefined {
     if (identifier.id) {
       const resource = this.get(projectKey, identifier.typeId, identifier.id)
       if (resource) {
-        return resource as ResourceMap[RepositoryTypes]
+        return resource as ResourceMap[RT]
       }
       console.error(
         `No resource found with typeId=${identifier.typeId}, id=${identifier.id}`
@@ -318,7 +376,7 @@ export class InMemoryStorage extends AbstractStorage {
           r => r.key === identifier.key
         )
         if (resource) {
-          return resource as ResourceMap[RepositoryTypes]
+          return resource as ResourceMap[RT]
         }
       } else {
         throw new Error(
@@ -369,7 +427,7 @@ export class InMemoryStorage extends AbstractStorage {
     return this.addProject(projectKey)
   }
 
-  private expand = <T>(
+  public expand = <T>(
     projectKey: string,
     obj: T,
     clause: undefined | string | string[]

package/src/types.ts

@@ -14,16 +14,21 @@ 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 RepositoryTypes = ReferenceTypeId | 'product-projection'
+export type RepositoryTypes =
+  | ReferenceTypeId
+  | 'standalone-price'
+  | 'product-projection'
 export type ServiceTypes =
   | RepositoryTypes
   | 'my-cart'
   | 'my-order'
   | 'my-payment'
   | 'my-customer'
+  | 'product-projection'
 
 export type Services = Partial<
   {
@@ -49,10 +54,12 @@ export type ResourceMap = {
   'product-discount': ctp.ProductDiscount
   'product-projection': ctp.ProductProjection
   'product-selection': ctp.ProductSelection
+  'product-price': ctp.StandalonePrice
   'product-type': ctp.ProductType
   review: ctp.Review
   'shipping-method': ctp.ShippingMethod
   'shopping-list': ctp.ShoppingList
+  'standalone-price': ctp.StandalonePrice
   state: ctp.State
   store: ctp.Store
   subscription: ctp.Subscription
@@ -105,7 +112,7 @@ export type RepositoryMap = {
   payment: PaymentRepository
   product: ProductRepository
   'product-projection': ProductProjectionRepository
-  'product-discount': never
+  'product-discount': ProductDiscountRepository
   'product-type': ProductTypeRepository
   review: never
   'shipping-method': ShippingMethodRepository