feat(firestore): added minimum and maximum FieldValue operations

Firestore/CHANGELOG.md

@@ -1,4 +1,5 @@
 # 12.13.0
+- [feature] Added support for `minimum` and `maximum` FieldValue operations.
 - [feature] Added search stage support for `languageCode`, `offset`, `limit`, and `retrievalDepth`.
 - [feature] Added support for Pipeline expressions `arraySlice`, `arrayFilter`, `arrayTransform` and `arrayTransformWithIndex`. (#16001)
 - [fixed] Add missing `noexcept` specifiers to move, hash, swap operations [#16117].

Firestore/Example/Tests/Integration/API/FIRNumericTransformTests.mm

@@ -18,6 +18,8 @@
 
 #import <XCTest/XCTest.h>
 
+#import <math.h>
+
 #import "Firestore/Source/API/FIRFieldValue+Internal.h"
 
 #import "Firestore/Example/Tests/Util/FSTEventAccumulator.h"
@@ -65,7 +67,7 @@
 - (void)writeInitialData:(NSDictionary<NSString *, id> *)data {
   [self writeDocumentRef:_docRef data:data];
   XCTAssertEqualObjects([_accumulator awaitLocalEvent].data, data);
   XCTAssertEqualObjects([_accumulator awaitRemoteEvent].data, data);
 }
 
 - (void)expectLocalAndRemoteValue:(int64_t)expectedSum {
@@ -215,4 +217,125 @@
   XCTAssertEqualWithAccuracy(0.111, [snap[@"sum"] doubleValue], DOUBLE_EPSILON);
 }
 
+- (void)testCreateDocumentWithMinimum {
+  [self writeDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMinimum:1337]}];
+  [self expectLocalAndRemoteValue:1337];
+}
+
+- (void)testCreateDocumentWithMaximum {
+  [self writeDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMaximum:1337]}];
+  [self expectLocalAndRemoteValue:1337];
+}
+
+- (void)testMinimumWithExistingInteger {
+  [self writeInitialData:@{@"sum" : @10}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMinimum:5]}];
+  [self expectLocalAndRemoteValue:5];
+
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMinimum:20]}];
+  [self expectLocalAndRemoteValue:5];
+}
+
+- (void)testMaximumWithExistingInteger {
+  [self writeInitialData:@{@"sum" : @10}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMaximum:5]}];
+  [self expectLocalAndRemoteValue:10];
+
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMaximum:20]}];
+  [self expectLocalAndRemoteValue:20];
+}
+
+- (void)testMinimumWithExistingDouble {
+  [self writeInitialData:@{@"sum" : @10.5}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForDoubleMinimum:5.5]}];
+  [self expectApproximateLocalAndRemoteValue:5.5];
+
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForDoubleMinimum:20.5]}];
+  [self expectApproximateLocalAndRemoteValue:5.5];
+}
+
+- (void)testMaximumWithExistingDouble {
+  [self writeInitialData:@{@"sum" : @10.5}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForDoubleMaximum:5.5]}];
+  [self expectApproximateLocalAndRemoteValue:10.5];
+
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForDoubleMaximum:20.5]}];
+  [self expectApproximateLocalAndRemoteValue:20.5];
+}
+
+- (void)testMixedTypesPreserveOperandTypeForMinimum {
+  // field and input value of mixed types: field takes on type of smaller operand
+  [self writeInitialData:@{@"sum" : @10}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForDoubleMinimum:5.5]}];
+  [self expectApproximateLocalAndRemoteValue:5.5];
+
+  [self writeInitialData:@{@"sum" : @10.5}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMinimum:5]}];
+  [self expectLocalAndRemoteValue:5];
+}
+
+- (void)testMixedTypesPreserveOperandTypeForMaximum {
+  // field and input value of mixed types: field takes on type of larger operand
+  [self writeInitialData:@{@"sum" : @10}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForDoubleMaximum:20.5]}];
+  [self expectApproximateLocalAndRemoteValue:20.5];
+
+  [self writeInitialData:@{@"sum" : @10.5}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMaximum:20]}];
+  [self expectLocalAndRemoteValue:20];
+}
+
+- (void)testEquivalentValuesDoNotChangeTypeForMinimum {
+  // equivalent (e.g. 3 and 3.0), field does not change type
+  [self writeInitialData:@{@"sum" : @3}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForDoubleMinimum:3.0]}];
+  [self expectLocalAndRemoteValue:3];
+
+  [self writeInitialData:@{@"sum" : @3.0}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMinimum:3]}];
+  [self expectApproximateLocalAndRemoteValue:3.0];
+}
+
+- (void)testEquivalentValuesDoNotChangeTypeForMaximum {
+  // equivalent (e.g. 3 and 3.0), field does not change type
+  [self writeInitialData:@{@"sum" : @3}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForDoubleMaximum:3.0]}];
+  [self expectLocalAndRemoteValue:3];
+
+  [self writeInitialData:@{@"sum" : @3.0}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMaximum:3]}];
+  [self expectApproximateLocalAndRemoteValue:3.0];
+}
+
+- (void)expectLocalAndRemoteNaN {
+  FIRDocumentSnapshot *snap = [_accumulator awaitLocalEvent];
+  XCTAssertTrue([snap[@"sum"] isKindOfClass:[NSNumber class]]);
+  XCTAssertTrue(isnan([snap[@"sum"] doubleValue]));
+  snap = [_accumulator awaitRemoteEvent];
+  XCTAssertTrue([snap[@"sum"] isKindOfClass:[NSNumber class]]);
+  XCTAssertTrue(isnan([snap[@"sum"] doubleValue]));
+}
+
+- (void)testMinimumWithNaN {
+  // If one of the values is NaN, minimum is NaN
+  [self writeInitialData:@{@"sum" : @(NAN)}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMinimum:5]}];
+  [self expectLocalAndRemoteNaN];
+
+  [self writeInitialData:@{@"sum" : @5}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForDoubleMinimum:NAN]}];
+  [self expectLocalAndRemoteNaN];
+}
+
+- (void)testMaximumWithNaN {
+  // If one of the values is NaN, maximum is NaN
+  [self writeInitialData:@{@"sum" : @(NAN)}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForIntegerMaximum:5]}];
+  [self expectLocalAndRemoteNaN];
+
+  [self writeInitialData:@{@"sum" : @5}];
+  [self updateDocumentRef:_docRef data:@{@"sum" : [FIRFieldValue fieldValueForDoubleMaximum:NAN]}];
+  [self expectLocalAndRemoteNaN];
+}
+
 @end

Firestore/Source/API/FIRFieldValue+Internal.h

@@ -60,4 +60,16 @@ NS_ASSUME_NONNULL_BEGIN
 @property(strong, nonatomic, readonly) NSNumber *operand;
 @end
 
+/** FIRFieldValue class for number minimum transforms. */
+@interface FSTNumericMinimumFieldValue : FIRFieldValue
+- (instancetype)init NS_UNAVAILABLE;
+@property(strong, nonatomic, readonly) NSNumber *operand;
+@end
+
+/** FIRFieldValue class for number maximum transforms. */
+@interface FSTNumericMaximumFieldValue : FIRFieldValue
+- (instancetype)init NS_UNAVAILABLE;
+@property(strong, nonatomic, readonly) NSNumber *operand;
+@end
+
 NS_ASSUME_NONNULL_END

Firestore/Source/API/FIRFieldValue.mm

@@ -144,6 +144,48 @@ - (NSString *)methodName {
 
 @end
 
+#pragma mark - FSTNumericMinimumFieldValue
+
+/* FieldValue class for minimum() transforms. */
+@interface FSTNumericMinimumFieldValue ()
+- (instancetype)initWithOperand:(NSNumber *)operand;
+@end
+
+@implementation FSTNumericMinimumFieldValue
+- (instancetype)initWithOperand:(NSNumber *)operand {
+  if (self = [super initPrivate]) {
+    _operand = operand;
+  }
+  return self;
+}
+
+- (NSString *)methodName {
+  return @"FieldValue.minimum()";
+}
+
+@end
+
+#pragma mark - FSTNumericMaximumFieldValue
+
+/* FieldValue class for maximum() transforms. */
+@interface FSTNumericMaximumFieldValue ()
+- (instancetype)initWithOperand:(NSNumber *)operand;
+@end
+
+@implementation FSTNumericMaximumFieldValue
+- (instancetype)initWithOperand:(NSNumber *)operand {
+  if (self = [super initPrivate]) {
+    _operand = operand;
+  }
+  return self;
+}
+
+- (NSString *)methodName {
+  return @"FieldValue.maximum()";
+}
+
+@end
+
 #pragma mark - FIRFieldValue
 
 @implementation FIRFieldValue
@@ -177,6 +219,22 @@ + (instancetype)fieldValueForIntegerIncrement:(int64_t)l {
   return [[FSTNumericIncrementFieldValue alloc] initWithOperand:@(l)];
 }
 
++ (instancetype)fieldValueForDoubleMinimum:(double)d {
+  return [[FSTNumericMinimumFieldValue alloc] initWithOperand:@(d)];
+}
+
++ (instancetype)fieldValueForIntegerMinimum:(int64_t)l {
+  return [[FSTNumericMinimumFieldValue alloc] initWithOperand:@(l)];
+}
+
++ (instancetype)fieldValueForDoubleMaximum:(double)d {
+  return [[FSTNumericMaximumFieldValue alloc] initWithOperand:@(d)];
+}
+
++ (instancetype)fieldValueForIntegerMaximum:(int64_t)l {
+  return [[FSTNumericMaximumFieldValue alloc] initWithOperand:@(l)];
+}
+
 + (nonnull FIRVectorValue *)vectorWithArray:(nonnull NSArray<NSNumber *> *)array {
   return [[FIRVectorValue alloc] initWithArray:array];
 }

Firestore/Source/API/FSTUserDataReader.mm

@@ -84,6 +84,8 @@
 using firebase::firestore::model::FieldTransform;
 using firebase::firestore::model::NullValue;
 using firebase::firestore::model::NumericIncrementTransform;
+using firebase::firestore::model::NumericMaximumTransform;
+using firebase::firestore::model::NumericMinimumTransform;
 using firebase::firestore::model::ObjectValue;
 using firebase::firestore::model::ResourcePath;
 using firebase::firestore::model::ServerTimestampTransform;
@@ -453,6 +455,20 @@ - (void)parseSentinelFieldValue:(FIRFieldValue *)fieldValue context:(ParseContex
 
     context.AddToFieldTransforms(*context.path(), std::move(numeric_increment));
 
+  } else if ([fieldValue isKindOfClass:[FSTNumericMinimumFieldValue class]]) {
+    auto *numericMinimumFieldValue = (FSTNumericMinimumFieldValue *)fieldValue;
+    auto operand = [self parsedQueryValue:numericMinimumFieldValue.operand];
+    NumericMinimumTransform numeric_minimum(std::move(operand));
+
+    context.AddToFieldTransforms(*context.path(), std::move(numeric_minimum));
+
+  } else if ([fieldValue isKindOfClass:[FSTNumericMaximumFieldValue class]]) {
+    auto *numericMaximumFieldValue = (FSTNumericMaximumFieldValue *)fieldValue;
+    auto operand = [self parsedQueryValue:numericMaximumFieldValue.operand];
+    NumericMaximumTransform numeric_maximum(std::move(operand));
+
+    context.AddToFieldTransforms(*context.path(), std::move(numeric_maximum));
+
   } else {
     HARD_FAIL("Unknown FIRFieldValue type: %s", NSStringFromClass([fieldValue class]));
   }

Firestore/Source/Public/FirebaseFirestore/FIRFieldValue.h

@@ -92,6 +92,54 @@ NS_SWIFT_NAME(FieldValue)
  */
 + (instancetype)fieldValueForIntegerIncrement:(int64_t)l NS_SWIFT_NAME(increment(_:));
 
+/**
+ * Returns a special value that can be used with `setData()` or `updateData()` that tells the server
+ * to set the field to the minimum of its current value and the given value.
+ *
+ * If the current field value is not an integer or double, or if the field does not yet exist,
+ * the transformation will set the field to the given value.
+ *
+ * @param d The double value to compare.
+ * @return The `FieldValue` sentinel for use in a call to `setData()` or `updateData()`.
+ */
++ (instancetype)fieldValueForDoubleMinimum:(double)d NS_SWIFT_NAME(minimum(_:));
+
+/**
+ * Returns a special value that can be used with `setData()` or `updateData()` that tells the server
+ * to set the field to the minimum of its current value and the given value.
+ *
+ * If the current field value is not an integer or double, or if the field does not yet exist,
+ * the transformation will set the field to the given value.
+ *
+ * @param l The integer value to compare.
+ * @return The `FieldValue` sentinel for use in a call to `setData()` or `updateData()`.
+ */
++ (instancetype)fieldValueForIntegerMinimum:(int64_t)l NS_SWIFT_NAME(minimum(_:));
+
+/**
+ * Returns a special value that can be used with `setData()` or `updateData()` that tells the server
+ * to set the field to the maximum of its current value and the given value.
+ *
+ * If the current field value is not an integer or double, or if the field does not yet exist,
+ * the transformation will set the field to the given value.
+ *
+ * @param d The double value to compare.
+ * @return The `FieldValue` sentinel for use in a call to `setData()` or `updateData()`.
+ */
++ (instancetype)fieldValueForDoubleMaximum:(double)d NS_SWIFT_NAME(maximum(_:));
+
+/**
+ * Returns a special value that can be used with `setData()` or `updateData()` that tells the server
+ * to set the field to the maximum of its current value and the given value.
+ *
+ * If the current field value is not an integer or double, or if the field does not yet exist,
+ * the transformation will set the field to the given value.
+ *
+ * @param l The integer value to compare.
+ * @return The `FieldValue` sentinel for use in a call to `setData()` or `updateData()`.
+ */
++ (instancetype)fieldValueForIntegerMaximum:(int64_t)l NS_SWIFT_NAME(maximum(_:));
+
 /**
  * Creates a new `VectorValue` constructed with a copy of the given array of NSNumbers.
  *