Function minusSameFieldPredicates

packages/db/src/query/predicate-utils.ts:409–529

* Helper function to compute difference for same-field predicates

(
  fromPred: Func,
  subtractPred: Func,
)

 * Helper function to compute difference for same-field predicates
 */
function minusSameFieldPredicates(
  fromPred: Func,
  subtractPred: Func,
): BasicExpression<boolean> | null {
  // Extract field information
  const fromField =
    extractComparisonField(fromPred) ||
    extractEqualityField(fromPred) ||
    extractInField(fromPred)
  const subtractField =
    extractComparisonField(subtractPred) ||
    extractEqualityField(subtractPred) ||
    extractInField(subtractPred)

  // Must be on the same field
  if (
    !fromField ||
    !subtractField ||
    !areRefsEqual(fromField.ref, subtractField.ref)
  ) {
    return null
  }

  // Handle IN minus IN: status IN [A,B,C,D] - status IN [B,C] = status IN [A,D]
  if (fromPred.name === `in` && subtractPred.name === `in`) {
    const fromInField = fromField as InField
    const subtractInField = subtractField as InField

    // Filter out values that are in the subtract set
    const remainingValues = fromInField.values.filter(
      (v) =>
        !arrayIncludesWithSet(
          subtractInField.values,
          v,
          subtractInField.primitiveSet ?? null,
          subtractInField.areAllPrimitives,
        ),
    )

    if (remainingValues.length === 0) {
      return { type: `val`, value: false } as BasicExpression<boolean>
    }

    if (remainingValues.length === 1) {
      return {
        type: `func`,
        name: `eq`,
        args: [fromField.ref, { type: `val`, value: remainingValues[0] }],
      } as BasicExpression<boolean>
    }

    return {
      type: `func`,
      name: `in`,
      args: [fromField.ref, { type: `val`, value: remainingValues }],
    } as BasicExpression<boolean>
  }