@webiny/app-headless-cms 0.0.0-mt-3 → 0.0.0-unstable.3386f66516

package/admin/components/ContentEntryForm/useContentEntryForm.js

@@ -1,73 +1,186 @@
-import _objectSpread from "@babel/runtime/helpers/objectSpread2";
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-import { useCallback, useMemo, useState } from "react";
-import pick from "lodash/pick";
-import { useRouter } from "@webiny/react-router";
-import { useSnackbar } from "@webiny/app-admin/hooks/useSnackbar";
-import * as GQL from "../../graphql/contentEntries";
-import { useMutation } from "../../hooks";
-import * as GQLCache from "../../views/contentEntries/ContentEntry/cache";
-import { prepareFormData } from "../../views/contentEntries/ContentEntry/prepareFormData";
-import { useContentEntry } from "../../views/contentEntries/hooks/useContentEntry";
-import { plugins } from "@webiny/plugins";
-export function useContentEntryForm(params) {
-  var _useContentEntry = useContentEntry(),
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useContentEntryForm = useContentEntryForm;
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _react = require("react");
+
+var _pick = _interopRequireDefault(require("lodash/pick"));
+
+var _reactRouter = require("@webiny/react-router");
+
+var _useSnackbar2 = require("@webiny/app-admin/hooks/useSnackbar");
+
+var _contentEntries = require("../../graphql/contentEntries");
+
+var _hooks = require("../../hooks");
+
+var GQLCache = _interopRequireWildcard(require("../../views/contentEntries/ContentEntry/cache"));
+
+var _prepareFormData = require("../../views/contentEntries/ContentEntry/prepareFormData");
+
+var _useContentEntry2 = require("../../views/contentEntries/hooks/useContentEntry");
+
+var _plugins = require("@webiny/plugins");
+
+var _getFetchPolicy = require("../../../utils/getFetchPolicy");
+
+/**
+ * Used for some fields to convert their values.
+ */
+var convertDefaultValue = function convertDefaultValue(field, value) {
+  switch (field.type) {
+    case "boolean":
+      return Boolean(value);
+
+    case "number":
+      return Number(value);
+
+    default:
+      return value;
+  }
+};
+
+function useEntry(entryFromProps) {
+  // We need to keep track of the entry locally
+  var _useState = (0, _react.useState)(entryFromProps),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      entry = _useState2[0],
+      setEntry = _useState2[1];
+
+  var _useCms = (0, _hooks.useCms)(),
+      onEntryRevisionPublish = _useCms.onEntryRevisionPublish;
+
+  (0, _react.useEffect)(function () {
+    setEntry(entryFromProps);
+
+    if (!entryFromProps.id) {
+      return;
+    }
+
+    return onEntryRevisionPublish(function (next) {
+      return /*#__PURE__*/function () {
+        var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee(params) {
+          var publishRes;
+          return (0, _regeneratorRuntime2.default)().wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 2;
+                  return next(params);
+
+                case 2:
+                  publishRes = _context.sent;
+                  setEntry(function (entry) {
+                    var _publishRes$entry;
+
+                    return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, entry), {}, {
+                      meta: (publishRes === null || publishRes === void 0 ? void 0 : (_publishRes$entry = publishRes.entry) === null || _publishRes$entry === void 0 ? void 0 : _publishRes$entry.meta) || {}
+                    });
+                  });
+                  return _context.abrupt("return", publishRes);
+
+                case 5:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee);
+        }));
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }();
+    });
+  }, [entryFromProps, entry.id]);
+  return entry;
+}
+
+function useContentEntryForm(params) {
+  var _useContentEntry = (0, _useContentEntry2.useContentEntry)(),
       listQueryVariables = _useContentEntry.listQueryVariables;
 
-  var contentModel = params.contentModel,
-      entry = params.entry;
+  var _useModel = (0, _hooks.useModel)(),
+      model = _useModel.model;
 
-  var _useRouter = useRouter(),
+  var _useRouter = (0, _reactRouter.useRouter)(),
       history = _useRouter.history;
 
-  var _useSnackbar = useSnackbar(),
+  var client = (0, _hooks.useApolloClient)();
+
+  var _useSnackbar = (0, _useSnackbar2.useSnackbar)(),
       showSnackbar = _useSnackbar.showSnackbar;
 
-  var _useState = useState({}),
-      _useState2 = _slicedToArray(_useState, 2),
-      invalidFields = _useState2[0],
-      setInvalidFields = _useState2[1];
+  var _useState3 = (0, _react.useState)({}),
+      _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+      invalidFields = _useState4[0],
+      setInvalidFields = _useState4[1];
 
-  var _useState3 = useState(false),
-      _useState4 = _slicedToArray(_useState3, 2),
-      loading = _useState4[0],
-      setLoading = _useState4[1];
+  var _useState5 = (0, _react.useState)(false),
+      _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+      loading = _useState6[0],
+      setLoading = _useState6[1];
 
-  var renderPlugins = useMemo(function () {
-    return plugins.byType("cms-editor-field-renderer");
+  var entry = useEntry(params.entry);
+  var renderPlugins = (0, _react.useMemo)(function () {
+    return _plugins.plugins.byType("cms-editor-field-renderer");
   }, []);
-  var goToRevision = useCallback(function (id) {
-    history.push("/cms/content-entries/".concat(contentModel.modelId, "?id=").concat(encodeURIComponent(id)));
+  var goToRevision = (0, _react.useCallback)(function (id) {
+    history.push("/cms/content-entries/".concat(model.modelId, "?id=").concat(encodeURIComponent(id)));
   }, []);
 
-  var _useMemo = useMemo(function () {
+  var _useMemo = (0, _react.useMemo)(function () {
     return {
-      LIST_CONTENT: GQL.createListQuery(contentModel),
-      CREATE_CONTENT: GQL.createCreateMutation(contentModel),
-      UPDATE_CONTENT: GQL.createUpdateMutation(contentModel),
-      CREATE_CONTENT_FROM: GQL.createCreateFromMutation(contentModel)
+      // LIST_CONTENT: createListQuery(model),
+      CREATE_CONTENT: (0, _contentEntries.createCreateMutation)(model),
+      UPDATE_CONTENT: (0, _contentEntries.createUpdateMutation)(model),
+      CREATE_CONTENT_FROM: (0, _contentEntries.createCreateFromMutation)(model)
     };
-  }, [contentModel.modelId]),
+  }, [model.modelId]),
       CREATE_CONTENT = _useMemo.CREATE_CONTENT,
       UPDATE_CONTENT = _useMemo.UPDATE_CONTENT,
       CREATE_CONTENT_FROM = _useMemo.CREATE_CONTENT_FROM;
 
-  var _useMutation = useMutation(CREATE_CONTENT),
-      _useMutation2 = _slicedToArray(_useMutation, 1),
+  var _useMutation = (0, _hooks.useMutation)(CREATE_CONTENT),
+      _useMutation2 = (0, _slicedToArray2.default)(_useMutation, 1),
       createMutation = _useMutation2[0];
 
-  var _useMutation3 = useMutation(UPDATE_CONTENT),
-      _useMutation4 = _slicedToArray(_useMutation3, 1),
+  var _useMutation3 = (0, _hooks.useMutation)(UPDATE_CONTENT),
+      _useMutation4 = (0, _slicedToArray2.default)(_useMutation3, 1),
       updateMutation = _useMutation4[0];
 
-  var _useMutation5 = useMutation(CREATE_CONTENT_FROM),
-      _useMutation6 = _slicedToArray(_useMutation5, 1),
+  var _useMutation5 = (0, _hooks.useMutation)(CREATE_CONTENT_FROM),
+      _useMutation6 = (0, _slicedToArray2.default)(_useMutation5, 1),
       createFromMutation = _useMutation6[0];
+  /**
+   * Note that when passing `error.data` variable we cast as InvalidFieldError[] because we know it is so.
+   */
+
 
   var setInvalidFieldValues = function setInvalidFieldValues(errors) {
+    if (Array.isArray(errors) === false || !errors) {
+      return;
+    }
+
     var values = (errors || []).reduce(function (acc, er) {
       acc[er.fieldId] = er.error;
       return acc;
@@ -83,254 +196,364 @@ export function useContentEntryForm(params) {
     });
   };
 
-  var createContent = useCallback( /*#__PURE__*/function () {
-    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(data) {
-      var response, _response$data$conten, error, entry;
+  var createContent = (0, _react.useCallback)( /*#__PURE__*/function () {
+    var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee2(formData, form) {
+      var response, _ref3, entry, error;
 
-      return _regeneratorRuntime.wrap(function _callee$(_context) {
+      return (0, _regeneratorRuntime2.default)().wrap(function _callee2$(_context2) {
         while (1) {
-          switch (_context.prev = _context.next) {
+          switch (_context2.prev = _context2.next) {
             case 0:
               setLoading(true);
-              _context.next = 3;
+              _context2.next = 3;
               return createMutation({
                 variables: {
-                  data: data
+                  data: formData
                 },
-                update: function update(cache, _ref2) {
-                  var data = _ref2.data;
-                  var _data$content = data.content,
-                      entry = _data$content.data,
-                      error = _data$content.error;
-
-                  if (error) {
-                    showSnackbar(error.message);
-                    setInvalidFieldValues(error.data);
-                    return;
-                  }
-
-                  resetInvalidFieldValues();
-                  GQLCache.addEntryToListCache(contentModel, cache, entry, listQueryVariables);
-                }
+                fetchPolicy: (0, _getFetchPolicy.getFetchPolicy)(model)
               });
 
             case 3:
-              response = _context.sent;
-              setLoading(false);
-              _response$data$conten = response.data.content, error = _response$data$conten.error, entry = _response$data$conten.data;
+              response = _context2.sent;
+              setLoading(false); // Finalize "create" process
+
+              if (response.data) {
+                _context2.next = 8;
+                break;
+              }
+
+              showSnackbar("Missing response data in Create Entry.");
+              return _context2.abrupt("return");
+
+            case 8:
+              _ref3 = response.data.content || {}, entry = _ref3.data, error = _ref3.error;
 
               if (!error) {
-                _context.next = 10;
+                _context2.next = 15;
                 break;
               }
 
               showSnackbar(error.message);
               setInvalidFieldValues(error.data);
-              return _context.abrupt("return", null);
+              return _context2.abrupt("return");
 
-            case 10:
+            case 15:
+              if (entry) {
+                _context2.next = 18;
+                break;
+              }
+
+              showSnackbar("Missing entry data in Create Entry Response.");
+              return _context2.abrupt("return");
+
+            case 18:
               resetInvalidFieldValues();
-              showSnackbar("".concat(contentModel.name, " entry created successfully!"));
-              goToRevision(entry.id);
-              return _context.abrupt("return", entry);
 
-            case 14:
+              if (params.addEntryToListCache) {
+                GQLCache.addEntryToListCache(model, client.cache, entry, listQueryVariables);
+              }
+
+              showSnackbar("".concat(model.name, " entry created successfully!"));
+
+              if (typeof params.onSubmit === "function") {
+                params.onSubmit(entry, form);
+              } else {
+                goToRevision(entry.id);
+              }
+
+              return _context2.abrupt("return", entry);
+
+            case 23:
             case "end":
-              return _context.stop();
+              return _context2.stop();
           }
         }
-      }, _callee);
+      }, _callee2);
     }));
 
-    return function (_x) {
-      return _ref.apply(this, arguments);
+    return function (_x2, _x3) {
+      return _ref2.apply(this, arguments);
     };
-  }(), [contentModel.modelId, listQueryVariables]);
-  var updateContent = useCallback( /*#__PURE__*/function () {
-    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(revision, data) {
+  }(), [model.modelId, listQueryVariables, params.onSubmit, params.addEntryToListCache]);
+  var updateContent = (0, _react.useCallback)( /*#__PURE__*/function () {
+    var _ref4 = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee3(revision, data) {
       var response, error, entry;
-      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      return (0, _regeneratorRuntime2.default)().wrap(function _callee3$(_context3) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context3.prev = _context3.next) {
             case 0:
               setLoading(true);
-              _context2.next = 3;
+              _context3.next = 3;
               return updateMutation({
                 variables: {
                   revision: revision,
                   data: data
-                }
+                },
+                fetchPolicy: (0, _getFetchPolicy.getFetchPolicy)(model)
               });
 
             case 3:
-              response = _context2.sent;
+              response = _context3.sent;
               setLoading(false);
+
+              if (response.data) {
+                _context3.next = 8;
+                break;
+              }
+
+              showSnackbar("Missing response data on Update Entry Response.");
+              return _context3.abrupt("return");
+
+            case 8:
               error = response.data.content.error;
 
               if (!error) {
-                _context2.next = 10;
+                _context3.next = 13;
                 break;
               }
 
               showSnackbar(error.message);
               setInvalidFieldValues(error.data);
-              return _context2.abrupt("return", null);
+              return _context3.abrupt("return", null);
 
-            case 10:
+            case 13:
               resetInvalidFieldValues();
               showSnackbar("Content saved successfully.");
               entry = response.data.content.data;
-              return _context2.abrupt("return", entry);
+              return _context3.abrupt("return", entry);
 
-            case 14:
+            case 17:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
         }
-      }, _callee2);
+      }, _callee3);
     }));
 
-    return function (_x2, _x3) {
-      return _ref3.apply(this, arguments);
+    return function (_x4, _x5) {
+      return _ref4.apply(this, arguments);
     };
-  }(), [contentModel.modelId]);
-  var createContentFrom = useCallback( /*#__PURE__*/function () {
-    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(revision, formData) {
-      var response, _response$data$conten2, data, error;
+  }(), [model.modelId]);
+  var createContentFrom = (0, _react.useCallback)( /*#__PURE__*/function () {
+    var _ref5 = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee4(revision, formData) {
+      var response, _response$data$conten, newRevision, error;
 
-      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      return (0, _regeneratorRuntime2.default)().wrap(function _callee4$(_context4) {
         while (1) {
-          switch (_context3.prev = _context3.next) {
+          switch (_context4.prev = _context4.next) {
             case 0:
               setLoading(true);
-              _context3.next = 3;
+              _context4.next = 3;
               return createFromMutation({
                 variables: {
                   revision: revision,
                   data: formData
                 },
-                update: function update(cache, _ref5) {
-                  var data = _ref5.data;
-                  var _data$content2 = data.content,
-                      newRevision = _data$content2.data,
-                      error = _data$content2.error;
-
-                  if (error) {
-                    showSnackbar(error.message);
-                    setInvalidFieldValues(error.data);
-                    return;
-                  }
-
-                  resetInvalidFieldValues();
-                  GQLCache.updateLatestRevisionInListCache(contentModel, cache, newRevision, listQueryVariables);
-                  GQLCache.addRevisionToRevisionsCache(contentModel, cache, newRevision);
-                  showSnackbar("A new revision was created!");
-                  history.push("/cms/content-entries/".concat(contentModel.modelId, "?id=").concat(encodeURIComponent(newRevision.id)));
-                }
+                fetchPolicy: (0, _getFetchPolicy.getFetchPolicy)(model)
               });
 
             case 3:
-              response = _context3.sent;
-              setLoading(false);
-              _response$data$conten2 = response.data.content, data = _response$data$conten2.data, error = _response$data$conten2.error;
+              response = _context4.sent;
+
+              if (response.data) {
+                _context4.next = 7;
+                break;
+              }
+
+              showSnackbar("Missing data in update callback on Create From Entry Response.");
+              return _context4.abrupt("return");
+
+            case 7:
+              _response$data$conten = response.data.content, newRevision = _response$data$conten.data, error = _response$data$conten.error;
 
               if (!error) {
-                _context3.next = 10;
+                _context4.next = 14;
                 break;
               }
 
               showSnackbar(error.message);
               setInvalidFieldValues(error.data);
-              return _context3.abrupt("return", null);
+              return _context4.abrupt("return");
 
-            case 10:
+            case 14:
+              if (newRevision) {
+                _context4.next = 17;
+                break;
+              }
+
+              showSnackbar("Missing entry data in update callback on Create From Entry.");
+              return _context4.abrupt("return");
+
+            case 17:
               resetInvalidFieldValues();
-              return _context3.abrupt("return", data);
+              GQLCache.updateLatestRevisionInListCache(model, client.cache, newRevision, listQueryVariables);
+              GQLCache.addRevisionToRevisionsCache(model, client.cache, newRevision);
+              showSnackbar("A new revision was created!");
+              goToRevision(newRevision.id);
+              setLoading(false);
+              return _context4.abrupt("return", newRevision);
 
-            case 12:
+            case 24:
             case "end":
-              return _context3.stop();
+              return _context4.stop();
           }
         }
-      }, _callee3);
+      }, _callee4);
     }));
 
-    return function (_x4, _x5) {
-      return _ref4.apply(this, arguments);
+    return function (_x6, _x7) {
+      return _ref5.apply(this, arguments);
     };
-  }(), [contentModel.modelId, listQueryVariables]);
+  }(), [model.modelId, listQueryVariables]);
+
+  var onChange = function onChange(data, form) {
+    if (!params.onChange) {
+      return;
+    }
+
+    return params.onChange(data, form);
+  };
 
   var onSubmit = /*#__PURE__*/function () {
-    var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(data) {
+    var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee5(data, form) {
       var fieldsIds, formData, gqlData, meta, _ref7, isLocked;
 
-      return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      return (0, _regeneratorRuntime2.default)().wrap(function _callee5$(_context5) {
         while (1) {
-          switch (_context4.prev = _context4.next) {
+          switch (_context5.prev = _context5.next) {
             case 0:
-              fieldsIds = contentModel.fields.map(function (item) {
+              fieldsIds = model.fields.map(function (item) {
                 return item.fieldId;
               });
-              formData = pick(data, _toConsumableArray(fieldsIds));
-              gqlData = prepareFormData(formData, contentModel);
+              formData = (0, _pick.default)(data, (0, _toConsumableArray2.default)(fieldsIds));
+              gqlData = (0, _prepareFormData.prepareFormData)(formData, model.fields);
 
               if (entry.id) {
-                _context4.next = 5;
+                _context5.next = 5;
                 break;
               }
 
-              return _context4.abrupt("return", createContent(gqlData));
+              return _context5.abrupt("return", createContent(gqlData, form));
 
             case 5:
               meta = entry.meta;
               _ref7 = meta || {}, isLocked = _ref7.locked;
 
               if (isLocked) {
-                _context4.next = 9;
+                _context5.next = 9;
                 break;
               }
 
-              return _context4.abrupt("return", updateContent(entry.id, gqlData));
+              return _context5.abrupt("return", updateContent(entry.id, gqlData));
 
             case 9:
-              return _context4.abrupt("return", createContentFrom(entry.id, gqlData));
+              return _context5.abrupt("return", createContentFrom(entry.id, gqlData));
 
             case 10:
             case "end":
-              return _context4.stop();
+              return _context5.stop();
           }
         }
-      }, _callee4);
+      }, _callee5);
     }));
 
-    return function onSubmit(_x6) {
+    return function onSubmit(_x8, _x9) {
       return _ref6.apply(this, arguments);
     };
   }();
 
-  var getDefaultValues = function getDefaultValues() {
-    var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var values = {}; // TODO: finish default values.
-
-    /*fields.forEach(field => {
-        const fieldId = field.fieldId;
-         if (
-            fieldId &&
-            "defaultValue" in field.settings &&
-            typeof field.settings.defaultValue !== "undefined"
-        ) {
-            values[fieldId] = field.settings.defaultValue;
+  var defaultValues = (0, _react.useMemo)(function () {
+    var values = {};
+    /**
+     * Assign the default values:
+     * * check the settings.defaultValue
+     * * check the predefinedValues for selected value
+     */
+
+    var _iterator = (0, _createForOfIteratorHelper2.default)(model.fields),
+        _step;
+
+    try {
+      var _loop = function _loop() {
+        var field = _step.value;
+
+        /**
+         * When checking if defaultValue is set in settings, we do the undefined check because it can be null, 0, empty string, false, etc...
+         */
+        var settings = field.settings,
+            _field$multipleValues = field.multipleValues,
+            multipleValues = _field$multipleValues === void 0 ? false : _field$multipleValues;
+
+        if (settings && settings.defaultValue !== undefined) {
+          /**
+           * Special type of field is the boolean one.
+           * We MUST set true/false for default value.
+           */
+          values[field.fieldId] = convertDefaultValue(field, settings.defaultValue);
+          return "continue";
         }
-    });*/
+        /**
+         * No point in going further if predefined values are not enabled.
+         */
 
-    return _objectSpread(_objectSpread({}, values), overrides);
-  };
 
+        var predefinedValues = field.predefinedValues;
+
+        if (!predefinedValues || !predefinedValues.enabled || Array.isArray(predefinedValues.values) === false) {
+          return "continue";
+        }
+        /**
+         * When field is not a multiple values one, we find the first possible default selected value and set it as field value.
+         */
+
+
+        if (!multipleValues) {
+          var selectedValue = predefinedValues.values.find(function (_ref8) {
+            var selected = _ref8.selected;
+            return !!selected;
+          });
+
+          if (selectedValue) {
+            values[field.fieldId] = convertDefaultValue(field, selectedValue.value);
+          }
+
+          return "continue";
+        }
+        /**
+         *
+         */
+
+
+        values[field.fieldId] = predefinedValues.values.filter(function (_ref9) {
+          var selected = _ref9.selected;
+          return !!selected;
+        }).map(function (_ref10) {
+          var value = _ref10.value;
+          return convertDefaultValue(field, value);
+        });
+      };
+
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _ret = _loop();
+
+        if (_ret === "continue") continue;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return values;
+  }, [model.modelId]);
   return {
-    data: entry ? entry : getDefaultValues(),
+    /**
+     * If entry is not set or `entry.id` does not exist, it means it's a new entry, so fetch default values.
+     */
+    data: entry && entry.id ? entry : defaultValues,
     loading: loading,
     setLoading: setLoading,
-    onChange: params.onChange,
+    onChange: onChange,
     onSubmit: onSubmit,
     invalidFields: invalidFields,
     renderPlugins: renderPlugins