@icure/api 6.4.0 → 7.0.0-beta.0

package/icc-x-api/utils/lru-temporised-async-cache.ts

@@ -0,0 +1,133 @@
+export class LruTemporisedAsyncCache<K, V> {
+  private readonly maxCacheSize: number
+  private readonly lifetimeForValue: (value: V) => number
+
+  private readonly nodesMap: Map<K, CacheNode<K, V>> = new Map()
+  private firstNode: CacheNode<K, V> | null = null
+  private lastNode: CacheNode<K, V> | null = null
+
+  /**
+   * @param maxCacheSize Maximum size of the cache. Any value <= 0 is considered as no limit.
+   * @param lifetimeForValue Get the maximum lifetime for an entry given its value.
+   */
+  constructor(maxCacheSize: number, lifetimeForValue: (value: V) => number) {
+    this.maxCacheSize = maxCacheSize
+    this.lifetimeForValue = lifetimeForValue
+  }
+
+  /**
+   * Gets a cached value or retrieves it and caches it if the value is not available or if it is available but expired. A value will never be expired
+   * if it was not yet retrieved, even if the retrieved value would be expired according to the {@link additionalExpirationCondition}
+   * @param key key of the entry
+   * @param retrieve given the previous value (if available, expired but not yet removed) of the entry retrieves an updated value.
+   * @param additionalExpirationCondition an expiration condition for already cached values to consider in addition to time-based expiration. Returns
+   * always false by default, meaning the value is not expired if its lifetime didn't already surpass the maximum lifetime.
+   * @return the cached value if present and not expired, else the retrieved value.
+   */
+  get(
+    key: K,
+    retrieve: (previousValue: V | undefined) => Promise<V>,
+    additionalExpirationCondition: (value: V) => boolean = () => false
+  ): Promise<V> {
+    const retrieved = this.nodesMap.get(key)
+    if (retrieved !== undefined) {
+      this.markUsed(retrieved)
+      const cachedValue = retrieved.cachedValue
+      if (retrieved.expired((x) => this.lifetimeForValue(x)) || (cachedValue !== undefined && additionalExpirationCondition(cachedValue))) {
+        retrieved.value = this.registerJob(key, () => retrieve(cachedValue))
+      }
+      return retrieved.valuePromise()
+    } else {
+      const newNode = new CacheNode(
+        key,
+        this.lastNode,
+        null,
+        this.registerJob(key, () => retrieve(undefined))
+      )
+      this.addToTail(key, newNode)
+      if (this.maxCacheSize > 0 && this.nodesMap.size > this.maxCacheSize) this.evict(this.firstNode!.key, this.firstNode!)
+      return newNode.valuePromise()
+    }
+  }
+
+  clear() {
+    this.firstNode = null
+    this.lastNode = null
+    this.nodesMap.clear()
+  }
+
+  private addToTail(key: K | null, node: CacheNode<K, V>) {
+    node.previous = this.lastNode
+    node.next = null
+    if (this.lastNode) this.lastNode.next = node
+    this.lastNode = node
+    if (this.firstNode === null) this.firstNode = node
+    if (key != null) this.nodesMap.set(key, node)
+  }
+
+  private evict(key: K | null, node: CacheNode<K, V>) {
+    if (node.previous) node.previous.next = node.next
+    if (node.next) node.next.previous = node.previous
+    if (this.firstNode === node) this.firstNode = node.next
+    if (this.lastNode === node) this.lastNode = node.previous
+    if (key !== null) this.nodesMap.delete(key)
+  }
+
+  private markUsed(node: CacheNode<K, V>) {
+    if (node !== this.lastNode) {
+      // No need to modify the nodes map
+      this.evict(null, node)
+      this.addToTail(null, node)
+    }
+  }
+
+  private registerJob(key: K, retrieve: () => Promise<V>): Promise<V> {
+    // The node may have already been evicted by the time the promise completed if the cached surpassed the maximum size.
+    return retrieve()
+      .then((v) => {
+        const node = this.nodesMap.get(key)
+        if (node) {
+          node.value = { cached: v, timestamp: Date.now() }
+        }
+        return v
+      })
+      .catch((e) => {
+        const node = this.nodesMap.get(key)
+        if (node) {
+          this.evict(key, node)
+        }
+        throw e
+      })
+  }
+}
+
+type Cached<V> = { cached: V; timestamp: number }
+
+class CacheNode<K, V> {
+  readonly key: K
+  previous: CacheNode<K, V> | null
+  next: CacheNode<K, V> | null
+  value: Promise<V> | Cached<V>
+
+  constructor(key: K, previous: CacheNode<K, V> | null, next: CacheNode<K, V> | null, value: Promise<V>) {
+    this.key = key
+    this.previous = previous
+    this.next = next
+    this.value = value
+  }
+
+  expired(lifetimeForValue: (value: V) => number): boolean {
+    if ('timestamp' in this.value) {
+      const maxLifetime = lifetimeForValue(this.value.cached)
+      return maxLifetime > 0 && Date.now() - this.value.timestamp > maxLifetime
+    } else return false
+  }
+
+  valuePromise(): Promise<V> {
+    return 'timestamp' in this.value ? Promise.resolve(this.value.cached) : this.value
+  }
+
+  get cachedValue(): V | undefined {
+    return 'timestamp' in this.value ? this.value.cached : undefined
+  }
+}

package/icc-x-api/utils/net-utils.ts

@@ -0,0 +1,243 @@
+export type PaginatorFunction<X> = (key: any, docId: string | null, limit: number | undefined) => Promise<PaginatorResponse<X>>
+
+export type PaginatorExecutor<X> = (
+  latestPaginatorFunctionResult: PaginatorResponse<X>,
+  acc: any[],
+  limit: number | undefined
+) => Promise<PaginatorResponse<X>>
+
+export interface PaginatorResponse<X> {
+  rows: Array<X>
+  nextKey: any | null | undefined
+  nextDocId: string | null | undefined
+  done: boolean
+}
+
+export interface RowsChunk<X> {
+  startIdx: number
+  endIdx: number
+  rows: Array<X>
+  nextKey: any | null
+  nextDocId: string | null
+}
+
+export interface MissingRowsChunk<X> {
+  missing: [number, number]
+  lastEndIdx: number
+  lastKey: any | null
+  lastDocId: string | null
+  rows?: Array<X> // Is going to be filled when we go through all missing rows chunks
+}
+
+export function sleep(ms: number): Promise<any> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export function retry<P>(fn: () => Promise<P>, retryCount = 3, sleepTime = 1000, exponentialFactor = 1): Promise<P> {
+  let retry = 0
+  const doFn: () => Promise<P> = () => {
+    return fn().catch((e) =>
+      retry++ < retryCount ? (sleepTime && sleep((sleepTime *= exponentialFactor)).then(() => doFn())) || doFn() : Promise.reject(e)
+    )
+  }
+  return doFn()
+}
+
+export async function getRowsUsingPagination<X>(
+  paginator: PaginatorFunction<X>,
+  filter?: (value: X, idx: number, array: Array<X>) => boolean,
+  startIdx?: number,
+  endIdx?: number,
+  cache?: Array<RowsChunk<X>>
+): Promise<Array<X>> {
+  const executePaginator: PaginatorExecutor<X> = async (latestResult: PaginatorResponse<X>, acc: Array<X>, limit: number | undefined) => {
+    const newResult = await paginator(
+      latestResult.nextKey || null,
+      latestResult.nextDocId || null,
+      endIdx && startIdx ? endIdx - startIdx : undefined
+    )
+    const rows = (filter ? newResult.rows && newResult.rows.filter(filter) : newResult.rows) || []
+    acc.push(...rows)
+    if (newResult.done || (limit && acc.length >= limit)) {
+      return {
+        rows: acc,
+        nextKey: newResult.nextKey,
+        nextDocId: newResult.nextDocId,
+        done: false,
+      }
+    } else {
+      return executePaginator(newResult, acc, limit)
+    }
+  }
+
+  if (cache && startIdx && endIdx) {
+    // Go through cache and build a list of existing rows (RowsChunks) and missing rows (MissingRowChunks)
+    // The cache is a sparse structure sorted by index
+    // At first, the cache is empty rows is going to be equal to [] and everything will be missing (see empty rows situation below)
+    const [rows, lastKey, lastDocId, lastEndIdx] = cache.reduce(
+      (
+        [rows, lastKey, lastDocId, lastEndIdx, lastTreatedIdx]: [
+          Array<RowsChunk<X> | MissingRowsChunk<X>>,
+          any | null,
+          string | null,
+          number,
+          number
+        ],
+        chunk
+      ) => {
+        const startOfZoi = lastTreatedIdx
+        const endOfZoi = endIdx
+
+        if (chunk.endIdx <= startOfZoi) {
+          //           [--zoi--] // Zone of interest starts at startOfZoi, ends at endIdx
+          // [-chunk-]
+          // Doesn't look like anything to me
+        } else if (chunk.startIdx >= endIdx) {
+          // [--zoi--]
+          //           [-chunk-]
+          if (startOfZoi < endIdx) {
+            rows.push({
+              missing: [startOfZoi, endIdx],
+              lastEndIdx,
+              lastKey,
+              lastDocId,
+            })
+            lastTreatedIdx = endOfZoi
+          }
+        } else {
+          if (chunk.startIdx <= lastTreatedIdx) {
+            if (chunk.endIdx <= endIdx) {
+              //       [--zoi--]
+              // [-chunk-]
+              rows.push({
+                startIdx: startOfZoi,
+                endIdx: chunk.endIdx,
+                rows: chunk.rows.slice(startOfZoi - chunk.startIdx, chunk.endIdx - chunk.startIdx),
+                nextKey: null,
+                nextDocId: null,
+              })
+              lastTreatedIdx = chunk.endIdx
+            } else {
+              //       [--zoi--]
+              // [------chunk------]
+              rows.push({
+                startIdx: startOfZoi,
+                endIdx: endOfZoi,
+                rows: chunk.rows.slice(startOfZoi - chunk.startIdx, endOfZoi - chunk.startIdx),
+                nextKey: null,
+                nextDocId: null,
+              })
+              lastTreatedIdx = endOfZoi
+            }
+          } else {
+            //  [--zoi--]
+            //        [-chunk-]
+            if (chunk.endIdx >= endOfZoi) {
+              rows.push({
+                missing: [startOfZoi, chunk.startIdx],
+                lastEndIdx,
+                lastKey,
+                lastDocId,
+              })
+              rows.push({
+                startIdx: chunk.startIdx,
+                endIdx: endOfZoi,
+                rows: chunk.rows.slice(0, endOfZoi - chunk.startIdx),
+                nextKey: null,
+                nextDocId: null,
+              })
+              lastTreatedIdx = endOfZoi
+            } else {
+              //  [-------zoi-------]
+              //       [-chunk-]
+              rows.push({
+                missing: [startOfZoi, chunk.startIdx],
+                lastEndIdx,
+                lastKey,
+                lastDocId,
+              })
+              rows.push({
+                startIdx: chunk.startIdx,
+                endIdx: chunk.endIdx,
+                rows: chunk.rows.slice(0, chunk.endIdx - chunk.startIdx),
+                nextKey: null,
+                nextDocId: null,
+              })
+              lastTreatedIdx = chunk.endIdx
+            }
+          }
+        }
+        return [rows, chunk.nextKey, chunk.nextDocId, chunk.endIdx, lastTreatedIdx]
+      },
+      [[], null, null, 0, startIdx || 0]
+    )
+    if (!rows.length) {
+      rows.push({
+        missing: [startIdx, endIdx],
+        lastKey: lastKey,
+        lastDocId: lastDocId,
+        lastEndIdx: lastEndIdx,
+      })
+    } else {
+      const lastRow = rows.length ? rows[rows.length - 1] : undefined
+      if (lastRow && lastRow.rows && (lastRow as RowsChunk<X>).startIdx + lastRow.rows.length < endIdx) {
+        rows.push({
+          missing: [(lastRow as RowsChunk<X>).startIdx + lastRow.rows.length, endIdx],
+          lastKey: lastKey,
+          lastDocId: lastDocId,
+          lastEndIdx: lastEndIdx,
+        })
+      }
+    }
+
+    // Once we we have determined which where the missing chunks. Go fetch them based on the lastKey/lastDocId + the limit computed with the lastEndIndex
+    await Promise.all(
+      rows
+        .filter((r: any) => r.missing)
+        .map(async (r: any) => {
+          const missing = r as MissingRowsChunk<X>
+          const { rows, nextKey, nextDocId } = await executePaginator(
+            {
+              nextKey: missing.lastKey,
+              nextDocId: missing.lastDocId,
+              rows: [],
+              done: false,
+            },
+            [],
+            missing.missing[1] - missing.lastEndIdx
+          )
+
+          missing.rows = rows.slice(missing.missing[0] - missing.lastEndIdx, missing.missing[1] - missing.lastEndIdx)
+          cache[missing.lastEndIdx] = {
+            rows,
+            startIdx: missing.missing[0],
+            endIdx: missing.missing[1],
+            nextKey: nextKey || null,
+            nextDocId: nextDocId || null,
+          }
+        })
+    )
+    return (rows || []).reduce(
+      (acc: X[], r: MissingRowsChunk<X> | RowsChunk<X>) =>
+        r.rows
+          ? r.rows.reduce((acc, r) => {
+              acc.push(r)
+              return acc
+            }, acc)
+          : acc,
+      []
+    )
+  } else {
+    const { rows } = await executePaginator(
+      {
+        nextKey: null,
+        nextDocId: null,
+        rows: [],
+        done: false,
+      },
+      [],
+      undefined
+    )
+    return rows
+  }
+}

package/icc-x-api/utils/person-util.ts

@@ -0,0 +1,29 @@
+import * as models from '../../icc-api/model/models'
+
+export function hasName(person: models.Patient | models.HealthcareParty, nameUse: models.PersonName.UseEnum) {
+  return person.names?.some((n) => n.use === nameUse)
+}
+
+export function findName(person: models.Patient | models.HealthcareParty, nameUse: models.PersonName.UseEnum): models.PersonName | undefined {
+  return person.names?.find((n) => n.use === nameUse)
+}
+
+export function garnishPersonWithName<P extends models.Patient | models.HealthcareParty>(
+  person: P,
+  nameUse: models.PersonName.UseEnum,
+  lastName?: string,
+  firstName?: string,
+  fullName: string = `${lastName} ${firstName ?? ''}`
+): P {
+  return {
+    ...person,
+    names: (person.names ?? []).concat([
+      new models.PersonName({
+        lastName: lastName,
+        firstNames: firstName ? [firstName] : [],
+        text: fullName,
+        use: nameUse,
+      }),
+    ]),
+  }
+}

package/icc-x-api/utils/uuid-encoder.ts

@@ -0,0 +1,127 @@
+import * as bigInt from 'big-integer'
+
+const knownBases: { [key: string]: string } = {
+  // pragma: allowlist nextline secret
+  base64: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/',
+  // pragma: allowlist nextline secret
+  base62: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+  // pragma: allowlist nextline secret
+  base58: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz', // Bitcoin base58
+  // pragma: allowlist nextline secret
+  base36: '0123456789abcdefghijklmnopqrstuvwxyz',
+  // pragma: allowlist nextline secret
+  base32: '0123456789abcdefghjkmnpqrstvwxyz', // Crockford's base32
+  // pragma: allowlist nextline secret
+  base16: '0123456789abcdef',
+  // pragma: allowlist nextline secret
+  base10: '0123456789',
+  base2: '01',
+}
+
+const caseSensitiveBases: { [key: string]: boolean } = {
+  base62: true,
+  base58: true,
+  base36: false,
+  base32: false,
+  base16: false,
+  base10: true,
+  base2: true,
+}
+
+export class UuidEncoder {
+  private encStr: string = knownBases.base36
+  private isCaseSensitive = false
+  private base = 36
+  /**
+   * @public
+   * @param [baseEncodingStr] A string containing all usable letters for encoding
+   * @constructor
+   */
+  constructor(baseEncodingStr = 'base36') {
+    this.setBaseEncodingStr(baseEncodingStr)
+  }
+
+  /**
+   * Set encoding base
+   * @param {string} baseEncodingStr A string containing all usable letters for encoding
+   * @public
+   */
+  setBaseEncodingStr(baseEncodingStr: string) {
+    this.encStr = UuidEncoder.resolveEncodingStr(baseEncodingStr)
+    this.isCaseSensitive = UuidEncoder.isCaseSensitiveBase(baseEncodingStr)
+    this.base = this.encStr.length
+  }
+
+  /**
+   * @private
+   * @param {string} baseEncodingStr
+   * @returns {string}
+   */
+  static resolveEncodingStr(baseEncodingStr: string) {
+    return Object.prototype.hasOwnProperty.call(knownBases, baseEncodingStr) ? knownBases[baseEncodingStr] : baseEncodingStr
+  }
+
+  /**
+   * @public
+   * @param baseEncodingStr
+   * @returns {boolean}
+   */
+  static isCaseSensitiveBase(baseEncodingStr: string) {
+    return Object.prototype.hasOwnProperty.call(caseSensitiveBases, baseEncodingStr) ? caseSensitiveBases[baseEncodingStr] : true
+  }
+
+  /**
+   * Encode a UUID
+   * @param {string} uuid Properly formatted UUID
+   * @returns {string} Encoded UUID
+   * @public
+   */
+  encode(uuid: string) {
+    const cleanUuid = uuid.replace(/-/g, '')
+    const { base, encStr } = this
+
+    let iUuid = bigInt(cleanUuid, 16)
+    let str = ''
+
+    do {
+      str = encStr.substr(iUuid.mod(base).valueOf(), 1) + str
+      iUuid = iUuid.divide(base)
+    } while (iUuid.greater(0))
+
+    return str
+  }
+
+  /**
+   * Decode an encoded UUID
+   * @public
+   * @param {string} str Previously encoded string
+   * @returns {string} Properly formatted UUID
+   * @throws Throws an {Error} when encountering invalid data
+   */
+  decode(str: string) {
+    let iUuid = bigInt(0)
+
+    const { base, encStr } = this
+    const len = str.length
+    const finalStr = this.isCaseSensitive ? str : str.toLowerCase()
+
+    for (let pos = 0; pos < len; pos += 1) {
+      const ch = finalStr.substr(pos, 1)
+      const encPos = encStr.indexOf(ch)
+
+      if (encPos < 0) {
+        throw new Error('Invalid encoded data')
+      }
+
+      iUuid = iUuid.add(encPos)
+
+      if (pos < len - 1) {
+        iUuid = iUuid.multiply(base)
+      }
+    }
+
+    const uuid = iUuid.toString(16).padStart(32, '0')
+
+    return `${uuid.substr(0, 8)}-${uuid.substr(8, 4)}-${uuid.substr(12, 4)}-${uuid.substr(16, 4)}-${uuid.substr(20)}`
+  }
+}

package/icure-pre-commit/.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+repos:
+  - repo: https://github.com/Yelp/detect-secrets
+    rev: v1.3.0
+    hooks:
+    - id: detect-secrets
+      args: ['--baseline', '.secrets.baseline']
+      exclude: package.lock.json
+      additional_dependencies:
+      - pyahocorasick==1.4.4
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.3.0
+    hooks:
+    - id: end-of-file-fixer
+      exclude: ^.*\.mustache$
+    - id: trailing-whitespace
+      exclude: ^.*\.mustache$

package/icure-pre-commit/.secrets.baseline

@@ -0,0 +1,109 @@
+{
+  "version": "1.3.0",
+  "plugins_used": [
+    {
+      "name": "ArtifactoryDetector"
+    },
+    {
+      "name": "AWSKeyDetector"
+    },
+    {
+      "name": "AzureStorageKeyDetector"
+    },
+    {
+      "name": "Base64HighEntropyString",
+      "limit": 4.5
+    },
+    {
+      "name": "BasicAuthDetector"
+    },
+    {
+      "name": "CloudantDetector"
+    },
+    {
+      "name": "GitHubTokenDetector"
+    },
+    {
+      "name": "HexHighEntropyString",
+      "limit": 3.0
+    },
+    {
+      "name": "IbmCloudIamDetector"
+    },
+    {
+      "name": "IbmCosHmacDetector"
+    },
+    {
+      "name": "JwtTokenDetector"
+    },
+    {
+      "name": "KeywordDetector",
+      "keyword_exclude": ""
+    },
+    {
+      "name": "MailchimpDetector"
+    },
+    {
+      "name": "NpmDetector"
+    },
+    {
+      "name": "PrivateKeyDetector"
+    },
+    {
+      "name": "SendGridDetector"
+    },
+    {
+      "name": "SlackDetector"
+    },
+    {
+      "name": "SoftlayerDetector"
+    },
+    {
+      "name": "SquareOAuthDetector"
+    },
+    {
+      "name": "StripeDetector"
+    },
+    {
+      "name": "TwilioKeyDetector"
+    }
+  ],
+  "filters_used": [
+    {
+      "path": "detect_secrets.filters.allowlist.is_line_allowlisted"
+    },
+    {
+      "path": "detect_secrets.filters.common.is_ignored_due_to_verification_policies",
+      "min_level": 2
+    },
+    {
+      "path": "detect_secrets.filters.heuristic.is_indirect_reference"
+    },
+    {
+      "path": "detect_secrets.filters.heuristic.is_likely_id_string"
+    },
+    {
+      "path": "detect_secrets.filters.heuristic.is_lock_file"
+    },
+    {
+      "path": "detect_secrets.filters.heuristic.is_not_alphanumeric_string"
+    },
+    {
+      "path": "detect_secrets.filters.heuristic.is_potential_uuid"
+    },
+    {
+      "path": "detect_secrets.filters.heuristic.is_prefixed_with_dollar_sign"
+    },
+    {
+      "path": "detect_secrets.filters.heuristic.is_sequential_string"
+    },
+    {
+      "path": "detect_secrets.filters.heuristic.is_swagger_file"
+    },
+    {
+      "path": "detect_secrets.filters.heuristic.is_templated_secret"
+    }
+  ],
+  "results": {},
+  "generated_at": "2022-08-05T08:21:51Z"
+}

package/icure-pre-commit/README.md

@@ -0,0 +1,17 @@
+# iCure pre-commit
+
+Installation scripts, sample configurations, custom detect-secrets plugins/filter and any other files related to pre-commit hooks we may want to share across multiple iCure projects.
+
+## Installation scripts
+
+Script to install various tools useful or necessary for pre-commit hooks.
+
+- **install_required_tools.sh:** system-wide installation of all tools required by pre-commit hooks (currently only `pre-commit` itself). This script will NOT set up the pre-commit hooks: after the installation is successful you must manually run `pre-commit install`.
+- **install_optional_detect-secrets.sh:** system-wide installation of `detect-secrets`, only necessary to create new secrets baseline or to update an existing baseline. This is usually not necessary if a secret baseline already exists, since pre-commit will automatically install `detect-secrets` in an isolated environment for executing the pre-commit hook.
+
+## Sample configurations
+
+Sample configurations for pre-commit hooks. To use one of these configurations copy it to the root of your repository, rename it to `.pre-commit-config.yaml` and run `pre-commit install`.
+
+- **basic.pre-commit-config.yaml:** basic pre-commit hook configuration with hooks to remove trailing spaces and ensure there is a newline in text files, and to check for potential secrets in committed files. To use it you first need to create a secret baseline using `detect-secrets`.
+- **kotlin.pre-commit-config.yaml:** basic configuration with the addition of automatic kotlin files formatting with ktlint. Ktlint will be automatically downloaded in the pre-commit hook environment.

package/icure-pre-commit/basic.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+repos:
+  - repo: https://github.com/Yelp/detect-secrets
+    rev: v1.3.0
+    hooks:
+    - id: detect-secrets
+      args: ['--baseline', '.secrets.baseline']
+      exclude: package.lock.json
+      additional_dependencies:
+      - pyahocorasick==1.4.4
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.3.0
+    hooks:
+    - id: end-of-file-fixer
+      exclude: ^.*\.mustache$
+    - id: trailing-whitespace
+      exclude: ^.*\.mustache$