@sjcrh/proteinpaint-server 2.44.0 → 2.46.1

package/routes/termdb.getdescrstats.ts

@@ -1,102 +0,0 @@
-import { getdescrstatsRequest, getdescrstatsResponse } from '#shared/types/routes/termdb.getdescrstats.ts'
-import { get_rows_by_one_key } from '../src/termdb.sql.js'
-import Summarystats from '../shared/descriptive.stats.js'
-
-export const api: any = {
-	endpoint: 'termdb/descrstats',
-	methods: {
-		all: {
-			init,
-			request: {
-				typeId: 'getdescrstatsRequest'
-			},
-			response: {
-				typeId: 'getdescrstatsResponse'
-			},
-			examples: [
-				{
-					request: {
-						body: {
-							genome: 'hg38-test',
-							dslabel: 'TermdbTest',
-							embedder: 'localhost',
-							tid: 'hrtavg',
-							filter: {
-								type: 'tvslst',
-								in: true,
-								join: '',
-								lst: [
-									{
-										tag: 'cohortFilter',
-										type: 'tvs',
-										tvs: {
-											term: {
-												name: 'Cohort',
-												type: 'categorical',
-												values: { ABC: { label: 'ABC' }, XYZ: { label: 'XYZ' } },
-												id: 'subcohort',
-												isleaf: false,
-												groupsetting: { disabled: true }
-											},
-											values: [{ key: 'ABC', label: 'ABC' }]
-										}
-									}
-								]
-							}
-						}
-					},
-					response: {
-						header: { status: 200 }
-					}
-				}
-			]
-		}
-	}
-}
-
-function init({ genomes }) {
-	return async (req: any, res: any): Promise<void> => {
-		const q = req.query as getdescrstatsRequest
-		try {
-			const g = genomes[req.query.genome]
-			if (!g) throw 'invalid genome name'
-			const ds = g.datasets[req.query.dslabel]
-			if (!ds) throw 'invalid dataset name'
-			const tdb = ds.cohort.termdb
-			if (!tdb) throw 'invalid termdb object'
-
-			await trigger_getdescrstats(q, res, ds) // as getdescrstatsResponse
-		} catch (e) {
-			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-			// @ts-ignore
-			res.send({ error: e?.message || e })
-			if (e instanceof Error && e.stack) console.log(e)
-		}
-	}
-}
-
-async function trigger_getdescrstats(q: any, res: any, ds: any) {
-	const term = ds.cohort.termdb.q.termjsonByOneid(q.tid)
-	if (!term) throw 'invalid termid'
-	if (term.type != 'float' && term.type != 'integer') throw 'not numerical term'
-	const rows = await get_rows_by_one_key({
-		ds,
-		key: q.tid,
-		filter: q.filter
-	})
-	const values: number[] = []
-	for (const { value } of rows) {
-		if (term.values?.[value]?.uncomputable) {
-			// skip uncomputable values
-			continue
-		}
-		//skip computing for zeros if scale is log.
-		if (q.settings?.violin?.unit === 'log') {
-			if (value === 0) {
-				continue
-			}
-		}
-		values.push(value)
-	}
-	res.send(Summarystats(values) as getdescrstatsResponse)
-}

package/routes/termdb.getnumericcategories.ts

@@ -1,99 +0,0 @@
-import {
-	getnumericcategoriesRequest,
-	getnumericcategoriesResponse
-} from '#shared/types/routes/termdb.getnumericcategories.ts'
-import * as termdbsql from '#src/termdb.sql.js'
-
-export const api: any = {
-	endpoint: 'termdb/numericcategories',
-	methods: {
-		get: {
-			init,
-			request: {
-				typeId: 'getnumericcategoriesRequest'
-			},
-			response: {
-				typeId: 'getnumericcategoriesResponse'
-			},
-			examples: [
-				{
-					request: {
-						body: {
-							genome: 'hg38-test',
-							dslabel: 'TermdbTest',
-							embedder: 'localhost',
-							tid: 'aaclassic_5',
-							filter: {
-								type: 'tvslst',
-								in: true,
-								join: '',
-								lst: [
-									{
-										tag: 'cohortFilter',
-										type: 'tvs',
-										tvs: {
-											term: {
-												name: 'Cohort',
-												type: 'categorical',
-												values: { ABC: { label: 'ABC' }, XYZ: { label: 'XYZ' } },
-												id: 'subcohort',
-												isleaf: false,
-												groupsetting: { disabled: true }
-											},
-											values: [{ key: 'ABC', label: 'ABC' }]
-										}
-									}
-								]
-							}
-						}
-					},
-					response: {
-						header: { status: 200 }
-					}
-				}
-			]
-		},
-		post: {
-			alternativeFor: 'get',
-			init
-		}
-	}
-}
-
-function init({ genomes }) {
-	return async (req: any, res: any): Promise<void> => {
-		const q = req.query as getnumericcategoriesRequest
-		try {
-			const g = genomes[req.query.genome]
-			if (!g) throw 'invalid genome name'
-			const ds = g.datasets[req.query.dslabel]
-			if (!ds) throw 'invalid dataset name'
-			const tdb = ds.cohort.termdb
-			if (!tdb) throw 'invalid termdb object'
-
-			await trigger_getnumericcategories(q, res, tdb, ds) // as getnumericcategoriesResponse
-		} catch (e) {
-			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-			// @ts-ignore
-			res.send({ error: e?.message || e })
-			if (e instanceof Error && e.stack) console.log(e)
-		}
-	}
-}
-
-async function trigger_getnumericcategories(
-	q: { tid: any; filter?: any },
-	res: { send: (arg0: { lst: any }) => void },
-	tdb: { q: { termjsonByOneid: (arg0: any) => any } },
-	ds: any
-) {
-	if (!q.tid) throw '.tid missing'
-	const term = tdb.q.termjsonByOneid(q.tid)
-	const arg = {
-		ds,
-		term_id: q.tid,
-		filter: q.filter
-	}
-	const lst = await termdbsql.get_summary_numericcategories(arg)
-	res.send({ lst } as getnumericcategoriesResponse)
-}

package/routes/termdb.getpercentile.ts

@@ -1,118 +0,0 @@
-import { getpercentileRequest, getpercentileResponse } from '#shared/types/routes/termdb.getpercentile.ts'
-import * as termdbsql from '../src/termdb.sql.js'
-import computePercentile from '../shared/compute.percentile.js'
-import { Filter } from '../shared/types/filter'
-
-export const api: any = {
-	endpoint: 'termdb/getpercentile',
-	methods: {
-		get: {
-			init,
-			request: {
-				typeId: 'getpercentileRequest'
-			},
-			response: {
-				typeId: 'getpercentileResponse'
-			},
-			examples: [
-				{
-					request: {
-						body: {
-							genome: 'hg38-test',
-							dslabel: 'TermdbTest',
-							embedder: 'localhost',
-							getpercentile: [50],
-							tid: 'agedx',
-							filter: {
-								type: 'tvslst',
-								in: true,
-								join: '',
-								lst: [
-									{
-										tag: 'cohortFilter',
-										type: 'tvs',
-										tvs: {
-											term: {
-												name: 'Cohort',
-												type: 'categorical',
-												values: { ABC: { label: 'ABC' }, XYZ: { label: 'XYZ' } },
-												id: 'subcohort',
-												isleaf: false,
-												groupsetting: { disabled: true }
-											},
-											values: [{ key: 'ABC', label: 'ABC' }]
-										}
-									}
-								]
-							}
-						}
-					},
-					response: {
-						header: { status: 200 }
-					}
-				}
-			]
-		},
-		post: {
-			alternativeFor: 'get',
-			init
-		}
-	}
-}
-
-function init({ genomes }) {
-	return async (req: any, res: any): Promise<void> => {
-		const q = req.query as getpercentileRequest
-		try {
-			const g = genomes[req.query.genome]
-			if (!g) throw 'invalid genome name'
-			const ds = g.datasets[req.query.dslabel]
-			if (!ds) throw 'invalid dataset name'
-			await trigger_getpercentile(q, res, ds) // as getpercentileResponse
-		} catch (e) {
-			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-			// @ts-ignore
-			res.send({ error: e?.message || e })
-			if (e instanceof Error && e.stack) console.log(e)
-		}
-	}
-}
-
-async function trigger_getpercentile(
-	q: { tid: string; getpercentile: number[]; filter: Filter },
-	res: { send: (arg0: { values: number[] }) => void },
-	ds: { cohort: { termdb: { q: { termjsonByOneid: (arg0: any) => any } } } }
-) {
-	const term = ds.cohort.termdb.q.termjsonByOneid(q.tid)
-	if (!term) throw 'invalid termid'
-	if (term.type != 'float' && term.type != 'integer') throw 'not numerical term'
-	const percentile_lst = q.getpercentile
-	const perc_values = [] as number[]
-	const values = [] as number[]
-	const rows = await termdbsql.get_rows_by_one_key({
-		ds,
-		key: q.tid,
-		filter: q.filter ? (typeof q.filter == 'string' ? JSON.parse(q.filter) : q.filter) : null
-	})
-	for (const { value } of rows) {
-		if (term.values && term.values[value] && term.values[value].uncomputable) {
-			// skip uncomputable values
-			continue
-		}
-
-		if (term.skip0forPercentile && value == 0) {
-			// quick fix: when the flag is true, will exclude 0 values from percentile computing
-			// to address an issue with computing knots
-			continue
-		}
-
-		values.push(Number(value))
-	}
-
-	// compute percentiles
-	for (const percentile of percentile_lst) {
-		const perc_value = computePercentile(values, percentile)
-		perc_values.push(perc_value)
-	}
-	res.send({ values: perc_values } as getpercentileResponse)
-}

package/routes/termdb.getrootterm.ts

@@ -1,73 +0,0 @@
-import { getroottermRequest, getroottermResponse } from '#shared/types/routes/termdb.getrootterm.ts'
-import { get_ds_tdb } from '#src/termdb.js'
-
-
-export const api: any = {
-	endpoint: 'termdb/rootterm',
-	methods: {
-		get: {
-			init,
-			request: {
-				typeId: 'getroottermRequest'
-			},
-			response: {
-				typeId: 'getroottermResponse'
-			},
-			examples: [
-				{
-					request: {
-						body: {
-							genome: 'hg38-test',
-							dslabel: 'TermdbTest',
-							embedder: 'localhost',
-							default_rootterm: 1,
-							cohortValues: 'ABC'
-						}
-					},
-					response: {
-						header: { status: 200 }
-					}
-				}
-			]
-		},
-		post: {
-			alternativeFor: 'get',
-			init
-		}
-	}
-}
-
-function init({ genomes }) {
-	return async (req: any, res: any): Promise<void> => {
-		const q = req.query as getroottermRequest
-		const cohortValues = q.cohortValues ? q.cohortValues : ''
-		const treeFilter = q.treeFilter ? q.treeFilter : ''
-		//res.send({ lst: await tdb.q.getRootTerms(cohortValues, treeFilter) })
-
-		try {
-			const g = genomes[req.query.genome]
-			if (!g) throw 'invalid genome name'
-
-			const [ds, tdb] = get_ds_tdb(g, q)
-			if (!ds) throw 'invalid dataset name'
-			if (!tdb) throw 'invalid termdb object'
-
-			await trigger_rootterm(q, res, tdb) // as getroottermResponse
-		} catch (e) {
-			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-			// @ts-ignore
-			res.send({ error: e?.message || e })
-			if (e instanceof Error && e.stack) console.log(e)
-		}
-	}
-}
-
-async function trigger_rootterm(
-	q: { cohortValues: any; treeFilter: any },
-	res: { send: (arg0: { lst: any }) => void },
-	tdb: { q: { getRootTerms: (arg0: any, arg1: any) => any } }
-) {
-	const cohortValues = q.cohortValues ? q.cohortValues : ''
-	const treeFilter = q.treeFilter ? q.treeFilter : ''
-	res.send({ lst: await tdb.q.getRootTerms(cohortValues, treeFilter) } as getroottermResponse)
-}

package/routes/termdb.gettermchildren.ts

@@ -1,82 +0,0 @@
-import { gettermchildrenRequest, gettermchildrenResponse } from '#shared/types/routes/termdb.gettermchildren.ts'
-import { copy_term, get_ds_tdb } from '#src/termdb.js'
-
-export const api: any = {
-	endpoint: 'termdb/termchildren',
-	methods: {
-		get: {
-			init,
-			request: {
-				typeId: 'gettermchildrenRequest'
-			},
-			response: {
-				typeId: 'gettermchildrenResponse'
-			},
-			examples: [
-				{
-					request: {
-						body: {
-							genome: 'hg38-test',
-							dslabel: 'TermdbTest',
-							embedder: 'localhost',
-							get_children: 1,
-							cohortValues: 'ABC',
-							tid: 'GO:0000001'
-						}
-					},
-					response: {
-						header: { status: 200 }
-					}
-				}
-			]
-		},
-		post: {
-			alternativeFor: 'get',
-			init
-		}
-	}
-}
-
-function init({ genomes }) {
-	return async (req: any, res: any): Promise<void> => {
-		const q = req.query as gettermchildrenRequest
-		try {
-			const g = genomes[req.query.genome]
-			if (!g) throw 'invalid genome name'
-			const [ds, tdb] =await get_ds_tdb(g, q)
-			if (!ds) throw 'invalid dataset name'
-			if (!tdb) throw 'invalid termdb object'
-
-
-			await trigger_children(q, res, tdb)
-		} catch (e) {
-			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-			// @ts-ignore
-			res.send({ error: e?.message || e })
-			if (e instanceof Error && e.stack) console.log(e)
-		}
-	}
-}
-
-async function trigger_children(
-	q: {
-		genome?: string
-		dslabel?: string
-		embedder?: string
-		get_children?: number
-		tid: any
-		cohortValues?: any
-		treeFilter?: any
-	},
-	res: { send: (arg0: gettermchildrenResponse) => void },
-	tdb: { q: { getTermChildren: (arg0: any, arg1: any, arg2: any) => any } }
-) {
-	/* get children terms
-may apply ssid: a premade sample set
-*/
-	if (!q.tid) throw 'no parent term id'
-	const cohortValues = q.cohortValues ? q.cohortValues : ''
-	const treeFilter = q.treeFilter ? q.treeFilter : ''
-	const terms = await tdb.q.getTermChildren(q.tid, cohortValues, treeFilter)
-	res.send({ lst: terms.map(copy_term) } as gettermchildrenResponse)
-}

package/routes/termdb.singleSampleMutation.ts

@@ -1,87 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { read_file } from '#src/utils.js'
-import serverconfig from '#src/serverconfig.js'
-import {
-	TermdbSingleSampleMutationRequest,
-	TermdbSingleSampleMutationResponse
-} from '#shared/types/routes/termdb.singleSampleMutation.ts'
-import { gdcValidate_query_singleSampleMutation } from '#src/mds3.gdc.js'
-
-export const api: any = {
-	endpoint: 'termdb/singleSampleMutation',
-	methods: {
-		get: {
-			init,
-			request: {
-				typeId: 'TermdbSingleSampleMutationRequest'
-			},
-			response: {
-				typeId: 'TermdbSingleSampleMutationResponse'
-			}
-		}
-	}
-}
-
-function init({ genomes }) {
-	return async (req: any, res: any): Promise<void> => {
-		const q: TermdbSingleSampleMutationRequest = req.query
-		let result
-		try {
-			const g = genomes[q.genome]
-			if (!g) throw 'invalid genome name'
-			const ds = g.datasets[q.dslabel]
-			if (!ds) throw 'invalid dataset name'
-			if (!ds.queries?.singleSampleMutation) throw 'not supported on this dataset'
-			result = (await ds.queries.singleSampleMutation.get(q)) as TermdbSingleSampleMutationResponse
-		} catch (e: any) {
-			if (e.stack) console.log(e.stack)
-			result = {
-				status: e.status || 400,
-				error: e.message || e
-			} as TermdbSingleSampleMutationResponse
-		}
-		res.send(result)
-	}
-}
-
-/////////////////// ds query validator
-export async function validate_query_singleSampleMutation(ds: any, genome: any) {
-	const _q = ds.queries.singleSampleMutation
-	if (!_q) return
-	if (_q.src == 'gdcapi') {
-		gdcValidate_query_singleSampleMutation(ds, genome)
-	} else if (_q.src == 'native') {
-		// using a folder to store text files for individual samples
-		// file names are integer sample id
-		_q.get = async (q: TermdbSingleSampleMutationRequest) => {
-			/* as mds3 client may not be using integer sample id for now,
-			the argument is string id and has to be mapped to integer id
-			*/
-			let fileName = q.sample
-			if (ds.cohort?.termdb?.q?.sampleName2id) {
-				// has name-to-id converter
-				fileName = ds.cohort.termdb.q.sampleName2id(q.sample)
-				if (fileName == undefined) {
-					// unable to convert string id to integer
-					return []
-				}
-			}
-
-			const file = path.join(serverconfig.tpmasterdir, _q.folder, fileName.toString())
-			try {
-				await fs.promises.stat(file)
-			} catch (e: any) {
-				if (e.code == 'EACCES') throw 'cannot read file, permission denied'
-				if (e.code == 'ENOENT') throw 'no data for this sample'
-				throw 'failed to load data'
-			}
-
-			const data = await read_file(file)
-			// object wraps around mlst[] so it's possible to add other attr e.g. total number of mutations that exceeds viewing limit
-			return { mlst: JSON.parse(data) }
-		}
-	} else {
-		throw 'unknown singleSampleMutation.src'
-	}
-}

package/routes/termdb.singlecellData.ts

@@ -1,49 +0,0 @@
-import {
-	TermdbSinglecellDataRequest,
-	TermdbSinglecellDataResponse
-} from '#shared/types/routes/termdb.singlecellData.ts'
-
-/*
-given a sample, return it's singlecell data from dataset
-*/
-
-export const api: any = {
-	endpoint: 'termdb/singlecellData',
-	methods: {
-		get: {
-			init,
-			request: {
-				typeId: 'TermdbSinglecellDataRequest'
-			},
-			response: {
-				typeId: 'TermdbSinglecellDataResponse'
-			}
-		},
-		post: {
-			alternativeFor: 'get',
-			init
-		}
-	}
-}
-
-function init({ genomes }) {
-	return async (req: any, res: any): Promise<void> => {
-		const q = req.query as TermdbSinglecellDataRequest
-		let result
-		try {
-			const g = genomes[q.genome]
-			if (!g) throw 'invalid genome name'
-			const ds = g.datasets[q.dslabel]
-			if (!ds) throw 'invalid dataset name'
-			if (!ds.queries?.singleCell) throw 'no singlecell data on this dataset'
-			result = (await ds.queries.singleCell.data.get(q)) as TermdbSinglecellDataResponse
-		} catch (e: any) {
-			if (e.stack) console.log(e)
-			result = {
-				status: e.status || 400,
-				error: e.message || e
-			} as TermdbSinglecellDataResponse
-		}
-		res.send(result)
-	}
-}