rxome-generator 1.0.2 → 1.0.4-beta.1

package/lib/rxome-api-demo.js

@@ -0,0 +1,26 @@
+const CRYPT_PRIVATE_KEY = '-----BEGIN PGP PRIVATE KEY BLOCK-----\n\nxYYEY0gdfxYJKwYBBAHaRw8BAQdAYqNejQxT4gE+w2nwBvP+pe19P152F6LV\n8sqM/Qhut2D+CQMIlk6wdgn1LOXgt14o00FVGL49l+pQB8umf27PPnWrJ9IS\nIElQjaCsRYA3ZD/rnDUZiBGVS9++PaegYL339QT2bDp8l6VVtvcxG77svZ2n\na80Xcnh0ZXN0IDxpbmZvQHJ4b21lLm5ldD7CjAQQFgoAHQUCY0gdfwQLCQcI\nAxUICgQWAAIBAhkBAhsDAh4BACEJEGvtGF4xeK/wFiEEP1IE7WS9w5iQJRD8\na+0YXjF4r/CW7AD7BlIn1BHx8kOdyrt6E0L1EKIUi88Q3jQghmvlQomsIzIB\nAKW3e7gYkQJufFTlTWmD5dYmP4v3DfAGvkmFljOvHfwGx4sEY0gdfxIKKwYB\nBAGXVQEFAQEHQNBoBiWwb9t6WCMulp6/opgVJ88iKOY9MpAoZ5dyEbJwAwEI\nB/4JAwhZhPonkWKqteBKH35kf07JpJVMX8LWmZCqdFqXw8tmsU81LtCxVRl8\nexJ0vJor/6LmBUnzMrVSG3S0PCVLw0hAfCH4nN9HxT5gEc1mFFfSwngEGBYI\nAAkFAmNIHX8CGwwAIQkQa+0YXjF4r/AWIQQ/UgTtZL3DmJAlEPxr7RheMXiv\n8FlgAP9S+Oc82N6iSA4gj9hOt6dz7E4YE/3XGf+7uVQb3xVYSQD6A4X+cisS\nfqCVd5bPCMqAQQHjHgGBQawPK/PXyk9JxQQ=\n=idJc\n-----END PGP PRIVATE KEY BLOCK-----\n';
+
+const CRYPT_PUBLIC_KEY = '-----BEGIN PGP PUBLIC KEY BLOCK-----\n\nxjMEY0gdfxYJKwYBBAHaRw8BAQdAYqNejQxT4gE+w2nwBvP+pe19P152F6LV\n8sqM/Qhut2DNF3J4dGVzdCA8aW5mb0ByeG9tZS5uZXQ+wowEEBYKAB0FAmNI\nHX8ECwkHCAMVCAoEFgACAQIZAQIbAwIeAQAhCRBr7RheMXiv8BYhBD9SBO1k\nvcOYkCUQ/GvtGF4xeK/wluwA+wZSJ9QR8fJDncq7ehNC9RCiFIvPEN40IIZr\n5UKJrCMyAQClt3u4GJECbnxU5U1pg+XWJj+L9w3wBr5JhZYzrx38Bs44BGNI\nHX8SCisGAQQBl1UBBQEBB0DQaAYlsG/belgjLpaev6KYFSfPIijmPTKQKGeX\nchGycAMBCAfCeAQYFggACQUCY0gdfwIbDAAhCRBr7RheMXiv8BYhBD9SBO1k\nvcOYkCUQ/GvtGF4xeK/wWWAA/1L45zzY3qJIDiCP2E63p3PsThgT/dcZ/7u5\nVBvfFVhJAPoDhf5yKxJ+oJV3ls8IyoBBAeMeAYFBrA8r89fKT0nFBA==\n=odkw\n-----END PGP PUBLIC KEY BLOCK-----\n';
+
+const R_ID = 'rxome';
+const R_PUBLIC_KEY =  '4OShAt7RQ/RJA0qAvoaOQ2jx7SFBYef70XPIz7r9924=';
+const R_PRIVATE_KEY = 'Rf7VbeUBQmjvAagwsWx6riaZYc7h4OBD4CuxYyZ5bgA=';
+// const R_PUBLIC_KEY =  '60uReCXTn7KTEIExM4KveKstBGI3TaSrQss4biaesNs=';
+// const R_PRIVATE_KEY = 'lBSkSxe/+UBWOeF5OJdQgf9qZhiI85hYE6yJCuWjCNk=';
+// const R_PRIVATE_KEY = 'NamaTB+xwDFxtkQyBBkjRr5GEaXNtCw/G4qydnhQk5Y=';
+// const R_PUBLIC_KEY  = 'XvbhLWKbA1wfKsx3B7FKQuDQsZTZ/dMXWiD1MehBxZg=';
+
+const J_ID = 'rxomej';
+const J_PRIVATE_KEY = 'QhcoRruGBVP39XCh8BujCE+q42qCRy/tu2CQ4YmRBgg=';
+const J_PUBLIC_KEY = 'XL/i8jrJC55AdOV3zYHIIa095De5eYbDqWDPDW2r8tk=';
+
+const DEMO_CREDENTIALS = {
+  id: R_ID,
+  user: 'test@rxome.net',
+  key: R_PRIVATE_KEY
+};
+
+export { CRYPT_PRIVATE_KEY, CRYPT_PUBLIC_KEY, DEMO_CREDENTIALS };
+export const DEMO_API_PRIVATE_KEY = R_PRIVATE_KEY;
+export const DEMO_API_PUBLIC_KEY = R_PUBLIC_KEY;
+export const DEMO_API_ID = R_ID;

package/lib/rxome-api.js

@@ -0,0 +1,247 @@
+// Using native fetch API instead of axios for better webpack compatibility
+import * as ED from 'noble-ed25519';
+import Protobuf from 'protobufjs';
+import { stringify } from 'querystring';
+
+const API = 'https://app.findme2care.de';
+const TESTAPI = 'https://stage.findme2care.de';
+const APIENTRY = 'api/v1';
+const VSTR = 'API1.0'
+const IS_DEMO = '_DEMO_PSEUDONYM_';
+
+export { API, TESTAPI, APIENTRY, VSTR, IS_DEMO };
+
+/************************************************************************************
+ * Helper functions
+ ************************************************************************************/
+
+// have issues:
+const base64ToBufferVintage = data => atob(data.toString());
+//const bufferToBase64 = data => Buffer.from(data).toString('base64');
+
+const unpack = (arr) => Uint8Array.from( arr.map( c => c.charCodeAt(0) ));
+
+let readSigKey = name => { console.log("Error: not supported") }
+
+const base64ToBuffer = enc => {
+  const len = Protobuf.util.base64.length(enc);
+  let buf = new Protobuf.util.Array( len );
+  Protobuf.util.base64.decode(enc, buf, 0);
+  return buf;
+}
+
+const bufferToBase64 = buf => {
+  return Protobuf.util.base64.encode(buf, 0, buf.length);
+}
+
+export { base64ToBuffer, bufferToBase64, unpack };
+
+/************************************************************************************
+ * Functions for node.js only
+ ************************************************************************************/
+
+// Node.js specific functions that require fs module
+readSigKey = async name => {
+  try {
+    const FS = await import('fs');
+    if (!FS.existsSync( name )) {
+      throw 'Key file not found!';
+    }
+    return FS.readFileSync( name ).slice(0,44);
+  } catch (e) {
+    if (e instanceof Error && e.code !== "MODULE_NOT_FOUND") {
+      throw e;
+    }
+    throw new Error('fs module not available - cannot read key file');
+  }
+}
+
+export const generateApiKeys = async () => {
+  const privateKey = ED.utils.randomPrivateKey();
+  const publicKey = await ED.getPublicKey(privateKey);
+  return {
+    privateKey: privateKey,
+    publicKey: publicKey
+  }
+}
+
+export const writeApiKeys = async (name = 'rxome', dir = '.') => {
+  try {
+    const FS = await import('fs');
+    const key = await generateApiKeys();
+    await Promise.all([
+      FS.writeFile( `${dir}/${name}.private.apikey`, bufferToBase64( key.privateKey ), { mode: 0o600 }, err => { if (err) throw err; } ),
+      FS.writeFile( `${dir}/${name}.public.apikey`, bufferToBase64( key.publicKey ), { mode: 0o600 }, err => { if (err) throw err; } )
+    ]);
+  } catch (e) {
+    if (e instanceof Error && e.code !== "MODULE_NOT_FOUND") {
+      throw e;
+    }
+    throw new Error('fs module not available - cannot write API keys');
+  }
+}
+
+export { readSigKey };
+
+/************************************************************************************/
+
+export const signData = async( keyId, user, keyB64, created, debug = false ) => {
+  const message = `x-date: ${created}\nx-rxome-user: ${user}`
+  const messageUi8 = unpack( Array.from(message) );
+
+  const key = unpack( [...base64ToBufferVintage(keyB64)] );
+  debug && console.log('Base 64 key: ', keyB64);
+  debug && console.log('Binary key: ', key, " Key length: ", key.length);
+
+  const signature = await ED.sign( messageUi8, key);
+  const sigB64 = bufferToBase64( signature );
+  const auth=`Signature keyId="${keyId}",algorithm="ed25519",headers="x-date x-rxome-user",signature="${sigB64}",created="${created}"`
+  debug && console.log('Auth string: ', auth);
+
+  return auth;
+}
+
+export const fetchData = async ( url, credentials, pseudonym = '', debug = false ) => {
+  debug && console.log( 'Fetching from', url )
+
+  const created = Date.now();
+  const keyId = credentials.keyId || "rxome";
+  const user = credentials.user || `${keyId}@rxome.net`;
+  const keyB64 = credentials.key || await readSigKey( process.cwd()+'/'+credentials.keyFile );
+
+  const auth = await signData( keyId, user, keyB64, created, debug );
+
+  // Build URL with query parameters
+  const urlParams = new URLSearchParams({
+    pslab: !!pseudonym.trim(),
+    demo: pseudonym === IS_DEMO
+  });
+  const fullUrl = `${url}?${urlParams}`;
+
+  // Create AbortController for timeout
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 5000);
+
+  return fetch(fullUrl, {
+    method: 'GET',
+    headers: {
+      Authorization: auth,
+      'x-date': created,
+      'x-rxome-user': user
+    },
+    signal: controller.signal
+  })
+  .then(async response => {
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      let errorData = null;
+      try {
+        errorData = await response.json();
+      } catch (e) {
+        // If response can't be parsed as JSON, use default error
+      }
+
+      const error = new Error(`HTTP error! status: ${response.status}`);
+      error.response = {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        data: errorData
+      };
+      throw error;
+    }
+    return response.json();
+  })
+  .then(data => {
+    debug && console.log( "Result Data= ", data );
+    return data;
+  })
+  .catch(error => {
+    clearTimeout(timeoutId);
+    if (error.name === 'AbortError') {
+      const timeoutError = new Error('Request timeout');
+      timeoutError.response = {
+        status: 408,
+        statusText: 'Request Timeout',
+        data: { message: 'Request timeout' }
+      };
+      throw timeoutError;
+    }
+    throw error;
+  })
+}
+
+export const pushData = async ( url, credentials, msg, debug = false ) => {
+  debug && console.log( 'Pushing to ', url )
+  console.log( 'Pushing to ', url )
+
+  const created = Date.now();
+  const keyId = credentials.keyId || "rxome";
+  const user = credentials.user || `${keyId}@rxome.net`;
+  const keyB64 = credentials.key || await readSigKey( process.cwd()+'/'+credentials.keyFile );
+
+  const auth = await signData( keyId, user, keyB64, created, debug );
+
+  // Create AbortController for timeout
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 5000);
+
+  return fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: auth,
+      'x-date': created,
+      'x-rxome-user': user
+    },
+    body: JSON.stringify(msg),
+    signal: controller.signal
+  })
+  .then(response => {
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      // Create error object similar to axios
+      const error = new Error(`HTTP error! status: ${response.status}`);
+      error.response = {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        data: null
+      };
+      throw error;
+    }
+    return response.json();
+  })
+  .then(data => {
+    debug && console.log( "Result Data= ", data );
+    return data;
+  })
+  .catch( (error) => {
+    clearTimeout(timeoutId);
+    let msg = null;
+    if (error.response) {
+      // Request made and server responded
+      if (error.response && error.response.data && error.response.data.message){
+        console.log( '[SendData Response Error] ', error.response.data.message );
+        msg = `Response Error: ${error.response.data.message}`;
+        console.log(error.response.data);
+      } else {
+        console.log( '[SendData Response Error] no message' );
+        msg = 'Unknown response error';
+      }
+      console.log(error.response.status);
+      console.log(error.response.headers);
+    } else if (error.name === 'AbortError') {
+      // Request was aborted (timeout)
+      console.log('[SendData Timeout Error]');
+      msg = 'Request timeout';
+    } else {
+      // Something happened in setting up the request that triggered an Error
+      console.log('[SendData Request Error]  ', error.message);
+      msg = `Request Error: ${error.message}`;
+    }
+    const err = new Error( `Error sending data: ${msg}` );
+    console.log(err.name + ': ' + err.message);
+    throw err;
+  })
+}

package/lib/rxome-api.test.js

@@ -1,19 +1,19 @@
-const RxAPI = require('./rxome-api');
-const FS = require('fs');
-const ED = require( 'noble-ed25519' );
+import * as RxAPI from './rxome-api.js';
+import { readFileSync, existsSync, statSync } from 'fs';
+import * as ED from 'noble-ed25519';
 
 describe('API access', () => {
   test.skip('generates valid API access keys', async () => {
     await RxAPI.writeApiKeys( '__TESTSUITE_jesttest' );
-    expect( FS.existsSync('__TESTSUITE_jesttest.private.apikey') ).toBe( true );
-    expect( FS.existsSync('__TESTSUITE_jesttest.public.apikey') ).toBe( true );
-    expect( FS.statSync('__TESTSUITE_jesttest.private.apikey').size - 44 ).toBeLessThan( 2 );
-    expect( FS.statSync('__TESTSUITE_jesttest.public.apikey').size - 44 ).toBeLessThan( 2 );
+    expect( existsSync('__TESTSUITE_jesttest.private.apikey') ).toBe( true );
+    expect( existsSync('__TESTSUITE_jesttest.public.apikey') ).toBe( true );
+    expect( statSync('__TESTSUITE_jesttest.private.apikey').size - 44 ).toBeLessThan( 2 );
+    expect( statSync('__TESTSUITE_jesttest.public.apikey').size - 44 ).toBeLessThan( 2 );
 
     const message='Answer to life the universe and everything';
     const messageUi8 = RxAPI.unpack(Array.from(message));
-    const privKey = RxAPI.unpack([...RxAPI.base64ToBuffer( FS.readFileSync('__TESTSUITE_jesttest.private.apikey'))])
-    const pubKey = RxAPI.unpack([...RxAPI.base64ToBuffer( FS.readFileSync('__TESTSUITE_jesttest.public.apikey'))])
+    const privKey = RxAPI.unpack([...RxAPI.base64ToBuffer( readFileSync('__TESTSUITE_jesttest.private.apikey'))])
+    const pubKey = RxAPI.unpack([...RxAPI.base64ToBuffer( readFileSync('__TESTSUITE_jesttest.public.apikey'))])
     const signature = await ED.sign(messageUi8, privKey);
     const isValid = await ED.verify(signature, messageUi8, pubKey);
     expect( isValid ).toBeTruthy;

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 )
+  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,26 @@ 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 ) =>
   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 +171,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 +224,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 +243,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 +260,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 +292,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 +323,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 +342,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 +352,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 +367,4 @@ exports.versionStr = () => {
   // const clearBin = Buffer.from (clearBufferBin, 'Binary');
   // const phenoPrimeBin = Coder.decodePhenoPacket(clearBin);
   // const phenoBin = JSON.parse(JSON.stringify(phenoPrimeBin));
-  // //// 
-
+  // ////