pryv 3.5.0 → 3.6.1

package/README.md

@@ -733,7 +733,15 @@ Assuming browser files are built and everything is up-to-date, including the REA
 ```
 just version <version>
 ```
-to update the version number of the lib and add-ons in lockstep, git commit and tag included
+to update the version number of the lib and add-ons in lockstep. This only edits the `package.json` files — **commit and tag manually**:
+
+```
+git commit -am "<version>"
+git tag -a <version> -m "<version>"
+git push && git push --tags
+```
+
+Tags are bare version numbers (e.g. `3.6.0`, no `v` prefix); every npm publish must have a matching pushed tag so npm, `package.json` and GitHub stay cross-checkable.
 
 ```
 just publish-npm

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pryv",
-  "version": "3.5.0",
+  "version": "3.6.1",
   "description": "Pryv JavaScript library",
   "keywords": [
     "Pryv",

package/src/Browser/LoginButton.js

@@ -126,6 +126,11 @@ class LoginButton {
           error: e
         };
       }
+      // The prYv* params are one-shot; leaving them in the visible URL
+      // puts stale auth state into bookmarks / copied links.
+      if (window.history && typeof window.history.replaceState === 'function') {
+        window.history.replaceState(null, '', utils.cleanURLFromPrYvParams(url));
+      }
     }
 
     function retrievePollUrl (url) {

package/src/Connection.js

@@ -8,6 +8,7 @@ const libGetEventStreamed = require('./lib/getEventStreamed');
 const PryvError = require('./lib/PryvError');
 const StaleAccessIdError = require('./lib/StaleAccessIdError');
 const buildSearchParams = require('./lib/buildSearchParams');
+const resolveDotPath = require('./lib/resolveDotPath');
 
 /**
  * @class Connection
@@ -350,6 +351,44 @@ class Connection {
     return res.body;
   }
 
+  /**
+   * Get the latest event per value for a content path — typical form-prefill
+   * lookup ("latest assertion per code"). Queries `events.get` with a
+   * `content` condition `{ path, in: values }` (server must support content
+   * queries — see `Service.supportsContentQueries()`), pages through the
+   * time-descending result and keeps the first (= latest) event per value.
+   * Handles paging internally, so the result is correct regardless of the
+   * default `events.get` page size.
+   * @param {string} path - dot-path into `content` (or `$` for the root value)
+   * @param {Array<string|number|boolean>} values - values to look up (one Map entry max per value)
+   * @param {Object} [baseQuery] - additional `events.get` params (e.g. `streams`, `types`, `fromTime`); passed through
+   * @returns {Promise<Map<string|number|boolean, Object>>} value → latest matching event; values with no match are absent
+   */
+  async getLatestByContent (path, values, baseQuery = {}) {
+    const PAGE_LIMIT = 1000;
+    const lookup = new Set(values);
+    const found = new Map();
+    const condition = { path, in: [...lookup] };
+    const content = (baseQuery.content || []).concat([condition]);
+    let skip = 0;
+    while (found.size < lookup.size) {
+      const params = Object.assign({}, baseQuery, {
+        content,
+        sortAscending: false,
+        skip,
+        limit: PAGE_LIMIT
+      });
+      const events = await this.apiOne('events.get', params, 'events');
+      for (const event of events) {
+        const value = resolveDotPath(event.content, path);
+        if (lookup.has(value) && !found.has(value)) found.set(value, event);
+      }
+      if (events.length < PAGE_LIMIT) break;
+      skip += events.length;
+    }
+    return found;
+  }
+
   /**
    * Create an event with attached file
    * NODE.jS ONLY

package/src/Service.js

@@ -80,6 +80,17 @@ class Service {
     return (infos.features == null || infos.features.noHF !== true);
   }
 
+  /**
+   * Whether the platform supports `events.get` content/clientData query
+   * conditions (`features.contentQueries` in service info). Older platforms
+   * reject the parameters with a 400 — use this to pick a fallback path.
+   * @returns {Promise<boolean>}
+   */
+  async supportsContentQueries () {
+    const infos = await this.info();
+    return infos.features != null && infos.features.contentQueries === true;
+  }
+
   /**
    * Check if a service has username in the hostname or in the path of the API.
    * @returns {Promise<boolean>} Promise resolving to true if the service does not rely on DNS to find a host related to a username
@@ -395,9 +406,9 @@ class Service {
         email: opts.email,
         hosting,
         language,
-        invitationToken
+        invitationToken,
+        ...(opts.referer != null && { referer: opts.referer })
       };
-      if (opts.referer != null) payload.referer = opts.referer;
     } else {
       url = serviceInfo.register + 'user';
       payload = {
@@ -407,9 +418,9 @@ class Service {
         email: opts.email,
         hosting,
         languageCode: language,
-        invitationtoken: invitationToken
+        invitationtoken: invitationToken,
+        ...(opts.referer != null && { referer: opts.referer })
       };
-      if (opts.referer != null) payload.referer = opts.referer;
     }
     const { response, body } = await utils.fetchPost(url, payload);
     if (!response.ok) throw PryvError.fromApiResponse(response, body);
@@ -618,8 +629,10 @@ const Connection = require('./Connection');
  * @property {string} support The email or URL of the support page.
  * @property {string} terms The terms and conditions, in plain text or the URL displaying them.
  * @property {string} eventTypes The URL of the list of validated event types.
+ * @property {string} [version] The platform version.
  * @property {Object} [assets] Holder for service specific Assets (icons, css, ...)
  * @property {string} [assets.definitions] URL to json object with assets definitions
  * @property {Object} [features] Platform feature flags
  * @property {boolean} [features.noHF] True if HF data is not supported
+ * @property {boolean} [features.contentQueries] True if events.get content/clientData query conditions are supported
  */

package/src/index.d.ts

@@ -100,20 +100,6 @@ declare module 'pryv' {
     };
   };
 
-  // HTTP only
-  type AuditLog = {
-    id: Identifier;
-    type: string;
-    time: Timestamp;
-    forwardedFor: string;
-    action: string;
-    query: string;
-    accessId: string;
-    status: number;
-    errorMessage?: string;
-    errorId?: string;
-  };
-
   export type HFSeries = {
     format: 'flatJSON';
     fields: string[];
@@ -267,6 +253,22 @@ declare module 'pryv' {
     not?: Identifier[];
   };
 
+  /**
+   * Condition on a JSON path of events' `content` or `clientData`.
+   * `path` is a dot-path (segments: [a-zA-Z0-9_:-]) or `$` for the root
+   * value; exactly one operator per condition. Conditions AND together.
+   * Server support is advertised by `features.contentQueries` (see
+   * `Service.supportsContentQueries()`).
+   */
+  export type ContentQueryCondition = { path: string } & (
+    | { eq: string | number | boolean }
+    | { neq: string | number | boolean }
+    | { in: Array<string | number | boolean> }
+    | { exists: boolean }
+    | { gt: number } | { gte: number } | { lt: number } | { lte: number }
+    | { prefix: string }
+  );
+
   export type EventQueryParams = {
     fromTime: Timestamp;
     toTime: Timestamp;
@@ -280,6 +282,8 @@ declare module 'pryv' {
     state: 'default' | 'trashed' | 'all';
     modifiedSince: Timestamp;
     includeDeletion: boolean;
+    content: ContentQueryCondition[];
+    clientData: ContentQueryCondition[];
   };
 
   export type EventQueryParamsStreamQuery = Omit<EventQueryParams, 'streams'> & {
@@ -705,6 +709,15 @@ declare module 'pryv' {
       queryParams: Partial<EventQueryParamsStreamQuery>,
       forEachEvent: StreamedEventsHandler,
     ): Promise<StreamedEventsResult>;
+    /**
+     * Latest event per value for a content path (form-prefill lookup).
+     * Pages internally; requires server content-query support.
+     */
+    getLatestByContent(
+      path: string,
+      values: Array<string | number | boolean>,
+      baseQuery?: Partial<EventQueryParamsStreamQuery>,
+    ): Promise<Map<string | number | boolean, Event>>;
     createEventWithFile(
       params: EventFileCreationParams,
       filePath: string | Buffer | Blob,
@@ -826,6 +839,8 @@ declare module 'pryv' {
     ): Promise<Connection>;
 
     supportsHF(): Promise<boolean>;
+    /** Whether the platform supports events.get content/clientData query conditions. */
+    supportsContentQueries(): Promise<boolean>;
     isDnsLess(): Promise<boolean>;
 
     userExists(userId: string): Promise<boolean>;

package/src/lib/buildSearchParams.js

@@ -4,8 +4,12 @@
  */
 
 /**
- * Build URL search params string from an object, properly handling arrays.
- * Arrays are expanded as repeated keys: { a: ['x', 'y'] } => 'a=x&a=y'
+ * Build URL search params string from an object, properly handling arrays
+ * and structured values.
+ * - Arrays of scalars are expanded as repeated keys: { a: ['x', 'y'] } => 'a=x&a=y'
+ * - Arrays containing objects (e.g. `content` / `clientData` conditions,
+ *   rich `streams` queries) and plain objects are sent as one
+ *   JSON-encoded parameter, which the API parses back.
  * @param {Object} params - Query parameters object
  * @returns {string} - URL encoded query string
  */
@@ -13,9 +17,15 @@ function buildSearchParams (params) {
   const searchParams = new URLSearchParams();
   for (const [key, value] of Object.entries(params)) {
     if (Array.isArray(value)) {
-      for (const item of value) {
-        searchParams.append(key, item);
+      if (value.some((item) => item !== null && typeof item === 'object')) {
+        searchParams.append(key, JSON.stringify(value));
+      } else {
+        for (const item of value) {
+          searchParams.append(key, item);
+        }
       }
+    } else if (value !== null && typeof value === 'object') {
+      searchParams.append(key, JSON.stringify(value));
     } else if (value !== undefined && value !== null) {
       searchParams.append(key, value);
     }

package/src/lib/getEventStreamed.js

@@ -33,6 +33,7 @@ async function getEventStreamed (conn, queryParam, parser) {
   /**
    * Holds results from the parser
    */
+  /** @type {(Error & { rawResponse?: string }) | undefined} */
   let errResult;
   let bodyObjectResult;
   /**

package/src/lib/resolveDotPath.js

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+
+/**
+ * Resolve a content-query dot-path against a JSON value.
+ * `$` addresses the root value itself. Returns `undefined` when the path
+ * does not lead to a value.
+ * @param {*} root - The JSON value (typically an event's `content`)
+ * @param {string} path - Dot-path (e.g. 'drug.codes.atc') or '$'
+ * @returns {*} The value at the path, or undefined
+ */
+function resolveDotPath (root, path) {
+  if (path === '$') return root;
+  let current = root;
+  for (const segment of path.split('.')) {
+    if (current == null || typeof current !== 'object' || Array.isArray(current)) return undefined;
+    if (!Object.prototype.hasOwnProperty.call(current, segment)) return undefined;
+    current = current[segment];
+  }
+  return current;
+}
+
+module.exports = resolveDotPath;

package/test/ContentQueries.test.js

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, expect, pryv */
+
+const { createId: cuid } = require('@paralleldrive/cuid2');
+const testData = require('../../../test/test-data');
+
+const buildSearchParams = require('../src/lib/buildSearchParams');
+const resolveDotPath = require('../src/lib/resolveDotPath');
+
+describe('[CQLJ] Content queries', () => {
+  describe('[CQLU] buildSearchParams structured values', () => {
+    it('[LU01] keeps scalar arrays as repeated keys', () => {
+      expect(buildSearchParams({ a: ['x', 'y'], b: 1 })).to.equal('a=x&a=y&b=1');
+    });
+
+    it('[LU02] JSON-encodes arrays of objects (conditions) as one parameter', () => {
+      const conditions = [{ path: 'drug.codes.atc', eq: 'G03DA04' }];
+      const out = buildSearchParams({ content: conditions });
+      expect(decodeURIComponent(out)).to.equal('content=' + JSON.stringify(conditions));
+    });
+
+    it('[LU03] JSON-encodes plain object values', () => {
+      const out = buildSearchParams({ streams: { any: ['a'] } });
+      expect(decodeURIComponent(out.replace(/\+/g, ' '))).to.equal('streams=' + JSON.stringify({ any: ['a'] }));
+    });
+  });
+
+  describe('[CQLR] resolveDotPath', () => {
+    it('[LR01] resolves nested paths, root $ and misses', () => {
+      const content = { drug: { codes: { atc: 'G03DA04' } }, taken: true };
+      expect(resolveDotPath(content, 'drug.codes.atc')).to.equal('G03DA04');
+      expect(resolveDotPath(content, 'taken')).to.equal(true);
+      expect(resolveDotPath(content, 'drug.codes.snomed')).to.equal(undefined);
+      expect(resolveDotPath(14.2, '$')).to.equal(14.2);
+      expect(resolveDotPath(undefined, 'a.b')).to.equal(undefined);
+      expect(resolveDotPath({ a: [1] }, 'a.0')).to.equal(undefined); // no array indices
+    });
+  });
+
+  describe('[CQLI] against a live platform (skipped when unsupported)', () => {
+    let conn, supported, streamId;
+    const codes = { progesterone: 'G03DA04', aspirin: 'B01AC06', missing: 'N02BE01' };
+
+    before(async function () {
+      this.timeout(15000);
+      await testData.prepare();
+      conn = new pryv.Connection(testData.apiEndpointWithToken);
+      supported = await conn.service.supportsContentQueries();
+      if (!supported) return;
+
+      streamId = 'cq-' + cuid().substring(0, 8);
+      const calls = [{ method: 'streams.create', params: { id: streamId, name: 'CQ ' + streamId, parentId: 'data' } }];
+      // two assertions per drug — older taken:false, newer taken:true — to verify "latest"
+      let time = 1700000000;
+      for (const code of [codes.progesterone, codes.aspirin]) {
+        calls.push({ method: 'events.create', params: { streamIds: [streamId], type: 'medication/exposure-assertion-v1', time: time++, content: { drug: { codes: { atc: code } }, taken: false } } });
+        calls.push({ method: 'events.create', params: { streamIds: [streamId], type: 'medication/exposure-assertion-v1', time: time++, content: { drug: { codes: { atc: code } }, taken: true } } });
+      }
+      const res = await conn.api(calls);
+      for (const r of res) expect(r.error).to.be.undefined;
+    });
+
+    it('[LI01] supportsContentQueries returns a boolean', async () => {
+      expect(typeof supported).to.equal('boolean');
+    });
+
+    it('[LI02] events.get accepts content conditions via GET (streamed)', async function () {
+      if (!supported) this.skip();
+      const collected = [];
+      await conn.getEventsStreamed(
+        { streams: [streamId], content: [{ path: 'drug.codes.atc', eq: codes.progesterone }, { path: 'taken', eq: true }] },
+        (event) => collected.push(event)
+      );
+      expect(collected.length).to.equal(1);
+      expect(collected[0].content.taken).to.equal(true);
+    });
+
+    it('[LI03] getLatestByContent returns the latest event per value', async function () {
+      if (!supported) this.skip();
+      const byCode = await conn.getLatestByContent(
+        'drug.codes.atc',
+        [codes.progesterone, codes.aspirin, codes.missing],
+        { streams: [streamId] }
+      );
+      expect(byCode.size).to.equal(2);
+      expect(byCode.get(codes.missing)).to.be.undefined;
+      // latest per code is the taken:true one (created later)
+      expect(byCode.get(codes.progesterone).content.taken).to.equal(true);
+      expect(byCode.get(codes.aspirin).content.taken).to.equal(true);
+    });
+  });
+});

package/test/LoginButton.urlCleanup.test.js

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, after, expect, JSDOM */
+
+const LoginButton = require('../src/Browser/LoginButton');
+const utils = require('../src/utils');
+
+describe('[LBRU] LoginButton URL cleanup after redirect', function () {
+  const PAGE_URL = 'http://localhost/app?x=1&prYvpoll=http%3A%2F%2Flocalhost%2Fpoll%2Fkey123&prYvstatus=ACCEPTED';
+  let dom;
+  let cleanupDom = false;
+  let originalFetchGet;
+
+  before(() => {
+    if (typeof document === 'undefined') {
+      cleanupDom = true;
+      dom = new JSDOM('<!DOCTYPE html><body></body>', { url: PAGE_URL });
+      global.document = dom.window.document;
+      global.window = dom.window;
+      global.location = dom.window.location;
+      global.navigator = { userAgent: 'Safari' };
+    }
+    originalFetchGet = utils.fetchGet;
+    utils.fetchGet = async () => ({ body: { status: 'ACCEPTED' } });
+  });
+
+  after(() => {
+    utils.fetchGet = originalFetchGet;
+    if (!cleanupDom) return;
+    delete global.document;
+    delete global.window;
+    delete global.location;
+    delete global.navigator;
+  });
+
+  it('[LBR1] strips consumed prYv* params from the visible URL', async () => {
+    const authController = { serviceInfo: {} };
+    await LoginButton.prototype.finishAuthProcessAfterRedirection.call({}, authController);
+    expect(authController.state).to.eql({ status: 'ACCEPTED' });
+    expect(global.window.location.href).to.equal('http://localhost/app?x=1');
+  });
+});