Fixing tests and improving test coverage

Author: MarkDuckworth

packages/firestore/lite/pipelines/pipelines.ts

@@ -107,7 +107,6 @@ export {
   bitXor,
   divide,
   isNotNan,
-  manhattanDistance,
   map,
   isNotNull,
   isNull,

packages/firestore/src/api_pipelines.ts

@@ -17,7 +17,11 @@
 
 export { PipelineSource } from './lite-api/pipeline-source';
 
-export { PipelineResult, PipelineSnapshot } from './lite-api/pipeline-result';
+export {
+  PipelineResult,
+  PipelineSnapshot,
+  pipelineResultEqual
+} from './lite-api/pipeline-result';
 
 export { Pipeline } from './api/pipeline';
 
@@ -130,7 +134,6 @@ export {
   mapMerge,
   documentId,
   substr,
-  manhattanDistance,
   Expr,
   ExprWithAlias,
   Field,

packages/firestore/src/core/pipeline-util.ts

@@ -65,9 +65,9 @@ export function toPipelineBooleanExpr(f: FilterInternal): BooleanExpr {
       }
     } else if (isNullValue(f.value)) {
       if (f.op === Operator.EQUAL) {
-        return and(fieldValue.exists(), fieldValue.eq(null));
+        return and(fieldValue.exists(), fieldValue.isNull());
       } else {
-        return and(fieldValue.exists(), fieldValue.neq(null));
+        return and(fieldValue.exists(), fieldValue.isNotNull());
       }
     } else {
       // Comparison filters
@@ -113,7 +113,7 @@ export function toPipelineBooleanExpr(f: FilterInternal): BooleanExpr {
             Constant._fromProto(val)
           );
           if (!values) {
-            return fieldValue.exists();
+            return and(fieldValue.exists(), fieldValue.eqAny([]));
           } else if (values.length === 1) {
             return and(fieldValue.exists(), fieldValue.eq(values[0]));
           } else {
@@ -131,7 +131,7 @@ export function toPipelineBooleanExpr(f: FilterInternal): BooleanExpr {
             Constant._fromProto(val)
           );
           if (!values) {
-            return fieldValue.exists();
+            return and(fieldValue.exists(), fieldValue.notEqAny([]));
           } else if (values.length === 1) {
             return and(fieldValue.exists(), fieldValue.neq(values[0]));
           } else {
@@ -215,13 +215,13 @@ export function toPipeline(query: Query, db: Firestore): Pipeline {
       // cursors
       if (query.startAt !== null) {
         pipeline = pipeline.where(
-          whereConditionsFromCursor(query.startAt, orderings, 'before')
+          whereConditionsFromCursor(query.startAt, orderings, 'after')
         );
       }
 
       if (query.endAt !== null) {
         pipeline = pipeline.where(
-          whereConditionsFromCursor(query.endAt, orderings, 'after')
+          whereConditionsFromCursor(query.endAt, orderings, 'before')
         );
       }
 
@@ -265,7 +265,7 @@ function whereConditionsFromCursor(
     const conditions: BooleanExpr[] = cursorSubset.map((cursor, index) => {
       if (index < cursorSubset.length - 1) {
         return eq(orderings[index].expr as Field, cursor);
-      } else if (bound.inclusive && i === orderings.length) {
+      } else if (bound.inclusive && i === orderings.length - 1) {
         return filterInclusiveFunc(orderings[index].expr as Field, cursor);
       } else {
         return filterFunc(orderings[index].expr as Field, cursor);

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

@@ -1208,7 +1208,7 @@ export abstract class Expr implements ProtoValueSerializable, UserData {
     ...others: Array<Expr | unknown>
   ): FunctionExpr {
     const values = [second, ...others];
-    return new FunctionExpr('logical_min', [
+    return new FunctionExpr('logical_minimum', [
       this,
       ...values.map(valueToDefaultExpr)
     ]);
@@ -1314,39 +1314,6 @@ export abstract class Expr implements ProtoValueSerializable, UserData {
     return new FunctionExpr('euclidean_distance', [this, vectorToExpr(other)]);
   }
 
-  /**
-   * @beta
-   *
-   * Calculates the Manhattan distance between the result of this expression and another VectorValue.
-   *
-   * ```typescript
-   * // Calculate the Manhattan distance between the 'location' field and a target location
-   * field("location").manhattanDistance(new VectorValue([37.7749, -122.4194]));
-   * ```
-   *
-   * @param vector The other vector (as a VectorValue) to compare against.
-   * @return A new {@code Expr} representing the Manhattan distance between the two vectors.
-   */
-  manhattanDistance(vector: VectorValue | number[]): FunctionExpr;
-
-  /**
-   * @beta
-   *
-   * Calculates the Manhattan distance between two vector expressions.
-   *
-   * ```typescript
-   * // Calculate the Manhattan distance between two vector fields: 'pointA' and 'pointB'
-   * field("pointA").manhattanDistance(field("pointB"));
-   * ```
-   *
-   * @param vectorExpression The other vector (represented as an Expr) to compare against.
-   * @return A new {@code Expr} representing the Manhattan distance between the two vectors.
-   */
-  manhattanDistance(vectorExpression: Expr): FunctionExpr;
-  manhattanDistance(other: Expr | number[] | VectorValue): FunctionExpr {
-    return new FunctionExpr('manhattan_distance', [this, vectorToExpr(other)]);
-  }
-
   /**
    * Creates an expression that interprets this expression as the number of microseconds since the Unix epoch (1970-01-01 00:00:00 UTC)
    * and returns a timestamp.
@@ -2281,8 +2248,6 @@ export function field(nameOrPath: string | FieldPath): Field {
       return new Field(documentIdFieldPath()._internalPath);
     }
     return new Field(fieldPathFromArgument('of', nameOrPath));
-  } else if (documentIdFieldPath().isEqual(nameOrPath)) {
-    return new Field(documentIdFieldPath()._internalPath);
   } else {
     return new Field(nameOrPath._internalPath);
   }
@@ -4611,6 +4576,21 @@ export function arrayContainsAll(
   return fieldOfOrExpr(array).arrayContainsAll(values);
 }
 
+/**
+ * @beta
+ *
+ * Creates an expression that calculates the length of an array in a specified field.
+ *
+ * ```typescript
+ * // Get the number of items in field 'cart'
+ * arrayLength('cart');
+ * ```
+ *
+ * @param fieldName The name of the field containing an array to calculate the length of.
+ * @return A new {@code Expr} representing the length of the array.
+ */
+export function arrayLength(fieldName: string): FunctionExpr;
+
 /**
  * @beta
  *
@@ -4624,8 +4604,9 @@ export function arrayContainsAll(
  * @param array The array expression to calculate the length of.
  * @return A new {@code Expr} representing the length of the array.
  */
-export function arrayLength(array: Expr): FunctionExpr {
-  return array.arrayLength();
+export function arrayLength(array: Expr): FunctionExpr;
+export function arrayLength(array: Expr | string): FunctionExpr {
+  return fieldOfOrExpr(array).arrayLength();
 }
 
 /**
@@ -5883,7 +5864,7 @@ export function strConcat(
   second: string | Expr,
   ...elements: Array<string | Expr>
 ): FunctionExpr {
-  return valueToDefaultExpr(first).strConcat(
+  return fieldOfOrExpr(first).strConcat(
     valueToDefaultExpr(second),
     ...elements.map(valueToDefaultExpr)
   );
@@ -6366,91 +6347,6 @@ export function euclideanDistance(
   return expr1.euclideanDistance(expr2);
 }
 
-/**
- * @beta
- *
- * Calculates the Manhattan distance between a field's vector value and a double array.
- *
- * ```typescript
- * // Calculate the Manhattan distance between the 'location' field and a target location
- * manhattanDistance("location", [37.7749, -122.4194]);
- * ```
- *
- * @param fieldName The name of the field containing the first vector.
- * @param vector The other vector (as an array of doubles or VectorValue) to compare against.
- * @return A new {@code Expr} representing the Manhattan distance between the two vectors.
- */
-export function manhattanDistance(
-  fieldName: string,
-  vector: number[] | VectorValue
-): FunctionExpr;
-
-/**
- * @beta
- *
- * Calculates the Manhattan distance between a field's vector value and a vector expression.
- *
- * ```typescript
- * // Calculate the Manhattan distance between two vector fields: 'pointA' and 'pointB'
- * manhattanDistance("pointA", field("pointB"));
- * ```
- *
- * @param fieldName The name of the field containing the first vector.
- * @param vectorExpression The other vector (represented as an Expr) to compare against.
- * @return A new {@code Expr} representing the Manhattan distance between the two vectors.
- */
-export function manhattanDistance(
-  fieldName: string,
-  vectorExpression: Expr
-): FunctionExpr;
-
-/**
- * @beta
- *
- * Calculates the Manhattan distance between a vector expression and a double array.
- *
- * ```typescript
- * // Calculate the Manhattan distance between the 'location' field and a target location
- *
- * manhattanDistance(field("location"), [37.7749, -122.4194]);
- * ```
- *
- * @param vectorExpression The first vector (represented as an Expr) to compare against.
- * @param vector The other vector (as an array of doubles or VectorValue) to compare against.
- * @return A new {@code Expr} representing the Manhattan distance between the two vectors.
- */
-export function manhattanDistance(
-  vectorExpression: Expr,
-  vector: number[] | VectorValue
-): FunctionExpr;
-
-/**
- * @beta
- *
- * Calculates the Manhattan distance between two vector expressions.
- *
- * ```typescript
- * // Calculate the Manhattan distance between two vector fields: 'pointA' and 'pointB'
- * manhattanDistance(field("pointA"), field("pointB"));
- * ```
- *
- * @param vectorExpression The first vector (represented as an Expr) to compare against.
- * @param otherVectorExpression The other vector (represented as an Expr) to compare against.
- * @return A new {@code Expr} representing the Manhattan distance between the two vectors.
- */
-export function manhattanDistance(
-  vectorExpression: Expr,
-  otherVectorExpression: Expr
-): FunctionExpr;
-export function manhattanDistance(
-  fieldOrExpr: Expr | string,
-  other: Expr | number[] | VectorValue
-): FunctionExpr {
-  const expr1 = fieldOfOrExpr(fieldOrExpr);
-  const expr2 = vectorToExpr(other);
-  return expr1.manhattanDistance(expr2);
-}
-
 /**
  * @beta
  *

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

@@ -812,10 +812,9 @@ export class Pipeline implements ProtoSerializable<ProtoPipeline> {
       if (typeof selectable === 'string') {
         result.set(selectable as string, field(selectable));
       } else if (selectable instanceof Field) {
-        result.set((selectable as Field).fieldName(), selectable);
+        result.set(selectable.alias, selectable.expr);
       } else if (selectable instanceof ExprWithAlias) {
-        const expr = selectable as ExprWithAlias;
-        result.set(expr.alias, expr.expr);
+        result.set(selectable.alias, selectable.expr);
       }
     }
     return result;

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

@@ -464,7 +464,7 @@ export class Unnest implements Stage {
  * @beta
  */
 export class Replace implements Stage {
-  name = 'replace';
+  name = 'replace_with';
 
   constructor(
     private field: Field,