Fixed all incompatibilities

packages/firestore/src/core/expressions.ts

@@ -83,7 +83,8 @@ import {
   TimestampSub,
   Field,
   Constant,
-  FilterExpr
+  FilterExpr,
+  IsNull
 } from '../lite-api/expressions';
 import {
   CREATE_TIME_NAME,
@@ -176,6 +177,8 @@ export function toEvaluable<T>(expr: T): EvaluableExpr {
     return new CoreNotEqAny(expr);
   } else if (expr instanceof IsNan) {
     return new CoreIsNan(expr);
+  } else if (expr instanceof IsNull) {
+    return new CoreIsNull(expr);
   } else if (expr instanceof Exists) {
     return new CoreExists(expr);
   } else if (expr instanceof Not) {
@@ -283,10 +286,7 @@ export class CoreField implements EvaluableExpr {
         timestampValue: toVersion(context.serializer, input.createTime)
       };
     }
-    return (
-      input.data.field(FieldPath.fromServerFormat(this.expr.fieldName())) ??
-      undefined
-    );
+    return input.data.field(this.expr.fieldPath) ?? undefined;
   }
 }
 
@@ -831,6 +831,24 @@ export class CoreIsNan implements EvaluableExpr {
   }
 }
 
+export class CoreIsNull implements EvaluableExpr {
+  constructor(private expr: IsNull) {}
+
+  evaluate(
+    context: EvaluationContext,
+    input: PipelineInputOutput
+  ): Value | undefined {
+    const evaluated = toEvaluable(this.expr.expr).evaluate(context, input);
+    return {
+      booleanValue: evaluated === undefined ? false : isNullValue(evaluated)
+    };
+  }
+
+  static fromProtoToApiObj(value: ProtoFunction): IsNan {
+    return new IsNan(exprFromProto(value.args![0]));
+  }
+}
+
 export class CoreExists implements EvaluableExpr {
   constructor(private expr: Exists) {}
 
@@ -839,11 +857,7 @@ export class CoreExists implements EvaluableExpr {
     input: PipelineInputOutput
   ): Value | undefined {
     const evaluated = toEvaluable(this.expr.expr).evaluate(context, input);
-    if (evaluated === undefined) {
-      return undefined;
-    }
-
-    return TRUE_VALUE;
+    return evaluated === undefined ? FALSE_VALUE : TRUE_VALUE;
   }
 
   static fromProtoToApiObj(value: ProtoFunction): Exists {

packages/firestore/src/lite-api/expressions.ts

@@ -885,6 +885,21 @@ export abstract class Expr implements ProtoSerializable<ProtoValue>, UserData {
     return new IsNan(this);
   }
 
+  /**
+   * Creates an expression that checks if this expression evaluates to `null`.
+   *
+   * ```typescript
+   * // Check if a field is set to value `null`. Returns false if it is set to
+   * // other values or is not set at all.
+   * Field.of("value").isNull();
+   * ```
+   *
+   * @return A new `Expr` representing the 'isNull' check.
+   */
+  isNull(): IsNan {
+    return new IsNull(this);
+  }
+
   /**
    * Creates an expression that checks if a field exists in the document.
    *
@@ -1923,7 +1938,7 @@ export class Field extends Expr implements Selectable {
    * @private
    */
   constructor(
-    private fieldPath: InternalFieldPath,
+    readonly fieldPath: InternalFieldPath,
     private pipeline: Pipeline | null = null
   ) {
     super();
@@ -1957,7 +1972,7 @@ export class Field extends Expr implements Selectable {
       if (DOCUMENT_KEY_NAME === pipelineOrName) {
         return new Field(documentId()._internalPath);
       }
-      return new Field(fieldPathFromArgument('of', pipelineOrName));
+      return new Field(InternalFieldPath.fromServerFormat(pipelineOrName));
     } else if (pipelineOrName instanceof FieldPath) {
       if (documentId().isEqual(pipelineOrName)) {
         return new Field(documentId()._internalPath);
@@ -2576,6 +2591,16 @@ export class IsNan extends FirestoreFunction implements FilterCondition {
   filterable = true as const;
 }
 
+/**
+ * @beta
+ */
+export class IsNull extends FirestoreFunction implements FilterCondition {
+  constructor(readonly expr: Expr) {
+    super('is_null', [expr]);
+  }
+  filterable = true as const;
+}
+
 /**
  * @beta
  */
@@ -4897,6 +4922,41 @@ export function isNan(value: Expr | string): IsNan {
   return new IsNan(valueExpr);
 }
 
+/**
+ * @beta
+ *
+ * Creates an expression that checks if an expression evaluates to 'null'.
+ *
+ * ```typescript
+ * // Check if the field is set to 'null'. Returns false if it is not set, or
+ * // set to any other value.
+ * isNull(Field.of("value"));
+ * ```
+ *
+ * @param value The expression to check.
+ * @return A new {@code Expr} representing the 'isNull' check.
+ */
+export function isNull(value: Expr): IsNull;
+
+/**
+ * @beta
+ *
+ * Creates an expression that checks if a field's value evaluates to 'null'.
+ *
+ * ```typescript
+ * // Check if the result of a calculation is null.
+ * isNull("value");
+ * ```
+ *
+ * @param value The name of the field to check.
+ * @return A new {@code Expr} representing the 'isNull' check.
+ */
+export function isNull(value: string): IsNull;
+export function isNull(value: Expr | string): IsNull {
+  const valueExpr = value instanceof Expr ? value : Field.of(value);
+  return new IsNull(valueExpr);
+}
+
 /**
  * @beta
  *

packages/firestore/test/unit/core/expressions.test.ts

@@ -351,7 +351,7 @@ function errorFilterExpr(): FilterExpr {
   return Field.of('not-an-array').gt(0);
 }
 
-describe.only('Comparison Expressions', () => {
+describe('Comparison Expressions', () => {
   describe('eq', () => {
     it('returns false for lessThan values', () => {
       ComparisonValueTestData.lessThanValues().forEach(({ left, right }) => {
@@ -955,7 +955,7 @@ function expectEqual(
   ).to.be.true;
 }
 
-describe.only('Expressions', () => {
+describe('Expressions', () => {
   describe('Arithmetic Expressions', () => {
     describe('add', () => {
       it('basic_add_numerics', () => {