Function analyzeJoinExpressions

packages/db/src/query/compiler/joins.ts:351–426

* Analyzes join expressions to determine which refers to which source * and returns them in the correct order (available source expression first, joined source expression second)

(
  left: BasicExpression,
  right: BasicExpression,
  allAvailableSourceAliases: Array<string>,
  joinedSource: string,
  allowResultFields: boolean = false,
)

 * and returns them in the correct order (available source expression first, joined source expression second)
 */
function analyzeJoinExpressions(
  left: BasicExpression,
  right: BasicExpression,
  allAvailableSourceAliases: Array<string>,
  joinedSource: string,
  allowResultFields: boolean = false,
): { mainExpr: BasicExpression; joinedExpr: BasicExpression } {
  // Filter out the joined source alias from the available source aliases
  const availableSources = allAvailableSourceAliases.filter(
    (alias) => alias !== joinedSource,
  )

  const leftSourceAliases = getSourceAliasesFromExpression(left)
  const rightSourceAliases = getSourceAliasesFromExpression(right)
  const leftReferencesJoined = leftSourceAliases.has(joinedSource)
  const rightReferencesJoined = rightSourceAliases.has(joinedSource)
  const leftAvailableAliases = [...leftSourceAliases].filter(
    (alias) =>
      availableSources.includes(alias) ||
      (allowResultFields && alias !== joinedSource),
  )
  const rightAvailableAliases = [...rightSourceAliases].filter(
    (alias) =>
      availableSources.includes(alias) ||
      (allowResultFields && alias !== joinedSource),
  )

  // If left expression refers to an available source and right refers to joined source, keep as is
  if (
    leftAvailableAliases.length > 0 &&
    !leftReferencesJoined &&
    rightReferencesJoined &&
    rightAvailableAliases.length === 0
  ) {
    return { mainExpr: left, joinedExpr: right }
  }

  // If left expression refers to joined source and right refers to an available source, swap them
  if (
    leftReferencesJoined &&
    leftAvailableAliases.length === 0 &&
    rightAvailableAliases.length > 0 &&
    !rightReferencesJoined
  ) {
    return { mainExpr: right, joinedExpr: left }
  }

  // If one expression doesn't refer to any source, this is an invalid join
  if (leftSourceAliases.size === 0 || rightSourceAliases.size === 0) {
    throw new InvalidJoinConditionSourceMismatchError()
  }

  // If both expressions refer to the same alias, this is an invalid join
  if (
    leftSourceAliases.size === 1 &&
    rightSourceAliases.size === 1 &&
    [...leftSourceAliases][0] === [...rightSourceAliases][0]
  ) {