@labdigital/commercetools-mock 0.10.0 → 0.10.1

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

@@ -1,117 +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'
-import { cloneObject } from './helpers'
-
-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 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: {
@@ -142,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>(),
@@ -170,7 +109,7 @@ export class InMemoryStorage extends AbstractStorage {
     }
   }
 
-  all<RT extends RepositoryTypes>(
+  all<RT extends ResourceType>(
     projectKey: string,
     typeId: RT
   ): ResourceMap[RT][] {
@@ -181,7 +120,7 @@ export class InMemoryStorage extends AbstractStorage {
     return []
   }
 
-  add<RT extends RepositoryTypes>(
+  add<RT extends ResourceType>(
     projectKey: string,
     typeId: RT,
     obj: ResourceMap[RT],
@@ -195,7 +134,7 @@ export class InMemoryStorage extends AbstractStorage {
     return cloneObject(resource)
   }
 
-  get<RT extends RepositoryTypes>(
+  get<RT extends ResourceType>(
     projectKey: string,
     typeId: RT,
     id: string,
@@ -209,7 +148,7 @@ export class InMemoryStorage extends AbstractStorage {
     return null
   }
 
-  getByKey<RT extends RepositoryTypes>(
+  getByKey<RT extends ResourceType>(
     projectKey: string,
     typeId: RT,
     key: string,
@@ -230,32 +169,32 @@ export class InMemoryStorage extends AbstractStorage {
     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) {
@@ -294,12 +233,12 @@ export class InMemoryStorage extends AbstractStorage {
       offset: offset,
       limit: limit,
       results: resources.map(cloneObject),
-    }
+    } as PagedQueryResponseMap[RT]
   }
 
   search(
     projectKey: string,
-    typeId: RepositoryTypes,
+    typeId: ResourceType,
     params: QueryParams
   ): PagedQueryResponse {
     let resources = this.all(projectKey, typeId)
@@ -344,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) {
@@ -356,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) {
@@ -378,7 +317,7 @@ export class InMemoryStorage extends AbstractStorage {
         )
       }
     }
-    return undefined
+    return null
   }
 
   addProject = (projectKey: string): Project => {

package/src/storage/index.ts

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

package/src/types.ts

@@ -1,33 +1,13 @@
-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'
-import { AbstractRepository } from 'repositories/abstract'
 
 export type Writable<T> = { -readonly [P in keyof T]: Writable<T[P]> }
-
-export type RepositoryTypes =
-  | ReferenceTypeId
-  | 'standalone-price'
-  | 'product-projection'
+export type ShallowWritable<T> = { -readonly [P in keyof T]: T[P] }
 
 export type ServiceTypes =
-  | RepositoryTypes
+  | ctp.ReferenceTypeId
+  | 'product-projection'
   | 'my-cart'
   | 'my-order'
   | 'my-payment'
@@ -38,67 +18,36 @@ export type Services = Partial<{
   [index in ServiceTypes]: AbstractService
 }>
 
-export type Repositories = Partial<{
-  [index in RepositoryTypes | 'project']: AbstractRepository
-}>
-
-
-export type Resource =
-  | ctp.BaseResource
-  | ctp.Cart
-  | ctp.CartDiscount
-  | ctp.Category
-  | ctp.Channel
-  | ctp.Customer
-  | ctp.CustomerGroup
-  | ctp.DiscountCode
-  | ctp.Extension
-  | ctp.InventoryEntry
-  | ctp.CustomObject
-  | ctp.Order
-  | ctp.OrderEdit
-  | ctp.Payment
-  | ctp.Product
-  | ctp.Project
-  | ctp.ProductDiscount
-  | ctp.ProductProjection
-  | ctp.ProductSelection
-  | ctp.StandalonePrice
-  | ctp.ProductType
-  | ctp.Review
-  | ctp.ShippingMethod
-  | ctp.ShoppingList
-  | ctp.StandalonePrice
-  | ctp.State
-  | ctp.Store
-  | ctp.Subscription
-  | ctp.TaxCategory
-  | ctp.Type
-  | ctp.Zone
+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
@@ -106,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
 }