@sjcrh/proteinpaint-server 2.39.2 → 2.39.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjcrh/proteinpaint-server",
-  "version": "2.39.2",
+  "version": "2.39.5",
   "description": "a genomics visualization tool for exploring a cohort's genotype and phenotype data",
   "main": "server.js",
   "bin": "start.js",

package/routes/gdc.topMutatedGenes.ts

@@ -1,62 +1,288 @@
-import { GdcTopMutatedGeneResponse } from '#shared/types/routes/gdc.topMutatedGenes.ts'
+import { GdcTopMutatedGeneRequest, GdcTopMutatedGeneResponse } from '#shared/types/routes/gdc.topMutatedGenes.ts'
 import path from 'path'
 import got from 'got'
 
+// TODO change to /termdb/topMutatedGenes
+
 const apihost = process.env.PP_GDC_HOST || 'https://api.gdc.cancer.gov'
+const apihostGraphql = apihost + (apihost.includes('/v0') ? '' : '/v0') + '/graphql'
 
 export const api = {
 	endpoint: 'gdc/topMutatedGenes',
 	methods: {
-		get: {
-			init({ genomes }) {
-				/*
-				genomes parameter is currently not used
-				could be used later to:
-				- verify hg38/GDC is on this instance and otherwise disable this route..
-				- perform conversion on gene name/id for future on needs
-				*/
-
-				return async (req: any, res: any): Promise<void> => {
-					try {
-						const genes = await getGenes(req.query)
-						const payload = { genes } as GdcTopMutatedGeneResponse
-						res.send(payload)
-					} catch (e: any) {
-						res.send({ status: 'error', error: e.message || e })
-					}
-				}
-			},
+		all: {
+			init,
 			request: {
-				typeId: null
-				//valid: default to type checker
+				typeId: 'GdcTopMutatedGeneRequest'
 			},
 			response: {
 				typeId: 'GdcTopMutatedGeneResponse'
-				// will combine this with type checker
-				//valid: (t) => {}
 			}
 		}
 	}
 }
 
-/*
-req.query {
-	filter0 // optional gdc GFF cohort filter, invisible and read only
-		FIXME should there be pp filter too?
-	geneFilter?: str
-	maxGenes: int
+function init() {
+	/*
+	genomes parameter is currently not used
+	could be used later to:
+	- verify hg38/GDC is on this instance and otherwise disable this route..
+	- perform conversion on gene name/id for future on needs
+	*/
+	return async (req: any, res: any): Promise<void> => {
+		const q: GdcTopMutatedGeneRequest = req.query
+		try {
+			const genes = await getGenesGraphql(q)
+			const payload: GdcTopMutatedGeneResponse = { genes }
+			res.send(payload)
+		} catch (e: any) {
+			res.send({ status: 'error', error: e.message || e })
+		}
+	}
 }
 
-mayAddCGC2filter() are copied to
-/utils/gdc/topSSMgenes.js
-and hosted on https://proteinpaint.stjude.org/GDC/
-*/
-async function getGenes(q: any) {
-	let _f = { op: 'and', content: [] } // allow blank filter to test geneset edit ui (without filter)
+const query = `
+query GenesTable_relayQuery(
+  $genesTable_filters: FiltersArgument
+  $genesTable_size: Int
+  $genesTable_offset: Int
+  $score: String
+  $ssmCase: FiltersArgument
+  $geneCaseFilter: FiltersArgument
+  $ssmTested: FiltersArgument
+  $cnvTested: FiltersArgument
+  $cnvGainFilters: FiltersArgument
+  $cnvLossFilters: FiltersArgument
+) {
+  genesTableViewer: viewer {
+    explore {
+      cases {
+        hits(first: 0, filters: $ssmTested) {
+          total
+        }
+      }
+      filteredCases: cases {
+        hits(first: 0, filters: $geneCaseFilter) {
+          total
+        }
+      }
+      cnvCases: cases {
+        hits(first: 0, filters: $cnvTested) {
+          total
+        }
+      }
+      genes {
+        hits(first: $genesTable_size, offset: $genesTable_offset, filters: $genesTable_filters, score: $score) {
+          total
+          edges {
+            node {
+              id
+              numCases: score
+              symbol
+              name
+              cytoband
+              biotype
+              gene_id
+              is_cancer_gene_census
+              ssm_case: case {
+                hits(first: 0, filters: $ssmCase) {
+                  total
+                }
+              }
+              cnv_case: case {
+                hits(first: 0, filters: $cnvTested) {
+                  total
+                }
+              }
+              case_cnv_gain: case {
+                hits(first: 0, filters: $cnvGainFilters) {
+                  total
+                }
+              }
+              case_cnv_loss: case {
+                hits(first: 0, filters: $cnvLossFilters) {
+                  total
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+`
+
+async function getGenesGraphql(q: GdcTopMutatedGeneRequest) {
+	// set type "any" to avoid complains
+	const variables: any = {
+		genesTable_filters: {
+			op: 'and',
+			content: []
+		},
+		genesTable_size: q.maxGenes || 50,
+		genesTable_offset: 0,
+		score: 'case.project.project_id',
+		ssmCase: {
+			op: 'and',
+			content: [
+				{
+					op: 'in',
+					content: {
+						field: 'cases.available_variation_data',
+						value: ['ssm']
+					}
+				},
+				{
+					op: 'NOT',
+					content: {
+						field: 'genes.case.ssm.observation.observation_id',
+						value: 'MISSING'
+					}
+				}
+			]
+		},
+		geneCaseFilter: {
+			content: [
+				{
+					content: {
+						field: 'cases.available_variation_data',
+						value: ['ssm']
+					},
+					op: 'in'
+				}
+			],
+			op: 'and'
+		},
+		ssmTested: {
+			content: [
+				{
+					content: {
+						field: 'cases.available_variation_data',
+						value: ['ssm']
+					},
+					op: 'in'
+				}
+			],
+			op: 'and'
+		},
+		cnvTested: {
+			op: 'and',
+			content: [
+				{
+					content: {
+						field: 'cases.available_variation_data',
+						value: ['cnv']
+					},
+					op: 'in'
+				}
+			]
+		},
+		cnvGainFilters: {
+			op: 'and',
+			content: [
+				{
+					content: {
+						field: 'cases.available_variation_data',
+						value: ['cnv']
+					},
+					op: 'in'
+				},
+				{
+					content: {
+						field: 'cnvs.cnv_change',
+						value: ['Gain']
+					},
+					op: 'in'
+				}
+			]
+		},
+		cnvLossFilters: {
+			op: 'and',
+			content: [
+				{
+					content: {
+						field: 'cases.available_variation_data',
+						value: ['cnv']
+					},
+					op: 'in'
+				},
+				{
+					content: {
+						field: 'cnvs.cnv_change',
+						value: ['Loss']
+					},
+					op: 'in'
+				}
+			]
+		}
+	}
+
 	if (q.filter0) {
-		if (typeof q.filter0 != 'object') throw 'filter0 not object'
-		_f = q.filter0
+		variables.genesTable_filters.content.push(JSON.parse(JSON.stringify(q.filter0)))
+		variables.geneCaseFilter.content.push(JSON.parse(JSON.stringify(q.filter0)))
+		variables.cnvTested.content.push(JSON.parse(JSON.stringify(q.filter0)))
+		variables.cnvGainFilters.content.push(JSON.parse(JSON.stringify(q.filter0)))
+		variables.cnvLossFilters.content.push(JSON.parse(JSON.stringify(q.filter0)))
+	}
+
+	if (q.geneFilter == 'CGC') {
+		variables.genesTable_filters.content.push(geneCGC())
+		variables.geneCaseFilter.content.push(geneCGC())
+		variables.cnvTested.content.push(geneCGC())
+		variables.cnvGainFilters.content.push(geneCGC())
+		variables.cnvLossFilters.content.push(geneCGC())
+	}
+
+	const response = await got.post(apihostGraphql, {
+		headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+		body: JSON.stringify({ query, variables })
+	})
+
+	const re: any = JSON.parse(response.body)
+	const genes: string[] = []
+	for (const g of re.data.genesTableViewer.explore.genes.hits.edges) {
+		/*
+		{
+		  node: {
+			biotype: 'protein_coding',
+			case_cnv_gain: { hits: [Object] },
+			case_cnv_loss: { hits: [Object] },
+			cnv_case: { hits: [Object] },
+			cytoband: [ '17q11.2' ],
+			gene_id: 'ENSG00000196712',
+			is_cancer_gene_census: true,
+			name: 'neurofibromin 1',
+			numCases: 93,
+			ssm_case: { hits: [Object] },
+			symbol: 'NF1'
+		  }
+		}
+		*/
+		genes.push(g.node.symbol)
 	}
+	return genes
+}
+
+function geneCGC() {
+	// return a copy of cgc filter obj each time
+	return {
+		content: {
+			field: 'genes.is_cancer_gene_census',
+			value: ['true']
+		},
+		op: 'in'
+	} as object
+}
+
+/*************************************
+      old method to use rest api
+**************************************
+this api only gets ssm-cases and does not account for cnv cases, will not return any gene for ssm-less cohort e.g. APOLLO-LUAD
+thus is replaced by getGenesGraphql
+*/
+async function getGenes(q: GdcTopMutatedGeneRequest) {
+	const _f = q.filter0 || { op: 'and', content: [] } // allow blank filter to test geneset edit ui (without filter)
 	const response = await got.post(path.join(apihost, '/analysis/top_mutated_genes_by_project'), {
 		headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
 		body: JSON.stringify({

package/routes/termdb.cluster.ts

@@ -1,11 +1,18 @@
-import { TermdbClusterRequest, TermdbClusterResponse } from '#shared/types/routes/termdb.cluster.ts'
 import path from 'path'
+import fs from 'fs'
+import lines2R from '#src/lines2R.js'
+import {
+	TermdbClusterRequest,
+	TermdbClusterResponse,
+	Clustering,
+	ValidResponse,
+	SinglegeneResponse
+} from '#shared/types/routes/termdb.cluster.ts'
 import * as utils from '#src/utils.js'
 import serverconfig from '#src/serverconfig.js'
 import { GeneExpressionQuery, GeneExpressionQueryNative } from '#shared/types/dataset.ts'
 import { gdc_validate_query_geneExpression } from '#src/mds3.gdc.js'
 import { mayLimitSamples } from '#src/mds3.filter.js'
-import { doClustering } from '#src/doClustering.js' // unable to convert this to ts yet, when converted, move all code here
 import { dtgeneexpression } from '#shared/common.js'
 
 export const api = {
@@ -57,14 +64,87 @@ async function getResult(q: TermdbClusterRequest, ds: any) {
 	if (gene2sample2value.size == 1) {
 		// get data for only 1 gene; still return data, may create violin plot later
 		const g = Array.from(gene2sample2value.keys())[0]
-		return { gene: g, data: gene2sample2value.get(g) }
+		return { gene: g, data: gene2sample2value.get(g) } as SinglegeneResponse
 	}
 
 	// have data for multiple genes, run clustering
 	const t = Date.now() // use "t=new Date()" will lead to tsc error
-	const clustering = await doClustering(gene2sample2value, q, ds)
+	const clustering: Clustering = await doClustering(gene2sample2value, q)
 	if (serverconfig.debugmode) console.log('clustering done:', Date.now() - t, 'ms')
-	return { clustering, byTermId, bySampleId }
+	return { clustering, byTermId, bySampleId } as ValidResponse
+}
+
+async function doClustering(data: any, q: TermdbClusterRequest) {
+	// get set of unique sample names, to generate col_names dimension
+	const sampleSet = new Set()
+	for (const o of data.values()) {
+		// {sampleId: value}
+		for (const s in o) sampleSet.add(s)
+		break
+	}
+
+	const inputData = {
+		matrix: [] as number[][],
+		row_names: [] as string[], // genes
+		col_names: [...sampleSet] as string[], // samples
+		cluster_method: q.clusterMethod as string,
+		plot_image: false // When true causes cluster.rs to plot the image into a png file (EXPERIMENTAL)
+	}
+
+	// compose "data{}" into a matrix
+	for (const [gene, o] of data) {
+		inputData.row_names.push(gene)
+		const row: number[] = []
+		for (const s of inputData.col_names) {
+			row.push(o[s] || 0)
+		}
+		inputData.matrix.push(getZscore(row))
+	}
+
+	const Rinputfile = path.join(serverconfig.cachedir, Math.random().toString() + '.json')
+	await utils.write_file(Rinputfile, JSON.stringify(inputData))
+	const Routput = JSON.parse(await lines2R(path.join(serverconfig.binpath, 'utils/hclust.R'), [], [Rinputfile]))
+	fs.unlink(Rinputfile, (arg: any) => {
+		return
+	})
+
+	const row_names_index: number[] = Routput.RowOrder.map(row => inputData.row_names.indexOf(row.name)) // sorted rows. value is array index in input data
+	const col_names_index: number[] = Routput.ColOrder.map(col => inputData.col_names.indexOf(col.name)) // sorted columns, value is array index from input array
+
+	// generated sorted matrix based on row/col clustering order
+	const output_matrix: number[][] = []
+	for (const rowI of row_names_index) {
+		const newRow: number[] = []
+		for (const colI of col_names_index) {
+			newRow.push(inputData.matrix[rowI][colI])
+		}
+		output_matrix.push(newRow)
+	}
+
+	return {
+		row: {
+			merge: Routput.RowMerge,
+			height: Routput.RowHeight,
+			order: Routput.RowOrder,
+			inputOrder: inputData.row_names
+		},
+		col: {
+			merge: Routput.ColumnMerge,
+			height: Routput.ColumnHeight,
+			order: Routput.ColOrder,
+			inputOrder: inputData.col_names
+		},
+		matrix: output_matrix
+	}
+}
+function getZscore(l: number[]) {
+	const mean: number = l.reduce((sum, v) => sum + v, 0) / l.length
+	const sd: number = Math.sqrt(l.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / l.length)
+
+	if (sd == 0) {
+		return l
+	}
+	return l.map(v => (v - mean) / sd)
 }
 
 export async function validate_query_geneExpression(ds: any, genome: any) {