cozy-client 29.2.0 → 31.0.1

package/dist/CozyClient.js

@@ -2550,7 +2550,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 = "29.2.0";
+CozyClient.version = "31.0.1";
 
 _microee.default.mixin(CozyClient);
 

package/dist/models/dacc.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.sendMeasureToDACC = exports.checkMeasureParams = void 0;
+exports.fetchAggregatesFromDACC = exports.buildAggregateParams = exports.sendMeasureToDACC = exports.checkMeasureParams = exports.isCorrectDateFormat = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
@@ -15,11 +15,31 @@ var _cozyLogger = _interopRequireDefault(require("cozy-logger"));
 
 var _types = require("../types");
 
+var _CozyClient = _interopRequireDefault(require("../CozyClient"));
+
+/**
+ * Check whether or not the given date is in YYYY-MM-DD format
+ *
+ * @param {string} date - The date to check
+ * @returns {boolean}
+ */
+var isCorrectDateFormat = function isCorrectDateFormat(date) {
+  try {
+    var parsedDate = new Date(Date.parse(date));
+    return !!parsedDate.toISOString().startsWith(date);
+  } catch (err) {
+    return false;
+  }
+};
 /**
  * Throw an errror if a DACC parameter is incorrect.
  *
  * @param { DACCMeasure} measure - The DACC measure
  */
+
+
+exports.isCorrectDateFormat = isCorrectDateFormat;
+
 var checkMeasureParams = function checkMeasureParams(measure) {
   var createdBy = measure.createdBy,
       measureName = measure.measureName,
@@ -41,9 +61,7 @@ var checkMeasureParams = function checkMeasureParams(measure) {
     throw new Error('Missing parameter: startDate');
   }
 
-  var parsedDate = new Date(Date.parse(startDate));
-
-  if (!parsedDate.toISOString().startsWith(startDate)) {
+  if (!isCorrectDateFormat(startDate)) {
     throw new Error('Date should be in YYYY-MM-DD format');
   }
 
@@ -62,7 +80,7 @@ var checkMeasureParams = function checkMeasureParams(measure) {
 /**
  * Send measures to a DACC through a remote doctype
  *
- * @param {object} client - The CozyClient instance
+ * @param {CozyClient} client - The CozyClient instance
  * @param {string} remoteDoctype - The remote doctype to use
  * @param {DACCMeasure} measure - The DACC measure
  */
@@ -80,7 +98,8 @@ var sendMeasureToDACC = /*#__PURE__*/function () {
             checkMeasureParams(measure);
             _context.next = 4;
             return client.getStackClient().fetchJSON('POST', "/remote/".concat(remoteDoctype), {
-              data: JSON.stringify(measure)
+              data: JSON.stringify(measure),
+              path: 'measure'
             });
 
           case 4:
@@ -105,5 +124,90 @@ var sendMeasureToDACC = /*#__PURE__*/function () {
     return _ref.apply(this, arguments);
   };
 }();
+/**
+ * Build parameters to request DACC aggregate
+ *
+ *
+ * @typedef Params - The unformatted DACC aggregate params
+ * @property {string} [measureName] - The measure name
+ * @property {string} [startDate]   - The measure start date
+ * @property {string} [endDate]     - The measure end date
+ *
+ * @param {Params} params - The unformatted DACC aggregate params
+ * @returns {DACCAggregatesParams}
+ */
+
+
+exports.sendMeasureToDACC = sendMeasureToDACC;
+
+var buildAggregateParams = function buildAggregateParams(params) {
+  var measureName = params.measureName;
+
+  if (!measureName || typeof measureName !== 'string') {
+    throw new Error('Missing or wrong type parameter: measureName');
+  }
+
+  var startDate = params.startDate || new Date(0).toISOString();
+  var endDate = params.endDate || new Date(Date.now()).toISOString();
+
+  if (!isCorrectDateFormat(startDate) || !isCorrectDateFormat(endDate)) {
+    (0, _cozyLogger.default)('error', "Date should be in YYYY-MM-DD format but received: startDate: ".concat(startDate, " | endDate: ").concat(endDate));
+    throw new Error('Date should be in YYYY-MM-DD format');
+  }
+
+  return {
+    measureName: measureName,
+    startDate: startDate,
+    endDate: endDate
+  };
+};
+/**
+ * Send measures to a DACC through a remote doctype
+ *
+ * @param {CozyClient} client - The CozyClient instance
+ * @param {string} remoteDoctype - The remote doctype to use
+ * @param {DACCAggregatesParams} params - The request params
+ * @returns { Promise<DACCAggregatesResponse> }
+ */
+
+
+exports.buildAggregateParams = buildAggregateParams;
+
+var fetchAggregatesFromDACC = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(client, remoteDoctype, params) {
+    var aggregateParams;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.prev = 0;
+            aggregateParams = buildAggregateParams(params);
+            _context2.next = 4;
+            return client.getStackClient().fetchJSON('POST', "/remote/".concat(remoteDoctype), {
+              data: JSON.stringify(aggregateParams),
+              path: 'aggregate'
+            });
+
+          case 4:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 7:
+            _context2.prev = 7;
+            _context2.t0 = _context2["catch"](0);
+            (0, _cozyLogger.default)('error', "Error while fetching aggregates to remote doctype: ".concat(_context2.t0.message));
+            throw _context2.t0;
+
+          case 11:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[0, 7]]);
+  }));
+
+  return function fetchAggregatesFromDACC(_x4, _x5, _x6) {
+    return _ref2.apply(this, arguments);
+  };
+}();
 
-exports.sendMeasureToDACC = sendMeasureToDACC;
+exports.fetchAggregatesFromDACC = fetchAggregatesFromDACC;

package/dist/models/dacc.spec.js

@@ -1,6 +1,6 @@
-import { checkMeasureParams } from './dacc'
+import { checkMeasureParams, buildAggregateParams } from './dacc'
 
-describe('dacc', () => {
+describe('checkMeasureParams', () => {
   const measure = {
     value: 42,
     measureName: 'theanswer',
@@ -104,3 +104,55 @@ describe('dacc', () => {
     ).toThrow()
   })
 })
+
+describe('buildAggregateParams', () => {
+  beforeAll(() => {
+    jest
+      .spyOn(global.Date, 'now')
+      .mockImplementation(() => new Date(2022, 5, 1).valueOf())
+  })
+  it('should throw if measure name is not correct', () => {
+    expect(() => buildAggregateParams({})).toThrow()
+    expect(() => buildAggregateParams({ measurName: 42 })).toThrow()
+  })
+
+  it('should throw if dates are not correct', () => {
+    expect(() =>
+      buildAggregateParams({
+        measureName: 'test',
+        startDate: 'Lundi 10 août 2021'
+      })
+    ).toThrow()
+    expect(() =>
+      buildAggregateParams({
+        measureName: 'test',
+        endDate: 'Lundi 10 août 2021'
+      })
+    ).toThrow()
+  })
+  it('should build dates if none provided', () => {
+    expect(buildAggregateParams({ measureName: 'test' })).toEqual({
+      measureName: 'test',
+      startDate: '1970-01-01T00:00:00.000Z',
+      endDate: new Date(2022, 5, 1).toISOString()
+    })
+  })
+  it('should build dates if startDate provided', () => {
+    expect(
+      buildAggregateParams({ measureName: 'test', startDate: '2021-08-10' })
+    ).toEqual({
+      measureName: 'test',
+      startDate: '2021-08-10',
+      endDate: new Date(2022, 5, 1).toISOString()
+    })
+  })
+  it('should build dates if endDate provided', () => {
+    expect(
+      buildAggregateParams({ measureName: 'test', endDate: '2022-05-02' })
+    ).toEqual({
+      measureName: 'test',
+      startDate: '1970-01-01T00:00:00.000Z',
+      endDate: '2022-05-02'
+    })
+  })
+})

package/dist/queries/dsl.js

@@ -29,6 +29,8 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
  * @property {Array} [indexedFields]
  * @property {Array} [sort]
  * @property {object} [selector]
+ * @property {object} [partialFilter]
+ * @property {Array} [fields]
  */
 
 /**
@@ -155,6 +157,42 @@ var QueryDefinition = /*#__PURE__*/function () {
         console.info("The use of the $ne operator is more efficient with a partial index.\n\n        Selector: ".concat(selector));
       }
     }
+    /**
+     * Check if the selected fields are all included in the selectors
+     *
+     * @param {PartialQueryDefinition} obj - A partial QueryDefinition to check
+     */
+
+  }, {
+    key: "checkSelectFields",
+    value: function checkSelectFields(_ref2) {
+      var fields = _ref2.fields,
+          selector = _ref2.selector,
+          partialFilter = _ref2.partialFilter;
+
+      var _fields = this.fields || fields;
+
+      var _selector = this.selector || selector;
+
+      var _partialFilter = this.partialFilter || partialFilter;
+
+      if (!_fields || !_selector && !_partialFilter) {
+        return;
+      }
+
+      var mergedSelector = _objectSpread(_objectSpread({}, _selector), _partialFilter);
+
+      var selectorAttributes = Object.keys(mergedSelector);
+      var hasEveryFieldsInSelector = selectorAttributes.every(function (attribute) {
+        return _fields.includes(attribute);
+      });
+
+      if (!hasEveryFieldsInSelector) {
+        throw new Error("The .select should includes all the fields used in where or partialIndex.\n        Please fix this query: fields: ".concat(JSON.stringify(this.toDefinition())));
+      }
+
+      return;
+    }
     /**
      * Query a single document on its id.
      *
@@ -202,6 +240,9 @@ var QueryDefinition = /*#__PURE__*/function () {
         selector: selector
       });
       this.checkSelector(selector);
+      this.checkSelectFields({
+        selector: selector
+      });
       return new QueryDefinition(_objectSpread(_objectSpread({}, this.toDefinition()), {}, {
         selector: selector
       }));
@@ -216,6 +257,9 @@ var QueryDefinition = /*#__PURE__*/function () {
   }, {
     key: "select",
     value: function select(fields) {
+      this.checkSelectFields({
+        fields: fields
+      });
       return new QueryDefinition(_objectSpread(_objectSpread({}, this.toDefinition()), {}, {
         fields: fields
       }));
@@ -250,6 +294,9 @@ var QueryDefinition = /*#__PURE__*/function () {
   }, {
     key: "partialIndex",
     value: function partialIndex(partialFilter) {
+      this.checkSelectFields({
+        partialFilter: partialFilter
+      });
       return new QueryDefinition(_objectSpread(_objectSpread({}, this.toDefinition()), {}, {
         partialFilter: partialFilter
       }));

package/dist/queries/dsl.spec.js

@@ -107,4 +107,43 @@ describe('QueryDefinition', () => {
     Q('io.cozy.files').where({ _id: { $ne: 'io.cozy.root-id' } })
     expect(console.info).toHaveBeenCalledTimes(1)
   })
+
+  it('should throw an error when there is a select without all the fields in selector', () => {
+    const query = () =>
+      Q('io.cozy.files')
+        .where({ name: 'saymyname' })
+        .select(['size'])
+    expect(() => query()).toThrow()
+  })
+  it('should throw an error when there is a select without all the fields in partial index', () => {
+    const query = () =>
+      Q('io.cozy.files')
+        .where({ size: 42 })
+        .partialIndex({ name: { $exists: true } })
+        .select(['size'])
+    expect(() => query()).toThrow()
+  })
+  it('should throw an error when there is a select without all the fields in nor selector nor partial index', () => {
+    const query = () =>
+      Q('io.cozy.files')
+        .where({ size: 42 })
+        .partialIndex({ name: { $exists: true } })
+        .select(['date'])
+    expect(() => query()).toThrow()
+  })
+  it('should not throw when there is a select with all the fields in selector and partial index', () => {
+    const query = () =>
+      Q('io.cozy.files')
+        .where(
+          {
+            size: 42
+          },
+          {
+            date: '2021-01-01'
+          }
+        )
+        .partialIndex({ name: { $exists: true } })
+        .select(['date', 'size', 'name', 'trashed'])
+    expect(() => query()).not.toThrow()
+  })
 })

package/dist/types.js

@@ -329,6 +329,36 @@ var _dsl = require("./queries/dsl");
  * @property {object} group3 - Should be a {key: value} where the key is set in the measure definition.
  */
 
+/**
+ * @typedef {object} DACCAggregatesParams
+ * See https://github.com/cozy/DACC
+ *
+ * @property {string} measureName - It must match an existing measure name on the DACC server
+ * @property {string} startDate - Start of the aggregation period. Should be in YYYY-MM-DD format
+ * @property {string} endDate - End of the aggregation period. Should be in YYYY-MM-DD format
+ */
+
+/**
+ * @typedef {Array<DACCAggregate>} DACCAggregatesResponse
+ * See https://github.com/cozy/DACC
+ */
+
+/**
+ * @typedef {object} DACCAggregate
+ * See https://github.com/cozy/DACC
+ *
+ * @property {string} measureName - The name of the measures aggregate
+ * @property {string} startDate - The aggregation start date
+ * @property {number} sum - The aggregate sum
+ * @property {number} count - The aggregate count
+ * @property {number} countNotZero - The aggregate count of values different from zero
+ * @property {number} avg - The aggregate average
+ * @property {number} min - The aggregate min
+ * @property {number} max - The aggregate max
+ * @property {number} std - The aggregate standard deviation
+ *
+ */
+
 /**
  * Receives the URL to present to the user as a parameter, and should return a promise that resolves with the URL the user was redirected to after accepting the permissions.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "29.2.0",
+  "version": "31.0.1",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -18,7 +18,7 @@
     "@types/jest": "^26.0.20",
     "@types/lodash": "^4.14.170",
     "btoa": "^1.2.1",
-    "cozy-stack-client": "^29.2.0",
+    "cozy-stack-client": "^31.0.0",
     "json-stable-stringify": "^1.0.1",
     "lodash": "^4.17.13",
     "microee": "^0.0.6",
@@ -73,5 +73,5 @@
     "react-native-ios11-devicecheck": "https://github.com/cozy/react-native-devicecheck#app-attest-v0.1"
   },
   "sideEffects": false,
-  "gitHead": "50cc3d6b5b6bdcbc231fe2a584fc17415d177bd6"
+  "gitHead": "e989cf8c1f026696b4bf0720f3161067f1166d8b"
 }

package/types/models/dacc.d.ts

@@ -1,3 +1,26 @@
+export function isCorrectDateFormat(date: string): boolean;
 export function checkMeasureParams(measure: DACCMeasure): void;
-export function sendMeasureToDACC(client: object, remoteDoctype: string, measure: DACCMeasure): Promise<void>;
+export function sendMeasureToDACC(client: CozyClient, remoteDoctype: string, measure: DACCMeasure): Promise<void>;
+export function buildAggregateParams(params: Params): DACCAggregatesParams;
+export function fetchAggregatesFromDACC(client: CozyClient, remoteDoctype: string, params: DACCAggregatesParams): Promise<DACCAggregatesResponse>;
+/**
+ * - The unformatted DACC aggregate params
+ */
+export type Params = {
+    /**
+     * - The measure name
+     */
+    measureName?: string;
+    /**
+     * - The measure start date
+     */
+    startDate?: string;
+    /**
+     * - The measure end date
+     */
+    endDate?: string;
+};
 import { DACCMeasure } from "../types";
+import CozyClient from "../CozyClient";
+import { DACCAggregatesParams } from "../types";
+import { DACCAggregatesResponse } from "../types";

package/types/queries/dsl.d.ts

@@ -68,6 +68,8 @@ export type PartialQueryDefinition = {
     indexedFields?: any[];
     sort?: any[];
     selector?: object;
+    partialFilter?: object;
+    fields?: any[];
 };
 export type MangoSelector = any;
 export type MangoPartialFilter = any;
@@ -78,6 +80,8 @@ import { Doctype } from "../types";
  * @property {Array} [indexedFields]
  * @property {Array} [sort]
  * @property {object} [selector]
+ * @property {object} [partialFilter]
+ * @property {Array} [fields]
  */
 /**
  * @typedef {object} MangoSelector
@@ -162,6 +166,12 @@ export class QueryDefinition {
      * @returns {void}
      */
     checkSelector(selector: MangoSelector): void;
+    /**
+     * Check if the selected fields are all included in the selectors
+     *
+     * @param {PartialQueryDefinition} obj - A partial QueryDefinition to check
+     */
+    checkSelectFields({ fields, selector, partialFilter }: PartialQueryDefinition): void;
     /**
      * Query a single document on its id.
      *

package/types/types.d.ts

@@ -390,6 +390,68 @@ export type DACCMeasure = {
      */
     group3: object;
 };
+/**
+ * See https://github.com/cozy/DACC
+ */
+export type DACCAggregatesParams = {
+    /**
+     * - It must match an existing measure name on the DACC server
+     */
+    measureName: string;
+    /**
+     * - Start of the aggregation period. Should be in YYYY-MM-DD format
+     */
+    startDate: string;
+    /**
+     * - End of the aggregation period. Should be in YYYY-MM-DD format
+     */
+    endDate: string;
+};
+/**
+ * See https://github.com/cozy/DACC
+ */
+export type DACCAggregatesResponse = DACCAggregate[];
+/**
+ * See https://github.com/cozy/DACC
+ */
+export type DACCAggregate = {
+    /**
+     * - The name of the measures aggregate
+     */
+    measureName: string;
+    /**
+     * - The aggregation start date
+     */
+    startDate: string;
+    /**
+     * - The aggregate sum
+     */
+    sum: number;
+    /**
+     * - The aggregate count
+     */
+    count: number;
+    /**
+     * - The aggregate count of values different from zero
+     */
+    countNotZero: number;
+    /**
+     * - The aggregate average
+     */
+    avg: number;
+    /**
+     * - The aggregate min
+     */
+    min: number;
+    /**
+     * - The aggregate max
+     */
+    max: number;
+    /**
+     * - The aggregate standard deviation
+     */
+    std: number;
+};
 /**
  * Receives the URL to present to the user as a parameter, and should return a promise that resolves with the URL the user was redirected to after accepting the permissions.
  */