pryv 2.4.4 → 2.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pryv",
-  "version": "2.4.4",
+  "version": "2.4.5",
   "description": "Pryv JavaScript library",
   "keywords": [
     "Pryv",
@@ -21,4 +21,4 @@
   "dependencies": {
     "superagent": "^9.0.0"
   }
-}
+}

package/src/Connection.js

@@ -26,7 +26,7 @@ const browserGetEventStreamed = require('./lib/browser-getEventStreamed');
  * @param {pryv.Service} [service] - eventually initialize Connection with a Service
  */
 class Connection {
-  constructor (apiEndpoint, service) {
+  constructor(apiEndpoint, service) {
     const { token, endpoint } = utils.extractTokenAndAPIEndpoint(apiEndpoint);
     this.token = token;
     this.endpoint = endpoint;
@@ -34,7 +34,7 @@ class Connection {
     this.options.chunkSize = 1000;
     this._deltaTime = { value: 0, weight: 0 };
     if (service && !(service instanceof Service)) {
-      throw new Error('Invalid service param');
+      throw new Error("Invalid service param");
     }
     this._service = service;
   }
@@ -44,9 +44,9 @@ class Connection {
    * @readonly
    * @property {pryv.Service} service
    */
-  get service () {
+  get service() {
     if (this._service) return this._service;
-    this._service = new Service(this.endpoint + 'service/info');
+    this._service = new Service(this.endpoint + "service/info");
     return this._service;
   }
 
@@ -56,7 +56,7 @@ class Connection {
    * @param {*} arrayOfAPICalls
    * @param {*} progress
    */
-  async username () {
+  async username() {
     const accessInfo = await this.accessInfo();
     return accessInfo.user.username;
   }
@@ -65,8 +65,8 @@ class Connection {
    * get access info
    * It's async as it is constructed with get function.
    */
-  async accessInfo () {
-    return this.get('access-info', null);
+  async accessInfo() {
+    return this.get("access-info", null);
   }
 
   /**
@@ -77,49 +77,131 @@ class Connection {
    * @param {Function} [progress] Return percentage of progress (0 - 100);
    * @returns {Promise<Array>} Promise to Array of results matching each method call in order
    */
-  async api (arrayOfAPICalls, progress) {
-    function httpHandler (batchCall) {
-      return this.post('', batchCall);
+  async api(arrayOfAPICalls, progress) {
+    function httpHandler(batchCall) {
+      return this.post("", batchCall);
+    }
+    return await this._chunkedBatchCall(
+      arrayOfAPICalls,
+      progress,
+      httpHandler.bind(this)
+    );
+  }
+
+  /**
+   * Make one api Api call
+   * @param {string} method - methodId
+   * @param {Object|Array} [params] - the params associated with this methodId
+   * @param {string} [resultKey] - if given, returns the value or throws an error if not present
+   * @throws {Error} if .error is present the response
+   */
+  async apiOne(method, params = {}, expectedKey) {
+    const result = await this.api([{ method, params }]);
+    if (
+      result[0] == null ||
+      result[0].error ||
+      (expectedKey != null && result[0][expectedKey] == null)
+    ) {
+      const innerObject = result[0]?.error || result;
+      const error = new Error(
+        `Error for api method: "${method}" with params: ${JSON.stringify(
+          params
+        )} >> Result: ${JSON.stringify(innerObject)}"`
+      );
+      error.innerObject = innerObject;
+      throw error;
+    }
+    if (expectedKey != null) return result[0][expectedKey];
+    return result[0];
+  }
+
+  /**
+   * Revoke : Delete the accessId
+   * - Do not thow error if access is already revoked, just return null;
+   * @param {boolean} [throwOnFail = true] - if set to false do not throw Error on failure
+   * @param {Connection} [usingConnection] - specify which connection issues the revoke, might be necessary when selfRovke
+   */
+  async revoke(throwOnFail = true, usingConnection) {
+    usingConnection = usingConnection || this;
+    let accessInfo = null;
+    // get accessId
+    try {
+      accessInfo = await this.accessInfo();
+    } catch (e) {
+      if (e.response?.body?.error?.id === "invalid-access-token") {
+        return null; // Already revoked OK..
+      }
+      if (throwOnFail) throw e;
+      return null;
+    }
+    // delete access
+    try {
+      const result = usingConnection.apiOne("accesses.delete", {
+        id: accessInfo.id,
+      });
+      return result;
+    } catch (e) {
+      if (throwOnFail) throw e;
+      return null;
     }
-    return await this._chunkedBatchCall(arrayOfAPICalls, progress, httpHandler.bind(this));
   }
 
   /**
    * @private
    */
-  async _chunkedBatchCall (arrayOfAPICalls, progress, callHandler) {
+  async _chunkedBatchCall(arrayOfAPICalls, progress, callHandler) {
     if (!Array.isArray(arrayOfAPICalls)) {
-      throw new Error('Connection.api() takes an array as input');
+      throw new Error("Connection.api() takes an array as input");
     }
 
     const res = [];
     let percent = 0;
-    for (let cursor = 0; arrayOfAPICalls.length >= cursor; cursor += this.options.chunkSize) {
+    for (
+      let cursor = 0;
+      arrayOfAPICalls.length >= cursor;
+      cursor += this.options.chunkSize
+    ) {
       const thisBatch = [];
-      const cursorMax = Math.min(cursor + this.options.chunkSize, arrayOfAPICalls.length);
+      const cursorMax = Math.min(
+        cursor + this.options.chunkSize,
+        arrayOfAPICalls.length
+      );
       // copy only method and params into a back call to be exuted
       for (let i = cursor; i < cursorMax; i++) {
-        thisBatch.push({ method: arrayOfAPICalls[i].method, params: arrayOfAPICalls[i].params });
+        thisBatch.push({
+          method: arrayOfAPICalls[i].method,
+          params: arrayOfAPICalls[i].params,
+        });
       }
       const resRequest = await callHandler(thisBatch);
 
       // result checks
       if (!resRequest || !Array.isArray(resRequest.results)) {
-        throw new Error('API call result is not an Array: ' + JSON.stringify(resRequest));
+        throw new Error(
+          "API call result is not an Array: " + JSON.stringify(resRequest)
+        );
       }
       if (resRequest.results.length !== thisBatch.length) {
-        throw new Error('API call result Array does not match request: ' + JSON.stringify(resRequest));
+        throw new Error(
+          "API call result Array does not match request: " +
+            JSON.stringify(resRequest)
+        );
       }
 
       // eventually call handleResult
       for (let i = 0; i < resRequest.results.length; i++) {
         if (arrayOfAPICalls[i + cursor].handleResult) {
-          await arrayOfAPICalls[i + cursor].handleResult.call(null, resRequest.results[i]);
+          await arrayOfAPICalls[i + cursor].handleResult.call(
+            null,
+            resRequest.results[i]
+          );
         }
       }
       Array.prototype.push.apply(res, resRequest.results);
-      percent = Math.round(100 * res.length / arrayOfAPICalls.length);
-      if (progress) { progress(percent, res); }
+      percent = Math.round((100 * res.length) / arrayOfAPICalls.length);
+      if (progress) {
+        progress(percent, res);
+      }
     }
     return res;
   }
@@ -131,7 +213,7 @@ class Connection {
    * @param {string} path
    * @returns {Promise<Array|Object>} Promise to result.body
    */
-  async post (path, data, queryParams) {
+  async post(path, data, queryParams) {
     const now = getTimestamp();
     const res = await this.postRaw(path, data, queryParams);
     this._handleMeta(res.body, now);
@@ -145,16 +227,15 @@ class Connection {
    * @param {string} path
    * @returns {request.superagent}  Promise from superagent's post request
    */
-  async postRaw (path, data, queryParams) {
-    return this._post(path)
-      .query(queryParams)
-      .send(data);
+  async postRaw(path, data, queryParams) {
+    return this._post(path).query(queryParams).send(data);
   }
 
-  _post (path) {
-    return utils.superagent.post(this.endpoint + path)
-      .set('Authorization', this.token)
-      .set('accept', 'json');
+  _post(path) {
+    return utils.superagent
+      .post(this.endpoint + path)
+      .set("Authorization", this.token)
+      .set("accept", "json");
   }
 
   /**
@@ -163,7 +244,7 @@ class Connection {
    * @param {string} path
    * @returns {Promise<Array|Object>}  Promise to result.body
    */
-  async get (path, queryParams) {
+  async get(path, queryParams) {
     const now = getTimestamp();
     const res = await this.getRaw(path, queryParams);
     this._handleMeta(res.body, now);
@@ -176,11 +257,12 @@ class Connection {
    * @param {string} path
    * @returns {request.superagent}  Promise from superagent's get request
    */
-  getRaw (path, queryParams) {
-    path = path || '';
-    return utils.superagent.get(this.endpoint + path)
-      .set('Authorization', this.token)
-      .set('accept', 'json')
+  getRaw(path, queryParams) {
+    path = path || "";
+    return utils.superagent
+      .get(this.endpoint + path)
+      .set("Authorization", this.token)
+      .set("accept", "json")
       .query(queryParams);
   }
 
@@ -188,15 +270,14 @@ class Connection {
    * ADD Data Points to HFEvent (flatJSON format)
    * https://api.pryv.com/reference/#add-hf-series-data-points
    */
-  async addPointsToHFEvent (eventId, fields, points) {
-    const res = await this.post('events/' + eventId + '/series',
-      {
-        format: 'flatJSON',
-        fields: fields,
-        points: points
-      });
-    if (!res.status === 'ok') {
-      throw new Error('Failed loading serie: ' + JSON.stringify(res.status));
+  async addPointsToHFEvent(eventId, fields, points) {
+    const res = await this.post("events/" + eventId + "/series", {
+      format: "flatJSON",
+      fields: fields,
+      points: points,
+    });
+    if (!res.status === "ok") {
+      throw new Error("Failed loading serie: " + JSON.stringify(res.status));
     }
     return res;
   }
@@ -209,25 +290,34 @@ class Connection {
    * @param {Function} forEachEvent Function taking one event as parameter. Will be called for each event
    * @returns {Promise<Object>} Promise to result.body transformed with `eventsCount: {count}` replacing `events: [...]`
    */
-  async getEventsStreamed (queryParams, forEachEvent) {
+  async getEventsStreamed(queryParams, forEachEvent) {
     const myParser = jsonParser(forEachEvent, queryParams.includeDeletions);
     let res = null;
-    if (typeof window === 'undefined') { // node
-      res = await this.getRaw('events', queryParams)
+    if (typeof window === "undefined") {
+      // node
+      res = await this.getRaw("events", queryParams)
         .buffer(false)
         .parse(myParser);
-    } else if (typeof fetch !== 'undefined' && !(typeof navigator !== 'undefined' && navigator.product === 'ReactNative')) { // browser supports fetch and it is not react native
+    } else if (
+      typeof fetch !== "undefined" &&
+      !(typeof navigator !== "undefined" && navigator.product === "ReactNative")
+    ) {
+      // browser supports fetch and it is not react native
       res = await browserGetEventStreamed(this, queryParams, myParser);
-    } else { // browser no fetch supports
-      console.log('WARNING: Browser does not support fetch() required by pryv.Connection.getEventsStreamed()');
-      res = await this.getRaw('events', queryParams);
+    } else {
+      // browser no fetch supports
+      console.log(
+        "WARNING: Browser does not support fetch() required by pryv.Connection.getEventsStreamed()"
+      );
+      res = await this.getRaw("events", queryParams);
       res.body.eventsCount = 0;
       if (res.body.events) {
         res.body.events.forEach(forEachEvent);
         res.body.eventsCount += res.body.events.length;
         delete res.body.events;
       }
-      if (res.body.eventDeletions) { // deletions are in a seprated Array
+      if (res.body.eventDeletions) {
+        // deletions are in a seprated Array
         res.body.eventDeletions.forEach(forEachEvent);
         res.body.eventsCount += res.body.eventDeletions.length;
         delete res.body.eventDeletions;
@@ -245,10 +335,10 @@ class Connection {
    * @param {Event} event
    * @param {string} filePath
    */
-  async createEventWithFile (event, filePath) {
-    const res = await this._post('events')
-      .field('event', JSON.stringify(event))
-      .attach('file', filePath);
+  async createEventWithFile(event, filePath) {
+    const res = await this._post("events")
+      .field("event", JSON.stringify(event))
+      .attach("file", filePath);
 
     const now = getTimestamp();
     this._handleMeta(res.body, now);
@@ -261,11 +351,12 @@ class Connection {
    * @param {Buffer|Blob} bufferData - Buffer for node, Blob for browser
    * @param {string} fileName
    */
-  async createEventWithFileFromBuffer (event, bufferData, filename) {
-    if (typeof window === 'undefined') { // node
-      const res = await this._post('events')
-        .field('event', JSON.stringify(event))
-        .attach('file', bufferData, filename);
+  async createEventWithFileFromBuffer(event, bufferData, filename) {
+    if (typeof window === "undefined") {
+      // node
+      const res = await this._post("events")
+        .field("event", JSON.stringify(event))
+        .attach("file", bufferData, filename);
 
       const now = getTimestamp();
       this._handleMeta(res.body, now);
@@ -273,21 +364,21 @@ class Connection {
     } else {
       /* global FormData */
       const formData = new FormData();
-      formData.append('file', bufferData, filename);
+      formData.append("file", bufferData, filename);
       const body = await this.createEventWithFormData(event, formData);
       return body;
     }
   }
 
   /**
- * Create an event with attached formData
- * !! BROWSER ONLY
- * @param {Event} event
- * @param {FormData} formData https://developer.mozilla.org/en-US/docs/Web/API/FormData/FormData
- */
-  async createEventWithFormData (event, formData) {
-    formData.append('event', JSON.stringify(event));
-    const res = await this._post('events').send(formData);
+   * Create an event with attached formData
+   * !! BROWSER ONLY
+   * @param {Event} event
+   * @param {FormData} formData https://developer.mozilla.org/en-US/docs/Web/API/FormData/FormData
+   */
+  async createEventWithFormData(event, formData) {
+    formData.append("event", JSON.stringify(event));
+    const res = await this._post("events").send(formData);
     return res.body;
   }
 
@@ -297,7 +388,7 @@ class Connection {
    * @readonly
    * @property {number} deltaTime
    */
-  get deltaTime () {
+  get deltaTime() {
     return this._deltaTime.value;
   }
 
@@ -306,17 +397,22 @@ class Connection {
    * @readonly
    * @property {APIEndpoint} deltaTime
    */
-  get apiEndpoint () {
+  get apiEndpoint() {
     return utils.buildAPIEndpoint(this);
   }
 
   // private method that handle meta data parsing
-  _handleMeta (res, requestLocalTimestamp) {
-    if (!res.meta) throw new Error('Cannot find .meta in response.');
-    if (!res.meta.serverTime) throw new Error('Cannot find .meta.serverTime in response.');
+  _handleMeta(res, requestLocalTimestamp) {
+    if (!res.meta) throw new Error("Cannot find .meta in response.");
+    if (!res.meta.serverTime)
+      throw new Error("Cannot find .meta.serverTime in response.");
 
     // update deltaTime and weight it
-    this._deltaTime.value = (this._deltaTime.value * this._deltaTime.weight + res.meta.serverTime - requestLocalTimestamp) / ++this._deltaTime.weight;
+    this._deltaTime.value =
+      (this._deltaTime.value * this._deltaTime.weight +
+        res.meta.serverTime -
+        requestLocalTimestamp) /
+      ++this._deltaTime.weight;
   }
 }
 

package/src/index.d.ts

@@ -575,8 +575,17 @@ declare module 'pryv' {
     username(): Promise<string>;
     api<Calls extends APICall[] = APICall[]>(
       apiCalls: Calls,
-      res?: APICallProgressHandler[],
+      progress?: APICallProgressHandler,
     ): Promise<Array<TypedAPICallResult>>;
+    apiOne(
+      method: keyof APICallMethods, 
+      params: APICallMethods[keyof APICallMethods], 
+    ): Promise<TypedAPICallResult>;
+    apiOne(
+      method: keyof APICallMethods, 
+      params: APICallMethods[keyof APICallMethods], 
+      expectedKey: string
+    ): Promise<TypedAPICallResult[keyof TypedAPICallResult]>;
     getEventsStreamed(
       queryParams: Partial<EventQueryParamsStreamQuery>,
       forEachEvent: StreamedEventsHandler,
@@ -598,8 +607,11 @@ declare module 'pryv' {
       id: Identifier,
       fields: string[],
       values: Array<string | number>,
-    ): Promise<void>;
+    ): Promise<any>;
     accessInfo(): Promise<AccessInfo>;
+    revoke(throwOnFail?: boolean, usingConnection?: Connection)
+    readonly deltaTime: number;
+    readonly apiEndpoint: string;
 
     post(
       path: string,
@@ -650,14 +662,27 @@ declare module 'pryv' {
     [key: string]: any;
   };
 
+  export class ServiceAssets {
+    static setup(pryvServiceAssetsSourceUrl: string): Promise<ServiceAssets>;
+    get(keyPath?: string): any;
+    getUrl(keyPath?: string): string;
+    relativeURL(url: string): string;
+    setAllDefaults(): Promise<void>;
+    setFavicon(): void;
+    loadCSS(): Promise<void>;
+    loginButtonLoadCSS(): Promise<void>;
+    loginButtonGetHTML(): Promise<string>;
+    loginButtonGetMessages(): Promise<KeyValue>;
+  }
+
   export class Service {
     constructor (
       serviceInfoUrl: string,
       serviceCustomizations?: serviceCustomizations,
     );
     info(forceFetch?: boolean): Promise<ServiceInfo>;
-    setServiceInfo(serviceInfo: Partial<ServiceInfo>): Promise<void>;
-    assets(forceFetch?: boolean): Promise<AssetsConfig>;
+    setServiceInfo(serviceInfo: Partial<ServiceInfo>): void;
+    assets(forceFetch?: boolean): Promise<ServiceAssets | null>;
     infoSync(): ServiceInfo | null;
     apiEndpointFor(username: string, token: string): Promise<string>;
     login(
@@ -666,6 +691,9 @@ declare module 'pryv' {
       appId: string,
       originHeader?: string,
     ): Promise<Connection>;
+
+    supportsHF(): Promise<boolean>;
+    isDnsLess(): Promise<boolean>;
   }
 
   export type AuthRequestedPermission = {
@@ -755,12 +783,13 @@ declare module 'pryv' {
   };
 
   export type CustomLoginButton = {
-    init?: () => Promise<void>;
-    getAuthorizationData(): string;
+    init?: () => Promise<Service>;
+    getAuthorizationData(): any;
     onStateChange(state: AuthStatePayload): Promise<void>;
     onClick(): void;
-    saveAuthorizationData?: (authData: string) => void;
+    saveAuthorizationData?: (authData: any) => void;
     deleteAuthorizationData?: () => Promise<void>;
+    finishAuthProcessAfterRedirection?: (authController: AuthController) => Promise<void>;
   }
 
   export class AuthController {
@@ -769,16 +798,15 @@ declare module 'pryv' {
       service: Service,
       loginButton: CustomLoginButton,
     );
-    init(): Promise<void>;
+    init(): Promise<Service>;
     stopAuthRequest(msg: string): void;
     handleClick(): Promise<void>;
     getReturnURL(
       returnURL: string,
-      windowLocationForTest: string,
-      navigatorForTests: string,
+      windowLocationForTest?: string,
+      navigatorForTests?: string,
     ): string | boolean;
     startAuthRequest(): Promise<any>;
-    doPolling(): Promise<void>;
     set state(newState: AuthStatePayload);
     get state(): AuthStatePayload;
   }
@@ -805,7 +833,7 @@ declare module 'pryv' {
 
   export type TokenAndAPIEndpoint = {
     endpoint: string;
-    token: string;
+    token: string | null;
   };
 
   export const utils: {
@@ -820,6 +848,32 @@ declare module 'pryv' {
   type version = string;
 
   let pryv: {
+    Service: typeof Service;
+    Connection: typeof Connection;
+    Auth: {
+      setupAuth: SetupAuth;
+      AuthStates: AuthStates;
+      AuthController: typeof AuthController;
+    };
+    Browser: {
+      LoginButton: CustomLoginButton;
+      CookieUtils: {
+        set(cookieKey: string, value: any, expireInDays: number): void;
+        get(cookieKey: string): any;
+        del(cookieKey: string): void;
+      };
+      AuthStates: AuthStates;
+      setupAuth: SetupAuth;
+      serviceInfoFromUrl: getServiceInfoFromURL;
+    };
+    utils: {
+      isBrowser(): boolean;
+      extractTokenAndAPIEndpoint(apiEndpoint: string): TokenAndAPIEndpoint;
+      buildAPIEndpoint(tokenAndAPI: TokenAndAPIEndpoint): string;
+      browserIsMobileOrTablet(navigator: string): boolean;
+      cleanURLFromPrYvParams(url: string): string;
+      getQueryParamsFromURL(url: string): KeyValue;
+    };
     version: version;
   };
 

package/test/Connection.test.js

@@ -89,6 +89,18 @@ describe('Connection', () => {
     });
   });
 
+  describe('.apiOne()', function () {
+    this.timeout(15000);
+    it('.apiOne("events.get")', async () => {
+      const res = await conn.apiOne('events.get');
+      expect(res.events).to.exist;
+    });
+     it('.apiOne("events.get")', async () => {
+      const res = await conn.apiOne('events.get', {}, 'events');
+      expect(Array.isArray(res)).to.equal(true);
+    });
+  });
+
   describe('.api()', function () {
     this.timeout(15000);
     it('.api() events.get', async () => {