@things-factory/warehouse-base 4.3.678 → 4.3.681

package/server/service/inventory-history/inventory-history-query.ts

@@ -235,7 +235,8 @@ export class InventoryHistoryQuery {
           OR Lower(prd.description) LIKE ANY(ARRAY[${productValue}])
           OR Lower(prd.brand) LIKE ANY(ARRAY[${productValue}])
           OR Lower(prd.brand_sku) LIKE ANY(ARRAY[${productValue}])
-        )`
+        )
+        `
       }
 
       let productDescQuery = ''
@@ -247,12 +248,11 @@ export class InventoryHistoryQuery {
       if (hasTransactionOrBalanceFilter && hasTransactionOrBalanceFilter.value) {
         hasTransactionOrBalanceQuery = 'and (src.totalRow > 1 or src.totalQty <> 0)'
       }
-
       await tx.query(
         `
       create temp table temp_products AS 
       (
-        select prd.*, prd.id::varchar as product_id from products prd
+        select prd.id, prd.sku, prd.name, prd.description, prd.type, prd.aux_value_1 from products prd
         inner join bizplaces b on b.id = prd.bizplace_id 
         inner join companies c on c.domain_id = b.domain_id 
         inner join bizplaces b2 on b2.company_id = c.id
@@ -261,20 +261,20 @@ export class InventoryHistoryQuery {
       )`,
         [bizplace.id]
       )
-
       await tx.query(
         `
       create temp table temp_data_src AS
       (
         SELECT prd.sku as sku, prd.name AS product_name, prd.description AS product_description, prd.type as product_type, prd.aux_value_1 AS product_aux_value_1, trim(invh.batch_id) as batch_id, invh.product_id,
-        invh.packing_type, invh.bizplace_id, invh.domain_id,
-        invh.ref_order_id, invh.order_no, invh.order_ref_no, invh.transaction_type, invh.status, invh.created_at,
+        invh.packing_type, invh.bizplace_id,
+        invh.order_no, invh.order_ref_no, invh.transaction_type, invh.status, invh.created_at,
         TRUNC(CAST(invh.qty AS NUMERIC), 3) as qty, TRUNC(CAST(invh.opening_qty AS NUMERIC), 3) as opening_qty, 
         invh.uom, TRUNC(CAST(COALESCE(invh.uom_value, 0) AS NUMERIC), 3) as uom_value, TRUNC(CAST(COALESCE(invh.opening_uom_value, 0) AS NUMERIC), 3) as opening_uom_value
-        FROM reduced_inventory_histories invh
+        FROM inventory_histories invh
         INNER JOIN temp_products prd ON prd.id = invh.product_id::uuid
         WHERE
-        invh.domain_id = $1
+        (invh.qty <> 0 OR invh.uom_value <> 0)
+        AND invh.domain_id = $1
         AND invh.bizplace_id = $2
         AND invh.created_at <= $3::timestamp
         ${batchNoQuery}
@@ -285,105 +285,94 @@ export class InventoryHistoryQuery {
 
       await tx.query(
         `
-        create temp table temp_inv_history as (
-          SELECT src.sku, src.product_name, src.product_description, src.product_type, src.product_aux_value_1, src.batch_id, src.product_id, src.packing_type, src.uom,
-          src.bizplace_id, src.domain_id,
-          TRUNC(CAST(SUM(COALESCE(src.qty,0)) AS NUMERIC), 3) AS qty,
-          TRUNC(CAST(SUM(COALESCE(src.opening_qty,0)) AS NUMERIC), 3) AS opening_qty,
-          TRUNC(CAST(SUM(COALESCE(src.uom_value,0)) AS NUMERIC), 3) AS uom_value,
-          TRUNC(CAST(SUM(COALESCE(src.opening_uom_value,0)) AS NUMERIC), 3) AS opening_uom_value,
+        CREATE TEMP TABLE temp_inv_history AS (
+        SELECT
+          src.sku,
+          src.product_name,
+          src.product_description,
+          src.product_type,
+          src.product_aux_value_1,
+          src.batch_id,
+          src.product_id,
+          src.packing_type,
+          src.uom,
+          src.bizplace_id,
+          TRUNC(CAST(SUM(COALESCE(src.qty, 0)) AS NUMERIC), 3) AS qty,
+          TRUNC(CAST(SUM(COALESCE(src.opening_qty, 0)) AS NUMERIC), 3) AS opening_qty,
+          TRUNC(CAST(SUM(COALESCE(src.uom_value, 0)) AS NUMERIC), 3) AS uom_value,
+          TRUNC(CAST(SUM(COALESCE(src.opening_uom_value, 0)) AS NUMERIC), 3) AS opening_uom_value,
           'Opening Balance' AS order_name,
           '-' AS ref_no,
-          '-' as transaction_type,
+          '-' AS transaction_type,
           0 AS rn,
-          $1::timestamp AS created_at,
-          $1::date AS created_date  
-          FROM temp_data_src src
-          WHERE src.created_at < $1::timestamp
-          GROUP BY src.sku, src.product_name, src.product_description, src.product_type, src.product_aux_value_1, src.batch_id, src.product_id, src.packing_type, src.uom,
-          src.bizplace_id, src.domain_id
-          UNION ALL
-          SELECT sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, TRUNC(CAST(sum(qty) AS NUMERIC), 3) as qty, TRUNC(CAST(sum(opening_qty) AS NUMERIC), 3) as opening_qty, TRUNC(CAST(sum(uom_value) AS NUMERIC), 3) as uom_value, TRUNC(CAST(sum(opening_uom_value) AS NUMERIC), 3) as opening_uom_value, 
-          order_name, ref_no, '-' as transaction_type ,1 AS rn, MIN(created_at) - $2::interval as created_at, (MIN(created_at) - $2::interval)::DATE as created_date
-          FROM (
-            SELECT invh.sku, invh.product_name, invh.product_description, invh.product_type, invh.product_aux_value_1, invh.batch_id, invh.product_id, invh.packing_type, invh.bizplace_id, 
-            invh.domain_id,
-            invh.qty, invh.opening_qty, invh.uom_value, invh.uom, invh.opening_uom_value,
-            COALESCE(order_no, '-') AS order_name,
-            COALESCE(order_ref_no, '-') AS ref_no,
-            COALESCE(invh.transaction_type, '-') AS transaction_type,
-            invh.created_at,
-            invh.created_at::date as created_date
-            FROM temp_data_src invh
-            WHERE (invh.qty <> 0 OR invh.uom_value <> 0) AND 
-            invh.transaction_type <> 'ADJUSTMENT' AND 
-            invh.transaction_type <> 'PICKING' AND 
-            invh.transaction_type <> 'CANCEL_ORDER' AND 
-            invh.transaction_type <>'NEW'
-            AND invh.created_at >= $1::timestamp
-          ) AS inv_movement
-          GROUP BY sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, order_name, ref_no, rn
-          UNION ALL
-          SELECT sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, TRUNC(CAST(sum(qty) AS NUMERIC), 3) as qty, TRUNC(CAST(sum(opening_qty) AS NUMERIC), 3) as opening_qty, TRUNC(CAST(sum(uom_value) AS NUMERIC), 3) as uom_value, TRUNC(CAST(sum(opening_uom_value) AS NUMERIC), 3) as opening_uom_value,
-          CASE 
-          WHEN transaction_type IN ('PICKING', 'CANCEL_ORDER') THEN order_no
-          ELSE order_name
-           END AS order_name,
+          $1::timestamp AS created_at
+        FROM temp_data_src src
+        WHERE src.created_at < $1::timestamp
+        GROUP BY
+          src.sku,
+          src.product_name,
+          src.product_description,
+          src.product_type,
+          src.product_aux_value_1,
+          src.batch_id,
+          src.product_id,
+          src.packing_type,
+          src.uom,
+          src.bizplace_id
+
+        UNION ALL
+
+        -- Part 2: All Inventory Movements (combined into a single scan)
+        -- This SELECT statement replaces the three separate UNION ALLs for
+        -- transaction movements, using CASE statements to handle different
+        -- transaction types and statuses in a single pass.
+        SELECT
+          sku,
+          product_name,
+          product_description,
+          product_type,
+          product_aux_value_1,
+          batch_id,
+          product_id,
+          packing_type,
+          uom,
+          bizplace_id,
+          TRUNC(CAST(SUM(
+            -- qty and uom_value logic for all cases combined
+            CASE
+              WHEN transaction_type = 'ADJUSTMENT' AND status = 'MISSING' THEN -opening_qty
+              ELSE qty
+            END
+          ) AS NUMERIC), 3) AS qty,
+          TRUNC(CAST(SUM(opening_qty) AS NUMERIC), 3) AS opening_qty,
+          TRUNC(CAST(SUM(
+            CASE
+              WHEN transaction_type = 'ADJUSTMENT' AND status = 'MISSING' THEN -opening_uom_value
+              ELSE uom_value
+            END
+          ) AS NUMERIC), 3) AS uom_value,
+          TRUNC(CAST(SUM(opening_uom_value) AS NUMERIC), 3) AS opening_uom_value,
           CASE
-          WHEN transaction_type IN ('PICKING', 'CANCEL_ORDER') THEN ref_no
-          ELSE order_name
-            END AS ref_no, 
-            transaction_type,
-            1 AS rn, 
-          created_at - $2::interval as created_at, 
-          created_at::date as created_date
-        FROM (
-          SELECT 
-            invh.sku, invh.product_name, invh.product_description, invh.product_type, invh.product_aux_value_1, invh.batch_id, invh.product_id, 
-            invh.packing_type, invh.uom, invh.bizplace_id, invh.domain_id,
-            invh.qty, invh.opening_qty,	invh.uom_value, invh.opening_uom_value,
-            invh.transaction_type,  
-            invh.transaction_type AS order_name,
-            order_no,
-            order_ref_no AS ref_no,
-            invh.created_at,
-            invh.created_at::date as created_date
-          FROM temp_data_src invh
-          WHERE (invh.qty <> 0 OR invh.uom_value <> 0) AND 
-            (invh.transaction_type = 'ADJUSTMENT' 
-            OR invh.transaction_type = 'PICKING'
-            OR invh.transaction_type = 'CANCEL_ORDER'
-            OR invh.transaction_type = 'NEW')
-            AND invh.created_at >= $1::timestamp
-        ) AS inv_movement 
-        GROUP BY 
-          sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, inv_movement.transaction_type,inv_movement.order_no,order_name, ref_no, rn, created_at
-          UNION ALL
-          SELECT sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, TRUNC(CAST(sum(-opening_qty) AS NUMERIC), 3) as qty, TRUNC(CAST(sum(opening_qty) AS NUMERIC), 3) as opening_qty, TRUNC(CAST(sum(-opening_uom_value) AS NUMERIC), 3) as uom_value, TRUNC(CAST(sum(opening_uom_value) AS NUMERIC), 3) as opening_uom_value,
-          order_name, ref_no, transaction_type,1 AS rn, created_at - $2::interval as created_at, created_at::date as created_date
-          FROM (
-            SELECT invh.sku, invh.product_name, invh.product_description, invh.product_type, invh.product_aux_value_1, invh.batch_id, invh.product_id, invh.packing_type, invh.uom, invh.bizplace_id, 
-            invh.domain_id,
-            invh.qty, invh.opening_qty,	invh.uom_value, invh.opening_uom_value,
-            invh.transaction_type as transaction_type,
-            invh.transaction_type AS order_name,
-            invh.transaction_type AS ref_no,
-            invh.created_at,
-            invh.created_at:: date as created_date
-            FROM temp_data_src invh
-            WHERE 
-            invh.transaction_type = 'ADJUSTMENT'
-            AND invh.status = 'MISSING'
-            AND invh.created_at >= $1::timestamp
-          ) AS inv_movement 
-          GROUP BY sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, order_name, ref_no, inv_movement.transaction_type,rn, created_at
-        )`,
+            WHEN transaction_type IN ('PICKING', 'CANCEL_ORDER') THEN order_no
+            WHEN transaction_type IN ('ADJUSTMENT', 'NEW') THEN transaction_type
+            ELSE COALESCE(order_no, '-')
+          END AS order_name,
+          CASE
+            WHEN transaction_type IN ('PICKING', 'CANCEL_ORDER') THEN order_ref_no
+            WHEN transaction_type IN ('ADJUSTMENT', 'NEW') THEN transaction_type
+            ELSE COALESCE(order_ref_no, '-')
+          END AS ref_no,
+          transaction_type,
+          1 AS rn,
+          MIN(created_at) - $2::interval AS created_at
+        FROM temp_data_src
+        WHERE
+          created_at >= $1::timestamp
+        GROUP BY
+          sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id,
+          packing_type, uom, bizplace_id,
+          order_name, ref_no, transaction_type
+      )`,
         [fromDate.value, tzoffset]
       )
 
@@ -393,7 +382,7 @@ export class InventoryHistoryQuery {
         result = await tx.query(
           ` 
           select sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, qty, opening_qty, round(uom_value::decimal,2) as uom_value, opening_uom_value, order_name, ref_no, transaction_type,created_at::date
+          qty, opening_qty, round(uom_value::decimal,2) as uom_value, opening_uom_value, order_name, ref_no, transaction_type,created_at::date
           from temp_inv_history invh where
           exists (
             select 1 from (
@@ -410,10 +399,10 @@ export class InventoryHistoryQuery {
         result = await tx.query(
           `
         select sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-        domain_id, sum(qty) as qty, sum(opening_qty) as opening_qty, sum(uom_value) as uom_value, sum(opening_uom_value) as opening_uom_value, order_name, ref_no, transaction_type, created_at::date
+        sum(qty) as qty, sum(opening_qty) as opening_qty, sum(uom_value) as uom_value, sum(opening_uom_value) as opening_uom_value, order_name, ref_no, transaction_type, created_at::date
         from(
           select sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-          domain_id, qty, opening_qty, TRUNC(CAST(uom_value AS NUMERIC), 3) as uom_value, opening_uom_value, order_name, ref_no, transaction_type,created_at::date
+          qty, opening_qty, TRUNC(CAST(uom_value AS NUMERIC), 3) as uom_value, opening_uom_value, order_name, ref_no, transaction_type,created_at
           from temp_inv_history invh where
           exists (
             select 1 from (
@@ -425,7 +414,7 @@ export class InventoryHistoryQuery {
           )
         ) foo
        GROUP BY sku, product_name, product_description, product_type, product_aux_value_1, batch_id, product_id, packing_type, uom, bizplace_id, 
-       domain_id, order_name, ref_no, transaction_type, created_at
+       order_name, ref_no, transaction_type, created_at
        ORDER BY sku asc, product_name asc, product_description asc, packing_type asc, batch_id asc, uom asc, created_at asc,
         CASE 
             WHEN transaction_type = 'CANCEL_ORDER' THEN 2
@@ -1712,92 +1701,252 @@ async function massageInventoryPalletSummary(tx: EntityManager, params: ListPara
 
   let hasTransactionOrBalanceQuery = ''
   if (hasTransactionOrBalanceFilter && hasTransactionOrBalanceFilter.value) {
-    hasTransactionOrBalanceQuery = 'and (opening_qty > 0 or total_in_qty > 0 or adjustment_qty > 0)'
+    hasTransactionOrBalanceQuery = 'and (c.opening_qty > 0 or c.total_in_qty > 0 or c.adjustment_qty > 0)'
   }
+
   await tx.query(
     `
-    create temp table temp_inventory_pallet_summary ON COMMIT DROP as (
-      select invh.*,
-      invh.opening_qty + invh.total_in_qty + invh.total_out_qty + invh.adjustment_qty as closing_qty from (
-        select product_sku, product_id, product_name, product_description, product_type,
-        SUM(case when invHistory.created_at < $1 then
-          case when invHistory.status = 'STORED' then 1 
-          when invhistory.status = 'TERMINATED' then -1
-            else 0 end
-            else 0 end) as opening_qty,
-        SUM(case when invHistory.created_at >= $1 and invHistory.created_at <= $2 then 
-          case when (invHistory.transaction_type = 'UNLOADING' or invHistory.transaction_type = 'NEW' or invHistory.transaction_type = 'CANCEL_ORDER') then 1 else 0 end
-            else 0 end) as total_in_qty,
-        SUM(case when invHistory.created_at >= $1 and invHistory.created_at <= $2 then 
-          case when invHistory.status = 'TERMINATED' AND invHistory.transaction_type <> 'ADJUSTMENT' then -1 else 0 end
-            else 0 end) as total_out_qty,
-        SUM(case when invHistory.created_at >= $1 and invHistory.created_at <= $2 then 
-          case when invHistory.status = 'TERMINATED' AND invHistory.transaction_type = 'ADJUSTMENT' then -1 
-               when invHistory.status = 'STORED' AND invHistory.transaction_type = 'ADJUSTMENT' then 1 else 0 end
-            else 0 end) as adjustment_qty
-        from(
-          select pallet_id, seq, status, transaction_type, product_sku, product_id, product_name, product_description, product_type,
-          inventory_history_id, packing_type, packing_size, qty, opening_qty, created_at from (
-            select row_number() over(partition by invh.pallet_id order by invh.created_at asc) as rn, invh.* ,
-            prd.sku as product_sku, prd.name as product_name, prd.description as product_description, prd.type AS product_type
-            from temp_inv_history invh
-            inner join temp_products prd on prd.id = invh.product_id
-            where (transaction_type = 'UNLOADING' or invh.transaction_type = 'NEW' or invh.transaction_type = 'CANCEL_ORDER')
-              and invh.created_at >= $1
-          ) as invIn where rn = 1
-          union all
-          select pallet_id, seq, status, transaction_type, product_sku, product_id, product_name, product_description, product_type,
-          inventory_history_id, packing_type, packing_size, qty, opening_qty, created_at from (
-            SELECT row_number() over(partition by pallet_id, invh.product_id order by seq asc) as rn, 
-            invh.pallet_id, invh.product_id, invh.packing_type, invh.packing_size,
-            invh.batch_id, invh.inventory_history_id, 
-            invh.seq, 'STORED' AS status, invh.transaction_type, invh.qty, invh.opening_qty,
-            invh.created_at,
-            prd.sku as product_sku, prd.name as product_name, prd.description as product_description, prd.type AS product_type
-            from temp_inv_history invh
-            inner join temp_products prd on prd.id = invh.product_id
-            where invh.created_at < $1
-            and (invh.status = 'STORED' or invh.status = 'UNLOADED')
-          ) as invStored where rn = 1
-          union all
-          select pallet_id, seq, status, transaction_type, product_sku, product_id, product_name, product_description, product_type,
-          inventory_history_id, packing_type, packing_size, qty, opening_qty, started_at as created_at from (
-            select row_number() over(partition by invh.pallet_id, invh.product_id order by invh.seq desc) as rn, invh.*,
-            prd.sku as product_sku, prd.name as product_name, prd.description as product_description, prd.type AS product_type, repeatedGroup.started_at
-            from temp_inv_history invh
-            inner join (
-              select pallet_id, min(created_at) as started_at, max(created_at) as ended_at, min(seq) as min_seq, max(seq) as max_seq, status from (
-                select startData.*, sum(startflag) over (partition by pallet_id order by seq) as grp from (
-                  select s.*,  
-                  (case when lag(status) over (partition by pallet_id order by seq) = status then 0 else 1 end) as startflag
-                  from temp_inv_history s
-                ) startData
-              ) endData
-              group by pallet_id, grp, status
-            ) repeatedGroup on repeatedGroup.pallet_id = invh.pallet_id and repeatedGroup.min_seq <= invh.seq and repeatedGroup.max_seq >= invh.seq
-            inner join temp_products prd on prd.id = invh.product_id
-            where invh.status = 'TERMINATED' and invh.transaction_type IN ('TERMINATED', 'ADJUSTMENT')
-          ) as invOut where rn=1
-          union all
-          SELECT invh.pallet_id, invh.seq, invh.status, invh.transaction_type,
-          prd.sku AS product_sku, invh.product_id, prd.name AS product_name, prd.description AS product_description, prd.type AS product_type,
-          invh.inventory_history_id, invh.packing_type, invh.packing_size, invh.qty, invh.opening_qty, invh.created_at
-          FROM temp_inv_history invh
-          INNER JOIN (
-            SELECT invh.pallet_id, invh.seq AS stored_seq, invh2.seq AS terminated_seq FROM temp_inv_history invh
-            INNER JOIN temp_inv_history invh2 ON invh2.pallet_id = invh.pallet_id AND invh2.status='STORED' AND invh2.seq = invh.seq + 1 AND invh2.product_id <> invh.product_id
-            WHERE invh.transaction_type = 'ADJUSTMENT'
-          ) dt ON dt.pallet_id = invh.pallet_id AND (dt.stored_seq = invh.seq OR dt.terminated_seq = invh.seq)
-          inner join temp_products prd on prd.id = invh.product_id
-          where invh.created_at >= $1
-          ORDER BY product_name, pallet_id, seq 
-        ) as invHistory         
-        group by product_sku, product_id, product_name, product_description, product_type
-      ) invh
-      where 1=1
-      ${hasTransactionOrBalanceQuery}
+   create temp table temp_inventory_pallet_summary ON COMMIT DROP as
+    with params as (
+      select $1::timestamp as t1, $2::timestamp as t2
+    ),
+    base as (
+      select
+        invh.*,
+        prd.sku         as product_sku,
+        prd.name        as product_name,
+        prd.description as product_description,
+        prd.type        as product_type
+      from temp_inv_history invh
+      join temp_products prd on prd.id = invh.product_id
+    ),
+
+    /* ---- Opening snapshot as-of t1 (FIX) ----
+      For each pallet, take the last row <= t1; if status='STORED',
+      count it toward that row's product_id opening.
+    */
+    opening_last_asof as (
+      select *
+      from (
+        select h.*,
+              row_number() over (partition by h.pallet_id order by h.created_at desc, h.seq desc) as rn
+        from temp_inv_history h
+        join params p on true
+        where h.created_at <= p.t1
+      ) x
+      where rn = 1 and status = 'STORED'
+    ),
+    opening_agg as (
+      select
+        p.sku  as product_sku,
+        p.id   as product_id,
+        p.name as product_name,
+        p.description as product_description,
+        p.type as product_type,
+        count(*)::int as opening_qty
+      from opening_last_asof o
+      join temp_products p on p.id = o.product_id
+      group by p.sku, p.id, p.name, p.description, p.type
+    ),
+
+    /* ---- Arrivals inside window: first arrival-like row per pallet (your rule) ---- */
+    invIn as (
+      select b.*,
+            row_number() over (partition by b.pallet_id order by b.created_at, b.seq) as rn
+      from base b
+      join params p on true
+      where b.transaction_type in ('UNLOADING','NEW','CANCEL_ORDER')
+        and b.created_at >= p.t1
+    ),
+    invIn_first as (
+      select
+        pallet_id, seq, status, transaction_type,
+        product_sku, product_id, product_name, product_description, product_type,
+        inventory_history_id, packing_type, packing_size, qty, opening_qty, created_at
+      from invIn
+      where rn = 1
+    ),
+
+    /* ---- TERMINATED reps (incl. ADJUSTMENT terminations), using your runs logic ---- */
+    status_runs as (
+      select
+        endData.pallet_id,
+        min(endData.created_at) as started_at,
+        max(endData.created_at) as ended_at,
+        min(endData.seq)        as min_seq,
+        max(endData.seq)        as max_seq,
+        endData.status
+      from (
+        select startData.*,
+              sum(startflag) over (partition by startData.pallet_id order by startData.seq) as grp
+        from (
+          select s.*,
+                case when lag(s.status) over (partition by s.pallet_id order by s.seq) = s.status then 0 else 1 end as startflag
+          from temp_inv_history s
+        ) startData
+      ) endData
+      group by endData.pallet_id, endData.status, endData.grp
+    ),
+    invOut_base as (
+      select b.*, r.started_at
+      from base b
+      join status_runs r
+        on r.pallet_id = b.pallet_id
+      and r.min_seq   <= b.seq
+      and r.max_seq   >= b.seq
+      where b.status = 'TERMINATED'
+        and b.transaction_type in ('TERMINATED','ADJUSTMENT')
+    ),
+
+    /* ---- Transfer pairing (seq-gap tolerant & tolerant txn tags) ---- */
+    /* STORED side in-window; pair to nearest prior TERMINATED (from raw history), different product */
+    adj_stored AS (
+      SELECT b.*
+      FROM base b
+      JOIN params p ON TRUE
+      WHERE b.status = 'STORED'
+        AND b.created_at BETWEEN p.t1 AND p.t2
+    ),
+    adj_pairs AS (
+      SELECT
+        s.pallet_id,
+        s.seq                  AS stored_seq,
+        t.seq                  AS terminated_seq,
+        s.product_id           AS new_product_id,
+        t.product_id           AS old_product_id,
+        s.inventory_history_id AS stored_inventory_history_id,
+        t.inventory_history_id AS terminated_inventory_history_id,
+        s.created_at           AS stored_at,
+        t.created_at           AS terminated_at,
+        s.transaction_type     AS stored_txn,
+        t.transaction_type     AS terminated_txn
+      FROM adj_stored s
+      JOIN LATERAL (
+        SELECT t.*
+        FROM temp_inv_history t                  -- use raw history (old product may be outside temp_products)
+        WHERE t.pallet_id = s.pallet_id
+          AND t.seq < s.seq
+          AND t.status = 'TERMINATED'
+        ORDER BY t.seq DESC
+        LIMIT 1
+      ) t ON TRUE
+      WHERE t.product_id IS DISTINCT FROM s.product_id
+        AND (s.transaction_type='ADJUSTMENT' OR t.transaction_type='ADJUSTMENT')
+    ),
+    adj_pairs_terminated_keys AS (
+      SELECT pallet_id, terminated_seq AS seq
+      FROM adj_pairs
+    ),
+
+    /* Representative TERMINATED per (pallet, product), EXCLUDING those used by a pair (avoid double-count) */
+    invOut_rep AS (
+      SELECT *
+      FROM (
+        SELECT iob.*,
+              row_number() over (partition by iob.pallet_id, iob.product_id order by iob.seq desc) as rn
+        FROM invOut_base iob
+        LEFT JOIN adj_pairs_terminated_keys k
+          ON k.pallet_id = iob.pallet_id
+        AND k.seq       = iob.seq
+        WHERE k.pallet_id IS NULL
+      ) z
+      WHERE rn = 1
+    ),
+
+    /* Materialize both sides of the paired transfer */
+    adj_pairs_stored_rows AS (
+      SELECT
+        b.pallet_id, b.seq, b.status, b.transaction_type,
+        b.product_sku, b.product_id, b.product_name, b.product_description, b.product_type,
+        b.inventory_history_id, b.packing_type, b.packing_size, b.qty, b.opening_qty, b.created_at
+      FROM base b
+      JOIN adj_pairs ap
+        ON ap.pallet_id = b.pallet_id
+      AND ap.stored_seq = b.seq
+    ),
+    adj_pairs_terminated_rows AS (
+      SELECT
+        b.pallet_id, b.seq, b.status, b.transaction_type,
+        b.product_sku, b.product_id, b.product_name, b.product_description, b.product_type,
+        b.inventory_history_id, b.packing_type, b.packing_size, b.qty, b.opening_qty, b.created_at
+      FROM base b
+      JOIN adj_pairs ap
+        ON ap.pallet_id = b.pallet_id
+      AND ap.terminated_seq = b.seq
+    ),
+
+    /* ---- Unified stream for window movement ---- */
+    invHistory as (
+      select * from invIn_first
+      union all
+      select
+        pallet_id, seq, status, transaction_type,
+        product_sku, product_id, product_name, product_description, product_type,
+        inventory_history_id, packing_type, packing_size, qty, opening_qty, created_at
+      from invOut_rep
+      union all
+      select * from adj_pairs_stored_rows
+      union all
+      select * from adj_pairs_terminated_rows
+    ),
+
+    /* ---- Movement aggregation only (no opening here) ---- */
+    movement_agg as (
+      select
+        ih.product_sku,
+        ih.product_id,
+        ih.product_name,
+        ih.product_description,
+        ih.product_type,
+
+        sum(case when ih.created_at >= (select t1 from params)
+                  and ih.created_at <= (select t2 from params) then
+              case when ih.transaction_type in ('UNLOADING','NEW','CANCEL_ORDER') then 1 else 0 end
+            else 0 end)::int as total_in_qty,
+
+        sum(case when ih.created_at >= (select t1 from params)
+                  and ih.created_at <= (select t2 from params) then
+              case when ih.status = 'TERMINATED'
+                    and ih.transaction_type <> 'ADJUSTMENT' then -1 else 0 end
+            else 0 end)::int as total_out_qty,
+
+        sum(case when ih.created_at >= (select t1 from params)
+                  and ih.created_at <= (select t2 from params) then
+              case when ih.status = 'TERMINATED' and ih.transaction_type = 'ADJUSTMENT' then -1
+                  when ih.status = 'STORED'     and ih.transaction_type = 'ADJUSTMENT' then  1
+                  else 0 end
+            else 0 end)::int as adjustment_qty
+
+      from invHistory ih
+      group by ih.product_sku, ih.product_id, ih.product_name, ih.product_description, ih.product_type
+    ),
+
+    /* ---- Combine opening snapshot + window movement ---- */
+    combined as (
+      select
+        coalesce(o.product_sku, m.product_sku)          as product_sku,
+        coalesce(o.product_id,  m.product_id)           as product_id,
+        coalesce(o.product_name,m.product_name)         as product_name,
+        coalesce(o.product_description,m.product_description) as product_description,
+        coalesce(o.product_type,m.product_type)         as product_type,
+
+        coalesce(o.opening_qty, 0)                      as opening_qty,
+        coalesce(m.total_in_qty, 0)                     as total_in_qty,
+        coalesce(m.total_out_qty, 0)                    as total_out_qty,
+        coalesce(m.adjustment_qty, 0)                   as adjustment_qty
+      from opening_agg o
+      full outer join movement_agg m
+        on m.product_id = o.product_id
     )
-  `,
+
+    select
+      c.*,
+      (c.opening_qty + c.total_in_qty + c.total_out_qty + c.adjustment_qty) as closing_qty
+    from combined c
+    where 1=1
+    ${hasTransactionOrBalanceQuery}
+    ;
+    `,
     [fromDate.value, toDate.value]
   )