Streamline Recorded FHIR Metadata (#109)

* use package json version

* update path

* log process version as OSVersion

* specify firebase

* update customCodes

* update subject reference

* change system to spezi.stanford.edu

* lint:fix

* fix import 2

* NicotineScoreCalculator.calculate function sync to iOS, null as default

* fix for smoking status codes

* add version to function packages

* add packageVersion helper

ES5 cant handle import assertions :(

* withdrawl -> withdrawl

thanks lukas

Co-Authored-By: Lukas Kollmer <contact@lukaskollmer.de>

* fix tests...

* lint:fix

* manual linter fixes

* package lock sync

* add tests for uncovered functions

* lint:fix

* manual linter fix

* manual linter fix 2

---------

Co-authored-by: Lukas Kollmer <contact@lukaskollmer.de>

Author: PaulGoldschmidt

functions/package-lock.json

@@ -1,5 +1,6 @@
 {
   "name": "functions",
+  "version": "0.1.1",
   "description": "Cloud Functions for Firebase",
   "type": "module",
   "scripts": {

functions/package.json

@@ -0,0 +1,60 @@
+//
+// This source file is part of the Stanford Biodesign Digital Health MyHeart Counts open-source project based on the Stanford Spezi Template Application project
+//
+// SPDX-FileCopyrightText: 2025 Stanford University
+//
+// SPDX-License-Identifier: MIT
+//
+
+import { expect } from "chai";
+import type { https } from "firebase-functions/v2";
+import { it } from "mocha";
+import { markAccountForStudyReenrollment } from "./markAccountForStudyReenrollment.js";
+import { describeWithEmulators } from "../tests/functions/testEnvironment.js";
+import { expectError } from "../tests/helpers.js";
+
+describeWithEmulators("function: markAccountForStudyReenrollment", (env) => {
+  it("re-enrolls user in study successfully", async () => {
+    const userId = await env.createUser({});
+
+    // First withdraw from study...
+    await env.factory.user().markAccountForStudyWithdrawal(userId, new Date());
+
+    // ... then re-enroll!
+    const result = await env.call(
+      markAccountForStudyReenrollment,
+      {},
+      { uid: userId },
+    );
+
+    expect(result.success).to.equal(true);
+    expect(result.reenrolledAt).to.be.a("string");
+    const reenrolledTime = new Date(result.reenrolledAt).getTime();
+    expect(reenrolledTime).to.be.lessThanOrEqual(Date.now());
+  });
+
+  it("throws error when user account not found", async () => {
+    const authUser = await env.auth.createUser({});
+
+    await expectError(
+      () =>
+        env.call(markAccountForStudyReenrollment, {}, { uid: authUser.uid }),
+      (error) => {
+        const httpsError = error as https.HttpsError;
+        expect(httpsError.code).to.equal("not-found");
+      },
+    );
+  });
+
+  it("throws error when user account is disabled", async () => {
+    const userId = await env.createUser({ disabled: true });
+
+    await expectError(
+      () => env.call(markAccountForStudyReenrollment, {}, { uid: userId }),
+      (error) => {
+        const httpsError = error as https.HttpsError;
+        expect(httpsError.code).to.equal("failed-precondition");
+      },
+    );
+  });
+});

functions/src/functions/markAccountForStudyReenrollment.test.ts

@@ -0,0 +1,55 @@
+//
+// This source file is part of the Stanford Biodesign Digital Health MyHeart Counts open-source project based on the Stanford Spezi Template Application project
+//
+// SPDX-FileCopyrightText: 2025 Stanford University
+//
+// SPDX-License-Identifier: MIT
+//
+
+import { expect } from "chai";
+import type { https } from "firebase-functions/v2";
+import { it } from "mocha";
+import { markAccountForStudyWithdrawal } from "./markAccountForStudyWithdrawl.js";
+import { describeWithEmulators } from "../tests/functions/testEnvironment.js";
+import { expectError } from "../tests/helpers.js";
+
+describeWithEmulators("function: markAccountForStudyWithdrawal", (env) => {
+  it("marks user for study withdrawal successfully", async () => {
+    const userId = await env.createUser({});
+
+    const result = await env.call(
+      markAccountForStudyWithdrawal,
+      {},
+      { uid: userId },
+    );
+
+    expect(result.success).to.equal(true);
+    expect(result.withdrawnAt).to.be.a("string");
+    const withdrawnTime = new Date(result.withdrawnAt).getTime();
+    expect(withdrawnTime).to.be.lessThanOrEqual(Date.now());
+  });
+
+  it("throws error when user account not found", async () => {
+    const authUser = await env.auth.createUser({});
+
+    await expectError(
+      () => env.call(markAccountForStudyWithdrawal, {}, { uid: authUser.uid }),
+      (error) => {
+        const httpsError = error as https.HttpsError;
+        expect(httpsError.code).to.equal("not-found");
+      },
+    );
+  });
+
+  it("throws error when user account is disabled", async () => {
+    const userId = await env.createUser({ disabled: true });
+
+    await expectError(
+      () => env.call(markAccountForStudyWithdrawal, {}, { uid: userId }),
+      (error) => {
+        const httpsError = error as https.HttpsError;
+        expect(httpsError.code).to.equal("failed-precondition");
+      },
+    );
+  });
+});

functions/src/functions/markAccountForStudyWithdrawl.test.ts

@@ -11,17 +11,17 @@ import { z } from "zod";
 import { validatedOnCall, defaultServiceAccount } from "./helpers.js";
 import { getServiceFactory } from "../services/factory/getServiceFactory.js";
 
-const markAccountForStudyWithdrawlInputSchema = z.object({});
+const markAccountForStudyWithdrawalInputSchema = z.object({});
 
-interface MarkAccountForStudyWithdrawlOutput {
+interface MarkAccountForStudyWithdrawalOutput {
   success: boolean;
   withdrawnAt: string;
 }
 
-export const markAccountForStudyWithdrawl = validatedOnCall(
-  "markAccountForStudyWithdrawl",
-  markAccountForStudyWithdrawlInputSchema,
-  async (request): Promise<MarkAccountForStudyWithdrawlOutput> => {
+export const markAccountForStudyWithdrawal = validatedOnCall(
+  "markAccountForStudyWithdrawal",
+  markAccountForStudyWithdrawalInputSchema,
+  async (request): Promise<MarkAccountForStudyWithdrawalOutput> => {
     const factory = getServiceFactory();
     const credential = factory.credential(request.auth);
     const userService = factory.user();
@@ -49,7 +49,7 @@ export const markAccountForStudyWithdrawl = validatedOnCall(
     }
 
     const withdrawnAt = new Date();
-    await userService.markAccountForStudyWithdrawl(userId, withdrawnAt);
+    await userService.markAccountForStudyWithdrawal(userId, withdrawnAt);
 
     logger.info(
       `User ${userId} successfully marked their account for study withdrawal`,

functions/src/functions/markAccountForStudyWithdrawl.ts

@@ -0,0 +1,39 @@
+//
+// This source file is part of the MyHeartCounts-Firebase project
+//
+// SPDX-FileCopyrightText: 2023 Stanford University
+//
+// SPDX-License-Identifier: MIT
+//
+
+// Small helper function to inject the current functions version to the backend generated FHIR Observations
+
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+interface PackageJson {
+  version: string;
+}
+
+let cachedVersion: string | undefined;
+
+export const getPackageVersion = (): string => {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+
+  try {
+    const packageJsonPath = join(__dirname, "../../package.json");
+    const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(packageJsonContent) as PackageJson;
+    cachedVersion = packageJson.version;
+    return cachedVersion;
+  } catch (error) {
+    console.error("Failed to read package.json version:", error);
+    return "unknown";
+  }
+};

functions/src/helpers/packageVersion.ts

@@ -52,6 +52,5 @@ export * from "./functions/onUserQuestionnaireResponseWritten.js";
 export * from "./functions/deleteHealthSamples.js";
 export * from "./functions/onArchivedLiveHealthSampleUploaded.js";
 export * from "./functions/markAccountForDeletion.js";
-export * from "./functions/markAccountForStudyWithdrawl.js";
 export * from "./functions/markAccountForStudyReenrollment.js";
 export * from "./functions/processUserDeletions.js";

functions/src/index.ts

@@ -12,6 +12,7 @@ import {
   type Score,
   type FHIRCodeableConcept,
 } from "@stanfordbdhg/myheartcounts-models";
+import { getPackageVersion } from "../../helpers/packageVersion.js";
 
 export interface QuestionnaireObservationConfig {
   customCode: string;
@@ -33,8 +34,7 @@ export const scoreToObservation = (
       {
         code: config.customCode,
         display: config.display,
-        system:
-          "https://myheartcounts.stanford.edu/fhir/CodeSystem/observation-codes",
+        system: "https://spezi.stanford.edu",
       },
     ],
     text: config.display,
@@ -44,7 +44,7 @@ export const scoreToObservation = (
     id: observationId,
     status: FHIRObservationStatus.final,
     subject: {
-      reference: `Patient/${userId}`,
+      reference: `user/${userId}`,
     },
     code: codeableConcept,
     valueQuantity: {
@@ -67,26 +67,26 @@ export const scoreToObservation = (
       },
       {
         url: "https://bdh.stanford.edu/fhir/defs/sourceRevision/source/name",
-        valueString: "My Heart Counts",
+        valueString: "My Heart Counts Firebase",
       },
       {
         url: "https://bdh.stanford.edu/fhir/defs/sourceRevision/source/bundleIdentifier",
         valueString: "edu.stanford.MyHeartCounts",
       },
       {
         url: "https://bdh.stanford.edu/fhir/defs/sourceRevision/version",
-        valueString: "3.0.0 (955)",
+        valueString: getPackageVersion(),
       },
       {
         url: "https://bdh.stanford.edu/fhir/defs/sourceRevision/OSVersion",
-        valueString: "18.5.0",
+        valueString: process.version,
       },
     ],
   });
 };
 
 export const getDietObservationConfig = (): QuestionnaireObservationConfig => ({
-  customCode: "diet-mepa-score",
+  customCode: "MHCCustomSampleTypeDietMEPAScore",
   display: "Diet MEPA Score",
   unit: "count",
   unitSystem: "http://unitsofmeasure.org",
@@ -95,15 +95,15 @@ export const getDietObservationConfig = (): QuestionnaireObservationConfig => ({
 
 export const getNicotineObservationConfig =
   (): QuestionnaireObservationConfig => ({
-    customCode: "nicotine-exposure-score",
+    customCode: "MHCCustomSampleTypeNicotineExposure",
     display: "Nicotine Exposure Score",
     unit: "count",
     unitSystem: "http://unitsofmeasure.org",
     ucumCode: "{count}",
   });
 
 export const getWho5ObservationConfig = (): QuestionnaireObservationConfig => ({
-  customCode: "who5-wellbeing-score",
+  customCode: "MHCCustomSampleTypeWHO5Score",
   display: "WHO-5 Well-Being Score",
   unit: "count",
   unitSystem: "http://unitsofmeasure.org",

functions/src/services/questionnaireResponse/fhirObservationConverter.ts

@@ -119,7 +119,7 @@ export class HeartRiskLdlParsingQuestionnaireResponseService extends Questionnai
       id: observationId,
       status: FHIRObservationStatus.final,
       subject: {
-        reference: `Patient/${userId}`,
+        reference: `user/${userId}`,
       },
       code: {
         coding: [
@@ -130,8 +130,7 @@ export class HeartRiskLdlParsingQuestionnaireResponseService extends Questionnai
           {
             code: "MHCCustomSampleTypeBloodLipidMeasurement",
             display: "LDL Cholesterol",
-            system:
-              "https://myheartcounts.stanford.edu/fhir/CodeSystem/observation-codes",
+            system: "https://spezi.stanford.edu",
           },
         ],
       },

functions/src/services/questionnaireResponse/heartRiskLdlParsingService.ts

@@ -95,11 +95,11 @@ export class HeartRiskNicotineScoringQuestionnaireResponseService extends Questi
       }
 
       const answer = responseItem.answer[0];
-      if (answer.valueCoding?.display) {
-        return answer.valueCoding.display;
+      if (answer.valueCoding?.code) {
+        return answer.valueCoding.code;
       }
 
-      logger.warn(`No valueCoding.display found for linkId '${linkId}'`);
+      logger.warn(`No valueCoding.code found for linkId '${linkId}'`);
       return null;
     } catch (error) {
       logger.warn(