@labdigital/commercetools-mock 0.5.11 → 0.5.14

package/src/storage.ts

@@ -2,6 +2,7 @@ import assert from 'assert'
 import {
   BaseResource,
   Cart,
+  Category,
   Customer,
   CustomObject,
   InventoryEntry,
@@ -9,20 +10,29 @@ import {
   PagedQueryResponse,
   QueryParam,
   Reference,
-  ReferenceTypeId,
   ResourceIdentifier,
   Product,
   Store,
   Type,
   Payment,
+  Project,
   State,
   TaxCategory,
   ShippingMethod,
   ProductType,
   InvalidInputError,
+  ProductProjection,
+  ShoppingList,
+  Extension,
+  CartDiscount,
+  CustomerGroup,
+  DiscountCode,
+  Zone,
+  Channel,
+  Subscription,
 } from '@commercetools/platform-sdk'
 import { parseExpandClause } from './lib/expandParser'
-import { ResourceMap, Writable } from './types'
+import { RepositoryTypes, ResourceMap, Writable } from './types'
 import { parseQueryExpression } from './lib/predicateParser'
 import { CommercetoolsError } from './exceptions'
 
@@ -43,33 +53,44 @@ type QueryParams = {
 export abstract class AbstractStorage {
   abstract clear(): void
 
-  abstract assertStorage(typeId: ReferenceTypeId): void
+  abstract assertStorage(typeId: RepositoryTypes): void
 
-  abstract all(projectKey: string, typeId: ReferenceTypeId): Array<BaseResource>
+  abstract all(projectKey: string, typeId: RepositoryTypes): Array<BaseResource>
 
-  abstract add<ReferenceTypeId extends keyof ResourceMap>(
+  abstract add<RepositoryTypes extends keyof ResourceMap>(
     projectKey: string,
-    typeId: ReferenceTypeId,
-    obj: ResourceMap[ReferenceTypeId]
+    typeId: RepositoryTypes,
+    obj: ResourceMap[RepositoryTypes]
   ): void
 
-  abstract get<ReferenceTypeId extends keyof ResourceMap>(
+  abstract get<RepositoryTypes extends keyof ResourceMap>(
     projectKey: string,
-    typeId: ReferenceTypeId,
+    typeId: RepositoryTypes,
     id: string,
     params: GetParams
-  ): ResourceMap[ReferenceTypeId] | null
+  ): ResourceMap[RepositoryTypes] | null
+
+  abstract getByKey<RepositoryTypes extends keyof ResourceMap>(
+    projectKey: string,
+    typeId: RepositoryTypes,
+    key: string,
+    params: GetParams
+  ): ResourceMap[RepositoryTypes] | null
+
+  abstract addProject(projectKey: string): Project
+  abstract getProject(projectKey: string): Project
+  abstract saveProject(project: Project): Project
 
   abstract delete(
     projectKey: string,
-    typeId: ReferenceTypeId,
+    typeId: RepositoryTypes,
     id: string,
     params: GetParams
   ): BaseResource | null
 
   abstract query(
     projectKey: string,
-    typeId: ReferenceTypeId,
+    typeId: RepositoryTypes,
     params: QueryParams
   ): PagedQueryResponse
 
@@ -81,7 +102,7 @@ export abstract class AbstractStorage {
 
 type ProjectStorage = Partial<
   {
-    [index in ReferenceTypeId]: Map<string, BaseResource>
+    [index in RepositoryTypes]: Map<string, BaseResource>
   }
 >
 
@@ -90,23 +111,40 @@ export class InMemoryStorage extends AbstractStorage {
     [projectKey: string]: ProjectStorage
   } = {}
 
+  protected projects: {
+    [projectKey: string]: Project
+  } = {}
+
   private forProjectKey(projectKey: string) {
+    this.addProject(projectKey)
+
     let projectStorage = this.resources[projectKey]
     if (!projectStorage) {
       projectStorage = this.resources[projectKey] = {
         cart: new Map<string, Cart>(),
+        'cart-discount': new Map<string, CartDiscount>(),
+        category: new Map<string, Category>(),
+        channel: new Map<string, Channel>(),
         customer: new Map<string, Customer>(),
+        'customer-group': new Map<string, CustomerGroup>(),
+        'discount-code': new Map<string, DiscountCode>(),
+        extension: new Map<string, Extension>(),
         'inventory-entry': new Map<string, InventoryEntry>(),
         'key-value-document': new Map<string, CustomObject>(),
         order: new Map<string, Order>(),
         payment: new Map<string, Payment>(),
         'product-type': new Map<string, ProductType>(),
         product: new Map<string, Product>(),
+        'product-selection': new Map<string, any>(),
+        'product-projection': new Map<string, ProductProjection>(),
         'shipping-method': new Map<string, ShippingMethod>(),
         state: new Map<string, State>(),
         store: new Map<string, Store>(),
+        'shopping-list': new Map<string, ShoppingList>(),
+        subscription: new Map<string, Subscription>(),
         'tax-category': new Map<string, TaxCategory>(),
         type: new Map<string, Type>(),
+        zone: new Map<string, Zone>(),
       }
     }
     return projectStorage
@@ -120,9 +158,9 @@ export class InMemoryStorage extends AbstractStorage {
     }
   }
 
-  assertStorage(typeId: ReferenceTypeId) {}
+  assertStorage(typeId: RepositoryTypes) {}
 
-  all(projectKey: string, typeId: ReferenceTypeId) {
+  all(projectKey: string, typeId: RepositoryTypes) {
     const store = this.forProjectKey(projectKey)[typeId]
     if (store) {
       return Array.from(store.values())
@@ -130,12 +168,12 @@ export class InMemoryStorage extends AbstractStorage {
     return []
   }
 
-  add<ReferenceTypeId extends keyof ResourceMap>(
+  add<RepositoryTypes extends keyof ResourceMap>(
     projectKey: string,
-    typeId: ReferenceTypeId,
-    obj: ResourceMap[ReferenceTypeId],
+    typeId: RepositoryTypes,
+    obj: ResourceMap[RepositoryTypes],
     params: GetParams = {}
-  ): ResourceMap[ReferenceTypeId] {
+  ): ResourceMap[RepositoryTypes] {
     this.forProjectKey(projectKey)[typeId]?.set(obj.id, obj)
 
     const resource = this.get(projectKey, typeId, obj.id, params)
@@ -143,44 +181,62 @@ export class InMemoryStorage extends AbstractStorage {
     return resource
   }
 
-  get<ReferenceTypeId extends keyof ResourceMap>(
+  get<RepositoryTypes extends keyof ResourceMap>(
     projectKey: string,
-    typeId: ReferenceTypeId,
+    typeId: RepositoryTypes,
     id: string,
     params: GetParams = {}
-  ): ResourceMap[ReferenceTypeId] | null {
+  ): ResourceMap[RepositoryTypes] | null {
     const resource = this.forProjectKey(projectKey)[typeId]?.get(id)
     if (resource) {
       return this.expand(
         projectKey,
         resource,
         params.expand
-      ) as ResourceMap[ReferenceTypeId]
+      ) as ResourceMap[RepositoryTypes]
     }
     return null
   }
 
+  getByKey<RepositoryTypes extends keyof ResourceMap>(
+    projectKey: string,
+    typeId: RepositoryTypes,
+    key: string,
+    params: GetParams = {}
+  ): ResourceMap[RepositoryTypes] | null {
+    const store = this.forProjectKey(projectKey)[typeId]
+    if (!store) {
+      throw new Error('No type')
+    }
+
+    const resources: any[] = Array.from(store.values())
+    const resource = resources.find(e => e.key === key)
+    if (params.expand) return this.expand(projectKey, resource, params.expand)
+    return resource
+  }
+
   delete(
     projectKey: string,
-    typeId: ReferenceTypeId,
+    typeId: RepositoryTypes,
     id: string,
     params: GetParams = {}
   ): BaseResource | 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[ReferenceTypeId]
+      ) as ResourceMap[RepositoryTypes]
     }
     return resource
   }
 
   query(
     projectKey: string,
-    typeId: ReferenceTypeId,
+    typeId: RepositoryTypes,
     params: QueryParams
   ): PagedQueryResponse {
     const store = this.forProjectKey(projectKey)[typeId]
@@ -199,7 +255,7 @@ export class InMemoryStorage extends AbstractStorage {
         throw new CommercetoolsError<InvalidInputError>(
           {
             code: 'InvalidInput',
-            message: err.message,
+            message: (err as any).message,
           },
           400
         )
@@ -230,14 +286,14 @@ export class InMemoryStorage extends AbstractStorage {
     }
   }
 
-  getByResourceIdentifier<ReferenceTypeId extends keyof ResourceMap>(
+  getByResourceIdentifier<RepositoryTypes extends keyof ResourceMap>(
     projectKey: string,
     identifier: ResourceIdentifier
-  ): ResourceMap[ReferenceTypeId] | undefined {
+  ): ResourceMap[RepositoryTypes] | undefined {
     if (identifier.id) {
       const resource = this.get(projectKey, identifier.typeId, identifier.id)
       if (resource) {
-        return resource as ResourceMap[ReferenceTypeId]
+        return resource as ResourceMap[RepositoryTypes]
       }
       console.error(
         `No resource found with typeId=${identifier.typeId}, id=${identifier.id}`
@@ -256,7 +312,7 @@ export class InMemoryStorage extends AbstractStorage {
           r => r.key === identifier.key
         )
         if (resource) {
-          return resource as ResourceMap[ReferenceTypeId]
+          return resource as ResourceMap[RepositoryTypes]
         }
       } else {
         throw new Error(
@@ -267,6 +323,46 @@ export class InMemoryStorage extends AbstractStorage {
     return undefined
   }
 
+  addProject = (projectKey: string): Project => {
+    if (!this.projects[projectKey]) {
+      this.projects[projectKey] = {
+        key: projectKey,
+        name: '',
+        countries: [],
+        currencies: [],
+        languages: [],
+        createdAt: '2018-10-04T11:32:12.603Z',
+        trialUntil: '2018-12',
+        carts: {
+          countryTaxRateFallbackEnabled: false,
+          deleteDaysAfterLastModification: 90,
+        },
+        messages: { enabled: false, deleteDaysAfterCreation: 15 },
+        shippingRateInputType: undefined,
+        externalOAuth: undefined,
+        searchIndexing: {
+          products: {
+            status: 'Deactivated',
+          },
+          orders: {
+            status: 'Deactivated',
+          },
+        },
+        version: 1,
+      }
+    }
+    return this.projects[projectKey]
+  }
+
+  saveProject = (project: Project): Project => {
+    this.projects[project.key] = project
+    return project
+  }
+
+  getProject = (projectKey: string): Project => {
+    return this.addProject(projectKey)
+  }
+
   private expand = <T>(
     projectKey: string,
     obj: T,

package/src/types.ts

@@ -1,3 +1,5 @@
+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 AbstractService from './services/abstract'
@@ -15,11 +17,12 @@ import { TaxCategoryRepository } from './repositories/tax-category'
 
 export type Writable<T> = { -readonly [P in keyof T]: Writable<T[P]> }
 
-type serviceTypes = ReferenceTypeId | 'my-payment'
+export type RepositoryTypes = ReferenceTypeId | 'product-projection'
+export type ServiceTypes = RepositoryTypes | 'my-cart' | 'my-payment'
 
 export type Services = Partial<
   {
-    [index in serviceTypes]: AbstractService
+    [index in ServiceTypes]: AbstractService
   }
 >
 
@@ -39,6 +42,8 @@ export type ResourceMap = {
   payment: ctp.Payment
   product: ctp.Product
   'product-discount': ctp.ProductDiscount
+  'product-projection': ctp.ProductProjection
+  'product-selection': ctp.ProductSelection
   'product-type': ctp.ProductType
   review: ctp.Review
   'shipping-method': ctp.ShippingMethod
@@ -94,11 +99,12 @@ export type RepositoryMap = {
   'order-edit': never
   payment: PaymentRepository
   product: ProductRepository
+  'product-projection': ProductProjectionRepository
   'product-discount': never
   'product-type': ProductTypeRepository
   review: never
   'shipping-method': ShippingMethodRepository
-  'shopping-list': never
+  'shopping-list': ShoppingListRepository
   state: StateRepository
   store: never
   subscription: never