@sjcrh/proteinpaint-shared 2.175.0 → 2.177.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-shared",
-  "version": "2.175.0",
+  "version": "2.177.0",
   "description": "ProteinPaint code that is shared between server and client-side workspaces",
   "type": "module",
   "main": "src/index.js",

package/src/common.js

@@ -17,21 +17,22 @@ import { getWrappedTvslst } from './filter.js'
 // part of 'common' argument to exported dataset js function, at server runtime
 export const TermTypeGroups = {
 	DICTIONARY_VARIABLES: 'Dictionary Variables',
-	MUTATION_CNV_FUSION: 'Mutation/CNV/Fusion',
-	VARIANT_GENOTYPE: 'Variant Genotype',
 	DNA_METHYLATION: 'DNA Methylation',
 	GENE_DEPENDENCY: 'Gene Dependency',
 	GENE_EXPRESSION: 'Gene Expression',
-	PROTEIN_EXPRESSION: 'Protein Expression',
-	SPLICE_JUNCTION: 'Splice Junction',
-	METABOLITE_INTENSITY: 'Metabolite Intensity',
 	GSEA: 'GSEA',
+	METABOLITE_INTENSITY: 'Metabolite Intensity',
+	MUTATION_CNV_FUSION: 'Mutation/CNV/Fusion',
 	MUTATION_SIGNATURE: 'Mutation Signature',
+	PROTEIN_EXPRESSION: 'Protein Expression',
+	SINGLECELL_CELLTYPE: 'Single-cell Cell Type',
 	SNP: 'SNP Genotype',
 	SNP_LIST: 'SNP List',
 	SNP_LOCUS: 'SNP Locus',
+	SPLICE_JUNCTION: 'Splice Junction',
 	SSGSEA: 'Geneset Expression',
-	TERM_COLLECTION: 'Term Collection'
+	TERM_COLLECTION: 'Term Collection',
+	VARIANT_GENOTYPE: 'Variant Genotype'
 }
 
 export const defaultcolor = rgb('#8AB1D4').darker()

package/src/fetch-helpers.js

@@ -1,5 +1,6 @@
 import { hash } from './hash.js'
 import { encode } from './urljson.js'
+import { deepFreeze } from './helpers.js'
 
 /*
 	ezFetch()
@@ -165,17 +166,15 @@ async function processNDJSON_nestedKey(r) {
 	return rootObj
 }
 
-// key: request object reference or conputed string dataName
-// value: fetch promise or response
+// key: request object reference or computed string dataName
+// value: {
+//   response: fetch promise or response,
+//   exp: expiration timestamp
+// }
 const dataCache = new Map()
-// NOTE: when caching by request object reference,
-// consumer code must call deleteCache(q) at the end of the request handling
-
-// when caching by string dataName, track entries to manage the cache size
-const cachedDataNames = []
-// maximum number of cached dataNames, oldest will be deleted if 1000 is exceeded
-const maxNumOfDataKeys = 360
-
+// maximum number of cached dataNames, oldest will be deleted if this is exceeded
+const maxNumOfDataKeys = 10
+const cacheLifetime = 1000 * 60 * 5
 /*
 	memFetch()
 	- fetch wrapper that saves cached responses into memory and recovers them for matching subsequent requests
@@ -188,65 +187,83 @@ const maxNumOfDataKeys = 360
 	url
 	init{headers?, body?}
 	- first two arguments are same as native fetch
+  - when passing opts.client, may include other applicable options inside the init{} object, such as retry
 
-	opts{q}
-	q?: request object (passed by reference, not copy)
-		- if provided, will be used as cache data key 
-	  - if not provided, then a string cache data key will be computed from the request url, body, headers
+	opts{client}
+
+  client: use this http client instead of native fetch
+    - since fetch-helpers is shared between server and frontend workspaces, 
+      cannot directly import non-native modules at the beginning of this code file 
+    - for server side usage, client may be `xfetch()`, `ky` or other libraries 
 */
 export async function memFetch(url, init, opts = {}) {
 	if (typeof init.body === 'object') init.body = JSON.stringify(init.body)
 	const dataKey = opts.q || (await getDataName(url, init))
-	let result = dataCache.get(dataKey)
+	const { response, exp } = dataCache.get(dataKey) || {}
+	const now = Date.now()
+	let result = response // either a Promise or actual data
 
-	if (!result || (typeof result != 'object' && !(result instanceof Promise))) {
-		dataCache.delete(dataKey)
-		result = undefined
-	}
-
-	if (!result) {
+	if (result) {
+		// extend the expiration, since exp is more about managing the cache size
+		// and not the validity of the cached response. A response for the current
+		// dataName req.url + body + headers is technically valid until a new data version
+		// gets published.
+		dataCache.set(dataKey, { response, exp: now + cacheLifetime })
+		return result
+	} else {
 		try {
-			// do not await so that this same promise may be reused by all subsequent requests with the same dataKey
-			dataCache.set(
-				dataKey,
-				fetch(url, init).then(async r => {
-					const response = await processResponse(r)
-					if (!r.ok) {
-						console.trace(response)
-						throw (
-							'memFetch error ' +
-							r.status +
-							': ' +
-							(typeof response == 'object' ? response.message || response.error : response)
-						)
-					}
-					// to-do: support opt.freeze to enforce deep freeze of data.json()
-					dataCache.set(dataKey, response)
-					return dataCache.get(dataKey)
-				})
-			)
-			result = dataCache.get(dataKey)
+			// IMPORTANT: do not await so that this same promise may be reused
+			// by subsequent requests with the same dataKey
+			result = opts.client
+				? opts.client(url, init, Object.assign(opts, { client: undefined })).then(response => {
+						// replace the cached promise result with the actual data,
+						// since persisting a cached promise for a long time is likely not best practice
+						dataCache.set(dataKey, { response, exp: Date.now() + cacheLifetime })
+						return response
+				  })
+				: fetch(url, init).then(async r => {
+						const response = await processResponse(r)
+						if (!r.ok) {
+							console.trace(response)
+							throw (
+								'memFetch error ' +
+								r.status +
+								': ' +
+								(typeof response == 'object' ? response.message || response.error : response)
+							)
+						}
+						// replace the cached promise result with the actual data,
+						// since persisting a cached promise for a long time is likely not best practice
+						dataCache.set(dataKey, { response: deepFreeze(response), exp: Date.now() + cacheLifetime })
+						return response
+				  })
+
+			dataCache.set(dataKey, { response: result, exp: Date.now() + cacheLifetime })
+			manageCacheSize(now)
+			return result
 		} catch (e) {
-			delete dataCache.delete(dataKey)
+			// delete this cache only if it is a promise;
+			// do not delete a valid resolved data cache
+			if (dataCache.get(dataKey) instanceof Promise) delete dataCache.delete(dataKey)
 			throw e
 		}
 	}
-	if (typeof dataKey === 'string') manageCacheSize(dataKey)
-	return result
 }
 
 export function deleteCache(key) {
-	delete dataCache.delete(key)
+	dataCache.delete(key)
 }
 
-export function manageCacheSize(dataKey) {
-	// manage the number of stored keys in dataCache
-	const i = cachedDataNames.indexOf(dataKey)
-	if (i !== -1) cachedDataNames.splice(i, 1) // if the dataKey already exists, delete from current place in tracking array to move to front
-	cachedDataNames.unshift(dataKey) // add the dataKey to the front of the tracking array
-	while (cachedDataNames.length > maxNumOfDataKeys) {
-		const oldestDataname = cachedDataNames.pop() // delete the dataKey from the tracking array
-		dataCache.delete(oldestDataname)
+export function manageCacheSize(_now) {
+	const now = _now || Date.now()
+	const keyExp = []
+	for (const [key, result] of dataCache.entries()) {
+		if (result.exp < now) dataCache.delete(key)
+		else keyExp.push({ key, exp: result.exp })
+	}
+	if (dataCache.size > maxNumOfDataKeys) {
+		const oldestEntries = keyExp.sort((a, b) => a.exp - b.exp).slice(maxNumOfDataKeys)
+		for (const entry of oldestEntries) dataCache.delete(entry.key)
 	}
 }
 
@@ -261,7 +278,7 @@ export async function getDataName(url, init) {
 }
 
 //
-export function clearCache(opts = {}) {
+export function clearMemFetchDataCache(opts = {}) {
 	if (!opts.serverData) {
 		dataCache.clear()
 		return

package/src/helpers.js

@@ -59,6 +59,15 @@ export function deepEqual(x, y) {
 	} else return false
 }
 
+export function deepFreeze(obj) {
+	Object.freeze(obj)
+	// not using for..in loop, in order to not descend into inherited props/methods
+	for (const value of Object.values(obj)) {
+		if (value !== null && typeof value == 'object') deepFreeze(value)
+	}
+	return obj
+}
+
 export class CustomError extends Error {
 	level = '' // '' | 'warn'
 

package/src/termdb.usecase.js

@@ -113,23 +113,7 @@ export function isUsableTerm(term, _usecase, termdbConfig, ds) {
 			}
 			return uses
 		case 'runChart2':
-			if (usecase.detail == 'date') {
-				if (term.type == 'date') {
-					uses.add('plot')
-				}
-				if (child_types.includes('date')) uses.add('branch')
-			} else if (usecase.detail == 'numeric') {
-				if (isNumericTerm(term) && term.type != 'date') {
-					uses.add('plot')
-				}
-				if (hasNumericChild(child_types)) uses.add('branch')
-			} else {
-				if (graphableTypes.has(term.type)) uses.add('plot')
-				if (!term.isleaf) uses.add('branch')
-			}
-			return uses
-		case 'frequencyChart':
-			if (usecase.detail == 'term') {
+			if (usecase.detail == 'date' || usecase.detail == 'xtw') {
 				if (term.type == 'date') {
 					uses.add('plot')
 				}

package/src/terms.js

@@ -70,7 +70,8 @@ export const typeGroup = {
 	[TermTypes.GENE_EXPRESSION]: TermTypeGroups.GENE_EXPRESSION,
 	[TermTypes.SSGSEA]: TermTypeGroups.SSGSEA,
 	[TermTypes.METABOLITE_INTENSITY]: TermTypeGroups.METABOLITE_INTENSITY,
-	[TermTypes.TERM_COLLECTION]: TermTypeGroups.TERM_COLLECTION
+	[TermTypes.TERM_COLLECTION]: TermTypeGroups.TERM_COLLECTION,
+	[TermTypes.SINGLECELL_CELLTYPE]: TermTypeGroups.SINGLECELL_CELLTYPE
 }
 
 const nonDictTypes = new Set([
@@ -196,6 +197,7 @@ export function getParentType(types, ds) {
 	if (!ids || ids.length == 0) return null
 	for (const id of ids) {
 		const typeObj = ds.cohort.termdb.sampleTypes[id]
+		if (!typeObj) continue
 		if (typeObj.parent_id == null) return id //this is the root type
 		//if my parent is in the list, then I am not the parent
 		if (ids.includes(typeObj.parent_id)) continue