Merge remote-tracking branch 'origin-cy/master' into T32139_default_negative_ids_by_default_revised # Conflicts: # dist/mobx-spine.cjs.js # dist/mobx-spine.es.js # src/Model.js # src/__tests__/Model.js

 Ref T32139

Author: robin

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: Continuous Integration
+
+on: push
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: ['14']
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Setup NodeJS ${{ matrix.node-version }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'yarn'
+
+      - name: Install requirements
+        run: |
+          yarn install --frozen-lockfile
+
+      - name: Run tests
+        run: |
+          yarn ci
+
+      - name: Upload coverage report
+        uses: codecov/codecov-action@v1

.travis.yml

@@ -222,7 +222,7 @@ The `save` function accepts a few paramaters as an `options` object:
 |data|undefined|When set, append `data` to result. Existing keys from `toBackend` will be overwritten by data, while new keys will be added. | `animal.save({ data: { id: 1, some_other_field: 'will be added' } })`
 |mapData|undefined|You can change the data which will be used for the request send by supplying a function. First argument is the formatted data ready for sending a request. Called at the very last of data formatting operations.| `animal.save({ mapData: data => (...data, some_other_field: 'will be added' } ) } })`
 |forceFields|undefined|When `onlyChanges` is given, you can force fields to be included despite of having no changes.| `animal.save({ onlyChanges: true, forceFields: ['name'] } ) } })`
-|relations|undefined|Relations to be instantiated when instantiating this model as well. Should be an array of strings.| `animal = new Animal({ relations: ['location', 'owner.parents'] })`
+|relations|undefined|Relations to save when saving this model as well. Note that its not needed to include relations here so that they will be linked, only to save the models themselves. Should be an array of strings.| `animal.save({ relations: ['location', 'owner.parents'] })`
 
 #### Backend request: delete
 

README.md

@@ -1,6 +1,6 @@
 {
   "name": "mobx-spine",
-  "version": "0.28.1",
+  "version": "0.28.4",
   "license": "ISC",
   "author": "Kees Kluskens <kees@webduck.nl>",
   "description": "MobX with support for models, relations and an API.",
@@ -19,7 +19,7 @@
     "version": "git add -A dist",
     "build": "rm -f dist/** && BABEL_ENV=production node build.js",
     "//precommit": "lint-staged",
-    "ci": "npm run -s lint && npm run -s test-coverage && codecov"
+    "ci": "npm run -s lint && npm run -s test-coverage"
   },
   "lint-staged": {
     "*.js": [
@@ -45,13 +45,13 @@
     "babel-plugin-transform-es2015-modules-commonjs": "6.26.2",
     "babel-preset-es2015": "6.24.1",
     "babel-preset-stage-2": "6.24.1",
-    "codecov": "3.4.0",
+    "codecov": "3.7.1",
     "eslint": "5.16.0",
     "eslint-config-codeyellow": "4.1.5",
     "husky": "0.14.3",
     "jest": "22.4.4",
     "lint-staged": "7.1.1",
-    "lodash": "4.17.11",
+    "lodash": "4.17.21",
     "luxon": "1.24.1",
     "mobx": "4.9.4",
     "moment": "2.24.0",
@@ -65,7 +65,7 @@
     "moment": "^2.22.0"
   },
   "jest": {
-    "testEnvironment": "node",
+    "testEnvironment": "jsdom",
     "roots": [
       "./src"
     ],

package.json

@@ -1,4 +1,4 @@
-import { get } from 'lodash';
+import { get, range } from 'lodash';
 import axios from 'axios';
 
 // Function ripped from Django docs.
@@ -8,6 +8,30 @@ function csrfSafeMethod(method) {
     return /^(GET|HEAD|OPTIONS|TRACE)$/i.test(method);
 }
 
+function escapeKey(key) {
+    return key.toString().replace(/([.\\])/g, '\\$1');
+}
+
+function extractFiles(data, prefix = '') {
+    const keys = (
+        Array.isArray(data)
+        ? range(data.length)
+        : typeof data === 'object' && data !== null
+        ? Object.keys(data)
+        : []
+    );
+    let files = {};
+    for (const key of keys) {
+        if (data[key] instanceof Blob) {
+            files[prefix + escapeKey(key)] = data[key];
+            data[key] = null;
+        } else if (typeof data[key] === 'object' && data[key] !== null) {
+            Object.assign(files, extractFiles(data[key], prefix + escapeKey(key) + '.'));
+        }
+    }
+    return files;
+}
+
 export default class BinderApi {
     baseUrl = null;
     csrfToken = null;
@@ -63,10 +87,26 @@ export default class BinderApi {
                 'X-Csrftoken': useCsrfToken,
             },
             this.defaultHeaders,
-            options.headers
+            options.headers,
         );
         axiosOptions.headers = headers;
 
+        if (
+            axiosOptions.data &&
+            !(axiosOptions.data instanceof Blob) &&
+            !(axiosOptions.data instanceof FormData)
+        ) {
+            const files = extractFiles(axiosOptions.data);
+            if (Object.keys(files).length > 0) {
+                const data = new FormData();
+                data.append('data', JSON.stringify(axiosOptions.data));
+                for (const [path, file] of Object.entries(files)) {
+                    data.append('file:' + path, file, file.name);
+                }
+                axiosOptions.data = data;
+            }
+        }
+
         const xhr = this.axios(axiosOptions);
 
         // We fork the promise tree as we want to have the error traverse to the listeners

src/BinderApi.js

@@ -14,7 +14,6 @@ import {
     mapValues,
     find,
     filter,
-    get,
     isPlainObject,
     isArray,
     omit,
@@ -23,7 +22,6 @@ import {
     uniqBy,
     mapKeys,
     result,
-    pick,
 } from 'lodash';
 import Store from './Store';
 import { invariant, snakeToCamel, camelToSnake, relationsToNestedKeys, forNestedRelations } from './utils';
@@ -577,7 +575,10 @@ export default class Model {
 
     __parseRepositoryToData(key, repository) {
         if (isArray(key)) {
-            return filter(repository, m => key.includes(m.id));
+            const idIndexes = Object.fromEntries(key.map((id, index) => [id, index]));
+            const models = repository.filter(({ id }) => idIndexes[id] !== undefined);
+            models.sort((l, r) => idIndexes[l.id] - idIndexes[r.id]);
+            return models;
         }
         return find(repository, { id: key });
     }
@@ -727,7 +728,7 @@ export default class Model {
             } else if (this.__activeCurrentRelations.includes(attr)) {
                 // In Binder, a relation property is an `int` or `[int]`, referring to its ID.
                 // However, it can also be an object if there are nested relations (non flattened).
-                if (isPlainObject(value) || isPlainObject(get(value, '[0]'))) {
+                if (isPlainObject(value) || (Array.isArray(value) && value.every(isPlainObject))) {
                     this[attr].parse(value);
                 } else if (value === null) {
                     // The relation is cleared.
@@ -797,63 +798,6 @@ export default class Model {
         );
     }
 
-    /**
-     * Validates a model by sending a save request to binder with the validate header set. Binder will return the validation
-     * errors without actually committing the save
-     *
-     * @param options - same as for a normal save request, example: {onlyChanges: true}
-     */
-    validate(options = {}){
-        // Add the validate parameter
-        if (options.params){
-            options.params.validate = true
-        } else {
-            options.params = { validate: true };
-        }
-        return this.save(options);
-    }
-
-    @action
-    save(options = {}) {
-        this.clearValidationErrors();
-        return this.wrapPendingRequestCount(
-            this.__getApi()
-            .saveModel({
-                url: options.url || this.url,
-                data: this.toBackend({
-                        data: options.data,
-                        mapData: options.mapData,
-                        fields: options.fields,
-                        onlyChanges: options.onlyChanges,
-                    }),
-                isNew: this.isNew,
-                requestOptions: omit(options, 'url', 'data', 'mapData')
-            })
-            .then(action(res => {
-                // Only update the model when we are actually trying to save
-                if (!options.params || !options.params.validate) {
-                    this.saveFromBackend({
-                        ...res,
-                        data: omit(res.data, this.fileFields().map(camelToSnake)),
-                    });
-                    this.clearUserFieldChanges();
-                    return this.saveFiles().then(() => {
-                        this.clearUserFileChanges();
-                        return Promise.resolve(res);
-                    });
-                }
-            }))
-            .catch(
-                action(err => {
-                    if (err.valErrors) {
-                        this.parseValidationErrors(err.valErrors);
-                    }
-                    throw err;
-                })
-            )
-        );
-    }
-
     @action
     setInput(name, value) {
         invariant(
@@ -911,23 +855,72 @@ export default class Model {
     }
 
     /**
-     * Validates a model and relations by sending a save request to binder with the validate header set. Binder will return the validation
+     * Validates a model by sending a save request to binder with the validate header set. Binder will return the validation
      * errors without actually committing the save
      *
-     * @param options - same as for a normal saveAll request, example {relations:['foo'], onlyChanges: true}
+     * @param options - same as for a normal save request, example: {onlyChanges: true}
      */
-    validateAll(options = {}){
-        // Add the validate option
+    validate(options = {}){
+        // Add the validate parameter
         if (options.params){
             options.params.validate = true
         } else {
             options.params = { validate: true };
         }
-        return this.saveAll(options);
+        return this.save(options);
+    }
+
+    save(options = {}) {
+        if (options.relations && options.relations.length > 0) {
+            return this._saveAll(options);
+        } else {
+            return this._save(options);
+        }
+    }
+
+    @action
+    _save(options = {}) {
+        this.clearValidationErrors();
+        return this.wrapPendingRequestCount(
+            this.__getApi()
+            .saveModel({
+                url: options.url || this.url,
+                data: this.toBackend({
+                        data: options.data,
+                        mapData: options.mapData,
+                        fields: options.fields,
+                        onlyChanges: options.onlyChanges,
+                    }),
+                isNew: this.isNew,
+                requestOptions: omit(options, 'url', 'data', 'mapData')
+            })
+            .then(action(res => {
+                // Only update the models if we are actually trying to save
+                if (!options.params || !options.params.validate) {
+                    this.saveFromBackend({
+                        ...res,
+                        data: omit(res.data, this.fileFields().map(camelToSnake)),
+                    });
+                    this.clearUserFieldChanges();
+                    return this.saveFiles().then(() => {
+                        this.clearUserFileChanges();
+                        return Promise.resolve(res);
+                    });
+                }
+            }))
+            .catch(
+                action(err => {
+                    if (err.valErrors) {
+                        this.parseValidationErrors(err.valErrors);
+                    }
+                    throw err;
+                })
+            )
+        );
     }
 
     @action
-    saveAll(options = {}) {
+    _saveAll(options = {}) {
         this.clearValidationErrors();
         return this.wrapPendingRequestCount(
             this.__getApi()