@webiny/app-headless-cms 5.19.0-beta.1 → 5.19.0-beta.5

package/admin/plugins/install.js

@@ -122,6 +122,13 @@ var plugin = {
         return import("./upgrades/v5.8.0");
       });
     }
+  }, {
+    version: "5.19.0",
+    getComponent: function getComponent() {
+      return /*#__PURE__*/lazy(function () {
+        return import("./upgrades/v5.19.0");
+      });
+    }
   }]
 };
 export default plugin;

package/admin/plugins/upgrades/5.19.0/UpgradeItemsInfo.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { UpgradeItems } from "./types";
+interface UpgradeItemsInfoProps {
+    upgradeItems: UpgradeItems | null;
+}
+export declare const UpgradeItemsInfo: React.FunctionComponent<UpgradeItemsInfoProps>;
+export {};

package/admin/plugins/upgrades/5.19.0/UpgradeItemsInfo.js

@@ -0,0 +1,53 @@
+import React from "react";
+import { Typography } from "@webiny/ui/Typography";
+
+var findUpgradingModel = function findUpgradingModel(locales) {
+  for (var locale in locales) {
+    if (!locales[locale]) {
+      continue;
+    }
+
+    var modelsData = Object.values(locales[locale]);
+
+    for (var modelId in modelsData) {
+      if (modelsData[modelId].upgrading !== true) {
+        continue;
+      }
+
+      return {
+        locale: locale,
+        model: modelsData[modelId].model,
+        total: modelsData[modelId].entries.length,
+        current: modelsData[modelId].entries.filter(function (item) {
+          return item.done;
+        }).length
+      };
+    }
+  }
+
+  return null;
+};
+
+export var UpgradeItemsInfo = function UpgradeItemsInfo(props) {
+  var upgradeItems = props.upgradeItems;
+
+  if (!upgradeItems || upgradeItems.loadedModels !== true || !upgradeItems.locales) {
+    return null;
+  }
+
+  var locales = upgradeItems.locales;
+  var result = findUpgradingModel(locales);
+
+  if (!result) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null);
+  }
+
+  var locale = result.locale,
+      model = result.model,
+      current = result.current,
+      total = result.total;
+  return /*#__PURE__*/React.createElement(Typography, {
+    use: "body1",
+    tag: "div"
+  }, "Upgrading model ", /*#__PURE__*/React.createElement("strong", null, model.name), " in locale ", /*#__PURE__*/React.createElement("strong", null, locale), " (", current, " of ", total, " updated)");
+};

package/admin/plugins/upgrades/5.19.0/createCmsApolloClient.d.ts

@@ -0,0 +1,7 @@
+import ApolloClient from "apollo-client";
+export interface Params {
+    locale: string;
+    apiUrl: string;
+    endpoint: "manage" | "read";
+}
+export declare const createCmsApolloClient: ({ locale, apiUrl, endpoint }: Params) => ApolloClient<import("apollo-cache-inmemory").NormalizedCacheObject>;

package/admin/plugins/upgrades/5.19.0/createCmsApolloClient.js

@@ -0,0 +1,49 @@
+import ApolloClient from "apollo-client";
+import { ApolloLink } from "apollo-link";
+import { ApolloDynamicLink } from "@webiny/app/plugins/ApolloDynamicLink";
+import { InMemoryCache } from "@webiny/app/apollo-client/InMemoryCache";
+import { plugins } from "@webiny/plugins";
+import { ApolloCacheObjectIdPlugin } from "@webiny/app/plugins/ApolloCacheObjectIdPlugin";
+import { BatchHttpLink } from "apollo-link-batch-http";
+export var createCmsApolloClient = function createCmsApolloClient(_ref) {
+  var locale = _ref.locale,
+      apiUrl = _ref.apiUrl,
+      endpoint = _ref.endpoint;
+  return new ApolloClient({
+    link: ApolloLink.from([
+    /**
+     * This will process links from plugins on every request.
+     */
+    new ApolloDynamicLink(),
+    /**
+     * This batches requests made to the API to pack multiple requests into a single HTTP request.
+     */
+    new BatchHttpLink({
+      uri: "".concat(apiUrl, "/cms/").concat(endpoint, "/").concat(locale)
+    })]),
+    cache: new InMemoryCache({
+      addTypename: true,
+      dataIdFromObject: function dataIdFromObject(obj) {
+        /**
+         * Since every data type coming from API can have a different data structure,
+         * we cannot rely on having an `id` field.
+         */
+        var getters = plugins.byType(ApolloCacheObjectIdPlugin.type);
+
+        for (var i = 0; i < getters.length; i++) {
+          var id = getters[i].getObjectId(obj);
+
+          if (typeof id !== "undefined") {
+            return id;
+          }
+        }
+        /**
+         * As a fallback, try getting object's `id`.
+         */
+
+
+        return obj.id || null;
+      }
+    })
+  });
+};

package/admin/plugins/upgrades/5.19.0/createListEntriesQuery.d.ts

@@ -0,0 +1,2 @@
+import { CmsEditorContentModel } from "../../../../types";
+export declare const createListEntriesQuery: (model: CmsEditorContentModel) => import("graphql").DocumentNode;

package/admin/plugins/upgrades/5.19.0/createListEntriesQuery.js

@@ -0,0 +1,12 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+
+var _templateObject;
+
+import upperFirst from "lodash/upperFirst";
+import pluralize from "pluralize";
+import gql from "graphql-tag";
+export var createListEntriesQuery = function createListEntriesQuery(model) {
+  var ucFirstPluralizedModelId = upperFirst(pluralize(model.modelId));
+  var ucFirstModelId = upperFirst(model.modelId);
+  return gql(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n        query CmsEntriesList", "($where: ", "ListWhereInput, $sort: [", "ListSorter], $limit: Int, $after: String) {\n            content: list", "(\n            where: $where\n            sort: $sort\n            limit: $limit\n            after: $after\n            ) {\n            data {\n                id\n            }\n            meta {\n                cursor\n                hasMoreItems\n                totalCount\n            }\n            error {\n                message\n                code\n                data\n            }\n        }\n        }\n    "])), ucFirstPluralizedModelId, ucFirstModelId, ucFirstModelId, ucFirstPluralizedModelId);
+};

package/admin/plugins/upgrades/5.19.0/createListModelsQuery.d.ts

@@ -0,0 +1 @@
+export declare const createListModelsQuery: () => import("graphql").DocumentNode;

package/admin/plugins/upgrades/5.19.0/createListModelsQuery.js

@@ -0,0 +1,8 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+
+var _templateObject;
+
+import gql from "graphql-tag";
+export var createListModelsQuery = function createListModelsQuery() {
+  return gql(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n        query CmsListContentModels {\n            listContentModels {\n                data {\n                    modelId\n                    name\n                    fields {\n                        id\n                        type\n                    }\n                }\n                error {\n                    message\n                    code\n                    data\n                }\n            }\n        }\n    "])));
+};

package/admin/plugins/upgrades/5.19.0/createRepublishMutation.d.ts

@@ -0,0 +1 @@
+export declare const createRepublishMutation: (model: any) => import("graphql").DocumentNode;

package/admin/plugins/upgrades/5.19.0/createRepublishMutation.js

@@ -0,0 +1,10 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+
+var _templateObject;
+
+import upperFirst from "lodash/upperFirst";
+import gql from "graphql-tag";
+export var createRepublishMutation = function createRepublishMutation(model) {
+  var ucFirstModelId = upperFirst(model.modelId);
+  return gql(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n        mutation CmsRepublish", "($revision: ID!) {\n            content: republish", "(revision: $revision) {\n            data {\n                id\n            }\n            error {\n                message\n                data\n                code\n            }\n        }\n    }"])), ucFirstModelId, ucFirstModelId);
+};

package/admin/plugins/upgrades/5.19.0/createUpgradeMutation.d.ts

@@ -0,0 +1 @@
+export declare const createUpgradeMutation: () => import("graphql").DocumentNode;

package/admin/plugins/upgrades/5.19.0/createUpgradeMutation.js

@@ -0,0 +1,8 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+
+var _templateObject;
+
+import gql from "graphql-tag";
+export var createUpgradeMutation = function createUpgradeMutation() {
+  return gql(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n        mutation UpgradeCMS($version: String!) {\n            cms {\n                upgrade(version: $version) {\n                    data\n                    error {\n                        code\n                        message\n                        data\n                    }\n                }\n            }\n        }\n    "])));
+};

package/admin/plugins/upgrades/5.19.0/fetchModelEntries.d.ts

@@ -0,0 +1,7 @@
+import { CmsEditorContentModel } from "../../../../types";
+import { ApolloClient } from "apollo-client";
+export interface Params {
+    model: CmsEditorContentModel;
+    client: ApolloClient<any>;
+}
+export declare const fetchModelEntries: (params: Params) => Promise<string[]>;

package/admin/plugins/upgrades/5.19.0/fetchModelEntries.js

@@ -0,0 +1,122 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { createListEntriesQuery } from "./createListEntriesQuery";
+
+var fetchEntries = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(params) {
+    var client, query, variables, response, _response$data$conten, items, error, meta;
+
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            client = params.client, query = params.query, variables = params.variables;
+            _context.next = 3;
+            return client.query({
+              query: query,
+              variables: variables
+            });
+
+          case 3:
+            response = _context.sent;
+            _response$data$conten = response.data.content, items = _response$data$conten.data, error = _response$data$conten.error, meta = _response$data$conten.meta;
+
+            if (!error) {
+              _context.next = 8;
+              break;
+            }
+
+            console.error(error.message);
+            return _context.abrupt("return", null);
+
+          case 8:
+            return _context.abrupt("return", {
+              items: items || [],
+              hasMoreItems: meta.hasMoreItems,
+              cursor: meta.cursor,
+              totalCount: meta.totalCount
+            });
+
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function fetchEntries(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+export var fetchModelEntries = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(params) {
+    var model, client, items, query, variables, result;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            model = params.model, client = params.client;
+            items = [];
+            query = createListEntriesQuery(model);
+            variables = {
+              limit: 100,
+              after: null,
+              where: {}
+            };
+
+          case 4:
+            _context2.next = 6;
+            return fetchEntries({
+              client: client,
+              query: query,
+              variables: variables
+            });
+
+          case 6:
+            if (!(result = _context2.sent)) {
+              _context2.next = 15;
+              break;
+            }
+
+            if (result) {
+              _context2.next = 9;
+              break;
+            }
+
+            return _context2.abrupt("return", items);
+
+          case 9:
+            items.push.apply(items, _toConsumableArray(result.items.map(function (item) {
+              return item.id;
+            })));
+
+            if (!(result.hasMoreItems === false)) {
+              _context2.next = 12;
+              break;
+            }
+
+            return _context2.abrupt("return", items);
+
+          case 12:
+            variables.after = result.cursor;
+            _context2.next = 4;
+            break;
+
+          case 15:
+            return _context2.abrupt("return", items);
+
+          case 16:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function fetchModelEntries(_x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();

package/admin/plugins/upgrades/5.19.0/types.d.ts

@@ -0,0 +1,47 @@
+import { ApolloClient } from "apollo-client";
+import { CmsEditorContentModel } from "../../../../types";
+export interface Clients {
+    read: ApolloClient<any>;
+    manage: ApolloClient<any>;
+}
+export interface CurrentlyUpgrading {
+    locale: string;
+    model: CmsEditorContentModel;
+    running: boolean;
+    fetchingEntries: boolean;
+    after: string;
+    entry: string | null;
+    totalCount: number | null;
+    currentEntry: number | null;
+    error?: {
+        message: string;
+        code: string;
+        data: any;
+    };
+    entries: {
+        id: string;
+        done: boolean;
+    }[];
+}
+export interface UpgradeEntryItem {
+    id: string;
+    done: boolean;
+}
+export interface UpgradeModelItem {
+    model: CmsEditorContentModel;
+    entries: UpgradeEntryItem[];
+    done: boolean;
+    upgrading: boolean;
+}
+export interface UpgradeModelItems {
+    [modelId: string]: UpgradeModelItem;
+}
+export interface UpgradeItems {
+    loadedModels: boolean;
+    locales: Record<string, UpgradeModelItems>;
+}
+export interface ErrorValue {
+    code?: string;
+    data?: any;
+    message: string;
+}

package/admin/plugins/upgrades/5.19.0/types.js

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

package/admin/plugins/upgrades/v5.19.0.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+declare const Upgrade: ({ onInstalled }: {
+    onInstalled: any;
+}) => JSX.Element;
+export default Upgrade;

package/admin/plugins/upgrades/v5.19.0.js

@@ -0,0 +1,647 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/taggedTemplateLiteral";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/createForOfIteratorHelper";
+
+var _templateObject, _templateObject2;
+
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import React, { useCallback, useEffect, useState } from "react";
+import { i18n } from "@webiny/app/i18n";
+import { SimpleForm, SimpleFormContent, SimpleFormFooter, SimpleFormHeader } from "@webiny/app-admin/components/SimpleForm";
+import { useApolloClient } from "@apollo/react-hooks";
+import { Alert } from "@webiny/ui/Alert";
+import { CircularProgress } from "@webiny/ui/Progress";
+import { Cell, Grid } from "@webiny/ui/Grid";
+import { ButtonPrimary } from "@webiny/ui/Button";
+import { Typography } from "@webiny/ui/Typography";
+import { createCmsApolloClient } from "./5.19.0/createCmsApolloClient";
+import { config as appConfig } from "@webiny/app/config";
+import { LIST_LOCALES } from "@webiny/app-i18n/admin/views/locales/hooks/graphql";
+import { UpgradeItemsInfo } from "./5.19.0/UpgradeItemsInfo";
+import { fetchModelEntries } from "./5.19.0/fetchModelEntries";
+import { createRepublishMutation } from "./5.19.0/createRepublishMutation";
+import { createUpgradeMutation } from "./5.19.0/createUpgradeMutation";
+import { createListModelsQuery } from "./5.19.0/createListModelsQuery";
+var t = i18n.ns("app-headless-cms/admin/installation");
+var clients = {};
+
+var getClient = function getClient(locale) {
+  if (!clients[locale]) {
+    throw new Error("There are no clients for locale \"".concat(locale, "\"."));
+  }
+
+  return clients[locale];
+};
+
+var getManageClient = function getManageClient(locale) {
+  return getClient(locale).manage;
+};
+
+var getReadClient = function getReadClient(locale) {
+  return getClient(locale).read;
+};
+
+var createUpgradeItems = function createUpgradeItems(params) {
+  var locales = params.locales;
+  var items = {
+    loadedModels: false,
+    locales: {}
+  };
+  var apiUrl = appConfig.getKey("API_URL", process.env.REACT_APP_API_URL);
+
+  var _iterator = _createForOfIteratorHelper(locales),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var locale = _step.value;
+      items.locales[locale.code] = null;
+      clients[locale.code] = {
+        read: createCmsApolloClient({
+          locale: locale.code,
+          apiUrl: apiUrl,
+          endpoint: "read"
+        }),
+        manage: createCmsApolloClient({
+          locale: locale.code,
+          apiUrl: apiUrl,
+          endpoint: "manage"
+        })
+      };
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return items;
+};
+
+var updateUpgradeItems = function updateUpgradeItems(params) {
+  var previous = params.previous,
+      models = params.models;
+  var locales = {};
+
+  for (var locale in previous.locales) {
+    locales[locale] = (models[locale] || []).reduce(function (collection, model) {
+      collection[model.modelId] = {
+        model: model,
+        done: false,
+        entries: [],
+        upgrading: false
+      };
+      return collection;
+    }, {});
+  }
+
+  return {
+    loadedModels: true,
+    locales: locales
+  };
+};
+
+var Upgrade = function Upgrade(_ref) {
+  var onInstalled = _ref.onInstalled;
+  var client = useApolloClient();
+
+  var _useState = useState(null),
+      _useState2 = _slicedToArray(_useState, 2),
+      error = _useState2[0],
+      setError = _useState2[1];
+
+  var _useState3 = useState(false),
+      _useState4 = _slicedToArray(_useState3, 2),
+      loading = _useState4[0],
+      setLoading = _useState4[1];
+
+  var _useState5 = useState(false),
+      _useState6 = _slicedToArray(_useState5, 2),
+      upgrade = _useState6[0],
+      setUpgrade = _useState6[1];
+
+  var _useState7 = useState("pending"),
+      _useState8 = _slicedToArray(_useState7, 2),
+      status = _useState8[0],
+      setStatus = _useState8[1];
+
+  var _useState9 = useState(null),
+      _useState10 = _slicedToArray(_useState9, 2),
+      upgradeItems = _useState10[0],
+      setUpgradeItems = _useState10[1];
+
+  useEffect(function () {
+    /**
+     * Never do this if we have upgrade items.
+     */
+    if (upgradeItems || loading === true) {
+      return;
+    }
+
+    setLoading(true);
+
+    var fetchLocales = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var response;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return client.query({
+                  query: LIST_LOCALES
+                });
+
+              case 2:
+                response = _context.sent;
+
+                if (!(!response || !response.data || !response.data.i18n || !response.data.i18n.listI18NLocales)) {
+                  _context.next = 8;
+                  break;
+                }
+
+                console.error("Missing response when fetching locales.");
+                return _context.abrupt("return");
+
+              case 8:
+                if (!response.data.i18n.listI18NLocales.error) {
+                  _context.next = 12;
+                  break;
+                }
+
+                console.error(response.data.i18n.listI18NLocales.error.message);
+                setError(error);
+                return _context.abrupt("return");
+
+              case 12:
+                /**
+                 * New state for the upgrade items.
+                 */
+                setUpgradeItems(function () {
+                  return createUpgradeItems({
+                    locales: response.data.i18n.listI18NLocales.data
+                  });
+                });
+                /**
+                 * And stop the spinner.
+                 */
+
+                setLoading(false);
+
+              case 14:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function fetchLocales() {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+
+    fetchLocales();
+  }, []);
+  useEffect(function () {
+    if (!upgradeItems || !upgradeItems.locales || upgradeItems.loadedModels === true || loading === true) {
+      return;
+    }
+
+    setLoading(true);
+
+    var fetchModels = /*#__PURE__*/function () {
+      var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var models, locales, query, locale, response, _ref4, listContentModels, data, _error;
+
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                models = {};
+                /**
+                 * Load all models from locales, one by one so we dont nuke API too much.
+                 */
+
+                locales = upgradeItems.locales;
+                /**
+                 * Query does not care about locale so we can create it before the loop.
+                 */
+
+                query = createListModelsQuery();
+                /**
+                 *
+                 */
+
+                _context2.t0 = _regeneratorRuntime.keys(locales);
+
+              case 4:
+                if ((_context2.t1 = _context2.t0()).done) {
+                  _context2.next = 26;
+                  break;
+                }
+
+                locale = _context2.t1.value;
+                _context2.next = 8;
+                return getManageClient(locale).query({
+                  query: query
+                });
+
+              case 8:
+                response = _context2.sent;
+                _ref4 = response.data || {}, listContentModels = _ref4.listContentModels;
+                data = listContentModels.data, _error = listContentModels.error;
+
+                if (!_error) {
+                  _context2.next = 16;
+                  break;
+                }
+
+                setError(_error);
+                return _context2.abrupt("return");
+
+              case 16:
+                if (data) {
+                  _context2.next = 21;
+                  break;
+                }
+
+                setError({
+                  message: "No data received when loading all models in locale \"".concat(locale, "\".")
+                });
+                return _context2.abrupt("return");
+
+              case 21:
+                if (!(data.length === 0)) {
+                  _context2.next = 23;
+                  break;
+                }
+
+                return _context2.abrupt("continue", 4);
+
+              case 23:
+                /**
+                 * We only need models that have at least one ref field or an object field that MIGHT contain ref fields.
+                 */
+                models[locale] = data.filter(function (model) {
+                  return model.fields.some(function (field) {
+                    return field.type === "object" || field.type === "ref";
+                  });
+                });
+                _context2.next = 4;
+                break;
+
+              case 26:
+                /**
+                 * We add models only once to skip unnecessary state changes.
+                 */
+                setUpgradeItems(function (previous) {
+                  return updateUpgradeItems({
+                    previous: previous,
+                    models: models
+                  });
+                });
+                setLoading(false);
+
+              case 28:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      return function fetchModels() {
+        return _ref3.apply(this, arguments);
+      };
+    }();
+
+    fetchModels();
+  }, [upgradeItems, loading]);
+  var startUpgrade = useCallback(function () {
+    if (!upgradeItems || upgradeItems.loadedModels !== true || upgrade === true) {
+      return;
+    }
+
+    setUpgrade(true);
+  }, [upgradeItems]);
+  useEffect(function () {
+    if (!upgrade || !upgradeItems || !upgradeItems.locales || upgradeItems.loadedModels === false || status !== "pending") {
+      return;
+    }
+
+    var locales = upgradeItems.locales;
+    setStatus("upgrading");
+
+    var republish = /*#__PURE__*/function () {
+      var _ref5 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        var _loop, locale, _ret, response, error;
+
+        return _regeneratorRuntime.wrap(function _callee3$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                _loop = /*#__PURE__*/_regeneratorRuntime.mark(function _loop(locale) {
+                  var localeData, manageClient, readClient, _loop2, modelId, _ret2;
+
+                  return _regeneratorRuntime.wrap(function _loop$(_context5) {
+                    while (1) {
+                      switch (_context5.prev = _context5.next) {
+                        case 0:
+                          localeData = locales[locale];
+                          manageClient = getManageClient(locale);
+                          readClient = getReadClient(locale);
+                          _loop2 = /*#__PURE__*/_regeneratorRuntime.mark(function _loop2(modelId) {
+                            var modelData, entries, mutation, _iterator2, _step2, _loop3, _ret3;
+
+                            return _regeneratorRuntime.wrap(function _loop2$(_context4) {
+                              while (1) {
+                                switch (_context4.prev = _context4.next) {
+                                  case 0:
+                                    modelData = localeData[modelId];
+                                    /**
+                                     * This should never be true but let's check just in case of some missed loop breaks.
+                                     */
+
+                                    if (!(modelData.done || modelData.upgrading)) {
+                                      _context4.next = 3;
+                                      break;
+                                    }
+
+                                    return _context4.abrupt("return", "continue");
+
+                                  case 3:
+                                    _context4.next = 5;
+                                    return fetchModelEntries({
+                                      model: modelData.model,
+                                      client: readClient
+                                    });
+
+                                  case 5:
+                                    entries = _context4.sent;
+                                    setUpgradeItems(function (previous) {
+                                      return _objectSpread(_objectSpread({}, previous), {}, {
+                                        locales: _objectSpread(_objectSpread({}, previous.locales), {}, _defineProperty({}, locale, _objectSpread(_objectSpread({}, previous.locales[locale]), {}, _defineProperty({}, modelId, {
+                                          model: modelData.model,
+                                          done: false,
+                                          upgrading: true,
+                                          entries: entries.map(function (id) {
+                                            return {
+                                              id: id,
+                                              done: false
+                                            };
+                                          })
+                                        }))))
+                                      });
+                                    });
+                                    mutation = createRepublishMutation(modelData.model);
+                                    _iterator2 = _createForOfIteratorHelper(entries);
+                                    _context4.prev = 9;
+                                    _loop3 = /*#__PURE__*/_regeneratorRuntime.mark(function _loop3() {
+                                      var id, republishResponse, error;
+                                      return _regeneratorRuntime.wrap(function _loop3$(_context3) {
+                                        while (1) {
+                                          switch (_context3.prev = _context3.next) {
+                                            case 0:
+                                              id = _step2.value;
+                                              _context3.next = 3;
+                                              return manageClient.mutate({
+                                                mutation: mutation,
+                                                variables: {
+                                                  revision: id
+                                                }
+                                              });
+
+                                            case 3:
+                                              republishResponse = _context3.sent;
+                                              error = republishResponse.data.content.error;
+
+                                              if (!error) {
+                                                _context3.next = 8;
+                                                break;
+                                              }
+
+                                              setError(error);
+                                              return _context3.abrupt("return", {
+                                                v: {
+                                                  v: {
+                                                    v: void 0
+                                                  }
+                                                }
+                                              });
+
+                                            case 8:
+                                              setUpgradeItems(function (previous) {
+                                                return _objectSpread(_objectSpread({}, previous), {}, {
+                                                  locales: _objectSpread(_objectSpread({}, previous.locales), {}, _defineProperty({}, locale, _objectSpread(_objectSpread({}, previous.locales[locale]), {}, _defineProperty({}, modelId, {
+                                                    model: previous.locales[locale][modelId].model,
+                                                    entries: previous.locales[locale][modelId].entries.map(function (info) {
+                                                      return {
+                                                        id: info.id,
+                                                        done: info.done === true || id === info.id
+                                                      };
+                                                    }),
+                                                    done: false,
+                                                    upgrading: true
+                                                  }))))
+                                                });
+                                              });
+
+                                            case 9:
+                                            case "end":
+                                              return _context3.stop();
+                                          }
+                                        }
+                                      }, _loop3);
+                                    });
+
+                                    _iterator2.s();
+
+                                  case 12:
+                                    if ((_step2 = _iterator2.n()).done) {
+                                      _context4.next = 19;
+                                      break;
+                                    }
+
+                                    return _context4.delegateYield(_loop3(), "t0", 14);
+
+                                  case 14:
+                                    _ret3 = _context4.t0;
+
+                                    if (!(typeof _ret3 === "object")) {
+                                      _context4.next = 17;
+                                      break;
+                                    }
+
+                                    return _context4.abrupt("return", _ret3.v);
+
+                                  case 17:
+                                    _context4.next = 12;
+                                    break;
+
+                                  case 19:
+                                    _context4.next = 24;
+                                    break;
+
+                                  case 21:
+                                    _context4.prev = 21;
+                                    _context4.t1 = _context4["catch"](9);
+
+                                    _iterator2.e(_context4.t1);
+
+                                  case 24:
+                                    _context4.prev = 24;
+
+                                    _iterator2.f();
+
+                                    return _context4.finish(24);
+
+                                  case 27:
+                                    setUpgradeItems(function (previous) {
+                                      return _objectSpread(_objectSpread({}, previous), {}, {
+                                        locales: _objectSpread(_objectSpread({}, previous.locales), {}, _defineProperty({}, locale, _objectSpread(_objectSpread({}, previous.locales[locale]), {}, _defineProperty({}, modelId, {
+                                          model: modelData.model,
+                                          entries: [],
+                                          done: true,
+                                          upgrading: false
+                                        }))))
+                                      });
+                                    });
+
+                                  case 28:
+                                  case "end":
+                                    return _context4.stop();
+                                }
+                              }
+                            }, _loop2, null, [[9, 21, 24, 27]]);
+                          });
+                          _context5.t0 = _regeneratorRuntime.keys(localeData);
+
+                        case 5:
+                          if ((_context5.t1 = _context5.t0()).done) {
+                            _context5.next = 15;
+                            break;
+                          }
+
+                          modelId = _context5.t1.value;
+                          return _context5.delegateYield(_loop2(modelId), "t2", 8);
+
+                        case 8:
+                          _ret2 = _context5.t2;
+
+                          if (!(_ret2 === "continue")) {
+                            _context5.next = 11;
+                            break;
+                          }
+
+                          return _context5.abrupt("continue", 5);
+
+                        case 11:
+                          if (!(typeof _ret2 === "object")) {
+                            _context5.next = 13;
+                            break;
+                          }
+
+                          return _context5.abrupt("return", _ret2.v);
+
+                        case 13:
+                          _context5.next = 5;
+                          break;
+
+                        case 15:
+                        case "end":
+                          return _context5.stop();
+                      }
+                    }
+                  }, _loop);
+                });
+                _context6.t0 = _regeneratorRuntime.keys(locales);
+
+              case 2:
+                if ((_context6.t1 = _context6.t0()).done) {
+                  _context6.next = 10;
+                  break;
+                }
+
+                locale = _context6.t1.value;
+                return _context6.delegateYield(_loop(locale), "t2", 5);
+
+              case 5:
+                _ret = _context6.t2;
+
+                if (!(typeof _ret === "object")) {
+                  _context6.next = 8;
+                  break;
+                }
+
+                return _context6.abrupt("return", _ret.v);
+
+              case 8:
+                _context6.next = 2;
+                break;
+
+              case 10:
+                _context6.next = 12;
+                return client.mutate({
+                  mutation: createUpgradeMutation(),
+                  variables: {
+                    version: "5.19.0"
+                  }
+                });
+
+              case 12:
+                response = _context6.sent;
+                error = response.data.cms.upgrade.error;
+                setStatus("completed");
+
+                if (!error) {
+                  _context6.next = 18;
+                  break;
+                }
+
+                setError(error);
+                return _context6.abrupt("return");
+
+              case 18:
+                onInstalled();
+
+              case 19:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee3);
+      }));
+
+      return function republish() {
+        return _ref5.apply(this, arguments);
+      };
+    }();
+
+    republish();
+  }, [upgrade, upgradeItems, status]);
+  var label = error ? /*#__PURE__*/React.createElement(Alert, {
+    title: t(_templateObject || (_templateObject = _taggedTemplateLiteral(["Something went wrong"]))),
+    type: "danger"
+  }, error.message) : upgrade ? t(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["Upgrading Headless CMS..."]))) : "Loading Headless CMS information";
+  return /*#__PURE__*/React.createElement(SimpleForm, null, (loading || error) && /*#__PURE__*/React.createElement(CircularProgress, {
+    label: label
+  }), /*#__PURE__*/React.createElement(SimpleFormHeader, {
+    title: "Upgrade Headless CMS"
+  }), /*#__PURE__*/React.createElement(SimpleFormContent, null, /*#__PURE__*/React.createElement(Grid, null, /*#__PURE__*/React.createElement(Cell, {
+    span: 12
+  }, /*#__PURE__*/React.createElement(Typography, {
+    use: "body1",
+    tag: "div"
+  }, "This upgrade will do the following:", /*#__PURE__*/React.createElement("ul", null, /*#__PURE__*/React.createElement("li", null, "update entries")), /*#__PURE__*/React.createElement(UpgradeItemsInfo, {
+    upgradeItems: upgradeItems
+  }))))), /*#__PURE__*/React.createElement(SimpleFormFooter, null, /*#__PURE__*/React.createElement(ButtonPrimary, {
+    disabled: loading || upgrade,
+    onClick: startUpgrade
+  }, "Upgrade")));
+};
+
+export default Upgrade;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/app-headless-cms",
-	"version": "5.19.0-beta.1",
+	"version": "5.19.0-beta.5",
 	"main": "index.js",
 	"repository": {
 		"type": "git",
@@ -24,22 +24,23 @@
 		"@fortawesome/react-fontawesome": "0.1.16",
 		"@svgr/webpack": "4.3.3",
 		"@types/react": "16.14.2",
-		"@webiny/app": "5.19.0-beta.1",
-		"@webiny/app-admin": "5.19.0-beta.1",
-		"@webiny/app-graphql-playground": "5.19.0-beta.1",
-		"@webiny/app-i18n": "5.19.0-beta.1",
-		"@webiny/app-plugin-admin-welcome-screen": "5.19.0-beta.1",
-		"@webiny/app-security": "5.19.0-beta.1",
-		"@webiny/error": "5.19.0-beta.1",
-		"@webiny/form": "5.19.0-beta.1",
-		"@webiny/plugins": "5.19.0-beta.1",
-		"@webiny/react-router": "5.19.0-beta.1",
-		"@webiny/ui": "5.19.0-beta.1",
-		"@webiny/utils": "5.19.0-beta.1",
-		"@webiny/validation": "5.19.0-beta.1",
+		"@webiny/app": "5.19.0-beta.5",
+		"@webiny/app-admin": "5.19.0-beta.5",
+		"@webiny/app-graphql-playground": "5.19.0-beta.5",
+		"@webiny/app-i18n": "5.19.0-beta.5",
+		"@webiny/app-plugin-admin-welcome-screen": "5.19.0-beta.5",
+		"@webiny/app-security": "5.19.0-beta.5",
+		"@webiny/error": "5.19.0-beta.5",
+		"@webiny/form": "5.19.0-beta.5",
+		"@webiny/plugins": "5.19.0-beta.5",
+		"@webiny/react-router": "5.19.0-beta.5",
+		"@webiny/ui": "5.19.0-beta.5",
+		"@webiny/utils": "5.19.0-beta.5",
+		"@webiny/validation": "5.19.0-beta.5",
 		"apollo-cache": "1.3.5",
 		"apollo-client": "2.6.10",
 		"apollo-link": "1.2.14",
+		"apollo-link-batch-http": "1.2.14",
 		"apollo-utilities": "1.3.4",
 		"classnames": "2.3.1",
 		"dot-prop-immutable": "2.1.1",
@@ -67,8 +68,8 @@
 		"@babel/preset-env": "^7.5.5",
 		"@babel/preset-react": "^7.0.0",
 		"@babel/preset-typescript": "^7.8.3",
-		"@webiny/cli": "^5.19.0-beta.1",
-		"@webiny/project-utils": "^5.19.0-beta.1",
+		"@webiny/cli": "^5.19.0-beta.5",
+		"@webiny/project-utils": "^5.19.0-beta.5",
 		"babel-plugin-emotion": "^9.2.8",
 		"babel-plugin-lodash": "^3.3.4",
 		"babel-plugin-module-resolver": "^4.1.0",
@@ -106,5 +107,5 @@
 			]
 		}
 	},
-	"gitHead": "dd406fbad0620ecce47063e9afbff40c502c3844"
+	"gitHead": "839188911bbaee4a596724c729c0a78f681fa614"
 }