@compassdigital/sdk.typescript 3.0.0-beta.18 → 3.0.0-beta.20

package/src/interface/partner.ts

@@ -291,6 +291,8 @@ export interface LocationGroup {
       brand?: string;
       // location
       location?: string;
+      // location group
+      group?: string;
       // payment
       payment_provider?: string;
       location_description?: string;
@@ -397,6 +399,235 @@ export type Hours = any;
 
 export type DeliveryHours = any;
 
+export interface Menu {
+  // menu
+  id?: string;
+  date?: {
+    created?: string;
+    modified?: string;
+    published?: string;
+  };
+  label?: {
+    en?: string;
+  };
+  groups?: {
+    // group
+    id?: string;
+    label?: {
+      en?: string;
+      fr?: string;
+    };
+    items?: {
+      // item
+      id?: string;
+      label?: {
+        en?: string;
+      };
+      description?: {
+        en?: string;
+      };
+      price?: {
+        amount?: number;
+        currency?: string;
+      };
+      // Meal exchange value of the item
+      meal_value?: number;
+      sale_price?: {
+        amount?: number;
+        currency?: string;
+      };
+      // The number of units that belong to this item. For example, a dozen doughnuts should have a unit value of 12
+      unit?: number;
+      ingredients?: any[];
+      amount_off_exclusions?: string[];
+      nutrition?: {
+        kcal?: number;
+        calories?: any;
+        serving_size?: any;
+        total_fat?: any;
+        saturated_fat?: any;
+        trans_fat?: any;
+        cholesterol?: any;
+        sodium?: {
+          amount?: number;
+          unit?: string;
+        };
+        total_carbohydrate?: any;
+        dietary_fiber?: any;
+        sugars?: any;
+        protein?: any;
+        well_being?: any;
+        [index: string]: any;
+      };
+      certified?: {
+        vegan?: boolean;
+        vegetarian?: boolean;
+        seafood_watch?: boolean;
+        wellbeing?: boolean;
+        farm_to_fork?: boolean;
+        in_balance?: boolean;
+        organic?: boolean;
+        no_gluten_ingredients?: boolean;
+        halal?: boolean;
+        kosher?: boolean;
+        humane?: boolean;
+        locally_crafted?: boolean;
+        nuts?: boolean;
+        oracle_garden_grown?: boolean;
+        oracle_oyes?: boolean;
+        peanut_free?: boolean;
+        tree_nut_free?: boolean;
+        wheat_free?: boolean;
+        non_gmo?: boolean;
+        milk_free?: boolean;
+        egg_free?: boolean;
+        soy_free?: boolean;
+        fair_trade?: boolean;
+        rainforest_alliance?: boolean;
+        salt_free?: boolean;
+      };
+      options?: {
+        // modifier_group
+        id?: string;
+        label?: {
+          en?: string;
+        };
+        unique_name?: string;
+        items?: {
+          // option
+          id?: string;
+          label?: {
+            en?: string;
+          };
+          price?: {
+            amount?: number;
+            currency?: string;
+          };
+          sku?: number;
+          nutrition?: {
+            kcal?: number;
+            calories?: any;
+          };
+          certified?: {
+            vegan?: boolean;
+          };
+          modifier_sets?: {
+            category?: string;
+            list?: string[];
+          }[];
+          meta?: {
+            // chit sort order
+            sort_number?: number;
+            // menu sort order
+            menu_sort_number?: number;
+            [index: string]: any;
+          };
+          is?: {
+            disabled?: boolean;
+            hidden?: boolean;
+            out_of_stock?: boolean;
+          };
+          amount_off_exclusions?: any[];
+        }[];
+        min?: number;
+        max?: number;
+        is?: {
+          disabled?: boolean;
+          hidden?: boolean;
+          out_of_stock?: boolean;
+        };
+        meta?: {
+          // chit sort order
+          sort_number?: number;
+          // menu sort order
+          menu_sort_number?: number;
+          [index: string]: any;
+        };
+        [index: string]: any;
+      }[];
+      required?: boolean;
+      special?: boolean;
+      meta?: {
+        superplate?: {
+          type_id?: number;
+          type?: string;
+        };
+        featured?: {
+          sort_number?: number;
+          dates?: {
+            start?: string;
+            end?: string;
+          };
+        };
+        // chit sort order
+        sort_number?: number;
+        // menu sort order
+        menu_sort_number?: number;
+      };
+      category?: {
+        en?: string;
+      };
+      location?: string;
+      sku?: number;
+      item_number?: number;
+      image?: {
+        src?: string;
+      };
+      is_deleted?: boolean;
+      is?: {
+        disabled?: boolean;
+        hidden?: boolean;
+        meq_eligible?: boolean;
+        out_of_stock?: boolean;
+        deleted?: boolean;
+        featured?: boolean;
+      };
+    }[];
+    is_disabled?: boolean;
+    name?: string;
+    is?: {
+      disabled?: boolean;
+      hidden?: boolean;
+    };
+    meta?: {
+      // chit sort order
+      sort_number?: number;
+      // menu sort order
+      menu_sort_number?: number;
+      [index: string]: any;
+    };
+  }[];
+  // menu
+  parent_id?: string;
+  // brand
+  location_brand?: string;
+  // company
+  company?: string;
+  // sector
+  sector?: string;
+  is?: {
+    disabled?: boolean;
+    hidden?: boolean;
+    linked?: boolean;
+    promo_exemptions_enabled?: boolean;
+    plu_enabled?: boolean;
+    item_images_enabled?: boolean;
+    item_showcase_enabled?: boolean;
+    item_desc_edit_enabled?: boolean;
+    calories_edit_enabled?: boolean;
+    item_label_edit_enabled?: boolean;
+  };
+  meta?: {
+    // User ID
+    locked_by_user?: string;
+    // User ID
+    last_modified_user?: string;
+    [index: string]: any;
+  };
+}
+
+export type Group = any;
+
 export interface CognitionStore {
   // UUID for external store
   uuid?: string;
@@ -433,14 +664,14 @@ export type CoolrImages = any[];
 // POST /partner/standardcognition/shoppingcart - Calculates a shoppingcart
 
 export interface PostPartnerStandardcognitionShoppingcartBody {
-  items?: {
+  items: {
     sku?: string;
     quantity?: number;
   }[];
   // brand
-  location_brand?: string;
-  // shoppingcart
-  shoppingcart?: string;
+  location_brand: string;
+  // CDL shoppingcart id. If provided, items will be added to this shoppingcart
+  shoppingcart: string;
 }
 
 export type PostPartnerStandardcognitionShoppingcartResponse = ShoppingCart;
@@ -463,6 +694,25 @@ export type GetPartnerStandardcognitionStoresResponse = CognitionStore;
 
 export type GetPartnerStandardcognitionStoresRequest = {};
 
+// POST /partner/standardcognition/menu - Create new Standard Cognition menu from JSON files
+
+export interface PostPartnerStandardcognitionMenuBody {
+  // CDL company ID
+  company: string;
+  // CDL sector ID
+  sector: string;
+  // CDL location brand ID
+  location_brand: string;
+  // Link for S3 menu file provided by Standard Cognition
+  s3_link: string;
+}
+
+export type PostPartnerStandardcognitionMenuResponse = Menu;
+
+export interface PostPartnerStandardcognitionMenuRequest {
+  body: PostPartnerStandardcognitionMenuBody;
+}
+
 // GET /partner/coolr/locations - Gets the locations where Coolr is available
 
 export interface GetPartnerCoolrLocationsResponse {

package/test/client.test.ts

@@ -4,16 +4,19 @@ import { Task } from "../src/interface/task";
 
 describe("ServiceClient", () => {
 
-  function response(status: number, body?: any): ResponseData {
-    const res = { ok: status === 200, status: status, body: "" };
+  function response(status: number, body?: any, err?: any): ResponseData {
+    const res = { ok: status === 200, status: status, body: "", err: undefined };
     if (body) {
       res.body = JSON.stringify(body);
     }
+    if (err) {
+      res.err = err;
+    }
     return res;
   }
 
-  function interceptor(status: number, body?: any): InterceptFn {
-    return (req: RequestData) => Promise.resolve(response(status, body));
+  function interceptor(status: number, body?: any, err?: any): InterceptFn {
+    return (req: RequestData) => Promise.resolve(response(status, body, err));
   }
 
   test("makes basic request", async () => {
@@ -67,7 +70,7 @@ describe("ServiceClient", () => {
     });
   });
 
-  test("client retries on failure", async () => {
+  test("client retries on bad status codes", async () => {
     const intercept = jest.fn(async (req: RequestData) => {
       if (intercept.mock.calls.length === 3) {
         return response(200, "{}");
@@ -79,6 +82,18 @@ describe("ServiceClient", () => {
     expect(intercept.mock.calls.length).toBe(3);
   });
 
+  test("client retries on network error", async () => {
+    const intercept = jest.fn(async (req: RequestData) => {
+      if (intercept.mock.calls.length === 3) {
+        return response(200, "{}");
+      }
+      return response(0, "", new Error("network error"));
+    });
+    const api = new ServiceClient({ intercept });
+    const task = await api.get_task("", { retry: 2 });
+    expect(intercept.mock.calls.length).toBe(3);
+  });
+
   test("client gives up after retry limit", async () => {
     const intercept = jest.fn(interceptor(500));
     const api = new ServiceClient({ intercept });
@@ -124,6 +139,19 @@ describe("ServiceClient", () => {
       }
     });
 
+    test("throws ServiceError for network errors", async () => {
+      const api = new ServiceClient({
+        intercept: interceptor(0, null, new Error("Network Error")),
+      });
+      try {
+        await api.get_task("");
+      } catch (err) {
+        expect(err).toBeInstanceOf(ServiceError);
+        expect(ServiceError.status(err)).toBe(0);
+        expect(ServiceError.code(err)).toBe(0);
+      }
+    });
+
     test("either should be true with 200 response", async () => {
       const api = new ServiceClient({
         intercept: interceptor(200, "{}"),