ga4-export-fixer 0.6.0 → 0.6.1-dev.1

package/package.json

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

package/tables/ga4EventsEnhanced/assertions/dailyQuality.js

@@ -88,48 +88,43 @@ raw_daily as (
         ${excludedEventsSQL}
         and cast(event_date as date format 'YYYYMMDD') >= date_sub(current_date(), interval 5 day)
     group by event_date, data_is_final
+),
+daily_comparison as (
+    select
+        coalesce(e.event_date, r.event_date) as event_date,
+        coalesce(e.data_is_final, r.data_is_final) as data_is_final,
+        e.session_count as enhanced_sessions,
+        r.session_count as raw_sessions,
+        e.event_count as enhanced_events,
+        r.event_count as raw_events,
+        round(e.total_item_revenue, 2) as enhanced_revenue,
+        round(r.total_item_revenue, 2) as raw_revenue
+    from
+        enhanced_daily e
+    full outer join
+        raw_daily r using(event_date, data_is_final)
 )
 select
-    coalesce(e.event_date, r.event_date) as event_date,
-    coalesce(e.data_is_final, r.data_is_final) as data_is_final,
-    e.session_count as enhanced_sessions,
-    r.session_count as raw_sessions,
-    e.event_count as enhanced_events,
-    r.event_count as raw_events,
-    round(e.total_item_revenue, 2) as enhanced_revenue,
-    round(r.total_item_revenue, 2) as raw_revenue,
-    case
-        when e.event_date is null and r.event_count > 0
-            then 'MISSING_DAY'
-        when coalesce(e.data_is_final, r.data_is_final) = true
-            and e.session_count != r.session_count
-            then 'SESSION_COUNT_MISMATCH'
-        when coalesce(e.data_is_final, r.data_is_final) = true
-            and e.event_count != r.event_count
-            then 'EVENT_COUNT_MISMATCH'
-        when coalesce(e.data_is_final, r.data_is_final) = true
-            and round(coalesce(e.total_item_revenue, 0), 2) != round(coalesce(r.total_item_revenue, 0), 2)
-            then 'REVENUE_MISMATCH'
-        when coalesce(e.data_is_final, r.data_is_final) = false
-            and coalesce(e.event_count, 0) > coalesce(r.event_count, 0)
-            then 'NON_FINAL_EXCESS_EVENTS'
-    end as violation_type
+    event_date,
+    data_is_final,
+    enhanced_sessions,
+    raw_sessions,
+    enhanced_events,
+    raw_events,
+    enhanced_revenue,
+    raw_revenue,
+    violation_type
 from
-    enhanced_daily e
-full outer join
-    raw_daily r using(event_date, data_is_final)
+    daily_comparison,
+    unnest([
+        if(enhanced_events is null and raw_events > 0, 'MISSING_DAY', null),
+        if(data_is_final = true and enhanced_sessions != raw_sessions, 'SESSION_COUNT_MISMATCH', null),
+        if(data_is_final = true and enhanced_events != raw_events, 'EVENT_COUNT_MISMATCH', null),
+        if(data_is_final = true and enhanced_revenue != raw_revenue, 'REVENUE_MISMATCH', null),
+        if(data_is_final = false and coalesce(enhanced_events, 0) > coalesce(raw_events, 0), 'NON_FINAL_EXCESS_EVENTS', null)
+    ]) as violation_type
 where
-    (coalesce(e.data_is_final, r.data_is_final) = true and (
-        e.session_count != r.session_count
-        or e.event_count != r.event_count
-        or round(coalesce(e.total_item_revenue, 0), 2) != round(coalesce(r.total_item_revenue, 0), 2)
-        or e.event_date is null
-    ))
-    or
-    (e.event_date is null and r.event_count > 0)
-    or
-    (coalesce(e.data_is_final, r.data_is_final) = false
-        and coalesce(e.event_count, 0) > coalesce(r.event_count, 0))`;
+    violation_type is not null`;
 };
 
 /**

package/utils.js

@@ -33,53 +33,87 @@ const mergeUniqueArrays = (...arrays) => {
  * @returns {string} Generated SQL query
  */
 const queryBuilder = (steps) => {
+    const INDENT = 2;
+    const pad = ' '.repeat(INDENT);
+
+    // Re-indents a multi-line SQL fragment so that continuation lines
+    // (lines after the first) have a consistent base indentation.
+    // Preserves relative indentation within the fragment.
+    const reindent = (sql, targetIndent) => {
+        if (!sql.includes('\n')) return sql;
+        const lines = sql.split('\n');
+        const continuationLines = lines.slice(1).filter(l => l.trim());
+        if (continuationLines.length === 0) return sql;
+        const minIndent = Math.min(
+            ...continuationLines.map(l => l.match(/^ */)[0].length)
+        );
+        const p = ' '.repeat(targetIndent);
+        return lines[0] + '\n' + lines.slice(1)
+            .map(l => l.trim() ? p + l.slice(minIndent) : '')
+            .join('\n');
+    };
+
+    // Shifts an entire SQL block right by the given number of spaces.
+    // Preserves relative indentation within the block.
+    const indentBlock = (sql, spaces) => {
+        const p = ' '.repeat(spaces);
+        return sql.split('\n')
+            .map(l => l.trim() ? p + l : '')
+            .join('\n');
+    };
+
     // Helper function to turn step.columns into SQL string
     const columnsToSQL = (columns) => {
         return Object.entries(columns)
             // exclude all columns that have been explicitly set to undefined
             .filter(([key, value]) => value !== undefined)
             .map(([key, value]) => {
+                let entry;
                 // if the key and value are the same, return the value as is (i.e. no alias)
                 if (key === value) {
-                    return value;
-                }
+                    entry = value;
                 // if the key starts with '[sql]', return the value as is (i.e. no alias)
-                if (key.startsWith('[sql]')) {
-                    return value;
+                } else if (key.startsWith('[sql]')) {
+                    entry = value;
+                } else {
+                    entry = `${value} as ${key}`;
                 }
-                return `${value} as ${key}`;
+                return reindent(entry, INDENT);
             })
-            .join(',\n    ');
+            .join(',\n' + pad);
     };
 
     const selectSQL = (step) => {
-        const leftJoinClauses = step.leftJoin ? step.leftJoin.map(join => `left join\n    ${join.table} ${join.condition}`) : [];
-        const whereClause = step.where ? `where\n    ${step.where}` : '';
-        const groupByClause = step.groupBy ? `group by\n    ${step.groupBy.join(', ')}` : '';
-
-        return `select
-    ${columnsToSQL(step.columns)}
-from
-    ${step.from}
-${leftJoinClauses.join('\n')}
-${whereClause}
-${groupByClause}`;
+        const parts = [`select\n${pad}${columnsToSQL(step.columns)}`];
+        parts.push(`from\n${pad}${step.from}`);
+
+        if (step.leftJoin) {
+            step.leftJoin.forEach(join => {
+                parts.push(`left join\n${pad}${join.table} ${join.condition}`);
+            });
+        }
+
+        if (step.where) {
+            parts.push(`where\n${pad}${reindent(step.where, INDENT)}`);
+        }
+
+        if (step.groupBy) {
+            parts.push(`group by\n${pad}${step.groupBy.join(', ')}`);
+        }
+
+        return parts.join('\n');
     };
 
-    let sql = "";
     if (steps.length === 1) {
-        // Only one step, no CTE needed
-        const step = steps[0];
-        sql = selectSQL(step);
-    } else {
-        // Multiple steps, all but last are CTEs
-        const ctes = steps.slice(0, -1).map(step => {
-            return `${step.name} as (${selectSQL(step)})`;
-        });
-        const lastStep = steps[steps.length - 1];
-        sql = `with ${ctes.join(',\n    ')}\n${selectSQL(lastStep)}`;
+        return selectSQL(steps[0]);
     }
-    return sql;
+
+    const ctes = steps.slice(0, -1).map(step => {
+        const body = indentBlock(selectSQL(step), INDENT);
+        return `${step.name} as (\n${body}\n)`;
+    });
+    const lastStep = steps[steps.length - 1];
+    return `with ${ctes.join(',\n')}\n${selectSQL(lastStep)}`;
 };
 
 /**