Merge pull request #1267 from joshunrau/fix-build

fix issue where export worker does not exist

Author: joshunrau

apps/api/libnest.config.ts

@@ -33,6 +33,10 @@ const config = defineUserConfig({
       await fs.cp(path.join(runtimeV1Dir, 'dist'), path.join(import.meta.dirname, 'dist/runtime/v1'), {
         recursive: true
       });
+      await fs.cp(
+        path.join(import.meta.dirname, 'src/instrument-records/export-worker.js'),
+        path.join(import.meta.dirname, 'dist/export-worker.js')
+      );
     },
     outfile: path.resolve(import.meta.dirname, 'dist/app.js')
   },

apps/api/src/instrument-records/export-worker.js

@@ -0,0 +1,174 @@
+import { parentPort } from 'worker_threads';
+
+/** @type {typeof import('@opendatacapture/schemas/core').DEFAULT_GROUP_NAME} */
+const DEFAULT_GROUP_NAME = 'root';
+
+/** @type {typeof import( '#runtime/v1/@opendatacapture/runtime-internal/index.js').removeSubjectIdScope} */
+let removeSubjectIdScope;
+
+// we need to resolve import correctly in development
+try {
+  const runtimeInternal = await import('#runtime/v1/@opendatacapture/runtime-internal/index.js');
+  removeSubjectIdScope = runtimeInternal.removeSubjectIdScope;
+} catch {
+  const runtimeInternal = await import('@opendatacapture/runtime-v1/@opendatacapture/runtime-internal/index.js');
+  removeSubjectIdScope = runtimeInternal.removeSubjectIdScope;
+}
+
+/**
+ * @typedef {Object} SuccessExpand
+ * @property {string} measure
+ * @property {any} measureValue
+ * @property {true} success
+ */
+
+/**
+ * @typedef {Object} FailureExpand
+ * @property {string} message
+ * @property {false} success
+ */
+
+/** @typedef {SuccessExpand | FailureExpand} ExpandDataType */
+
+/**
+ * Flattens nested record array data into a list of expandable data objects.
+ * @param {any[]} listEntry - The array of records to expand.
+ * @returns {ExpandDataType[]} An array of expanded measure objects.
+ * @throws {Error} If the provided listEntry is empty.
+ */
+function expandData(listEntry) {
+  /** @type {SuccessExpand[]} */
+  const validRecordArrayList = [];
+  if (listEntry.length < 1) {
+    throw new Error('Record Array is Empty');
+  }
+  for (const objectEntry of Object.values(listEntry)) {
+    for (const [dataKey, dataValue] of Object.entries(objectEntry)) {
+      validRecordArrayList.push({
+        measure: dataKey,
+        measureValue: dataValue,
+        success: true
+      });
+    }
+  }
+  return validRecordArrayList;
+}
+
+/**
+ * Internal cache for instrument metadata.
+ * @type {Map<string | undefined, { edition: number, id: string, name: string }>}
+ */
+let initData;
+
+/**
+ * Initializes the worker with instrument metadata.
+ * * @param {Array<{id: string, edition: number, name: string}>} data - The initialization payload.
+ */
+function handleInit(data) {
+  initData = new Map(data.map((instrument) => [instrument.id, instrument]));
+  parentPort?.postMessage({ success: true });
+}
+
+/**
+ * Processes a chunk of records and posts results back to the parent thread.
+ * @param {import('./thread-types').BeginChunkProcessingData} _data - The collection of records to process.
+ * @throws {Error} If initData is not defined.
+ */
+function handleChunkComplete(_data) {
+  if (!initData) {
+    throw new Error('Expected init data to be defined');
+  }
+  const instrumentsMap = initData;
+
+  /**
+   * Transforms a single record into an array of exportable rows.
+   * @param {import('./thread-types').RecordType} record - The raw instrument record.
+   * @returns {import('@opendatacapture/schemas/instrument-records').InstrumentRecordsExport} The processed rows.
+   */
+  const processRecord = (record) => {
+    const instrument = instrumentsMap.get(record.instrumentId);
+    if (!instrument) {
+      throw new Error(`Instrument not found for ID: ${record.instrumentId}`);
+    }
+
+    if (!record.computedMeasures) {
+      return [];
+    }
+
+    const rows = [];
+
+    for (const [measureKey, measureValue] of Object.entries(record.computedMeasures)) {
+      if (measureValue == null) continue;
+
+      if (!Array.isArray(measureValue)) {
+        rows.push({
+          groupId: record.groupId ?? DEFAULT_GROUP_NAME,
+          instrumentEdition: instrument.edition,
+          instrumentName: instrument.name,
+          measure: measureKey,
+          sessionDate: record.session.date,
+          sessionId: record.session.id,
+          sessionType: record.session.type,
+          subjectAge: record.subject.age,
+          subjectId: removeSubjectIdScope(record.subject.id),
+          subjectSex: record.subject.sex,
+          timestamp: record.date,
+          username: record.session.user?.username ?? 'N/A',
+          value: measureValue
+        });
+        continue;
+      }
+
+      if (measureValue.length < 1) continue;
+
+      const expanded = expandData(measureValue);
+      for (const entry of expanded) {
+        if (!entry.success) {
+          throw new Error(`exportRecords: ${instrument.name}.${measureKey} — ${entry.message}`);
+        }
+        rows.push({
+          groupId: record.groupId ?? DEFAULT_GROUP_NAME,
+          instrumentEdition: instrument.edition,
+          instrumentName: instrument.name,
+          measure: `${measureKey} - ${entry.measure}`,
+          sessionDate: record.session.date,
+          sessionId: record.session.id,
+          sessionType: record.session.type,
+          subjectAge: record.subject.age,
+          subjectId: removeSubjectIdScope(record.subject.id),
+          subjectSex: record.subject.sex,
+          timestamp: record.date,
+          username: record.session.user?.username ?? 'N/A',
+          value: entry.measureValue
+        });
+      }
+    }
+    return rows;
+  };
+
+  try {
+    const results = _data.map(processRecord);
+    parentPort?.postMessage({ data: results.flat(), success: true });
+  } catch (error) {
+    if (error instanceof Error) {
+      parentPort?.postMessage({ error: error.message, success: false });
+    } else {
+      parentPort?.postMessage({ error: 'Unknown Error', success: false });
+    }
+  }
+}
+
+/**
+ * Worker Message Router
+ * @param {import('./thread-types').ParentMessage} message
+ */
+parentPort?.on('message', (message) => {
+  switch (message.type) {
+    case 'BEGIN_CHUNK_PROCESSING':
+      return handleChunkComplete(message.data);
+    case 'INIT':
+      return handleInit(message.data);
+    default:
+      throw new Error(`Unexpected message type: ${message.type}`);
+  }
+});

apps/api/src/instrument-records/export-worker.ts

@@ -164,7 +164,7 @@ export class InstrumentRecordsService {
 
     const workerPromises = chunks.map((chunk) => {
       return new Promise<InstrumentRecordsExport>((resolve, reject) => {
-        const worker = new Worker(join(import.meta.dirname, 'export-worker.ts'));
+        const worker = new Worker(join(import.meta.dirname, 'export-worker.js'));
         worker.postMessage({ data: availableInstrumentArray, type: 'INIT' } satisfies InitMessage);
 
         worker.on('message', (message: InitialMessage) => {

apps/api/src/instrument-records/instrument-records.service.ts

@@ -1,7 +1,9 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
+    "allowJs": true,
     "baseUrl": ".",
+    "checkJs": true,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,
     "paths": {

apps/api/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "name": "opendatacapture",
   "type": "module",
-  "version": "1.12.1",
+  "version": "1.12.2",
   "private": true,
   "packageManager": "pnpm@10.7.0",
   "license": "Apache-2.0",

package.json

@@ -13,3 +13,6 @@ export declare function encodeUnicodeToBase64(s: string): string;
 
 /** Decodes a Base64 string back into a Unicode string. */
 export declare function decodeBase64ToUnicode(s: string): string;
+
+/** Remove the scope from a subject ID (e.g., root$123 -> 123) */
+export declare function removeSubjectIdScope(id: string): string;

packages/runtime-internal/src/index.d.ts

@@ -21,3 +21,11 @@ export function decodeBase64ToUnicode(s) {
   const bytes = Uint8Array.from(binaryString, (c) => c.charCodeAt(0));
   return new TextDecoder().decode(bytes);
 }
+
+/** @type {import('./index.d.ts').removeSubjectIdScope} */
+export function removeSubjectIdScope(id) {
+  if (id.includes('$')) {
+    return /** @type {string} */ (id.split('$')[1]);
+  }
+  return id;
+}

packages/runtime-internal/src/index.js

@@ -13,6 +13,7 @@
   },
   "dependencies": {
     "@douglasneuroinformatics/libcrypto": "catalog:",
+    "@opendatacapture/runtime-internal": "workspace:*",
     "@opendatacapture/schemas": "workspace:*",
     "transliteration": "^2.3.5"
   },

packages/subject-utils/package.json

@@ -55,9 +55,4 @@ export function encodeScopedSubjectId(id: number | string, options: { groupName:
   return options.groupName.replaceAll(' ', '_') + '$' + id;
 }
 
-export function removeSubjectIdScope(id: string) {
-  if (id.includes('$')) {
-    return id.split('$')[1]!;
-  }
-  return id;
-}
+export { removeSubjectIdScope } from '@opendatacapture/runtime-internal';