cozy-client 41.0.0 → 41.1.0

package/dist/CozyClient.js

@@ -2695,7 +2695,7 @@ var CozyClient = /*#__PURE__*/function () {
 CozyClient.hooks = CozyClient.hooks || {};
 CozyClient.fetchPolicies = _policies.default; //COZY_CLIENT_VERSION_PACKAGE in replaced by babel. See babel config
 
-CozyClient.version = "41.0.0";
+CozyClient.version = "41.1.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/hooks/index.js

@@ -47,6 +47,12 @@ Object.defineProperty(exports, "useQueryAll", {
     return _useQueryAll.default;
   }
 });
+Object.defineProperty(exports, "useMutation", {
+  enumerable: true,
+  get: function get() {
+    return _useMutation.useMutation;
+  }
+});
 
 var _useAppLinkWithStoreFallback = _interopRequireDefault(require("./useAppLinkWithStoreFallback"));
 
@@ -60,4 +66,6 @@ var _useQuery = _interopRequireDefault(require("./useQuery"));
 
 var _useAppsInMaintenance = _interopRequireDefault(require("./useAppsInMaintenance"));
 
-var _useQueryAll = _interopRequireDefault(require("./useQueryAll"));
+var _useQueryAll = _interopRequireDefault(require("./useQueryAll"));
+
+var _useMutation = require("./useMutation");

package/dist/hooks/useMutation.js

@@ -0,0 +1,119 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMutation = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _react = require("react");
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _useClient = _interopRequireDefault(require("./useClient"));
+
+/**
+ * This hook manages the state during the saving of a document
+ *
+ * @returns {import("../types").UseMutationReturnValue}
+ */
+var useMutation = function useMutation(_ref) {
+  var onSuccess = _ref.onSuccess,
+      onError = _ref.onError;
+  var client = (0, _useClient.default)();
+  /** @type {import("../types").useState<import("../types").QueryFetchStatus>} */
+
+  var _useState = (0, _react.useState)('pending'),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      mutationStatus = _useState2[0],
+      setMutationStatus = _useState2[1];
+
+  var _useState3 = (0, _react.useState)(),
+      _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+      error = _useState4[0],
+      setError = _useState4[1];
+
+  var _useState5 = (0, _react.useState)(),
+      _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+      data = _useState6[0],
+      setData = _useState6[1];
+
+  var mutate = (0, _react.useCallback)( /*#__PURE__*/function () {
+    var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(doc) {
+      var resp;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              setError(undefined);
+              setMutationStatus('loading');
+              _context.prev = 2;
+              _context.next = 5;
+              return client.save(doc);
+
+            case 5:
+              resp = _context.sent;
+              setData(resp.data);
+
+              if (!(typeof onSuccess === 'function')) {
+                _context.next = 10;
+                break;
+              }
+
+              _context.next = 10;
+              return onSuccess(resp.data);
+
+            case 10:
+              setMutationStatus('loaded');
+              _context.next = 20;
+              break;
+
+            case 13:
+              _context.prev = 13;
+              _context.t0 = _context["catch"](2);
+              setMutationStatus('failed');
+              setError(_context.t0);
+
+              if (!(typeof onError === 'function')) {
+                _context.next = 20;
+                break;
+              }
+
+              _context.next = 20;
+              return onError(_context.t0);
+
+            case 20:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, null, [[2, 13]]);
+    }));
+
+    return function (_x) {
+      return _ref2.apply(this, arguments);
+    };
+  }(), [client, onError, onSuccess]);
+  return {
+    mutate: mutate,
+    mutationStatus: mutationStatus,
+    error: error,
+    data: data
+  };
+};
+
+exports.useMutation = useMutation;
+useMutation.propTypes = {
+  /** This function is triggered when the save is successful */
+  onSuccess: _propTypes.default.func,
+
+  /** This function is triggered when the save has failed */
+  onError: _propTypes.default.func
+};

package/dist/hooks/useMutation.spec.jsx

@@ -0,0 +1,81 @@
+import { renderHook, act } from '@testing-library/react-hooks'
+
+import { useMutation } from './useMutation'
+import useClient from './useClient'
+
+jest.mock('./useClient')
+
+describe('useMutation', () => {
+  const setup = ({ onSuccess, onError, saveSpy = jest.fn() } = {}) => {
+    useClient.mockReturnValue({
+      save: saveSpy
+    })
+
+    return renderHook(() =>
+      useMutation({
+        onSuccess,
+        onError
+      })
+    )
+  }
+
+  it('should be in pending status', () => {
+    const {
+      result: { current }
+    } = setup()
+    expect(current.mutationStatus).toBe('pending')
+  })
+
+  it('should be in loading status after mutate', async () => {
+    const saveSpy = jest.fn().mockImplementation(() => new Promise(() => {}))
+
+    const { result } = setup({ saveSpy })
+
+    await act(async () => {
+      result.current.mutate({
+        doctype: 'io.cozy.simpsons'
+      })
+    })
+
+    expect(result.current.mutationStatus).toBe('loading')
+  })
+
+  it('should be in loaded status after mutate', async () => {
+    const successSpy = jest.fn()
+    const saveSpy = jest.fn().mockResolvedValue({ data: 'test' })
+    const { result } = setup({
+      onSuccess: successSpy,
+      saveSpy
+    })
+
+    await act(async () => {
+      result.current.mutate({
+        doctype: 'io.cozy.simpsons'
+      })
+    })
+
+    expect(result.current.mutationStatus).toBe('loaded')
+    expect(saveSpy).toBeCalledTimes(1)
+    expect(successSpy).toBeCalledTimes(1)
+    expect(result.current.data).toBe('test')
+  })
+
+  it('should be in failed status after mutate', async () => {
+    const errorSpy = jest.fn()
+    const saveSpy = jest.fn().mockRejectedValue({ error: 'test' })
+    const { result } = setup({
+      onError: errorSpy,
+      saveSpy
+    })
+
+    await act(async () => {
+      result.current.mutate({
+        doctype: 'io.cozy.simpsons'
+      })
+    })
+
+    expect(result.current.mutationStatus).toBe('failed')
+    expect(errorSpy).toBeCalledTimes(1)
+    expect(result.current.error).toStrictEqual({ error: 'test' })
+  })
+})

package/dist/types.js

@@ -208,6 +208,14 @@ var _dsl = require("./queries/dsl");
  * @typedef {QueryState & FetchMoreAble & FetchAble} UseQueryReturnValue
  */
 
+/**
+ * @typedef {object} UseMutationReturnValue
+ * @property {Function} mutate - Function to save the document
+ * @property {QueryFetchStatus} mutationStatus - Status of the current mutation
+ * @property {object} [error] - Error if the mutation failed
+ * @property {object} [data] - Data return after the mutation
+ */
+
 /**
  * A reference to a document
  *
@@ -540,5 +548,12 @@ var _dsl = require("./queries/dsl");
  * @property {string} pathname - The redirect link's path (i.e. 'public')
  * @property {string} hash - The redirect link's path (i.e. '/folder/SOME_FOLDER_ID')
  */
+
+/**
+ * Template to type useState
+ *
+ * @template T
+ * @typedef {[T, import('react').Dispatch<import('react').SetStateAction<T>>]} useState
+ */
 var _default = {};
 exports.default = _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "41.0.0",
+  "version": "41.1.0",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -75,5 +75,5 @@
     "react-native-ios11-devicecheck": "https://github.com/cozy/react-native-devicecheck#app-attest-v0.1"
   },
   "sideEffects": false,
-  "gitHead": "407e4545f27490d0b0e1450ebcd9a70c1ab17aff"
+  "gitHead": "1678577c9fab7d28e9579cd4fbeab825cfcd2b9c"
 }

package/types/hooks/index.d.ts

@@ -5,3 +5,4 @@ export { default as useClient } from "./useClient";
 export { default as useQuery } from "./useQuery";
 export { default as useAppsInMaintenance } from "./useAppsInMaintenance";
 export { default as useQueryAll } from "./useQueryAll";
+export { useMutation } from "./useMutation";

package/types/hooks/useMutation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * This hook manages the state during the saving of a document
+ *
+ * @returns {import("../types").UseMutationReturnValue}
+ */
+export function useMutation({ onSuccess, onError }: {
+    onSuccess: any;
+    onError: any;
+}): import("../types").UseMutationReturnValue;
+export namespace useMutation {
+    namespace propTypes {
+        const onSuccess: PropTypes.Requireable<(...args: any[]) => any>;
+        const onError: PropTypes.Requireable<(...args: any[]) => any>;
+    }
+}
+import PropTypes from "prop-types";

package/types/types.d.ts

@@ -365,6 +365,24 @@ export type FetchAble = {
     fetch: Function;
 };
 export type UseQueryReturnValue = QueryState & FetchMoreAble & FetchAble;
+export type UseMutationReturnValue = {
+    /**
+     * - Function to save the document
+     */
+    mutate: Function;
+    /**
+     * - Status of the current mutation
+     */
+    mutationStatus: QueryFetchStatus;
+    /**
+     * - Error if the mutation failed
+     */
+    error?: object;
+    /**
+     * - Data return after the mutation
+     */
+    data?: object;
+};
 /**
  * A reference to a document
  */
@@ -879,4 +897,8 @@ export type RedirectLinkData = {
      */
     hash: string;
 };
+/**
+ * Template to type useState
+ */
+export type useState<T> = [T, import("react").Dispatch<import("react").SetStateAction<T>>];
 import { QueryDefinition } from "./queries/dsl";