@tanstack/optimistic/dist/esm/query/joins.js

Core optimistic updates library

import { map, join, consolidate, filter } from "@electric-sql/d2ts";
import { evaluateConditionOnNestedRow } from "./evaluators.js";
import { extractJoinKey } from "./extractors.js";
function processJoinClause(pipeline, query, tables, mainTableAlias, allInputs) {
  if (!query.join) return pipeline;
  const input = allInputs[query.from];
  for (const joinClause of query.join) {
    const joinedTableAlias = joinClause.as || joinClause.from;
    const joinType = joinClause.type === `cross` ? `inner` : joinClause.type;
    const mainPipeline = pipeline.pipe(
      map((nestedRow) => {
        const mainRow = nestedRow[mainTableAlias];
        const keyValue = extractJoinKey(
          mainRow,
          joinClause.on[0],
          mainTableAlias
        );
        return [keyValue, nestedRow];
      })
    );
    let joinedTableInput;
    if (allInputs[joinClause.from]) {
      joinedTableInput = allInputs[joinClause.from];
    } else {
      joinedTableInput = input.graph.newInput();
    }
    tables[joinedTableAlias] = joinedTableInput;
    const joinedPipeline = joinedTableInput.pipe(
      map((row) => {
        const nestedRow = { [joinedTableAlias]: row };
        const keyValue = extractJoinKey(row, joinClause.on[2], joinedTableAlias);
        return [keyValue, nestedRow];
      })
    );
    switch (joinType) {
      case `inner`:
        pipeline = mainPipeline.pipe(
          join(joinedPipeline, `inner`),
          consolidate(),
          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
        );
        break;
      case `left`:
        pipeline = mainPipeline.pipe(
          join(joinedPipeline, `left`),
          consolidate(),
          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
        );
        break;
      case `right`:
        pipeline = mainPipeline.pipe(
          join(joinedPipeline, `right`),
          consolidate(),
          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
        );
        break;
      case `full`:
        pipeline = mainPipeline.pipe(
          join(joinedPipeline, `full`),
          consolidate(),
          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
        );
        break;
      default:
        pipeline = mainPipeline.pipe(
          join(joinedPipeline, `inner`),
          consolidate(),
          processJoinResults(mainTableAlias, joinedTableAlias, joinClause)
        );
    }
  }
  return pipeline;
}
function processJoinResults(mainTableAlias, joinedTableAlias, joinClause) {
  return function(pipeline) {
    return pipeline.pipe(
      // Process the join result and handle nulls in the same step
      map((result) => {
        const [_key, [mainNestedRow, joinedNestedRow]] = result;
        if (joinClause.type === `inner` || joinClause.type === `cross`) {
          if (!mainNestedRow || !joinedNestedRow) {
            return void 0;
          }
        }
        if (joinClause.type === `left` && !mainNestedRow) {
          return void 0;
        }
        if (joinClause.type === `right` && !joinedNestedRow) {
          return void 0;
        }
        const mergedNestedRow = {};
        if (mainNestedRow) {
          Object.entries(mainNestedRow).forEach(([tableAlias, tableData]) => {
            mergedNestedRow[tableAlias] = tableData;
          });
        }
        if (joinedNestedRow) {
          Object.entries(joinedNestedRow).forEach(([tableAlias, tableData]) => {
            mergedNestedRow[tableAlias] = tableData;
          });
        } else if (joinClause.type === `left` || joinClause.type === `full`) {
          mergedNestedRow[joinedTableAlias] = null;
        }
        if (!mainNestedRow && (joinClause.type === `right` || joinClause.type === `full`)) {
          mergedNestedRow[mainTableAlias] = null;
        }
        return mergedNestedRow;
      }),
      // Filter out undefined results
      filter(
        (value) => value !== void 0
      ),
      // Process the ON condition
      filter((nestedRow) => {
        if (!joinClause.on || joinClause.type === `cross`) {
          return true;
        }
        if (joinClause.type === `left` && nestedRow[joinedTableAlias] === null) {
          return true;
        }
        if (joinClause.type === `right` && nestedRow[mainTableAlias] === null) {
          return true;
        }
        if (joinClause.type === `full` && (nestedRow[mainTableAlias] === null || nestedRow[joinedTableAlias] === null)) {
          return true;
        }
        const result = evaluateConditionOnNestedRow(
          nestedRow,
          joinClause.on,
          mainTableAlias,
          joinedTableAlias
        );
        return result;
      }),
      // Process the WHERE clause for the join if it exists
      filter((nestedRow) => {
        if (!joinClause.where) {
          return true;
        }
        const result = evaluateConditionOnNestedRow(
          nestedRow,
          joinClause.where,
          mainTableAlias,
          joinedTableAlias
        );
        return result;
      })
    );
  };
}
export {
  processJoinClause,
  processJoinResults
};
//# sourceMappingURL=joins.js.map