feat: Sum and average aggregation queries

src/aggregate.ts

@@ -46,11 +46,35 @@
    * @param {string} alias
    * @returns {AggregateQuery}
    */
-  count(alias: string): AggregateQuery {
+  count(alias?: string): AggregateQuery {
     this.aggregations.push(AggregateField.count().alias(alias));
     return this;
   }
 
+  /**
+   * Add a `sum` aggregate query to the list of aggregations.
+   *
+   * @param {string} property
+   * @param {string} alias
+   * @returns {AggregateQuery}
+   */
+  sum(property: string, alias?: string): AggregateQuery {
+    this.aggregations.push(AggregateField.sum(property).alias(alias));
+    return this;
+  }
+
+  /**
+   * Add a `average` aggregate query to the list of aggregations.
+   *
+   * @param {string} property
+   * @param {string} alias
+   * @returns {AggregateQuery}
+   */
+  average(property: string, alias?: string): AggregateQuery {
+    this.aggregations.push(AggregateField.average(property).alias(alias));
+    return this;
+  }
+
   /**
    * Add a custom aggregation to the list of aggregations.
    *
@@ -99,8 +123,7 @@
    * Get the proto for the list of aggregations.
    *
    */
-  // eslint-disable-next-line
   toProto(): any {
     return this.aggregations.map(aggregation => aggregation.toProto());
   }
 }
@@ -122,23 +145,42 @@
   }
 
   /**
-   * Gets a copy of the Count aggregate field.
+   * Gets a copy of the Sum aggregate field.
+   *
+   * @returns {Sum}
+   */
+  static sum(property: string): Sum {
+    return new Sum(property);
+  }
+
+  /**
+   * Gets a copy of the Average aggregate field.
+   *
+   * @returns {Average}
+   */
+  static average(property: string): Average {
+    return new Average(property);
+  }
+
+  /**
+   * Sets the alias on the aggregate field that should be used.
    *
    * @param {string} alias The label used in the results to describe this
    * aggregate field when a query is run.
    * @returns {AggregateField}
    */
-  alias(alias: string): AggregateField {
-    this.alias_ = alias;
+  alias(alias?: string): AggregateField {
+    if (alias) {
+      this.alias_ = alias;
+    }
     return this;
   }
 
   /**
    * Gets the proto for the aggregate field.
    *
    */
-  // eslint-disable-next-line
   abstract toProto(): any;
 }
 
 /**
@@ -146,15 +188,63 @@
  *
  */
 class Count extends AggregateField {
-  // eslint-disable-next-line
   /**
    * Gets the proto for the count aggregate field.
    *
    */
   toProto(): any {
     const count = Object.assign({});
     return Object.assign({count}, this.alias_ ? {alias: this.alias_} : null);
   }
 }
 
+/**
+ * A PropertyAggregateField is a class that contains data that defines any
+ * aggregation that is performed on a property.
+ *
+ */
+abstract class PropertyAggregateField extends AggregateField {
+  abstract operator: string;
+
+  /**
+   * Build a PropertyAggregateField object.
+   *
+   * @param {string} property
+   */
+  constructor(public property_: string) {
+    super();
+  }
+
+  /**
+   * Gets the proto for the property aggregate field.
+   *
+   */
+  toProto(): any {
+    const aggregation = this.property_
+      ? {property: {name: this.property_}}
+      : {};
+    return Object.assign(
+      {operator: this.operator},
+      this.alias_ ? {alias: this.alias_} : null,
+      {[this.operator]: aggregation}
+    );
+  }
+}
+
+/**
+ * A Sum is a class that contains data that defines a Sum aggregation.
+ *
+ */
+class Sum extends PropertyAggregateField {
+  operator = 'sum';
+}
+
+/**
+ * An Average is a class that contains data that defines an Average aggregation.
+ *
+ */
+class Average extends PropertyAggregateField {
+  operator = 'avg';
+}
+
 export {AggregateField, AggregateQuery, AGGREGATE_QUERY};

src/index.ts

@@ -40,8 +40,9 @@ import * as is from 'is';
 import {Transform, pipeline} from 'stream';
 
 import {entity, Entities, Entity, EntityProto, ValueProto} from './entity';
+import {AggregateField} from './aggregate';
 import Key = entity.Key;
-export {Entity, Key};
+export {Entity, Key, AggregateField};
 import {PropertyFilter, and, or} from './filter';
 export {PropertyFilter, and, or};
 import {
@@ -1818,7 +1819,6 @@ promisifyAll(Datastore, {
     'isDouble',
     'geoPoint',
     'getProjectId',
-    'getSharedQueryOptions',
     'isGeoPoint',
     'index',
     'int',

src/request.ts

@@ -44,7 +44,7 @@
   KeyProto,
   ResponseResult,
   Entities,
   ValueProto,
 } from './entity';
 import {
   Query,
@@ -276,28 +276,8 @@
     }
 
     const makeRequest = (keys: entity.Key[] | KeyProto[]) => {
-      const reqOpts: RequestOptions = {
-        keys,
-      };
-
-      if (options.consistency) {
-        const code = CONSISTENCY_PROTO_CODE[options.consistency.toLowerCase()];
-
-        reqOpts.readOptions = {
-          readConsistency: code,
-        };
-      }
-      if (options.readTime) {
-        if (reqOpts.readOptions === undefined) {
-          reqOpts.readOptions = {};
-        }
-        const readTime = options.readTime;
-        const seconds = readTime / 1000;
-        reqOpts.readOptions.readTime = {
-          seconds: Math.floor(seconds),
-        };
-      }
-
+      const reqOpts = this.getRequestOptions(options);
+      Object.assign(reqOpts, {keys});
       this.request_(
         {
           client: 'DatastoreClient',
@@ -596,7 +576,7 @@
       setImmediate(callback, e as Error);
       return;
     }
-    const sharedQueryOpts = this.getSharedQueryOptions(query.query, options);
+    const sharedQueryOpts = this.getQueryOptions(query.query, options);
     const aggregationQueryOptions: AggregationQueryOptions = {
       nestedQuery: queryProto,
       aggregations: query.toProto(),
@@ -616,9 +596,9 @@
           const results = res.batch.aggregationResults;
           const finalResults = results
             .map(
               (aggregationResult: any) => aggregationResult.aggregateProperties
             )
             .map((aggregateProperties: any) =>
               Object.fromEntries(
                 new Map(
                   Object.keys(aggregateProperties).map(key => [
@@ -811,7 +791,7 @@
         setImmediate(onResultSet, e as Error);
         return;
       }
-      const sharedQueryOpts = this.getSharedQueryOptions(query, options);
+      const sharedQueryOpts = this.getQueryOptions(query, options);
 
       const reqOpts: RequestOptions = sharedQueryOpts;
       reqOpts.query = queryProto;
@@ -887,9 +867,8 @@
     return stream;
   }
 
-  private getSharedQueryOptions(
-    query: Query,
-    options: RunQueryStreamOptions = {}
+  private getRequestOptions(
+    options: RunQueryStreamOptions
   ): SharedQueryOptions {
     const sharedQueryOpts = {} as SharedQueryOptions;
     if (options.consistency) {
@@ -898,6 +877,24 @@
         readConsistency: code,
       };
     }
+    if (options.readTime) {
+      if (sharedQueryOpts.readOptions === undefined) {
+        sharedQueryOpts.readOptions = {};
+      }
+      const readTime = options.readTime;
+      const seconds = readTime / 1000;
+      sharedQueryOpts.readOptions.readTime = {
+        seconds: Math.floor(seconds),
+      };
+    }
+    return sharedQueryOpts;
+  }
+
+  private getQueryOptions(
+    query: Query,
+    options: RunQueryStreamOptions = {}
+  ): SharedQueryOptions {
+    const sharedQueryOpts = this.getRequestOptions(options);
     if (query.namespace) {
       sharedQueryOpts.partitionId = {
         namespaceId: query.namespace,
@@ -936,7 +933,7 @@
     callback?: SaveCallback
   ): void | Promise<CommitResponse> {
     const transaction = this.datastore.transaction();
     transaction.run(async (err: any) => {
       if (err) {
         try {
           await transaction.rollback();
@@ -1191,7 +1188,7 @@
  * that a callback is omitted.
  */
 promisifyAll(DatastoreRequest, {
-  exclude: ['getSharedQueryOptions'],
+  exclude: ['getQueryOptions', 'getRequestOptions'],
 });
 
 /**