rxome-generator 1.0.3 → 1.0.4-beta.2

package/lib/{rxome-generator.cjs → rxome-generator.js}

@@ -1,16 +1,17 @@
 // https://openpgpjs.org/
-const PGP = require( 'openpgp' );
+import * as PGP from 'openpgp';
 
 // https://github.com/soldair/node-qrcode
-const QRCode = require( 'qrcode' );
+import QRCode from 'qrcode';
 
-const jsonKeyConverter = require('json-key-converter');
-const Protobuf = require('protobufjs');
-const PhenoPacketDescriptor = require("./phenopackets.json");
+import jsonKeyConverter from 'json-key-converter';
+import Protobuf from 'protobufjs';
+import PhenoPacketDescriptor from "./phenopackets.js";
+import { version } from './package-info.js';
 
 //const { constants } = require('buffer');
 
-const RxAPI= require('./rxome-api.cjs');
+import * as RxAPI from './rxome-api.js';
 
 const apiVer = '1.0';
 const RXAPI = RxAPI.API;
@@ -24,35 +25,42 @@ const ProtoBufRoot = Protobuf.Root.fromJSON( PhenoPacketDescriptor );
 const PhenoPacket = ProtoBufRoot.lookupType('org.phenopackets.schema.v2.Phenopacket')
 
 const ENUM_SEX = ['UNKNOWN', 'FEMALE', 'MALE', 'OTHER']
-exports.ENUM_SEX = ENUM_SEX;
+export { ENUM_SEX };
 
 const ENUM_PROG_STATE = ['UNKNOWN_PROGRESS', 'IN_PROGRESS', 'COMPLETED', 'SOLVED', 'UNSOLVED']
-exports.ENUM_PROG_STATE = ENUM_PROG_STATE;
+export { ENUM_PROG_STATE };
 
-const ENUM_ACMG = 
+const ENUM_ACMG =
   ['NOT_PROVIDED', 'BENIGN', 'LIKELY_BENIGN', 'UNCERTAIN_SIGNIFICANCE', 'LIKELY_PATHOGENIC', 'PATHOGENIC'];
 
-exports.ENUM_ACMG = ENUM_ACMG;
+export { ENUM_ACMG };
 
 
 /************************************************************************************
  * Functions for node.js only
  ************************************************************************************/
 
-try {
-  const FS = require( 'fs/promises' );
-  const { version } = require('os');
-  
-  exports.generateRxomeKeyFiles = async (name = 'rxome', dir = '.') => {
-    const { privateKey, publicKey } = await exports.generateRxomeKeys( name );
+export const generateRxomeKeyFiles = async (name = 'rxome', dir = '.') => {
+  try {
+    const FS = await import('fs/promises');
+    const { privateKey, publicKey } = await generateRxomeKeys( name );
     await Promise.all([
       FS.writeFile(`${dir}/${name}.private.key`, privateKey, { mode: 0o600 }, err => { console.log(err); }),
       FS.writeFile(`${dir}/${name}.public.key`, publicKey, { mode: 0o600 }, function (err) { console.log(err); })
     ]);
   }
- 
-  exports.writeQR = async ( filename, data, api = RXAPI, apiEntry = APIENTRY ) => {
-    const {qrData, pseudonym, content} = await exports.prepareQR( data, api, apiEntry );
+  catch (e) {
+    if (e instanceof Error && e.code !== "MODULE_NOT_FOUND") {
+      throw e;
+    } else {
+      throw new Error('fs module not available - cannot write key files');
+    }
+  }
+}
+
+export const writeQR = async ( filename, data, api = RXAPI, apiEntry = APIENTRY ) => {
+  try {
+    const {qrData, pseudonym, content} = await prepareQR( data, api, apiEntry );
     //const base64Data = qr_code.replace(/^data:image\/png;base64,/, "");
     //FS.writeFile(filename, base64Data, 'base64', (err) => {console.log(err)} );
     QRCode.toFile( filename, JSON.stringify( qrData ), { type: 'png'} )
@@ -61,19 +69,20 @@ try {
       qr_content: content
     }
   }
-}
-
-catch (e) {
-  if (e instanceof Error && e.code !== "MODULE_NOT_FOUND") {
-    throw e;
+  catch (e) {
+    if (e instanceof Error && e.code !== "MODULE_NOT_FOUND") {
+      throw e;
+    } else {
+      throw new Error('fs module not available - cannot write QR file');
+    }
   }
 }
 
 /************************************************************************************/
 
 
-exports.generateRxomeKeys = async (name = 'rxome') => {
-  return { privateKey, publicKey, revocationCertificate } = await PGP.generateKey({
+export const generateRxomeKeys = async (name = 'rxome') => {
+  const { privateKey, publicKey, revocationCertificate } = await PGP.generateKey({
     type: 'ecc',
     curve: 'curve25519',
     //type: 'rsa',
@@ -82,41 +91,42 @@ exports.generateRxomeKeys = async (name = 'rxome') => {
     passphrase: PASSPHRASE,
     format: 'armored'
   });
+  return { privateKey, publicKey, revocationCertificate };
 }
 
 
-exports.fetchKey = async ( credentials, pseudonym = '', api = RXAPI, debug = false, apiEntry = APIENTRY ) => {
+export const fetchKey = async ( credentials, pseudonym = '', api = RXAPI, debug = false, apiEntry = APIENTRY ) => {
   const result = await RxAPI.fetchData( `${api}/${apiEntry}/getpseudonym`, credentials, pseudonym, debug )
   if ( result.pseudonym === '' )
     result.pseudonym = pseudonym;
   return result;
 }
-/* 
+/*
   yields: { key: PGP_key, version: ..., pseudonym: ... }
 */
- 
- 
-exports.fetchDemoPrivateKey = async ( credentials, api=RXTESTAPI, debug = false, apiEntry = APIENTRY ) => 
+
+
+export const fetchDemoPrivateKey = async ( credentials, api=RXTESTAPI, debug = false, apiEntry = APIENTRY ) =>
   await RxAPI.fetchData( `${api}/${apiEntry}/getprivatedemokey`, credentials, '', debug )
 
-/* 
-   yields: { private_key: PGP_key } 
+/*
+   yields: { private_key: PGP_key }
 */
 
-exports.fetchRxomeKey = async ( credentials, api = RXAPI, debug = false, apiEntry = APIENTRY ) => 
+export const fetchRxomeKey = async ( credentials, api = RXAPI, debug = false, apiEntry = APIENTRY ) =>
   await RxAPI.fetchData( `${api}/${apiEntry}/getrxomekey`, credentials, '', debug )
 
-/* 
-   yields: { key: PGP_key, version: ... } 
+/*
+   yields: { key: PGP_key, version: ... }
 */
-exports.convert_to_snake_case = data => jsonKeyConverter.convert( data, { camel: false } );
+export const convert_to_snake_case = data => jsonKeyConverter.convert( data, { camel: false } );
 
-exports.convertToCamelCase = data => jsonKeyConverter.convert( data, { camel: true } );
+export const convertToCamelCase = data => jsonKeyConverter.convert( data, { camel: true } );
 
-exports.compressPhenoPacket = ( data ) => {
+export const compressPhenoPacket = ( data ) => {
   const compressedData = {
     ...data,
-  };  
+  };
   if ( data.phenotypicFeatures ) {
     compressedData.compressedFeatures = {
       includes: data.phenotypicFeatures.filter( feat => feat.excluded === undefined  || feat.excluded === false || feat.excluded === 'false' ).map( feat => feat.type.id ),
@@ -128,26 +138,30 @@ exports.compressPhenoPacket = ( data ) => {
 }
 
 
-exports.sanitizeSex = ( str ) =>
+export const sanitizeSex = ( str ) =>
   isNaN(+(str.toString()))
   ? Math.max(0, ENUM_SEX.indexOf(str.toUpperCase().replace('_SEX', '')))
   : +str;
 
 
-exports.sanitizeProgState = ( str ) =>
+export const sanitizeProgState = ( str ) =>
   isNaN(+(str.toString()))
   ? Math.max(0, ENUM_PROG_STATE.indexOf(str.toUpperCase()))
   : +str;
 
 
-exports.sanitizeACMG = ( str ) =>
+export const sanitizeACMG = ( str ) => {
+  // special case for 'RISK_ALLELE'
+  if ( str == 'RISK_ALLELE' ) {
+    return 999;
+  }
   isNaN(+(str.toString()))
   ? Math.max(0, ENUM_ACMG.indexOf(str.toUpperCase()))
   : +str
+}
 
-
-exports.whiteListPhenoPacket = ( data ) => {
-  res = {};
+export const whiteListPhenoPacket = ( data ) => {
+  let res = {};
   data.id  && (res.id = data.id);
   data.comment  && (res.comment = data.comment);
   data.subject  && (res.subject = data.subject);
@@ -161,48 +175,48 @@ exports.whiteListPhenoPacket = ( data ) => {
 }
 
 
-exports.sanitizePhenoPacket = ( data, key = '' ) => {
+export const sanitizePhenoPacket = ( data, key = '' ) => {
   if ( data instanceof Object ) {
     if (Array.isArray( data )) {
-      return data.map( x => exports.sanitizePhenoPacket(x));
+      return data.map( x => sanitizePhenoPacket(x));
     } else {
       let obj={};
-      for ( let k in data ) { 
-        obj[k] = exports.sanitizePhenoPacket( data[k], k );
+      for ( let k in data ) {
+        obj[k] = sanitizePhenoPacket( data[k], k );
       }
       return obj;
     }
   } else {
     switch( key ){
       case 'sex':
-        return exports.sanitizeSex( data );
+        return sanitizeSex( data );
       case 'progressStatus':
-        return exports.sanitizeProgState( data );
+        return sanitizeProgState( data );
       case 'acmgPathogenicityClassification':
-        return exports.sanitizeACMG( data );
-      default: 
+        return sanitizeACMG( data );
+      default:
         return data;
     }
   }
 }
 
 
-exports.verifyPhenoPacket = (data) => (
+export const verifyPhenoPacket = (data) => (
   PhenoPacket.verify( data )
 )
 
 
-exports.encodePhenoPacket = (data) => (
+export const encodePhenoPacket = (data) => (
   PhenoPacket.encode( data ).finish()
 )
 
 
-exports.decodePhenoPacket = (data) => (
+export const decodePhenoPacket = (data) => (
   PhenoPacket.decode( data )
 )
 
 
-exports.encode_serial = async (publicKeyStr, message) => {
+export const encode_serial = async (publicKeyStr, message) => {
   const publicKey = await PGP.readKey({ armoredKey: publicKeyStr });
   const encrypted = await PGP.encrypt({
     message: await PGP.createMessage({ text: message }),
@@ -214,10 +228,10 @@ exports.encode_serial = async (publicKeyStr, message) => {
 }
 
 
-exports.encode = async (publicKeyStr, message, binary = false) => {
+export const encode = async (publicKeyStr, message, binary = false) => {
   return await Promise.all([
     PGP.readKey({ armoredKey: publicKeyStr }),
-    PGP.createMessage( (binary 
+    PGP.createMessage( (binary
                         ? { binary: message, format: 'binary' }
                         : { text: message }) )
   ]).then( async ([publicKey, message]) => {
@@ -233,7 +247,7 @@ exports.encode = async (publicKeyStr, message, binary = false) => {
 }
 
 
-exports.decode_serial = async (privateKeyStr, encrypted) => {
+export const decode_serial = async (privateKeyStr, encrypted) => {
   const privateKey = await PGP.readPrivateKey( { armoredKey: privateKeyStr } );
   const privateKeyDecr = await PGP.decryptKey({
     privateKey: privateKey,
@@ -250,16 +264,16 @@ exports.decode_serial = async (privateKeyStr, encrypted) => {
 }
 
 
-exports.decode = async (privateKeyStr, encrypted, binary = false) => {
+export const decode = async (privateKeyStr, encrypted, binary = false) => {
   return await Promise.all([
     PGP.readPrivateKey({ armoredKey: privateKeyStr })
     .then( (privateKey) => {
       return PGP.decryptKey({
         privateKey: privateKey,
-        passphrase: PASSPHRASE 
+        passphrase: PASSPHRASE
       })
     }),
-    PGP.readMessage( (binary 
+    PGP.readMessage( (binary
                       ? {binaryMessage: encrypted}
                       : {armoredMessage: encrypted} )
     )
@@ -282,27 +296,28 @@ exports.decode = async (privateKeyStr, encrypted, binary = false) => {
 }
 
 
-exports.prepareQR = async ( data, api = RXAPI, apiEntry = APIENTRY ) => {
+export const prepareQR = async ( data, api = RXAPI, apiEntry = APIENTRY ) => {
+  console.log(`RxOME QR Generator version: ${version}`);
   const { metaData, credentials, ...medical } = data;
 
-  const whiteListMedical  = exports.whiteListPhenoPacket( medical );
-  const sanitizedMedical  = exports.sanitizePhenoPacket( whiteListMedical );
-  const compressedMedical = exports.compressPhenoPacket( sanitizedMedical );
-  const protobufMedical   = exports.encodePhenoPacket( compressedMedical );
+  const whiteListMedical  = whiteListPhenoPacket( medical );
+  const sanitizedMedical  = sanitizePhenoPacket( whiteListMedical );
+  const compressedMedical = compressPhenoPacket( sanitizedMedical );
+  const protobufMedical   = encodePhenoPacket( compressedMedical );
   const base64Medical     = RxAPI.bufferToBase64(protobufMedical);
 
-  const key = await this.fetchKey( credentials, metaData?.pseudonym || '', api, false, apiEntry );
+  const key = await fetchKey( credentials, (metaData && metaData.pseudonym) || '', api, false, apiEntry );
 
   // check:
   const buff = RxAPI.base64ToBuffer( base64Medical );
-  const pheno = exports.decodePhenoPacket( buff );
+  const pheno = decodePhenoPacket( buff );
   const medicalDeciphered = JSON.parse( JSON.stringify( pheno ));
   // console.log( JSON.stringify(medicalDeciphered,' ', 2 ))
 
-  const cipher = await exports.encode( key.key, base64Medical );
+  const cipher = await encode( key.key, base64Medical );
 
   //delete metaData.pseudonym;
-  const newMetaData = Object.fromEntries( 
+  const newMetaData = Object.fromEntries(
     Object.entries( metaData ).filter( ([key, val]) => key !== 'pseudonym')
   )
 
@@ -312,7 +327,7 @@ exports.prepareQR = async ( data, api = RXAPI, apiEntry = APIENTRY ) => {
     labid: key.lab_id,
     keyver: key.version,
     apiver: apiVer,
-    pseudonym: key.pseudonym,    
+    pseudonym: key.pseudonym,
     payload: cipher.toString()
   }
 
@@ -331,8 +346,8 @@ exports.prepareQR = async ( data, api = RXAPI, apiEntry = APIENTRY ) => {
 }
 
 
-exports.makeQR = async ( data, api = RXAPI, apiEntry = APIENTRY ) => {
-  const {qrData, pseudonym, content} = await exports.prepareQR( data, api, apiEntry );
+export const makeQR = async ( data, api = RXAPI, apiEntry = APIENTRY ) => {
+  const {qrData, pseudonym, content} = await prepareQR( data, api, apiEntry );
   return {
     qr_code: await QRCode.toDataURL( JSON.stringify( qrData )),
     pseudonym: pseudonym,
@@ -341,8 +356,8 @@ exports.makeQR = async ( data, api = RXAPI, apiEntry = APIENTRY ) => {
   }
 }
 
-exports.versionStr = () => {
-  return 'RxOME QR Generator 1.0.0, 2022 Tom Kamphans, GeneTalk GmbH'
+export const versionStr = () => {
+  return `RxOME QR Generator ${version}, 2025 Tom Kamphans, GeneTalk GmbH/RxOme GmbH`
 }
 
 
@@ -356,5 +371,4 @@ exports.versionStr = () => {
   // const clearBin = Buffer.from (clearBufferBin, 'Binary');
   // const phenoPrimeBin = Coder.decodePhenoPacket(clearBin);
   // const phenoBin = JSON.parse(JSON.stringify(phenoPrimeBin));
-  // //// 
-
+  // ////

package/lib/rxome-generator.test.js

@@ -1,9 +1,10 @@
-const Coder = require('./rxome-generator');
-const RxAPI = require( './rxome-api' );
-const ApiDemo = require( './rxome-api-demo');
+import * as Coder from './rxome-generator.js';
+import * as RxAPI from './rxome-api.js';
+import * as ApiDemo from './rxome-api-demo.js';
+import { getFetch } from './rxome-api.js';
 
-const FS = require('fs');
-const Axios = require( 'axios' );
+import { readFileSync } from 'fs';
+// Using native fetch API instead of axios
 
 const RXAPI = RxAPI.API;
 const RXTESTAPI = RxAPI.TESTAPI;
@@ -16,9 +17,9 @@ const CREDENTIALS = {
   key: ApiDemo.DEMO_API_PRIVATE_KEY
 }
 
-const DEMO_DATA = JSON.parse(FS.readFileSync('./demos/demo_data_full.json'));
+const DEMO_DATA = JSON.parse(readFileSync('./demos/demo_data_full.json'));
 
-const DEMO_DATA_COMPRESSED = JSON.parse(FS.readFileSync('./demos/demo_data_full_compressed.json'));
+const DEMO_DATA_COMPRESSED = JSON.parse(readFileSync('./demos/demo_data_full_compressed.json'));
 // compressed: without credentials due to whitelist/phenopacket filtering
 
 const DEMO_PSEUDONYM = 'HANSMOTKAMP';
@@ -98,7 +99,7 @@ describe('API access', () => {
     Coder.fetchKey(wrong_credentials, 'lab_ps', RXTESTAPI)
       .then(data => { })
       .catch(err => {
-        expect(err.response?.status.toString().toMatch('403'));
+        expect(err.response && err.response.status.toString().toMatch('403'));
       });
   });
 });
@@ -277,8 +278,8 @@ describe('Coder', () => {
   test('should encode and decode with key files', async () => {
     const message = 'Be Sure To Drink Your Ovaltine';
     await Coder.generateRxomeKeyFiles( 'testsuite' );
-    const privateKey = FS.readFileSync('./testsuite.private.key').toString();
-    const publicKey = FS.readFileSync('./testsuite.public.key').toString();
+    const privateKey = readFileSync('./testsuite.private.key').toString();
+    const publicKey = readFileSync('./testsuite.public.key').toString();
     const cipher = await Coder.encode(publicKey, message);
     const clear = await Coder.decode(privateKey, cipher);
     expect(clear).toBe(message);
@@ -291,14 +292,22 @@ describe('Rails', () => {
     const message = 'A-well-a bird bird bird, bird is the word';
     const cipher = await Coder.encode(PUBLIC_KEY, message);
 
-    const res = await Axios({
-      method$: 'GET',
-      url: `${RXTESTAPI}/api/v1/decryptTest`,
-      data: {
-        cipher: cipher
+    const params = new URLSearchParams({
+      cipher: cipher
+    });
+    const fetch = await getFetch();
+    const res = await fetch(`${RXTESTAPI}/api/v1/decryptTest?${params}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json'
       }
-    })
-    expect( res.data?.clearText ).toEqual( message ) 
+    }).then(response => {
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      return response.json();
+    }).then(data => ({ data }))
+    expect( res.data && res.data.clearText ).toEqual( message ) 
   });
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rxome-generator",
-  "version": "1.0.3",
+  "version": "1.0.4-beta.2",
   "description": "Generates QR codes containing medical information for use with the FindMe2Care platform.",
   "main": "index.js",
   "type": "module",
@@ -32,10 +32,10 @@
   "homepage": "https://github.com/GeneTalkTK/rxome-qrcode-generator#readme",
   "dependencies": {
     "@noble/ed25519": "^2.2.3",
-    "axios": "^1.7.9",
     "commander": "^13.1.0",
     "json-key-converter": "^1.0.0",
     "noble-ed25519": "^1.2.6",
+    "node-fetch": "^3.3.2",
     "openpgp": "^6.1.0",
     "protobufjs": "^7.4.0",
     "protobufjs-cli": "^1.1.3",
@@ -48,5 +48,14 @@
   },
   "bin": {
     "rxcode": "rxcode.js"
+  },
+  "jest": {
+    "globals": {
+      "NODE_OPTIONS": "--experimental-vm-modules"
+    },
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    },
+    "transform": {}
   }
 }

package/rxcode.js

@@ -4,9 +4,9 @@ import * as FS from 'fs';
 import sharp from 'sharp';
 
 // const Coder = require( './lib/rxome-generator' );
-import * as Coder from './lib/rxome-generator.cjs';
-import * as ApiDemo from './lib/rxome-api-demo.cjs' ;
-import * as RxAPI from './lib/rxome-api.cjs';
+import * as Coder from './lib/rxome-generator.js';
+import * as ApiDemo from './lib/rxome-api-demo.js' ;
+import * as RxAPI from './lib/rxome-api.js';
 
 import { program } from 'commander';
 import * as Path from 'path';
@@ -186,6 +186,10 @@ program.command('preprocess')
   .option('-c, --compress', 'Compact HPO term list')
   .action( async (inputfile, options) => {
     let data = JSON.parse(FS.readFileSync( inputfile || '/dev/stdin' ));
+    if (! (options.case || options.whitelist || options.sanitize || options.compress)) {
+      process.stderr.write( 'Error: at least one preprocessing option must be selected (-C, -w, -s, -c).');
+      return 1;
+    }
     options.case && (data = Coder.convertToCamelCase( data ));
     options.whitelist && (data = Coder.whiteListPhenoPacket( data ));
     options.sanitize && (data = Coder.sanitizePhenoPacket( data ));
@@ -306,12 +310,15 @@ program.command('decrypt')
       key = FS.readFileSync( options.keyfile ).toString();
     }
 
+    //@TODO: Guard against missing key or cipher
     const data = await Coder.decode( key, cipher.toString() );
 
     let result;
     if ( options.complete ){
-      const clearBufferB64 = await Coder.decode( key, cipher.toString() );
-      options.debug && console.error( "buffer:", clearBufferB64 )
+      if ( options.debug ) {
+        const clearBufferB64 = await Coder.decode( key, cipher.toString() );
+        console.error( "buffer:", clearBufferB64 )
+      }
       const clearB64 = RxAPI.base64ToBuffer(data);
       options.debug && console.error( "clear ", clearB64 )
       const phenoPrimeB64 = Coder.decodePhenoPacket(clearB64);