industrial-model 0.3.0 → 0.5.0

package/dist/index.js

@@ -26,6 +26,21 @@ var CogniteSdkAdapter = class {
       nextCursor: response.nextCursor
     };
   }
+  async searchInstances(request) {
+    const search = this.client.instances.search;
+    const response = await search(request);
+    return {
+      items: response.items
+    };
+  }
+  async aggregateInstances(request) {
+    const response = await this.client.instances.aggregate(
+      request
+    );
+    return {
+      items: response.items
+    };
+  }
 };
 
 // src/constants.ts
@@ -34,6 +49,8 @@ var EDGE_MARKER = "<EdgeMarker>";
 var MAX_LIMIT = 1e4;
 var DEFAULT_LIMIT = 1e3;
 var MAX_DEPENDENCY_DEPTH = 3;
+var AGGREGATE_LIMIT = 1e3;
+var MAX_GROUP_BY = 5;
 
 // src/mappers/utils.ts
 var NODE_PROPERTIES = /* @__PURE__ */ new Set([
@@ -75,135 +92,32 @@ function buildSelect(source, properties) {
   if (properties.length === 0) return {};
   return { sources: [{ source, properties }] };
 }
-
-// src/mappers/filter-mapper.ts
-var LEAF_OPS = /* @__PURE__ */ new Set([
-  "eq",
-  "in",
-  "gt",
-  "gte",
-  "lt",
-  "lte",
-  "exists",
-  "prefix",
-  "containsAny",
-  "containsAll"
+var GROUPABLE_PROPERTY_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "direct",
+  "int32",
+  "int64",
+  "float32",
+  "float64",
+  "boolean",
+  "enum"
 ]);
-function isLeafFilter(value) {
-  return Object.keys(value).some((k) => LEAF_OPS.has(k));
+var NUMERIC_PROPERTY_TYPES = /* @__PURE__ */ new Set(["int32", "int64", "float32", "float64"]);
+function isGroupableProperty(property) {
+  if (!isViewPropertyDefinition(property)) return false;
+  if (property.type.list === true) return false;
+  const type = property.type.type;
+  return type != null && GROUPABLE_PROPERTY_TYPES.has(type);
 }
-var FilterMapper = class {
-  constructor(viewMapper) {
-    this.viewMapper = viewMapper;
-  }
-  async map(input, rootView) {
-    const result = [];
-    for (const [key, value] of Object.entries(input)) {
-      if (value == null) continue;
-      if (key === "AND") {
-        const clauses = Array.isArray(value) ? value : [value];
-        const inner = await Promise.all(clauses.map((c) => this.whereInputToSingle(c, rootView)));
-        result.push({ and: inner });
-      } else if (key === "OR") {
-        const clauses = value;
-        const branches = await Promise.all(
-          clauses.map((c) => this.whereInputToSingle(c, rootView))
-        );
-        result.push({ or: branches });
-      } else if (key === "NOT") {
-        const clauses = Array.isArray(value) ? value : [value];
-        const [firstClause, ...restClauses] = clauses;
-        const combined = restClauses.length === 0 && firstClause !== void 0 ? firstClause : { AND: clauses };
-        result.push({ not: await this.whereInputToSingle(combined, rootView) });
-      } else {
-        const filterValue = value;
-        const property = getPropertyRef(key, rootView);
-        if (isLeafFilter(filterValue)) {
-          result.push(...this.leafToFilterDefs(property, filterValue));
-        } else {
-          const targetView = await this.getNestedTargetView(key, rootView);
-          const innerFilter = await this.whereInputToSingle(filterValue, targetView);
-          result.push({ nested: { scope: property, filter: innerFilter } });
-        }
-      }
-    }
-    return result;
-  }
-  async whereInputToSingle(input, rootView) {
-    const filters = await this.map(input, rootView);
-    const [firstFilter, ...restFilters] = filters;
-    if (restFilters.length === 0 && firstFilter !== void 0) {
-      return firstFilter;
-    }
-    return { and: filters };
-  }
-  leafToFilterDefs(property, filter) {
-    const result = [];
-    if ("eq" in filter && filter.eq !== void 0) {
-      result.push({
-        equals: { property, value: this.coerceValue(filter.eq) }
-      });
-    }
-    if ("in" in filter && filter.in !== void 0) {
-      result.push({
-        in: { property, values: this.coerceValue(filter.in) }
-      });
-    }
-    if ("gt" in filter && filter.gt !== void 0) {
-      result.push({ range: { property, gt: this.coerceValue(filter.gt) } });
-    }
-    if ("gte" in filter && filter.gte !== void 0) {
-      result.push({ range: { property, gte: this.coerceValue(filter.gte) } });
-    }
-    if ("lt" in filter && filter.lt !== void 0) {
-      result.push({ range: { property, lt: this.coerceValue(filter.lt) } });
-    }
-    if ("lte" in filter && filter.lte !== void 0) {
-      result.push({ range: { property, lte: this.coerceValue(filter.lte) } });
-    }
-    if ("exists" in filter) {
-      if (filter.exists === true) {
-        result.push({ exists: { property } });
-      } else if (filter.exists === false) {
-        result.push({ not: { exists: { property } } });
-      }
-    }
-    if ("prefix" in filter && filter.prefix !== void 0) {
-      result.push({ prefix: { property, value: this.coerceValue(filter.prefix) } });
-    }
-    if ("containsAll" in filter && filter.containsAll !== void 0) {
-      result.push({
-        containsAll: {
-          property,
-          values: this.coerceValue(filter.containsAll)
-        }
-      });
-    }
-    if ("containsAny" in filter && filter.containsAny !== void 0) {
-      result.push({
-        containsAny: {
-          property,
-          values: this.coerceValue(filter.containsAny)
-        }
-      });
-    }
-    return result;
-  }
-  async getNestedTargetView(property, rootView) {
-    const viewProp = rootView.properties[property];
-    if (!viewProp || !isViewPropertyDefinition(viewProp)) {
-      throw new Error(`Property "${property}" is not a mapped property`);
-    }
-    const source = getDirectRelationSource(viewProp);
-    if (!source) throw new Error(`Property "${property}" has no relation source`);
-    return this.viewMapper.getView(source.externalId);
-  }
-  coerceValue(value) {
-    if (value instanceof Date) return value.toISOString();
-    if (Array.isArray(value)) return value.map((v) => this.coerceValue(v));
-    return value;
-  }
-};
+function isNumericProperty(property) {
+  const type = property.type.type;
+  return type != null && NUMERIC_PROPERTY_TYPES.has(type);
+}
+function getSelectedGroupByKeys(groupBy) {
+  return Object.entries(groupBy).filter((entry) => entry[1] === true).map(([key]) => key);
+}
+
+// src/validation.ts
 var nodeIdSchema = z.object({
   space: z.string().min(1),
   externalId: z.string().min(1)
@@ -277,13 +191,14 @@ var leafOps = /* @__PURE__ */ new Set([
   "lte",
   "exists",
   "prefix",
+  "search",
   "containsAny",
   "containsAll"
 ]);
 function isRecord(value) {
   return value != null && typeof value === "object" && !Array.isArray(value);
 }
-function isLeafFilter2(value) {
+function isLeafFilter(value) {
   return Object.keys(value).some((key) => leafOps.has(key));
 }
 function issuePath(path) {
@@ -329,19 +244,33 @@ function leafFilterSchema(property) {
   const value = baseValueSchema(property);
   const isList = typeof property !== "string" && property.type.list === true;
   if (isList) {
-    return z.object({
+    const shape = {
       containsAny: z.array(value).optional(),
       containsAll: z.array(value).optional(),
       exists: z.boolean().optional()
-    }).strict();
+    };
+    if (property.type.type === "text") {
+      shape.search = z.object({
+        query: z.string(),
+        operator: z.enum(["OR", "AND"]).optional()
+      }).strict().optional();
+    }
+    return z.object(shape).strict();
   }
   if (property === "node-string" || typeof property !== "string" && property.type.type === "text") {
-    return z.object({
+    const shape = {
       eq: z.string().optional(),
       in: z.array(z.string()).optional(),
       prefix: z.string().optional(),
       exists: z.boolean().optional()
-    }).strict();
+    };
+    if (property !== "node-string") {
+      shape.search = z.object({
+        query: z.string(),
+        operator: z.enum(["OR", "AND"]).optional()
+      }).strict().optional();
+    }
+    return z.object(shape).strict();
   }
   if (typeof property !== "string" && property.type.type === "enum") {
     return z.object({
@@ -403,7 +332,7 @@ var QueryValidator = class {
       errors.push(...await this.validateSelect(options.select, rootView, ["select"]));
     }
     if (options.filters !== void 0) {
-      errors.push(...await this.validateFilters(options.filters, rootView, ["filters"]));
+      errors.push(...await this.validateWhereInput(options.filters, rootView, ["filters"]));
     }
     if (options.sort !== void 0) {
       errors.push(...this.validateSort(options.sort, rootView, ["sort"]));
@@ -463,6 +392,9 @@ ${errors.map((error) => `- ${error}`).join("\n")}`);
     }
     return errors;
   }
+  async validateWhereInput(filters, view, path) {
+    return this.validateFilters(filters, view, path);
+  }
   async validateFilters(filters, view, path) {
     const shape = {
       AND: z.union([recordSchema, z.array(recordSchema)]).optional(),
@@ -506,7 +438,7 @@ ${errors.map((error) => `- ${error}`).join("\n")}`);
       if (!property) continue;
       if (isViewPropertyDefinition(property)) {
         const target2 = getDirectRelationSource(property);
-        if (target2 != null && !isLeafFilter2(value)) {
+        if (target2 != null && !isLeafFilter(value)) {
           const targetView = await this.viewMapper.getView(target2.externalId);
           errors.push(...await this.validateFilters(value, targetView, [...path, name]));
         } else {
@@ -544,6 +476,380 @@ ${errors.map((error) => `- ${error}`).join("\n")}`);
   }
 };
 
+// src/mappers/aggregate-validator.ts
+var NODE_COUNT_PROPERTIES = /* @__PURE__ */ new Set(["externalId", "space"]);
+function issuePath2(path) {
+  return path.length === 0 ? "aggregate" : path.map(String).join(".");
+}
+function formatZodIssues2(error, path) {
+  return error.issues.map((issue) => `${issuePath2([...path, ...issue.path])}: ${issue.message}`);
+}
+function isEmptyObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+var AggregateValidator = class {
+  constructor(viewMapper) {
+    this.queryValidator = new QueryValidator(viewMapper);
+  }
+  async validate(options, rootView) {
+    const errors = [];
+    errors.push(...this.validateOptionsShape(options, rootView));
+    const selectedGroupBy = options.groupBy ? getSelectedGroupByKeys(options.groupBy) : [];
+    if (selectedGroupBy.length === 0 && options.aggregate === void 0) {
+      errors.push("aggregate: either groupBy or aggregate must be provided");
+    }
+    if (options.filters !== void 0) {
+      errors.push(
+        ...await this.queryValidator.validateWhereInput(options.filters, rootView, ["filters"])
+      );
+    }
+    if (options.groupBy !== void 0) {
+      errors.push(...this.validateGroupBy(options.groupBy, rootView, ["groupBy"]));
+    }
+    if (options.aggregate !== void 0) {
+      errors.push(
+        ...this.validateAggregate(
+          options.aggregate,
+          rootView,
+          ["aggregate"]
+        )
+      );
+    }
+    if (errors.length > 0) {
+      throw new Error(
+        `Invalid aggregate options:
+${errors.map((error) => `- ${error}`).join("\n")}`
+      );
+    }
+  }
+  validateOptionsShape(options, rootView) {
+    const schema = z.object({
+      viewExternalId: z.literal(rootView.externalId),
+      filters: z.unknown().optional(),
+      groupBy: z.unknown().optional(),
+      aggregate: z.unknown().optional()
+    }).strict();
+    const result = schema.safeParse(options);
+    return result.success ? [] : formatZodIssues2(result.error, []);
+  }
+  validateGroupBy(groupBy, view, path) {
+    const shape = {};
+    for (const [name, property] of Object.entries(view.properties)) {
+      if (isGroupableProperty(property)) {
+        shape[name] = z.literal(true).optional();
+      }
+    }
+    const result = z.object(shape).strict().safeParse(groupBy);
+    if (!result.success) {
+      return formatZodIssues2(result.error, path);
+    }
+    const selected = getSelectedGroupByKeys(groupBy);
+    const errors = [];
+    if (selected.length === 0) {
+      errors.push(`${issuePath2(path)}: at least one property must be set to true`);
+    }
+    if (selected.length > MAX_GROUP_BY) {
+      errors.push(`${issuePath2(path)}: at most ${MAX_GROUP_BY} properties can be grouped`);
+    }
+    for (const name of selected) {
+      const property = view.properties[name];
+      if (!property || !isGroupableProperty(property)) {
+        errors.push(`${issuePath2([...path, name])}: property "${name}" cannot be used in groupBy`);
+      }
+    }
+    return errors;
+  }
+  validateAggregate(aggregate, view, path) {
+    if ("count" in aggregate) {
+      const property2 = aggregate.count;
+      if (isEmptyObject(property2)) {
+        return [];
+      }
+      if (typeof property2 === "string") {
+        if (NODE_COUNT_PROPERTIES.has(property2)) {
+          return [];
+        }
+        const viewProperty = view.properties[property2];
+        if (!viewProperty || !isGroupableProperty(viewProperty)) {
+          return [`${issuePath2([...path, "count"])}: property "${property2}" cannot be counted`];
+        }
+        return [];
+      }
+      return [`${issuePath2([...path, "count"])}: invalid count property`];
+    }
+    let propertyName;
+    let numericOp = null;
+    if ("avg" in aggregate) {
+      numericOp = "avg";
+      propertyName = aggregate.avg;
+    } else if ("min" in aggregate) {
+      numericOp = "min";
+      propertyName = aggregate.min;
+    } else if ("max" in aggregate) {
+      numericOp = "max";
+      propertyName = aggregate.max;
+    } else if ("sum" in aggregate) {
+      numericOp = "sum";
+      propertyName = aggregate.sum;
+    }
+    if (numericOp == null) {
+      return [`${issuePath2(path)}: unknown aggregate operation`];
+    }
+    if (typeof propertyName !== "string") {
+      return [`${issuePath2(path)}: aggregate property must be a string`];
+    }
+    const property = view.properties[propertyName];
+    if (!property || !isViewPropertyDefinition(property) || !isNumericProperty(property)) {
+      return [
+        `${issuePath2([...path, numericOp])}: property "${propertyName}" must be a numeric view property`
+      ];
+    }
+    if (getDirectRelationSource(property) != null) {
+      return [
+        `${issuePath2([...path, numericOp])}: property "${propertyName}" is a relation and cannot be aggregated`
+      ];
+    }
+    return [];
+  }
+};
+
+// src/mappers/filter-mapper.ts
+var LEAF_OPS = /* @__PURE__ */ new Set([
+  "eq",
+  "in",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "exists",
+  "prefix",
+  "containsAny",
+  "containsAll"
+]);
+function isLeafFilter2(value) {
+  return Object.keys(value).some((k) => LEAF_OPS.has(k));
+}
+var FilterMapper = class {
+  constructor(viewMapper, cognite) {
+    this.viewMapper = viewMapper;
+    this.cognite = cognite;
+  }
+  async map(input, rootView) {
+    const result = [];
+    const searchQueries = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (value == null) continue;
+      if (key === "AND") {
+        const clauses = Array.isArray(value) ? value : [value];
+        const inner = await Promise.all(clauses.map((c) => this.whereInputToSingle(c, rootView)));
+        result.push({ and: inner });
+      } else if (key === "OR") {
+        const clauses = value;
+        const branches = await Promise.all(
+          clauses.map((c) => this.whereInputToSingle(c, rootView))
+        );
+        result.push({ or: branches });
+      } else if (key === "NOT") {
+        const clauses = Array.isArray(value) ? value : [value];
+        const [firstClause, ...restClauses] = clauses;
+        const combined = restClauses.length === 0 && firstClause !== void 0 ? firstClause : { AND: clauses };
+        result.push({ not: await this.whereInputToSingle(combined, rootView) });
+      } else {
+        const filterValue = value;
+        const property = getPropertyRef(key, rootView);
+        const hasLeafFilter = isLeafFilter2(filterValue);
+        if (hasLeafFilter) {
+          result.push(...this.leafToFilterDefs(property, filterValue));
+        }
+        if ("search" in filterValue && filterValue.search != null) {
+          searchQueries[key] = filterValue.search;
+        } else if (!hasLeafFilter) {
+          const targetView = await this.getNestedTargetView(key, rootView);
+          const innerFilter = await this.whereInputToSingle(filterValue, targetView);
+          result.push({ nested: { scope: property, filter: innerFilter } });
+        }
+      }
+    }
+    if (Object.keys(searchQueries).length > 0) {
+      const searchFilters = await Promise.all(
+        Object.entries(searchQueries).map(
+          ([key, filterValue]) => this.searchToFilterDef(key, filterValue, rootView)
+        )
+      );
+      result.push(...searchFilters);
+    }
+    return result;
+  }
+  async searchToFilterDef(propertyName, search, rootView) {
+    const response = await this.cognite.searchInstances({
+      view: toViewReference(rootView),
+      query: search.query,
+      instanceType: "node",
+      properties: [propertyName],
+      operator: search.operator ?? "OR",
+      limit: 1e3
+    });
+    const instanceRefs = response.items.map((item) => ({
+      space: item.space,
+      externalId: item.externalId
+    }));
+    return { instanceReferences: instanceRefs };
+  }
+  async whereInputToSingle(input, rootView) {
+    const filters = await this.map(input, rootView);
+    const [firstFilter, ...restFilters] = filters;
+    if (restFilters.length === 0 && firstFilter !== void 0) {
+      return firstFilter;
+    }
+    return { and: filters };
+  }
+  leafToFilterDefs(property, filter) {
+    const result = [];
+    if ("eq" in filter && filter.eq !== void 0) {
+      result.push({
+        equals: { property, value: this.coerceValue(filter.eq) }
+      });
+    }
+    if ("in" in filter && filter.in !== void 0) {
+      result.push({
+        in: { property, values: this.coerceValue(filter.in) }
+      });
+    }
+    if ("gt" in filter && filter.gt !== void 0) {
+      result.push({ range: { property, gt: this.coerceValue(filter.gt) } });
+    }
+    if ("gte" in filter && filter.gte !== void 0) {
+      result.push({ range: { property, gte: this.coerceValue(filter.gte) } });
+    }
+    if ("lt" in filter && filter.lt !== void 0) {
+      result.push({ range: { property, lt: this.coerceValue(filter.lt) } });
+    }
+    if ("lte" in filter && filter.lte !== void 0) {
+      result.push({ range: { property, lte: this.coerceValue(filter.lte) } });
+    }
+    if ("exists" in filter) {
+      if (filter.exists === true) {
+        result.push({ exists: { property } });
+      } else if (filter.exists === false) {
+        result.push({ not: { exists: { property } } });
+      }
+    }
+    if ("prefix" in filter && filter.prefix !== void 0) {
+      result.push({ prefix: { property, value: this.coerceValue(filter.prefix) } });
+    }
+    if ("containsAll" in filter && filter.containsAll !== void 0) {
+      result.push({
+        containsAll: {
+          property,
+          values: this.coerceValue(filter.containsAll)
+        }
+      });
+    }
+    if ("containsAny" in filter && filter.containsAny !== void 0) {
+      result.push({
+        containsAny: {
+          property,
+          values: this.coerceValue(filter.containsAny)
+        }
+      });
+    }
+    return result;
+  }
+  async getNestedTargetView(property, rootView) {
+    const viewProp = rootView.properties[property];
+    if (!viewProp || !isViewPropertyDefinition(viewProp)) {
+      throw new Error(`Property "${property}" is not a mapped property`);
+    }
+    const source = getDirectRelationSource(viewProp);
+    if (!source) throw new Error(`Property "${property}" has no relation source`);
+    return this.viewMapper.getView(source.externalId);
+  }
+  coerceValue(value) {
+    if (value instanceof Date) return value.toISOString();
+    if (Array.isArray(value)) return value.map((v) => this.coerceValue(v));
+    return value;
+  }
+};
+
+// src/mappers/aggregate-mapper.ts
+var AggregateMapper = class {
+  constructor(viewMapper, cognite) {
+    this.viewMapper = viewMapper;
+    this.filterMapper = new FilterMapper(viewMapper, cognite);
+    this.validator = new AggregateValidator(viewMapper);
+  }
+  async map(options) {
+    const { viewExternalId, filters, groupBy, aggregate } = options;
+    const rootView = await this.viewMapper.getView(viewExternalId);
+    await this.validator.validate(options, rootView);
+    const filterParts = filters ? await this.filterMapper.map(filters, rootView) : [];
+    const filter = filterParts.length === 0 ? void 0 : filterParts.length === 1 ? filterParts[0] : { and: filterParts };
+    return {
+      view: toViewReference(rootView),
+      instanceType: "node",
+      limit: AGGREGATE_LIMIT,
+      ...filter !== void 0 ? { filter } : {},
+      ...groupBy ? { groupBy: getSelectedGroupByKeys(groupBy) } : {},
+      ...aggregate ? { aggregates: [mapAggregateDefinition(aggregate)] } : {}
+    };
+  }
+};
+function mapAggregateDefinition(aggregate) {
+  if ("count" in aggregate) {
+    const property = aggregate.count;
+    if (property != null && typeof property === "object" && !Array.isArray(property) && Object.keys(property).length === 0) {
+      return { count: {} };
+    }
+    if (typeof property === "string") {
+      return { count: { property } };
+    }
+    return { count: {} };
+  }
+  if ("avg" in aggregate) {
+    return { avg: { property: aggregate.avg } };
+  }
+  if ("min" in aggregate) {
+    return { min: { property: aggregate.min } };
+  }
+  if ("max" in aggregate) {
+    return { max: { property: aggregate.max } };
+  }
+  if ("sum" in aggregate) {
+    return { sum: { property: aggregate.sum } };
+  }
+  throw new Error("Invalid aggregate definition");
+}
+
+// src/mappers/aggregate-result-mapper.ts
+function isNodeId(value) {
+  return value != null && typeof value === "object" && "space" in value && "externalId" in value && typeof value.space === "string" && typeof value.externalId === "string";
+}
+var AggregateResultMapper = class {
+  map(response, options) {
+    const groupByKeys = options.groupBy ? getSelectedGroupByKeys(options.groupBy) : [];
+    return response.items.map((item) => {
+      let group;
+      if (item.group != null && groupByKeys.length > 0) {
+        group = {};
+        for (const key of groupByKeys) {
+          const value = item.group[key];
+          if (value === void 0) continue;
+          group[key] = isNodeId(value) ? { space: value.space, externalId: value.externalId } : value;
+        }
+        if (Object.keys(group).length === 0) {
+          group = void 0;
+        }
+      }
+      const aggregateValue = item.aggregates[0];
+      const aggregate = aggregateValue?.value !== void 0 ? aggregateValue.property != null ? { property: aggregateValue.property, value: aggregateValue.value } : { value: aggregateValue.value } : void 0;
+      return {
+        ...group !== void 0 ? { group } : {},
+        ...aggregate !== void 0 ? { aggregate } : {}
+      };
+    });
+  }
+};
+
 // src/mappers/sort-mapper.ts
 var SortMapper = class {
   map(sort, rootView) {
@@ -564,9 +870,9 @@ var SortMapper = class {
 
 // src/mappers/query-mapper.ts
 var QueryMapper = class {
-  constructor(viewMapper) {
+  constructor(viewMapper, cognite) {
     this.viewMapper = viewMapper;
-    this.filterMapper = new FilterMapper(viewMapper);
+    this.filterMapper = new FilterMapper(viewMapper, cognite);
     this.sortMapper = new SortMapper();
     this.validator = new QueryValidator(viewMapper);
   }
@@ -1112,7 +1418,9 @@ var IndustrialModelClient = class {
     const cognite = createCogniteAdapter(client);
     this.cognite = cognite;
     const viewMapper = new ViewMapper(cognite, dataModelId);
-    this.queryMapper = new QueryMapper(viewMapper);
+    this.queryMapper = new QueryMapper(viewMapper, cognite);
+    this.aggregateMapper = new AggregateMapper(viewMapper, cognite);
+    this.aggregateResultMapper = new AggregateResultMapper();
     this.resultMapper = new QueryResultMapper(viewMapper);
     this.resultValidator = new QueryResultValidator(viewMapper);
     this.validateResults = options.validateResults ?? false;
@@ -1121,6 +1429,19 @@ var IndustrialModelClient = class {
     const execute = (options) => this.queryInternal(options);
     return execute;
   }
+  aggregate() {
+    const execute = (options) => this.aggregateInternal(options);
+    return execute;
+  }
+  async aggregateInternal(options) {
+    const cogniteRequest = await this.aggregateMapper.map(options);
+    const response = await this.cognite.aggregateInstances(cogniteRequest);
+    const items = this.aggregateResultMapper.map(
+      response,
+      options
+    );
+    return { items };
+  }
   async queryInternal(options) {
     const { viewExternalId, limit = DEFAULT_LIMIT } = options;
     const allPages = options.limit === -1;