@icure/api 7.1.6 → 7.1.8

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

@@ -1,133 +0,0 @@
-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

@@ -1,243 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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)}`
-  }
-}