@coorpacademy/app-review 0.1.4 → 0.1.7

package/lib/middlewares/on-receive-progression.js

@@ -0,0 +1,27 @@
+import get from 'lodash/fp/get';
+// eslint-disable-next-line import/no-named-as-default
+import fetchSlide from '../services/fetch-slide';
+import { errorFetchingSlide, storeFirstSlide } from '../actions/data/slides';
+import { RECEIVE_PROGRESSION } from '../actions/data/progression';
+var onReceiveProgression = function (_a) {
+    var dispatch = _a.dispatch;
+    return function (next) {
+        return function (action) {
+            if (action.type === RECEIVE_PROGRESSION) {
+                var _a = action.payload, progression = _a.progression, token = _a.token;
+                var slideRef = get('state.nextContent.ref', progression);
+                // TOASK: do we need to check for exit nodes before fetching??
+                // TODO: To implement fetchSlide in next ticket
+                fetchSlide(slideRef, token)
+                    .then(function (slide) {
+                    return dispatch(storeFirstSlide(slide));
+                })
+                    .catch(function (err) {
+                    return dispatch(errorFetchingSlide(err));
+                });
+            }
+            return next(action);
+        };
+    };
+};
+export default onReceiveProgression;

package/lib/middlewares/on-receive-progression.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middlewares/on-receive-progression.test.js

@@ -0,0 +1,88 @@
+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 test from 'ava';
+import { receiveProgression } from '../actions/data/progression';
+import { mockedProgression } from '../services/post-progression.mock';
+import { sleep } from '../services/tools/sleep';
+import { STORE_FIRST_SLIDE } from '../actions/data/slides';
+import onReceiveProgression from './on-receive-progression';
+var appOptions = {
+    token: process.env.API_TEST_TOKEN || ''
+};
+var otherAction = function (payload) { return ({
+    type: '@@other/OTHER',
+    payload: payload
+}); };
+test('should not dispatch anything if action is not RECEIVE_PROGRESSION', function (t) {
+    t.plan(1);
+    var dispatch = function () {
+        t.fail();
+    };
+    var next = function () {
+        return t.pass();
+    };
+    onReceiveProgression({ dispatch: dispatch })(next)(otherAction('other'));
+});
+test('should dispatch actions: STORE_FIRST_SLIDE', function (t) { return __awaiter(void 0, void 0, void 0, function () {
+    var dispatch, next;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                t.plan(2);
+                dispatch = function (action) {
+                    switch (action.type) {
+                        case STORE_FIRST_SLIDE: {
+                            var slide = action.payload;
+                            t.deepEqual(slide, {});
+                            return;
+                        }
+                        default:
+                            t.fail();
+                            break;
+                    }
+                };
+                next = function () {
+                    return t.pass();
+                };
+                onReceiveProgression({ dispatch: dispatch })(next)(receiveProgression({ token: appOptions.token, progression: mockedProgression }));
+                return [4 /*yield*/, sleep(1000)];
+            case 1:
+                _a.sent(); // wait for the .then to fire
+                return [2 /*return*/];
+        }
+    });
+}); });

package/lib/middlewares/on-start-app.js

@@ -1,22 +1,30 @@
 import { VIEWS } from '../common';
 import { storeToken } from '../actions/data/token';
 import { receivedSkills, errorFetchingSkills } from '../actions/data/skills';
-import { storeFirstSlide } from '../actions/data/slides';
 import { navigateTo, START_APP } from '../actions/ui/navigation';
 // eslint-disable-next-line import/no-named-as-default
 import fetchSkills from '../services/fetch-skills';
+// eslint-disable-next-line import/no-named-as-default
+import postProgression from '../services/post-progression';
+import { errorCreatingProgression, receiveProgression } from '../actions/data/progression';
 var onStartApp = function (_a) {
     var dispatch = _a.dispatch;
     return function (next) {
         return function (action) {
             if (action.type === START_APP) {
-                var _a = action.payload, slide = _a.slide, token = _a.token;
-                dispatch(storeToken(token));
-                if (slide) {
-                    dispatch(storeFirstSlide(slide));
+                var _a = action.payload, skillRef = _a.skillRef, token_1 = _a.token;
+                dispatch(storeToken(token_1));
+                if (skillRef) {
+                    postProgression(skillRef, token_1)
+                        .then(function (progression) {
+                        return dispatch(receiveProgression({ progression: progression, token: token_1 }));
+                    })
+                        .catch(function (err) {
+                        return dispatch(errorCreatingProgression(err));
+                    });
                 }
                 else {
-                    fetchSkills(token)
+                    fetchSkills(token_1)
                         .then(function (skills) {
                         return dispatch(receivedSkills(skills));
                     })
@@ -24,7 +32,7 @@ var onStartApp = function (_a) {
                         return dispatch(errorFetchingSkills(err));
                     });
                 }
-                var initialView = slide ? VIEWS.slides : VIEWS.skills;
+                var initialView = skillRef ? VIEWS.slides : VIEWS.skills;
                 dispatch(navigateTo(initialView));
             }
             return next(action);

package/lib/middlewares/on-start-app.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middlewares/on-start-app.test.js

@@ -0,0 +1,98 @@
+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 test from 'ava';
+import { STORE_TOKEN } from '../actions/data/token';
+import { RECEIVE_PROGRESSION } from '../actions/data/progression';
+import { NAVIGATE_TO, startApp } from '../actions/ui/navigation';
+import { mockedProgression } from '../services/post-progression.mock';
+import { VIEWS } from '../common';
+import { sleep } from '../services/tools/sleep';
+import onStartApp from './on-start-app';
+var appOptions = {
+    token: process.env.API_TEST_TOKEN || '',
+    skillRef: 'skill_NJC0jFKoH'
+};
+var otherAction = function (payload) { return ({
+    type: '@@other/OTHER',
+    payload: payload
+}); };
+test('should not dispatch anything if action is not START_APP', function (t) {
+    t.plan(1);
+    var dispatch = function () {
+        t.fail();
+    };
+    var next = function () {
+        return t.pass();
+    };
+    onStartApp({ dispatch: dispatch })(next)(otherAction('other'));
+});
+test('should dispatch actions: STORE_TOKEN && RECEIVE_PROGRESSION if an skillRef is given, on a successful response', function (t) { return __awaiter(void 0, void 0, void 0, function () {
+    var dispatch, next;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                t.plan(5);
+                dispatch = function (action) {
+                    switch (action.type) {
+                        case STORE_TOKEN:
+                            t.is(action.payload, appOptions.token);
+                            return;
+                        case RECEIVE_PROGRESSION: {
+                            var _a = action.payload, token = _a.token, progression = _a.progression;
+                            t.is(token, appOptions.token);
+                            t.deepEqual(progression, JSON.parse(JSON.stringify(mockedProgression)));
+                            return;
+                        }
+                        case NAVIGATE_TO:
+                            t.is(action.payload, VIEWS.slides);
+                            return;
+                        default:
+                            t.fail();
+                            break;
+                    }
+                };
+                next = function () {
+                    return t.pass();
+                };
+                onStartApp({ dispatch: dispatch })(next)(startApp(appOptions));
+                return [4 /*yield*/, sleep(1000)];
+            case 1:
+                _a.sent(); // wait for the .then to fire
+                return [2 /*return*/];
+        }
+    });
+}); });

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

@@ -3,5 +3,5 @@ declare const _default: import("redux").Reducer<import("redux").CombinedState<{
     skills: import("../../types/skills").Skills;
     slides: import("./slides").SlidesState;
     token: import("./token").TokenState;
-}>, import("../../actions/data/slides").ValidateSlide | import("../../actions/data/slides").SlidesAction | import("../../actions/data/skills").ReceivedSkills | import("../../actions/data/token").StoreToken>;
+}>, import("../../actions/data/progression").ReceiveProgression | import("../../actions/data/slides").ValidateSlide | import("../../actions/data/slides").SlidesAction | import("../../actions/data/skills").ReceivedSkills | import("../../actions/data/token").StoreToken>;
 export default _default;

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

@@ -1,14 +1,20 @@
+import { ReceiveProgression } from '../../actions/data/progression';
 import { ValidateSlide } from '../../actions/data/slides';
-import { AnswerUI } from '../../types/slides';
 export declare type ProgressionState = {
-    slideNumber: number;
-    isCorrect?: boolean;
-    exitNode?: 'successExitNode' | 'failExitNode';
-    nextSlide?: {
-        questionText?: string;
-        answerUI?: AnswerUI;
+    _id?: string;
+    state: {
+        isCorrect: boolean;
+        nextContent: {
+            ref: 'successExitNode' | string;
+            type: 'success' | 'slide';
+        };
+        pendingSlides: string[];
+        step: {
+            current: number;
+        };
     };
+    slideNumber?: number;
 } | null;
 export declare const initialState: ProgressionState;
-declare const reducer: (state: ProgressionState | undefined, action: ValidateSlide) => ProgressionState;
+declare const reducer: (state: ProgressionState | undefined, action: ValidateSlide | ReceiveProgression) => ProgressionState;
 export default reducer;

package/lib/reducers/data/progression.js

@@ -1,4 +1,5 @@
-import { getOr, noop } from 'lodash/fp';
+import { getOr } from 'lodash/fp';
+import { RECEIVE_PROGRESSION } from '../../actions/data/progression';
 import { VALIDATE_SLIDE } from '../../actions/data/slides';
 // -----------------------------------------------------------------------------
 export var initialState = null;
@@ -11,66 +12,28 @@ state, action) {
         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 RECEIVE_PROGRESSION: {
+            var progression = action.payload.progression;
+            return progression;
+        }
         default:
             return state;
     }

package/lib/reducers/data/slides.js

@@ -12,6 +12,7 @@ var __assign = (this && this.__assign) || function () {
 import map from 'lodash/fp/map';
 import { STORE_FIRST_SLIDE, 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';
 // -----------------------------------------------------------------------------
 var getInitialState = function () {
     var state = {
@@ -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;
@@ -104,7 +105,11 @@ var reducer = function (state, action) {
     if (state === void 0) { state = initialState; }
     switch (action.type) {
         case STORE_FIRST_SLIDE: {
-            return setFirstSlide(state, action.payload);
+            // 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/index.d.ts

@@ -11,5 +11,5 @@ declare const _default: import("redux").Reducer<import("redux").CombinedState<{
         reviewStatus: import("./ui/review-status").ReviewStatusState;
         stepItems: import("./ui/step-items").StepItems;
     }>;
-}>, 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/progression").ReceiveProgression | 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>;
 export default _default;

package/lib/services/fetch-skills.js

@@ -40,7 +40,7 @@ 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;
+    var _a, userId, host, response;
     return __generator(this, function (_b) {
         switch (_b.label) {
             case 0:
@@ -50,10 +50,7 @@ var fetchSkills = function (fetch) { return function (token) { return __awaiter(
                     })];
             case 1:
                 response = _b.sent();
-                return [4 /*yield*/, toJSON(response)];
-            case 2:
-                skills = (_b.sent());
-                return [2 /*return*/, skills];
+                return [2 /*return*/, toJSON(response)];
         }
     });
 }); }; };

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

@@ -0,0 +1,8 @@
+import crossFetch from 'cross-fetch';
+import { SlideFromAPI } from '../actions/data/slides';
+declare type FetchSlide = (slideRef: string, token: string) => Promise<SlideFromAPI>;
+declare type FetchSlideBuilder = (fetch: typeof crossFetch) => FetchSlide;
+declare const fetchSlide: FetchSlideBuilder;
+export { fetchSlide };
+declare const _default: FetchSlide;
+export default _default;

package/lib/services/fetch-slide.js

@@ -0,0 +1,64 @@
+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 {JWT} from '../types/common';
+// import {toJSON} from './tools/fetch-responses';
+import { okJSONResponse } from './tools/fetch.mocks';
+// -----------------------------------------------------------------------------
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, unicorn/consistent-function-scoping, require-await
+var fetchSlide = function (fetch) { return function (slideRef, token) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        // const {host}: JWT = decode(token);
+        // const response = await fetch(`${host}/api/v2/slide/${slideRef}`, {
+        //   headers: {authorization: token}
+        // });
+        // const slide = (await toJSON(response)) as SlideFromAPI;
+        // return slide;
+        return [2 /*return*/, {}];
+    });
+}); }; };
+// -----------------------------------------------------------------------------
+var createFetchSlide = function () {
+    if (process.env.SERVICES !== 'mocks') {
+        return fetchSlide(crossFetch);
+    }
+    // TODO: use an appropriate mock
+    return fetchSlide(okJSONResponse({}));
+};
+// -----------------------------------------------------------------------------
+export { fetchSlide };
+export default createFetchSlide();

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

@@ -0,0 +1,8 @@
+import crossFetch from 'cross-fetch';
+import { ProgressionFromAPI } from '../actions/data/progression';
+declare type PostProgression = (skillRef: string, token: string) => Promise<ProgressionFromAPI>;
+declare type CreatePostProgression = (fetch: typeof crossFetch) => PostProgression;
+declare const postProgression: CreatePostProgression;
+export { postProgression };
+declare const _default: PostProgression;
+export default _default;

package/lib/services/post-progression.js

@@ -0,0 +1,77 @@
+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';
+import mockPostProgression from './post-progression.mock';
+// -----------------------------------------------------------------------------
+var postProgression = function (fetch) { return 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*/, fetch("".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)];
+        }
+    });
+}); }; };
+// -----------------------------------------------------------------------------
+var createPostProgression = function () {
+    if (process.env.SERVICES !== 'mocks') {
+        return postProgression(crossFetch);
+    }
+    return postProgression(mockPostProgression);
+};
+// -----------------------------------------------------------------------------
+export { postProgression };
+export default createPostProgression();