ga4-export-fixer 0.9.0-dev.7 → 0.9.0-dev.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ga4-export-fixer",
-  "version": "0.9.0-dev.7",
+  "version": "0.9.0-dev.8",
   "description": "",
   "main": "index.js",
   "files": [

package/tables/ga4EventsEnhanced/index.js

@@ -324,16 +324,19 @@ ${excludedEventsSQL}`,
     // enrichments throw "not yet supported" inside the utility — they will arrive in a later release.
     const { steps: enrichmentSteps, joins: enrichmentJoins, columns: enrichmentColumns,
             columnNames: enrichmentColumnNames } = utils.buildEnrichments(mergedConfig.enrichments);
-    const enrichmentExcludedColumns = [...enrichmentColumnNames];
 
-    // Only forward enrichment columns to each wildcard's EXCEPT input if they actually exist
-    // in that wildcard's source CTE. Otherwise BigQuery rejects with "Column X in SELECT *
-    // EXCEPT list does not exist". After M1, Object.keys(step.select.columns) is the complete
-    // column set of both event_data and session_data — so the same predicate works for both.
-    const eventDataExplicit = new Set(Object.keys(eventDataStep.select.columns));
-    const sessionDataExplicit = new Set(Object.keys(sessionDataStep.select.columns));
-    const eventDataEnrichmentExcept = enrichmentExcludedColumns.filter(c => eventDataExplicit.has(c));
-    const sessionDataEnrichmentExcept = enrichmentExcludedColumns.filter(c => sessionDataExplicit.has(c));
+    // Build the set of columns the outer SELECT already maps explicitly (so wildcards skip them)
+    // plus internal-only columns that should never reach enhanced_events.
+    const alreadyMapped = [
+        ...Object.keys(finalColumnOrder),
+        ...Object.keys(itemListOverrides),
+        ...enrichmentColumnNames,
+        'entrances',
+        mergedConfig.sessionParams.length > 0 ? 'session_params_prep' : undefined,
+        'data_is_final',
+        'export_type',
+        ...itemListExcludedColumns,
+    ];
 
     // Join event_data and session_data, include additional logic
     // Named 'enhanced_events' so user-supplied customSteps can reference it as a stable handle.
@@ -345,27 +348,10 @@ ${excludedEventsSQL}`,
                 ...finalColumnOrder,
                 ...itemListOverrides,
                 // event-level enrichment columns: override matching explicit columns; new columns added.
-                // Wildcard-column overlap is handled below via excludedColumns.
                 ...enrichmentColumns,
-                // get the rest of the event_data columns
-                '[sql]event_data': utils.selectOtherColumns(
-                    eventDataStep,
-                    Object.keys(finalColumnOrder),
-                    [
-                        'entrances',
-                        mergedConfig.sessionParams.length > 0 ? 'session_params_prep' : undefined,
-                        'data_is_final',
-                        'export_type',
-                        ...itemListExcludedColumns,
-                        ...eventDataEnrichmentExcept,
-                    ]
-                ),
-                // get the rest of the session_data columns
-                '[sql]session_data': utils.selectOtherColumns(
-                    sessionDataStep,
-                    Object.keys(finalColumnOrder),
-                    sessionDataEnrichmentExcept,
-                ),
+                // explicit pass-throughs for the rest of event_data and session_data
+                ...utils.buildQualifiedPassThroughs(eventDataStep, alreadyMapped),
+                ...utils.buildQualifiedPassThroughs(sessionDataStep, alreadyMapped),
                 // include additional columns
                 row_inserted_timestamp: 'current_timestamp()',
                 data_is_final: 'data_is_final',

package/utils.js

@@ -474,53 +474,6 @@ const mergeDataformTableConfigurations = (defaultConfig, inputConfig = {}) => {
     return deepMerge(defaultConfig, inputConfig);
 };
 
-/**
- * Generates a SQL selection string for a given query step, excluding columns already defined elsewhere
- * or columns that should be excluded.
- *
- * This utility is helpful when joining tables/CTEs to avoid selecting duplicate or already-present columns.
- * 
- * @param {Object} step - A queryBuilder structured step containing a `name` (CTE/table alias) and a `select.columns` object.
- * @param {string[]} [alreadyDefinedColumns=[]] - Columns that have already been defined and should be excluded from selection.
- * @param {string[]} [excludedColumns=[]] - Additional columns to explicitly exclude from selection.
- * @returns {string|undefined} A SQL select string (e.g. 'stepName.*' or 'stepName.* except (col1, col2)'), or undefined if all columns are excluded.
- */
-const selectOtherColumns = (step, alreadyDefinedColumns = [], excludedColumns = []) => {
-    const stepName = step.name;
-    const stepColumns = Object.keys(step.select.columns);
-
-    // Columns in step.select.columns that should be excluded (already-defined or explicitly listed)
-    const internalExcept = stepColumns.filter(
-        column => alreadyDefinedColumns.includes(column) || excludedColumns.includes(column)
-    );
-
-    // Columns in excludedColumns that aren't enumerated in step.select.columns. These are
-    // wildcard-sourced columns (e.g. default GA4 export columns coming through `event_data.*`
-    // inside event_data's own select). The caller knows what to exclude; trust them.
-    // BigQuery throws at dry-run if the column doesn't exist in the source — surfaces typos.
-    // Filter out undefined/null entries (callers can pass conditional values like
-    // `cond ? 'col' : undefined` for ergonomics).
-    const externalExcept = excludedColumns.filter(
-        c => typeof c === 'string' && c.length > 0 && !stepColumns.includes(c)
-    );
-
-    const allExcept = [...internalExcept, ...externalExcept];
-
-    // If nothing is excluded, select everything
-    if (allExcept.length === 0) {
-        return `${stepName}.*`;
-    }
-
-    // If every enumerated column is excluded and there are no external excepts to apply,
-    // there's nothing to select via the wildcard
-    if (internalExcept.length === stepColumns.length && externalExcept.length === 0) {
-        return;
-    }
-
-    return `${stepName}.* except (${allExcept.join(', ')})`;
-};
-
-
 /**
  * Builds a queryBuilder `select.columns` fragment that passes through every source column
  * not already covered by an explicit columns object.
@@ -641,6 +594,38 @@ const buildEnrichments = (enrichments) => {
 };
 
 
+/**
+ * Builds a qualified pass-through fragment for spreading into a downstream SELECT's
+ * `select.columns`. For each column in `step.select.columns` not already in `alreadyCovered`,
+ * emits an entry of the form `{ <col>: '<step.name>.<col>' }`.
+ *
+ * Columns whose values in `step.select.columns` are `undefined` (the user-exclusion sentinel
+ * shape from getExcludedColumns) are skipped. Names in `alreadyCovered` that don't exist in
+ * `step.select.columns` are silently ignored — the loop only iterates `step.select.columns`,
+ * so unknown names cause no harm. This is the safety property that lets callers pass
+ * "everything that might collide" without pre-filtering.
+ *
+ * @param {Object} step - A queryBuilder step with a `name` and `select.columns` object.
+ * @param {Iterable<string>} alreadyCovered - Column names already mapped elsewhere in the
+ *   downstream SELECT, plus any internal-only columns the downstream SELECT shouldn't re-emit.
+ * @returns {Object} A map of `{ <col>: '<step.name>.<col>' }` entries.
+ *
+ * @example
+ *   buildQualifiedPassThroughs(eventDataStep, ['event_date', 'session_id', 'entrances']);
+ *   // → { event_name: 'event_data.event_name', user_pseudo_id: 'event_data.user_pseudo_id', ... }
+ */
+const buildQualifiedPassThroughs = (step, alreadyCovered) => {
+    const covered = new Set(alreadyCovered);
+    const passThroughs = {};
+    for (const [col, expr] of Object.entries(step.select.columns)) {
+        if (expr === undefined) continue;
+        if (covered.has(col)) continue;
+        passThroughs[col] = `${step.name}.${col}`;
+    }
+    return passThroughs;
+};
+
+
 /**
  * Processes a date input string and returns a corresponding SQL date casting expression,
  * or passes through BigQuery SQL statements as-is.
@@ -715,9 +700,9 @@ module.exports = {
     queryBuilder,
     isDataformTableReferenceObject,
     setDataformContext,
-    selectOtherColumns,
     buildPassThroughs,
     buildEnrichments,
+    buildQualifiedPassThroughs,
     processDate,
     getDatasetName
 };