@icure/api 5.3.6 → 5.3.7

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

@@ -1,220 +0,0 @@
-import { parseNumber, formatNumber, isValidNumber, ParsedNumber } from 'libphonenumber-js'
-
-import * as moment from 'moment'
-import * as _ from 'lodash'
-import { Moment } from 'moment'
-
-// TODO: move this to env.js?
-const DEFAULT_COUNTRY = 'BE'
-
-export const nihiiRegExp = new RegExp('^(\\d{1})(\\d{5})(\\d{2})(\\d{3})$')
-export const ssinRegExp = new RegExp('^(\\d{2})(\\d{2})(\\d{2})(\\d{3})(\\d{2})$')
-export const ibanRegExp = new RegExp('^(\\d{4})(\\d{4})(\\d{4})(\\d{4})$')
-
-const patterns = {
-  IBAN: (iban: string) => /^BE\d{14}$/.test(iban) && isValidIBAN(iban),
-  IBANBE: (iban: string) => /^BE\d{14}$/.test(iban) && isValidIBAN(iban),
-}
-
-//http://ht5ifv.serprest.pt/extensions/tools/IBAN/
-export function isValidIBAN(iban: string) {
-  //This function check if the checksum if correct
-  iban = iban.replace(/^(.{4})(.*)$/, '$2$1') //Move the first 4 chars from left to the right
-  const fun = (e: string) => (e.charCodeAt(0) - 'A'.charCodeAt(0) + 10).toString()
-  iban = iban.replace(/[A-Z]/g, fun) //Convert A-Z to 10-25
-  let $sum = 0
-  let $ei = 1 //First exponent
-  for (let $i = iban.length - 1; $i >= 0; $i--) {
-    $sum += $ei * parseInt(iban.charAt($i), 10) //multiply the digit by it's exponent
-    $ei = ($ei * 10) % 97 //compute next base 10 exponent  in modulus 97
-  }
-  return $sum % 97 === 1
-}
-
-export function ibanValidate(iban: string) {
-  if (iban.startsWith('BE')) {
-    return patterns.IBANBE(iban)
-  } else {
-    return patterns.IBAN(iban)
-  }
-}
-
-export function ibanFormat(iban: string): string {
-  return iban.replace(ibanRegExp, '$1 $2 $3 $4')
-}
-
-export function nihiiFormat(nihii: string): string {
-  return nihii.replace(nihiiRegExp, '$1 $2 $3 $4')
-}
-
-export function nihiiValidate(nihii: string): boolean {
-  return !!nihii.match(nihiiRegExp)
-}
-
-export function ssinFormat(ssin: string): string {
-  return ssin.replace(ssinRegExp, '$1 $2 $3 $4 $5')
-}
-
-export function ssinValidate(ssin: string): boolean {
-  return !!ssin.match(ssinRegExp)
-}
-
-/* Alternate lib free version
-export function phoneNumberValidate(phoneNumber: string): boolean {
-  return (
-    !!phoneNumber.match(/(?:\+|00)([1-9][0-9]{1-2})([- /.]*([0-9]+))+/) ||
-    !!phoneNumber.match(/(0[1-9][0-9]*)([- /.]*([0-9]+))+/)
-  )
-}
-
-export function phoneNumberFormat(phoneNumber: string): string {
-  let match = phoneNumber.match(/(?:\+|00)([1-9][0-9]{1-2})([- /.]*([0-9]+))+/)
-  if (match) {
-    return `+${match[1]} ${match[2].replace(/[- /.]/g, " ")}`.replace(/  /g, " ")
-  }
-  match = phoneNumber.match(/0([1-9][0-9]*)([- /.]*([0-9]+))+/)
-  if (match) {
-    return `+32 ${match[1]} ${match[2].replace(/[- /.]/g, " ")}`.replace(/  /g, " ")
-  }
-  return phoneNumber
-}
-*/
-
-export function phoneNumberValidate(phoneNumber: string): boolean {
-  return isValidNumber(phoneNumber)
-}
-
-export function phoneNumberFormat(phoneNumber: string): string {
-  const parsedPhoneNumber = parseNumber(phoneNumber, DEFAULT_COUNTRY) as ParsedNumber
-  if (_.isEmpty(parsedPhoneNumber)) {
-    // The number is not valid, so we leave the input string as-is.
-    return phoneNumber
-  }
-  return formatNumber(parsedPhoneNumber, 'INTERNATIONAL')
-}
-
-/**
- * Converts a backend date number (e.g., patient birth date) into a Date object.
- * @param dateNumber a YYYYMMDD date number from the backend
- * @return a Date object
- * @throws Error if it is impossible to create a date from the number, other if dateNumber is negative.
- * @see #dateEncode
- * @see #timeDecode
- */
-export function dateDecode(dateNumber: number): Date | undefined {
-  if (!dateNumber) {
-    return undefined
-  }
-
-  if (dateNumber < 0) {
-    throw new Error("We don't decode negative dates. Please make sure you have valid data.")
-  }
-  const dateNumberStr: string = _.padStart(dateNumber.toString(), 8, '19700101')
-  if (dateNumberStr.length > 8) {
-    if (dateNumberStr.endsWith('000000')) {
-      return dateNumber ? moment(dateNumberStr, 'YYYYMMDD000000').toDate() : undefined
-    }
-
-    throw Error("Decoded date is over year 9999. We can't format it properly.")
-  }
-  return dateNumber ? moment(dateNumberStr, 'YYYYMMDD').toDate() : undefined
-}
-
-/**
- * Converts a backend time number (e.g., health element openingDate) into a Date object.
- * @param timeNumber a YYYYMMDD date number from the backend
- * @return a Date object
- * @see #timeEncode
- * @see #dateDecode
- */
-export function timeDecode(timeNumber: number): Date | undefined {
-  return timeNumber ? moment(timeNumber.toString(), 'YYYYMMDDHHmmss').toDate() : undefined
-}
-
-/**
- * Encodes a Date object into a backend date number (e.g., patient birth date).
- * @param date a Date object
- * @return a YYYYMMDD date number for the backend
- * @see #dateDecode
- * @see #timeEncode
- */
-export function dateEncode(date: Date): number | undefined {
-  const dateStr = _.padStart(moment(date).format('YYYYMMDD'), 8, '19700101')
-  // date is null if the field is not set
-  return date ? Number(dateStr) : undefined
-}
-
-/**
- * Encodes a Date object into a backend time number (e.g., health element openingDate).
- * @param date a Date object
- * @return a YYYYMMDDHHmmss date number for the backend
- * @see #timeDecode
- * @see #dateEncode
- */
-export function timeEncode(date: Date): number | undefined {
-  return date ? Number(moment(date).format('YYYYMMDDHHmmss')) : undefined
-}
-
-/**
- * Formats a value and a physical unit into text.
- * @param value the numerical or string value to encode
- * @param unit the unit represented as a string (an empty string is also supported)
- */
-export function unit(value: number | string, unit: string | null): string {
-  unit = unit || ''
-  let separator: string
-  if (!unit || unit.startsWith('°')) {
-    separator = ''
-  } else {
-    // including '%'
-    separator = '\xa0'
-  }
-  return value + separator + unit
-}
-
-/**
- * 0.1 + 0.2 = 0.30000000000000004. Use this function to be better at maths.
- * @param a number
- * @return the rounded number, two after the comma
- */
-export function amount(value: number): number {
-  return Number((value || 0).toFixed(2))
-}
-
-/**
- * A simple formatter to keep the logic across the app.
- * Input: 2.1 ; Output: 2.10€
- */
-export function money(value: number): string {
-  return [(value || 0).toFixed(2), '€'].join('')
-}
-
-/**
- * Transform a dictionary to a url params.
- * From { key1: value1, key2: value2, ... } returns key1=value1&key2=value2&...=...
- */
-export function toUrlParams(params: { [key: string]: string }): string {
-  return _.filter(_.map(params, (value, key) => (value ? key + '=' + value : undefined))).join('&')
-}
-
-export function personName(person: { firstName?: string; lastName?: string }): string {
-  return `${person.firstName || ''} ${person.lastName || ''}`.trim()
-}
-
-export function personNameAbbrev(person: { firstName?: string; lastName?: string }): string {
-  const firstName = person.firstName ? person.firstName[0] + '.' : undefined
-  return personName({ ...person, firstName })
-}
-
-export function toMoment(epochOrLongCalendar: number): Moment | null {
-  if (!epochOrLongCalendar && epochOrLongCalendar !== 0) {
-    return null
-  }
-  if (epochOrLongCalendar >= 18000101 && epochOrLongCalendar < 25400000) {
-    return moment('' + epochOrLongCalendar, 'YYYYMMDD')
-  } else if (epochOrLongCalendar >= 18000101000000) {
-    return moment('' + epochOrLongCalendar, 'YYYYMMDDhhmmss')
-  } else {
-    return moment(epochOrLongCalendar)
-  }
-}

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

@@ -1,16 +0,0 @@
-export function also<T>(value: T, lambda: (it: T) => void) {
-  lambda(value)
-  return value
-}
-
-export function fold<T, R>(whereToFold: Array<T>, initial: R, operation: (acc: R, element: T) => R): R {
-  let accumulator = initial
-  for (let i = 0; i < whereToFold.length; i++) accumulator = operation(accumulator, whereToFold[i])
-  return accumulator
-}
-
-export async function foldAsync<T, R>(whereToFold: Array<T>, initial: R, operation: (acc: R, element: T) => Promise<R>): Promise<R> {
-  let accumulator = initial
-  for (let i = 0; i < whereToFold.length; i++) accumulator = await operation(accumulator, whereToFold[i])
-  return accumulator
-}

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

@@ -1,122 +0,0 @@
-import * as _ from 'lodash'
-import { HealthcareParty, Telecom } from '../../icc-api/model/models'
-
-export interface KendoDropdownSpeciality {
-  text: string
-  value: string
-}
-
-export const SPECIALITIES: Array<string> = [
-  'ADMINISTRATION',
-  'CARE_GIVER',
-  'ANATOMOPATHOLOGY',
-  'ANESTHESIOLOGY',
-  'SOCIAL_WORKER',
-  'PHARMA_ASSISTANT',
-  'AUDIOLOGIST',
-  'BACTERIOLOGY',
-  'TRUSS_ORTHOTIST',
-  'CLINICAL_BIOLOGY',
-  'CARDIOLOGY',
-  'GENERAL_SURGERY',
-  'MAXILLOFACIAL_SURGERY',
-  'PLASTIC_SURGERY',
-  'STOMATOLOGICAL_SURGERY',
-  'CARDIOVASCULAR_SURGERY',
-  'DENTISTRY',
-  'DERMATOLOGY',
-  'DIETETIC',
-  'ENDOCRINOLOGY',
-  'OCCUPATIONAL_THERAPIST',
-  'GASTROENTEROLOGY',
-  'GENETIC',
-  'GERIATRICS',
-  'GYNECOLOGY',
-  'HEMATOLOGY',
-  'NURSE',
-  'NURSE_EDUCATOR',
-  'PHYSIOTHERAPY',
-  'SPEECH',
-  'ACUTE_MEDICINE',
-  'GENERAL_MEDICINE',
-  'INTERNAL_MEDICINE',
-  'NUCLEAR_MEDICINE',
-  'PHYSICAL_MEDICINE',
-  'NEONATOLOGY',
-  'NEPHROLOGY',
-  'NEUROSURGERY',
-  'NEUROLOGY',
-  'NEUROPEDIATRICS',
-  'NEUROPSYCHIATRY',
-  'NUTRITIONIST',
-  'ONCOLOGY',
-  'OPHTHALMOLOGY',
-  'ORTHOPEDICS',
-  'ORTHOPTISTE',
-  'OTORHINOLARYNGOLOGY',
-  'PEDIATRICS',
-  'PHARMACOLOGY',
-  'RESPIRATORY',
-  'PODIATRIST',
-  'PUBLIC_HEALTH_PREVENTION',
-  'PROSTHETIST',
-  'PSYCHIATRY',
-  'MEDICAL_PSYCHOLOGY',
-  'RADIODIAGNOSTICS',
-  'RADIOTHERAPY',
-  'RESUSCITATION',
-  'RHEUMATOLOGY',
-  'MIDWIFE',
-  'STOMATOLOGY',
-  'EMERGENCY',
-  'UROLOGY',
-  'TOXICOLOGY',
-  'TRANSPORT',
-]
-
-/**
- * Translation keys for specialities.
- * @see SPECIALITIES
- */
-export const SPECIALITIES_KEYS: { [spec: string]: string } = _.fromPairs(SPECIALITIES.map((spec) => [spec, 'hcp-form.SPECIALITIES.' + spec]))
-
-export function isDoctor(nihii: string): boolean {
-  return !!nihii && nihii.length === 11 && nihii.startsWith('1') && !nihii.endsWith('005') && !nihii.endsWith('006')
-}
-
-export function isDoctorAssistant(nihii: string): boolean {
-  return !!nihii && nihii.length === 11 && nihii.startsWith('1') && nihii.endsWith('005') && nihii.endsWith('006')
-}
-
-export function getPhoneNumber(hcp: HealthcareParty, maxLength: number | undefined): number | null {
-  const phoneNumbers = (hcp.addresses || []).map((a) => {
-    const t = (a.telecoms || []).find(
-      (t: Telecom) => t.telecomType === Telecom.TelecomTypeEnum.Phone.toString() || t.telecomType === Telecom.TelecomTypeEnum.Mobile.toString()
-    )
-    let res = t && t.telecomNumber
-    if (res && maxLength) {
-      while (res.length > maxLength) {
-        if (res.startsWith('0032')) {
-          res = '0' + res.substr(4)
-        } else if (res.startsWith('+32')) {
-          res = '0' + res.substr(3)
-        } else if (res.startsWith('32')) {
-          res = '0' + res.substr(2)
-        } else if (res.startsWith('00')) {
-          res = res.substr(2)
-        } else if (res.startsWith('0')) {
-          res = res.substr(1)
-        } else if (res.startsWith('352')) {
-          res = '0' + res.substr(3)
-        } else if (res.startsWith('33')) {
-          res = '0' + res.substr(2)
-        } else {
-          res = res.substr(1)
-        }
-      }
-    }
-    return res && Number(res)
-  })
-
-  return (!phoneNumbers.length || _.isNaN(phoneNumbers[0]) ? null : phoneNumbers[0]) || null
-}

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

@@ -1,7 +0,0 @@
-export * from './code-util'
-export * from './net-utils'
-export * from './crypto-utils'
-export * from './formatting-util'
-export * from './binary-utils'
-export * from './hcp-util'
-export * from './functional-util'

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

@@ -1,54 +0,0 @@
-import * as _ from 'lodash'
-import { Patient, Insurability } from '../../icc-api/model/models'
-
-export function isBIM(ct1: number | string | undefined, ct2: number | string | undefined): boolean {
-  //BIM if ct1 ood and ct2 ood
-  return +(ct1 ?? 0) % 2 !== 0 && +(ct2 ?? 0) % 2 !== 0
-}
-
-export function patientIsBIM(patient: Patient) {
-  // FIXME this doesn't check the date of the insurability. It is related to the idea of having only on insurability at a time.
-  return isBIM(_.get(patient, 'insurabilities[0].parameters.tc1'), _.get(patient, 'insurabilities[0].parameters.tc2'))
-}
-
-export function isPatientPaymentByIo(patient: Patient) {
-  const paymentByIo = _.get(patient, 'insurabilities[0].parameters.paymentByIo')
-  return paymentByIo === 'true'
-}
-
-/**
- * Returns the titulary id from patient insurability
- * @throws error if the patient has no insurability data
- * @param patient The patient
- */
-export function getMembership(patient: Patient): string {
-  const ioCode = _.get(patient, 'insurabilities[0].identificationNumber')
-  if (_.isUndefined(ioCode)) {
-    // TODO translate
-    throw new Error("Le patient n'a pas de données d'assurabilité")
-  }
-  return ioCode
-}
-
-/**
- * Returns the insurability from patient
- * @throws error if the patient has no insurability data
- * @param patient The patient
- */
-export function getInsurability(patient: Patient): Insurability {
-  const insurability = _.get(patient, 'insurabilities[0]')
-  if (_.isUndefined(insurability)) {
-    // TODO translate
-    throw new Error("Le patient n'a pas de données d'assurabilité")
-  }
-  return insurability
-}
-
-/**
- * Returns the insurability from patient
- * @throws error if the patient has no insurability data
- * @param patient
- */
-export function isPatientHospitalized(patient: Patient): boolean {
-  return getInsurability(patient).hospitalisation || false
-}

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,
-      }),
-    ]),
-  }
-}