Refactor core/target.ts, extracting classes Bound, OrderBy, and Filter

packages/firestore/src/core/bound.ts

@@ -0,0 +1,131 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Document } from '../model/document';
+import { DocumentKey } from '../model/document_key';
+import { isReferenceValue, valueCompare, valueEquals } from '../model/values';
+import { Value as ProtoValue } from '../protos/firestore_proto_api';
+import { debugAssert } from '../util/assert';
+
+import { Direction, OrderBy } from './order_by';
+
+/**
+ * Represents a bound of a query.
+ *
+ * The bound is specified with the given components representing a position and
+ * whether it's just before or just after the position (relative to whatever the
+ * query order is).
+ *
+ * The position represents a logical index position for a query. It's a prefix
+ * of values for the (potentially implicit) order by clauses of a query.
+ *
+ * Bound provides a function to determine whether a document comes before or
+ * after a bound. This is influenced by whether the position is just before or
+ * just after the provided values.
+ */
+export class Bound {
+  constructor(readonly position: ProtoValue[], readonly inclusive: boolean) {}
+}
+
+function boundCompareToDocument(
+  bound: Bound,
+  orderBy: OrderBy[],
+  doc: Document
+): number {
+  debugAssert(
+    bound.position.length <= orderBy.length,
+    "Bound has more components than query's orderBy"
+  );
+  let comparison = 0;
+  for (let i = 0; i < bound.position.length; i++) {
+    const orderByComponent = orderBy[i];
+    const component = bound.position[i];
+    if (orderByComponent.field.isKeyField()) {
+      debugAssert(
+        isReferenceValue(component),
+        'Bound has a non-key value where the key path is being used.'
+      );
+      comparison = DocumentKey.comparator(
+        DocumentKey.fromName(component.referenceValue),
+        doc.key
+      );
+    } else {
+      const docValue = doc.data.field(orderByComponent.field);
+      debugAssert(
+        docValue !== null,
+        'Field should exist since document matched the orderBy already.'
+      );
+      comparison = valueCompare(component, docValue);
+    }
+    if (orderByComponent.dir === Direction.DESCENDING) {
+      comparison = comparison * -1;
+    }
+    if (comparison !== 0) {
+      break;
+    }
+  }
+  return comparison;
+}
+
+/**
+ * Returns true if a document sorts after a bound using the provided sort
+ * order.
+ */
+export function boundSortsAfterDocument(
+  bound: Bound,
+  orderBy: OrderBy[],
+  doc: Document
+): boolean {
+  const comparison = boundCompareToDocument(bound, orderBy, doc);
+  return bound.inclusive ? comparison >= 0 : comparison > 0;
+}
+
+/**
+ * Returns true if a document sorts before a bound using the provided sort
+ * order.
+ */
+export function boundSortsBeforeDocument(
+  bound: Bound,
+  orderBy: OrderBy[],
+  doc: Document
+): boolean {
+  const comparison = boundCompareToDocument(bound, orderBy, doc);
+  return bound.inclusive ? comparison <= 0 : comparison < 0;
+}
+
+export function boundEquals(left: Bound | null, right: Bound | null): boolean {
+  if (left === null) {
+    return right === null;
+  } else if (right === null) {
+    return false;
+  }
+
+  if (
+    left.inclusive !== right.inclusive ||
+    left.position.length !== right.position.length
+  ) {
+    return false;
+  }
+  for (let i = 0; i < left.position.length; i++) {
+    const leftPosition = left.position[i];
+    const rightPosition = right.position[i];
+    if (!valueEquals(leftPosition, rightPosition)) {
+      return false;
+    }
+  }
+  return true;
+}