@coorpacademy/app-review 0.1.5 → 0.1.8

package/lib/reducers/data/progression.js

@@ -1,76 +1,36 @@
-import { getOr, noop } from 'lodash/fp';
+import { getOr } from 'lodash/fp';
 import { VALIDATE_SLIDE } from '../../actions/data/slides';
-// -----------------------------------------------------------------------------
-export var initialState = null;
-// -----------------------------------------------------------------------------
+import { POST_PROGRESSION_SUCCESS } from '../../actions/api/post-progression';
 var reducer = function (
 // eslint-disable-next-line default-param-last
 state, action) {
-    if (state === void 0) { state = initialState; }
+    if (state === void 0) { state = null; }
     switch (action.type) {
         case VALIDATE_SLIDE: {
             var previousSlideNumber = getOr(-1, 'slideNumber', state);
             // hard coded for now
+            // TODO: fix on VALIDATE ticket
             return {
+                _id: '1234',
                 // virtual field
                 slideNumber: previousSlideNumber + 1,
-                isCorrect: true,
-                // exitNode
-                // TODO: create another action, to retrieve the next slide
-                // nextSlide should be corrected to nextContent, when this new action is created
-                // ex: nextContent: {ref: "sli_E1n2i2sBo", type: "slide"}
-                // the middleware should trigger a next content request once the result is
-                // received && update the state accordingly,
-                //
-                nextSlide: {
-                    questionText: 'Test',
-                    answerUI: {
-                        model: {
-                            answers: [
-                                {
-                                    title: 'There is no need for a password',
-                                    // TODO: onClick of each answer should use a dispatcher to
-                                    // update selected answers (in order to use them on validation)
-                                    // in each retrieval, the answers of answerUI need to be augmented
-                                    // for the onClick prop to achieve this.
-                                    onClick: noop,
-                                    selected: false,
-                                    help: 'help'
-                                },
-                                {
-                                    title: 'Lorem ipsum',
-                                    onClick: noop,
-                                    selected: false,
-                                    help: 'help'
-                                },
-                                {
-                                    title: 'Lorem',
-                                    onClick: noop,
-                                    selected: true,
-                                    order: 1,
-                                    help: 'help'
-                                },
-                                {
-                                    title: 'You need to have a password',
-                                    onClick: noop,
-                                    selected: false,
-                                    help: 'help'
-                                },
-                                {
-                                    title: 'Pouet',
-                                    onClick: noop,
-                                    selected: true,
-                                    order: 0,
-                                    help: 'help'
-                                }
-                            ],
-                            type: 'qcmDrag'
-                        },
-                        help: 'Help text will appear here'
+                state: {
+                    pendingSlides: [],
+                    step: {
+                        current: Number.NaN
+                    },
+                    isCorrect: true,
+                    nextContent: {
+                        ref: 'sli_V1gKpYYZ2',
+                        type: 'slide'
                     }
                 }
             };
         }
+        case POST_PROGRESSION_SUCCESS: {
+            var progression = action.payload;
+            return progression;
+        }
         default:
             return state;
     }

package/lib/reducers/data/skills.d.ts

@@ -1,6 +1,5 @@
-import { ReceivedSkills } from '../../actions/data/skills';
-import { Skills } from '../../types/skills';
-export declare type SkillsState = Skills;
-export declare const initialState: SkillsState;
-declare const reducer: (state: Skills | undefined, action: ReceivedSkills) => Skills;
+import { Skill } from '../../types/common';
+import { ReceivedSkills } from '../../actions/api/fetch-skills';
+export declare type SkillsState = Skill[];
+declare const reducer: (state: SkillsState | undefined, action: ReceivedSkills) => SkillsState;
 export default reducer;

package/lib/reducers/data/skills.js

@@ -1,15 +1,12 @@
-import { RECEIVED_SKILLS } from '../../actions/data/skills';
-export var initialState = [];
-// -----------------------------------------------------------------------------
+import { SKILLS_FETCH_SUCCESS } from '../../actions/api/fetch-skills';
 // eslint-disable-next-line default-param-last
 var reducer = function (state, action) {
-    if (state === void 0) { state = initialState; }
+    if (state === void 0) { state = []; }
     switch (action.type) {
-        case RECEIVED_SKILLS:
+        case SKILLS_FETCH_SUCCESS:
             return action.payload;
         default:
             return state;
     }
 };
-// -----------------------------------------------------------------------------
 export default reducer;

package/lib/reducers/data/slides.d.ts

@@ -1,4 +1,5 @@
-import { Slide, SlidesAction } from '../../actions/data/slides';
+import { SlidesAction } from '../../actions/data/slides';
+import { Slide } from '../../types/common';
 export declare type SlidesState = {
     slideNumbers: number[];
     [key: number]: Slide;

package/lib/reducers/data/slides.js

@@ -10,9 +10,10 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import map from 'lodash/fp/map';
-import { STORE_FIRST_SLIDE, UPDATE_SLIDES_ON_NEXT, UPDATE_SLIDES_ON_VALIDATION } from '../../actions/data/slides';
+import { UPDATE_SLIDES_ON_NEXT, UPDATE_SLIDES_ON_VALIDATION } from '../../actions/data/slides';
 import { HIGHEST_INDEX, slideNumbers, TOTAL_SLIDES_STACK } from '../../common';
-// -----------------------------------------------------------------------------
+import { slide as qcmSlide } from '../../fixtures/qcm-slide';
+import { SLIDE_FETCH_SUCCESS } from '../../actions/api/fetch-slide';
 var getInitialState = function () {
     var state = {
         slideNumbers: slideNumbers
@@ -41,7 +42,7 @@ var setFirstSlide = function (state, slide) {
 // ||-------> Handles the updates of a given slide on validation,
 // & then updates de remaining slides if this given change should impact their content
 var stateUpdateOnValidation = function (state, payload) {
-    var slideNumber = payload.slideNumber, newSlideContent = payload.newSlideContent, numberOfFinishedSlides = payload.numberOfFinishedSlides, nextSlide = payload.nextSlide;
+    var slideNumber = payload.slideNumber, newSlideContent = payload.newSlideContent, numberOfFinishedSlides = payload.numberOfFinishedSlides, nextContent = payload.nextContent;
     var _state = {
         slideNumbers: slideNumbers
     };
@@ -52,7 +53,7 @@ var stateUpdateOnValidation = function (state, payload) {
         if (index === slideNumber) {
             // only one slide remaining, presets the next value
             if (numberOfFinishedSlides === HIGHEST_INDEX) {
-                _state[index] = __assign(__assign({}, previousValue), { nextSlide: nextSlide, position: newSlideContent.position, isCorrect: newSlideContent.isCorrect });
+                _state[index] = __assign(__assign({}, previousValue), { nextContent: nextContent, position: newSlideContent.position, isCorrect: newSlideContent.isCorrect });
             }
             else
                 _state[slideNumber] = __assign(__assign({}, previousValue), newSlideContent);
@@ -60,7 +61,7 @@ var stateUpdateOnValidation = function (state, payload) {
         else {
             // updates the rest of the slides here
             var hidden = previousValue.hidden, position = previousValue.position;
-            _state[index] = __assign(__assign({}, nextSlide), { endReview: newSlideContent.endReview, hidden: hidden, position: position });
+            _state[index] = __assign(__assign({}, nextContent), { endReview: newSlideContent.endReview, hidden: hidden, position: position });
         }
     }, state.slideNumbers);
     return _state;
@@ -78,8 +79,8 @@ var stateUpdateOnNext = function (state, payload) {
         // the current slide
         if (index === slideNumber) {
             // when there is only one slide remaining, updates the slide value
-            if (numberOfFinishedSlides === HIGHEST_INDEX && previousValue.nextSlide) {
-                _state[index] = __assign(__assign({}, previousValue.nextSlide), { position: previousValue.position });
+            if (numberOfFinishedSlides === HIGHEST_INDEX && previousValue.nextContent) {
+                _state[index] = __assign(__assign({}, previousValue.nextContent), { position: previousValue.position });
             }
             else
                 _state[slideNumber] = newSlideContent;
@@ -103,8 +104,12 @@ var stateUpdateOnNext = function (state, payload) {
 var reducer = function (state, action) {
     if (state === void 0) { state = initialState; }
     switch (action.type) {
-        case STORE_FIRST_SLIDE: {
-            return setFirstSlide(state, action.payload);
+        case SLIDE_FETCH_SUCCESS: {
+            // TODO: An intermediate slide transform is needed here (or in fetchSlide)
+            // const apiSlide = action.payload;
+            // apiSlide adapt to uiSlide
+            var uiSlide = qcmSlide;
+            return setFirstSlide(state, uiSlide);
         }
         case UPDATE_SLIDES_ON_VALIDATION: {
             return stateUpdateOnValidation(state, action.payload);

package/lib/reducers/data/token.d.ts

@@ -1,5 +1,4 @@
 import { StoreToken } from '../../actions/data/token';
 export declare type TokenState = string | null;
-export declare const initialState: TokenState;
 declare const reducer: (state: TokenState | undefined, action: StoreToken) => TokenState;
 export default reducer;

package/lib/reducers/data/token.js

@@ -1,10 +1,7 @@
 import { STORE_TOKEN } from '../../actions/data/token';
-// -----------------------------------------------------------------------------
-export var initialState = null;
-// -----------------------------------------------------------------------------
 // eslint-disable-next-line default-param-last
 var reducer = function (state, action) {
-    if (state === void 0) { state = initialState; }
+    if (state === void 0) { state = null; }
     switch (action.type) {
         case STORE_TOKEN:
             return action.payload;
@@ -12,5 +9,4 @@ var reducer = function (state, action) {
             return state;
     }
 };
-// -----------------------------------------------------------------------------
 export default reducer;

package/lib/reducers/index.d.ts

@@ -1,7 +1,13 @@
+import { DataState } from './data';
+import { UIState } from './ui';
+export declare type StoreState = {
+    ui: UIState;
+    data: DataState;
+};
 declare const _default: import("redux").Reducer<import("redux").CombinedState<{
     data: import("redux").CombinedState<{
         progression: import("./data/progression").ProgressionState;
-        skills: import("../types/skills").Skills;
+        skills: import("./data/skills").SkillsState;
         slides: import("./data/slides").SlidesState;
         token: import("./data/token").TokenState;
     }>;
@@ -9,7 +15,7 @@ declare const _default: import("redux").Reducer<import("redux").CombinedState<{
         finishedSlides: import("./ui/finished-slides").FinishedSlidesState;
         navigation: import("./ui/navigation").NavigationState;
         reviewStatus: import("./ui/review-status").ReviewStatusState;
-        stepItems: import("./ui/step-items").StepItems;
+        stepItems: import("./ui/step-items").StepItemsState;
     }>;
-}>, import("../actions/data/slides").ValidateSlide | import("../actions/data/slides").SlidesAction | import("../actions/data/skills").ReceivedSkills | import("../actions/data/token").StoreToken | import("../actions/ui/finished-slides").UpdateFinishedSlides | import("../actions/ui/navigation").NavigateTo | import("../actions/ui/navigation").NavigateBack | import("../actions/ui/review-status").UpdateReviewStatus | import("../actions/ui/step-items").StepItemsAction>;
+}>, import("../actions/data/slides").ValidateSlide | import("../actions/data/slides").SlidesAction | import("../actions/api/post-progression").ReceiveProgression | import("../actions/api/fetch-skills").ReceivedSkills | import("../actions/data/token").StoreToken | import("../actions/ui/finished-slides").UpdateFinishedSlides | import("../actions/ui/navigation").NavigateTo | import("../actions/ui/navigation").NavigateBack | import("../actions/ui/review-status").UpdateReviewStatus | import("../actions/ui/step-items").StepItemsAction>;
 export default _default;

package/lib/reducers/ui/finished-slides.d.ts

@@ -3,6 +3,5 @@ export declare type FinishedSlidesState = {
     slideNumbers: number[];
     [key: number]: true;
 };
-export declare const initialState: FinishedSlidesState;
 declare const reducer: (state: FinishedSlidesState | undefined, action: UpdateFinishedSlides) => FinishedSlidesState;
 export default reducer;

package/lib/reducers/ui/finished-slides.js

@@ -12,11 +12,9 @@ var __rest = (this && this.__rest) || function (s, e) {
 import forEach from 'lodash/fp/forEach';
 import { UPDATE_FINISHED_SLIDES } from '../../actions/ui/finished-slides';
 import { slideNumbers } from '../../common';
-// -----------------------------------------------------------------------------
-export var initialState = {
+var initialState = {
     slideNumbers: slideNumbers
 };
-// -----------------------------------------------------------------------------
 var _forEach = forEach.convert({
     cap: false
 });

package/lib/reducers/ui/index.d.ts

@@ -1,7 +1,17 @@
+import { FinishedSlidesState } from './finished-slides';
+import { NavigationState } from './navigation';
+import { ReviewStatusState } from './review-status';
+import { StepItemsState } from './step-items';
+export declare type UIState = {
+    navigation: NavigationState;
+    stepItems: StepItemsState;
+    finishedSlides: FinishedSlidesState;
+    reviewStatus: ReviewStatusState;
+};
 declare const _default: import("redux").Reducer<import("redux").CombinedState<{
-    finishedSlides: import("./finished-slides").FinishedSlidesState;
-    navigation: import("./navigation").NavigationState;
-    reviewStatus: import("./review-status").ReviewStatusState;
-    stepItems: import("./step-items").StepItems;
+    finishedSlides: FinishedSlidesState;
+    navigation: NavigationState;
+    reviewStatus: ReviewStatusState;
+    stepItems: StepItemsState;
 }>, import("../../actions/ui/finished-slides").UpdateFinishedSlides | import("../../actions/ui/navigation").NavigateTo | import("../../actions/ui/navigation").NavigateBack | import("../../actions/ui/review-status").UpdateReviewStatus | import("../../actions/ui/step-items").StepItemsAction>;
 export default _default;

package/lib/reducers/ui/navigation.d.ts

@@ -1,5 +1,4 @@
 import { type NavigateTo, type NavigateBack } from '../../actions/ui/navigation';
 export declare type NavigationState = Array<'skills' | 'onboarding' | 'slides'>;
-export declare const initialState: NavigationState;
 declare const reducer: (state: NavigationState | undefined, action: NavigateTo | NavigateBack) => NavigationState;
 export default reducer;

package/lib/reducers/ui/navigation.js

@@ -8,12 +8,10 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { NAVIGATE_BACK, NAVIGATE_TO } from '../../actions/ui/navigation';
-export var initialState = [];
-// -----------------------------------------------------------------------------
 var reducer = function (
 // eslint-disable-next-line default-param-last
 state, action) {
-    if (state === void 0) { state = initialState; }
+    if (state === void 0) { state = []; }
     switch (action.type) {
         case NAVIGATE_TO: {
             return __spreadArray(__spreadArray([], state, true), [action.payload], false);

package/lib/reducers/ui/review-status.d.ts

@@ -1,5 +1,4 @@
 import { UpdateReviewStatus } from '../../actions/ui/review-status';
 export declare type ReviewStatusState = 'finished' | 'ongoing';
-export declare const initialState: ReviewStatusState;
 declare const reducer: (state: ReviewStatusState | undefined, action: UpdateReviewStatus) => ReviewStatusState;
 export default reducer;

package/lib/reducers/ui/review-status.js

@@ -1,10 +1,8 @@
 import { UPDATE_REVIEW_STATUS } from '../../actions/ui/review-status';
-export var initialState = 'ongoing';
-// -----------------------------------------------------------------------------
 var reducer = function (
 // eslint-disable-next-line default-param-last
 state, action) {
-    if (state === void 0) { state = initialState; }
+    if (state === void 0) { state = 'ongoing'; }
     switch (action.type) {
         case UPDATE_REVIEW_STATUS: {
             return action.payload;
@@ -13,5 +11,4 @@ state, action) {
             return state;
     }
 };
-// -----------------------------------------------------------------------------
 export default reducer;

package/lib/reducers/ui/step-items.d.ts

@@ -1,14 +1,14 @@
-import { IconValue, StepItemsAction } from '../../actions/ui/step-items';
-declare type StepItem = {
+import { IconValue } from '../../types/common';
+import { StepItemsAction } from '../../actions/ui/step-items';
+export declare type StepItem = {
     current: boolean;
     icon: IconValue;
     value: string;
 };
-export declare type StepItems = {
+export declare type StepItemsState = {
     slideNumbers: number[];
     [key: number]: StepItem;
 };
-export declare type StepItemsState = StepItems;
 export declare const initialState: StepItemsState;
-declare const reducer: (state: StepItems | undefined, action: StepItemsAction) => StepItemsState;
+declare const reducer: (state: StepItemsState | undefined, action: StepItemsAction) => StepItemsState;
 export default reducer;

package/lib/reducers/ui/step-items.js

@@ -14,7 +14,6 @@ import has from 'lodash/fp/has';
 import map from 'lodash/fp/map';
 import { UPDATE_STEP_ITEMS_ON_NEXT, UPDATE_STEP_ITEMS_ON_VALIDATION } from '../../actions/ui/step-items';
 import { HIGHEST_INDEX, slideNumbers, TOTAL_SLIDES_STACK } from '../../common';
-// -----------------------------------------------------------------------------
 var getInitialState = function () {
     var state = {
         slideNumbers: slideNumbers

package/lib/services/fetch-skills.d.ts

@@ -1,8 +1,2 @@
-import crossFetch from 'cross-fetch';
-import { Skills } from '../types/skills';
-declare type FetchSkills = (token: string) => Promise<Skills>;
-declare type CreateFetchSkills = (fetch: typeof crossFetch) => FetchSkills;
-declare const fetchSkills: CreateFetchSkills;
-export { fetchSkills };
-declare const _default: FetchSkills;
-export default _default;
+import { Skill } from '../types/common';
+export declare const fetchSkills: (token: string) => Promise<Skill[]>;

package/lib/services/fetch-skills.js

@@ -37,33 +37,18 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import crossFetch from 'cross-fetch';
 import decode from 'jwt-decode';
 import { toJSON } from './tools/fetch-responses';
-import mockFetchSkills from './fetch-skills.mock';
-// -----------------------------------------------------------------------------
-var fetchSkills = function (fetch) { return function (token) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, userId, host, response, skills;
+export var fetchSkills = function (token) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, userId, host, response;
     return __generator(this, function (_b) {
         switch (_b.label) {
             case 0:
                 _a = decode(token), userId = _a.user, host = _a.host;
-                return [4 /*yield*/, fetch("".concat(host, "/api/v2/skills/review/user/").concat(userId), {
+                return [4 /*yield*/, crossFetch("".concat(host, "/api/v2/skills/review/user/").concat(userId), {
                         headers: { authorization: token }
                     })];
             case 1:
                 response = _b.sent();
-                return [4 /*yield*/, toJSON(response)];
-            case 2:
-                skills = (_b.sent());
-                return [2 /*return*/, skills];
+                return [2 /*return*/, toJSON(response)];
         }
     });
-}); }; };
-// -----------------------------------------------------------------------------
-var createFetchSkills = function () {
-    if (process.env.SERVICES !== 'mocks') {
-        return fetchSkills(crossFetch);
-    }
-    return fetchSkills(mockFetchSkills);
-};
-// -----------------------------------------------------------------------------
-export { fetchSkills };
-export default createFetchSkills();
+}); };

package/lib/services/fetch-slide.d.ts

@@ -0,0 +1,2 @@
+import { SlideFromAPI } from '../types/common';
+export declare const fetchSlide: (slideRef: string, token: string) => Promise<SlideFromAPI | void>;

package/lib/services/fetch-slide.js

@@ -0,0 +1,57 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import crossFetch from 'cross-fetch';
+import decode from 'jwt-decode';
+import { toJSON } from './tools/fetch-responses';
+export var fetchSlide = function (slideRef, token) { return __awaiter(void 0, void 0, void 0, function () {
+    var host, response, slide;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                host = decode(token).host;
+                return [4 /*yield*/, crossFetch("".concat(host, "/api/v2/slide/").concat(slideRef), {
+                        headers: { authorization: token }
+                    })];
+            case 1:
+                response = _a.sent();
+                return [4 /*yield*/, toJSON(response)];
+            case 2:
+                slide = (_a.sent());
+                return [2 /*return*/, slide];
+        }
+    });
+}); };

package/lib/services/index.d.ts

@@ -0,0 +1,2 @@
+import { Services } from '../types/common';
+export declare const getServices: () => Services;

package/lib/services/index.js

@@ -0,0 +1,8 @@
+import { fetchSkills } from './fetch-skills';
+import { postProgression } from './post-progression';
+import { fetchSlide } from './fetch-slide';
+export var getServices = function () { return ({
+    fetchSkills: fetchSkills,
+    fetchSlide: fetchSlide,
+    postProgression: postProgression
+}); };

package/lib/services/post-progression.d.ts

@@ -0,0 +1,2 @@
+import { ProgressionFromAPI } from '../types/common';
+export declare const postProgression: (skillRef: string, token: string) => Promise<ProgressionFromAPI>;

package/lib/services/post-progression.js

@@ -0,0 +1,65 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import crossFetch from 'cross-fetch';
+import decode from 'jwt-decode';
+import { toJSON } from './tools/fetch-responses';
+export var postProgression = function (skillRef, token) { return __awaiter(void 0, void 0, void 0, function () {
+    var host, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                host = decode(token).host;
+                return [4 /*yield*/, crossFetch("".concat(host, "/api/v2/progressions"), {
+                        method: 'post',
+                        headers: { authorization: token },
+                        body: JSON.stringify({
+                            content: {
+                                ref: skillRef,
+                                type: 'slide'
+                            },
+                            engine: {
+                                ref: 'review',
+                                version: '1'
+                            }
+                        })
+                    })];
+            case 1:
+                response = _a.sent();
+                return [2 /*return*/, toJSON(response)];
+        }
+    });
+}); };

package/lib/services/{fetch-skills.test.js → test/fetch-skills.test.js}

@@ -35,23 +35,31 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import test from 'ava';
-import { fetchSkills } from './fetch-skills';
-import { okJSONResponse, token } from './tools/fetch.mocks';
+import nock from 'nock';
+import { fetchSkills } from '../fetch-skills';
+var result = [
+    {
+        slidesToReview: 1,
+        name: 'skill-test',
+        custom: false,
+        skillRef: '_skill-ref'
+    }
+];
+test.before(function () {
+    nock('http://localhost:3000')
+        .get('/api/v2/skills/review/user/592d830b240b923f00bffba6')
+        .reply(200, result);
+});
+test.after(function () {
+    nock.cleanAll();
+});
 test('should fetch skills with success', function (t) { return __awaiter(void 0, void 0, void 0, function () {
-    var result, mockedFetchSkills, skills;
+    var token, skills;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                result = [
-                    {
-                        slidesToReview: 1,
-                        name: 'skill-test',
-                        custom: false,
-                        skillRef: '_skill-ref'
-                    }
-                ];
-                mockedFetchSkills = fetchSkills(okJSONResponse(result));
-                return [4 /*yield*/, mockedFetchSkills(token)];
+                token = process.env.API_TEST_TOKEN || '';
+                return [4 /*yield*/, fetchSkills(token)];
             case 1:
                 skills = _a.sent();
                 t.deepEqual(result, skills);
@@ -60,13 +68,12 @@ test('should fetch skills with success', function (t) { return __awaiter(void 0,
     });
 }); });
 test('should reject bad token', function (t) { return __awaiter(void 0, void 0, void 0, function () {
-    var badToken, mockedFetchSkills, error;
+    var badToken, error;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 badToken = 'token is not a jwt';
-                mockedFetchSkills = fetchSkills(okJSONResponse([]));
-                return [4 /*yield*/, t.throwsAsync(function () { return mockedFetchSkills(badToken); })];
+                return [4 /*yield*/, t.throwsAsync(function () { return fetchSkills(badToken); })];
             case 1:
                 error = _a.sent();
                 t.is(error === null || error === void 0 ? void 0 : error.message, "Invalid token specified: Cannot read properties of undefined (reading 'replace')");