@adriansteffan/reactive 0.0.44 → 0.1.1

package/src/utils/upload.ts

@@ -6,6 +6,31 @@ type DataObject = {
   [key: string]: string | number | boolean | null | undefined;
 };
 
+
+const flattenerRegistry: Record<string, {
+  csv: string | null;
+  flatten?: (item: TrialData) => any[];
+}[]> = {};
+
+export function registerFlattener(
+  type: string,
+  csv: string | null,
+  flatten?: (item: TrialData) => any[],
+) {
+  if (!flattenerRegistry[type]) flattenerRegistry[type] = [];
+  flattenerRegistry[type].push({ csv, flatten });
+}
+
+// Reusable flattener for components whose responseData is an array of objects.
+// Each array element becomes a CSV row. Non-array responseData produces an empty result.
+export function arrayFlattener(item: TrialData): any[] {
+  const responseData = item.responseData;
+  if (Array.isArray(responseData)) {
+    return responseData.map((i) => ({ block: item.name, ...i }));
+  }
+  return [];
+}
+
 export function escapeCsvValue(value: any): string {
   if (value === null || value === undefined) {
     return '';
@@ -48,137 +73,109 @@ export function convertArrayOfObjectsToCSV(data: DataObject[]): string {
   return [headerRow, ...dataRows].join('\n');
 }
 
-export const defaultFlatteningFunctions: Record<
-  string,
-  (item: TrialData) => any[] | Record<string, any[]>
-> = {
-  CanvasBlock: (item: TrialData) => {
-    const responseData = item.responseData;
-    if (Array.isArray(responseData)) {
-      return responseData.map((i) => ({
-        block: item.name,
-        ...i,
-      }));
+// Extracts experiment parameter values (URL params / registered params) from the initial metadata trial.
+// Each param entry has { value, defaultValue, ... } — we pick value if set, otherwise the default.
+function extractParams(data: any[]): Record<string, any> {
+  const paramsSource = data?.[0]?.responseData?.params;
+  if (!paramsSource || typeof paramsSource !== 'object') return {};
+  const result: Record<string, any> = {};
+  for (const [name, details] of Object.entries(paramsSource) as [string, any][]) {
+    if (details && typeof details === 'object') {
+      result[name] = details.value ?? details.defaultValue;
     }
-    return [];
-  },
-};
-
-export const transform = ({ responseData, ...obj }: any) => ({
-  ...obj,
-  ...Object.entries(responseData || {}).reduce(
-    (acc, [k, v]) => ({ ...acc, [`data_${k}`]: v }),
-    {},
-  ),
-});
-
-export type CSVBuilder = {
-  filename?: string;
-  trials?: string[];
-  fun?: (row: Record<string, any>) => Record<string, any>;
-};
-
-export function combineTrialsToCsv(
-  data: any[],
-  filename: string,
-  names: string[],
-  flatteningFunctions: Record<string, (item: any) => any[] | Record<string, any[]>>,
-  fun?: (obj: any) => any,
-): FileUpload | FileUpload[] {
-  // Collect all flattener results first, filtering out completely empty results
-  const allResults: (any[] | Record<string, any[]>)[] = names
-    .flatMap((name) => {
-      const matchingItems = data.filter((d) => d.name === name);
-
-      return matchingItems.map((item) => {
-        const flattener = item.type && flatteningFunctions[item.type];
-        const result = flattener ? flattener(item) : [transform(item)];
-
-        if (Array.isArray(result) && result.length === 0) {
-          return null;
-        }
-
-        if (result && typeof result === 'object' && !Array.isArray(result)) {
-          const hasAnyData = Object.values(result).some(
-            (val) => Array.isArray(val) && val.length > 0,
-          );
-          if (!hasAnyData) {
-            return null;
-          }
-        }
-
-        return result;
-      });
-    })
-    .filter((result) => result !== null);
-
-  const hasMultiTable = allResults.some(
-    (result) =>
-      result &&
-      typeof result === 'object' &&
-      !Array.isArray(result) &&
-      Object.keys(result).some((key) => Array.isArray(result[key])),
-  );
+  }
+  return result;
+}
 
-  if (!hasMultiTable) {
-    const processedData = allResults
-      .flatMap((result) => (Array.isArray(result) ? result : []))
-      .map((x) => (fun ? fun(x) : x));
+// Built-in fields on every trial data object — not user data.
+// Used to distinguish user-provided metadata from framework fields when building CSVs.
+const trialBuiltinKeys = new Set(['index', 'trialNumber', 'start', 'end', 'duration', 'type', 'name', 'csv', 'responseData', 'metadata']);
+// Subset of builtins that represent trial identity/timing — included in non-session CSVs with trial_ prefix
+const trialInfoKeys = new Set(['index', 'trialNumber', 'start', 'end', 'duration', 'type', 'name']);
+
+// Automatically builds CSV files from trial data using the flattener registry.
+// Each trial is routed to a CSV file based on: item.csv override > registry default > skipped.
+// The 'session' group is special: all trials merge into a single row, with keys namespaced
+// by trial name (e.g. 'nickname_value', 'devicecheck_browser') to avoid collisions.
+// All other groups produce multi-row CSVs, one row per trial (or more if the flattener expands them).
+function autoBuildCSVs(sessionID: string, data: any[], sessionData?: Record<string, any>): FileUpload[] {
+  const files: FileUpload[] = [];
 
-    if (processedData.length === 0) {
-      return [];
+  // Group trials by their target CSV file name.
+  // A component can register multiple targets, so one trial may appear in multiple groups.
+  // A per-item csv override replaces all registered targets.
+  const groups: Record<string, { item: any; flatten?: (item: TrialData) => any[] }[]> = {};
+  for (const item of data) {
+    if (item.index === -1) continue; // skip initial metadata entry
+    const csvOverride = item.csv;
+    const targets = csvOverride
+      ? (Array.isArray(csvOverride) ? csvOverride : [csvOverride]).map((csv: string) => ({ csv }))
+      : flattenerRegistry[item.type] ?? [];
+    for (const target of targets) {
+      if (!target.csv) continue;
+      if (!groups[target.csv]) groups[target.csv] = [];
+      groups[target.csv].push({ item, flatten: 'flatten' in target ? target.flatten : undefined });
     }
-
-    return {
-      filename,
-      encoding: 'utf8' as const,
-      content: convertArrayOfObjectsToCSV(processedData),
-    };
   }
 
-  const allTableKeys = new Set<string>();
-  allResults.forEach((result) => {
-    if (result && typeof result === 'object' && !Array.isArray(result)) {
-      Object.keys(result).forEach((key) => {
-        if (Array.isArray(result[key])) {
-          allTableKeys.add(key);
-        }
-      });
-    }
-  });
-
-  const files: FileUpload[] = [];
-
-  for (const tableKey of allTableKeys) {
-    const tableData = allResults
-      .flatMap((result) => {
-        if (Array.isArray(result)) {
-          return result;
-        } else if (result && typeof result === 'object' && result[tableKey]) {
-          return result[tableKey];
+  // 'session' group: one row per participant with metadata + responseData namespaced by trial name
+  if (groups['session']) {
+    const row: Record<string, any> = {
+      sessionID,
+      userAgent: data?.[0]?.responseData?.userAgent,
+      ...extractParams(data),
+      ...sessionData,
+    };
+    for (const { item } of groups['session']) {
+      const prefix = item.name || item.type;
+      // Add user-provided metadata (non-builtin top-level keys), namespaced by trial name
+      for (const [key, value] of Object.entries(item)) {
+        if (!trialBuiltinKeys.has(key)) row[`${prefix}_${key}`] = value;
+      }
+      // Add responseData fields, namespaced by trial name
+      if (item.responseData && typeof item.responseData === 'object' && !Array.isArray(item.responseData)) {
+        for (const [key, value] of Object.entries(item.responseData)) {
+          row[`${prefix}_${key}`] = value;
         }
-        return [];
-      })
-      .map((x) => (fun ? fun(x) : x));
-
-    if (tableData.length === 0) {
-      continue;
+      }
     }
-
-    const baseFilename = filename.replace(/\.csv$/, '');
-
     files.push({
-      filename: `${baseFilename}_${tableKey}.csv`,
+      filename: `session.${sessionID}.${Date.now()}.csv`,
+      content: convertArrayOfObjectsToCSV([row]),
       encoding: 'utf8' as const,
-      content: convertArrayOfObjectsToCSV(tableData),
     });
+    delete groups['session'];
   }
 
-  if (files.length === 0) {
-    return [];
+  // All other groups: multi-row CSVs using registered flatteners (or raw responseData spread).
+  // Each row is prepended with standard trial fields (prefixed trial_) plus any extra
+  // metadata fields (unprefixed). The flattener's output overwrites these if keys collide.
+  for (const [csvName, entries] of Object.entries(groups)) {
+    const rows = entries.flatMap(({ item, flatten }) => {
+      const base: Record<string, any> = {};
+      for (const [key, value] of Object.entries(item)) {
+        if (trialBuiltinKeys.has(key)) {
+          if (trialInfoKeys.has(key)) base[`trial_${key}`] = value;
+        } else {
+          base[key] = value;
+        }
+      }
+      // When no flatten function is registered, spread responseData directly.
+      const flatRows = flatten
+        ? flatten(item)
+        : [item.responseData && typeof item.responseData === 'object' ? { ...item.responseData } : {}];
+      return flatRows.map((row: any) => ({ ...base, ...row }));
+    });
+    if (rows.length > 0) {
+      files.push({
+        filename: `${csvName}.${sessionID}.${Date.now()}.csv`,
+        content: convertArrayOfObjectsToCSV(rows),
+        encoding: 'utf8' as const,
+      });
+    }
   }
 
-  return files.length === 1 ? files[0] : files;
+  return files;
 }
 
 export function buildUploadFiles(config: {
@@ -186,11 +183,7 @@ export function buildUploadFiles(config: {
   data: any[];
   store?: Store;
   generateFiles?: (sessionID: string, data: any[], store?: Store) => FileUpload[];
-  sessionCSVBuilder?: CSVBuilder;
-  trialCSVBuilder?: {
-    flatteners: Record<string, (item: any) => any[] | Record<string, any[]>>;
-    builders: CSVBuilder[];
-  };
+  sessionData?: Record<string, any>;
   uploadRaw?: boolean;
 }): FileUpload[] {
   const {
@@ -198,8 +191,7 @@ export function buildUploadFiles(config: {
     data,
     store,
     generateFiles,
-    sessionCSVBuilder,
-    trialCSVBuilder,
+    sessionData,
     uploadRaw = true,
   } = config;
 
@@ -213,87 +205,7 @@ export function buildUploadFiles(config: {
     });
   }
 
-  if (sessionCSVBuilder) {
-    type ParamDetails = {
-      value?: any;
-      defaultValue: any;
-    };
-    let paramsDict: Record<string, any> = {};
-    const paramsSource: Record<string, ParamDetails | any> | undefined =
-      data?.[0]?.responseData?.params;
-    if (paramsSource && typeof paramsSource === 'object' && paramsSource !== null) {
-      paramsDict = Object.entries(paramsSource).reduce(
-        (
-          accumulator: Record<string, any>,
-          [paramName, paramDetails]: [string, ParamDetails | any],
-        ) => {
-          if (
-            paramDetails &&
-            typeof paramDetails === 'object' &&
-            'defaultValue' in paramDetails
-          ) {
-            const chosenValue = paramDetails.value ?? paramDetails.defaultValue;
-            accumulator[paramName] = chosenValue;
-          }
-          return accumulator;
-        },
-        {} as Record<string, any>,
-      );
-    }
-
-    let content: Record<string, any> = {
-      sessionID,
-      userAgent: data?.[0]?.responseData?.userAgent,
-      ...paramsDict,
-    };
-
-    if (
-      sessionCSVBuilder.trials &&
-      Array.isArray(sessionCSVBuilder.trials) &&
-      sessionCSVBuilder.trials.length > 0
-    ) {
-      for (const trialName of sessionCSVBuilder.trials) {
-        const matchingDataElement = data.find((element) => element.name === trialName);
-
-        if (matchingDataElement?.responseData) {
-          if (
-            typeof matchingDataElement.responseData === 'object' &&
-            matchingDataElement.responseData !== null
-          ) {
-            content = { ...content, ...matchingDataElement.responseData };
-          }
-        }
-      }
-    }
-
-    files.push({
-      content: convertArrayOfObjectsToCSV([
-        sessionCSVBuilder.fun ? sessionCSVBuilder.fun(content) : content,
-      ]),
-      filename: `${sessionID}${sessionCSVBuilder.filename}.csv`,
-      encoding: 'utf8' as const,
-    });
-  }
-
-  if (trialCSVBuilder) {
-    for (const builder of trialCSVBuilder.builders) {
-      const result = combineTrialsToCsv(
-        data,
-        `${sessionID}${builder.filename}.csv`,
-        builder.trials ?? [],
-        { ...defaultFlatteningFunctions, ...trialCSVBuilder.flatteners },
-        builder.fun,
-      );
-
-      if (Array.isArray(result)) {
-        if (result.length > 0) {
-          files.push(...result);
-        }
-      } else {
-        files.push(result);
-      }
-    }
-  }
+  files.push(...autoBuildCSVs(sessionID, data, sessionData));
 
   return files;
 }