@osdk/faux 0.6.0-beta.4 → 0.6.0-beta.6

package/build/cjs/index.cjs

@@ -3,7 +3,6 @@
 var generatorConverters = require('@osdk/generator-converters');
 var crypto = require('crypto');
 var msw = require('msw');
-var mnemonist = require('mnemonist');
 var util = require('util');
 var invariant4 = require('tiny-invariant');
 var deepEqual = require('fast-deep-equal');
@@ -575,6 +574,49 @@ function pageThroughResponseSearchParams(iter, {
 function isBaseServerObject(obj) {
   return typeof obj === "object" && obj != null && "__primaryKey" in obj && "__apiName" in obj && !("$apiName" in obj) && !("$primaryKey" in obj);
 }
+
+// src/FauxFoundry/collections/DefaultMap.ts
+var DefaultMap = class extends Map {
+  #factory;
+  constructor(factory) {
+    super();
+    this.#factory = factory;
+  }
+  get(key) {
+    if (!super.has(key)) {
+      super.set(key, this.#factory(key));
+    }
+    return super.get(key);
+  }
+};
+
+// src/FauxFoundry/collections/SetMultiMap.ts
+var SetMultiMap = class {
+  #map = /* @__PURE__ */ new Map();
+  set(key, value) {
+    let s = this.#map.get(key);
+    if (!s) {
+      s = /* @__PURE__ */ new Set();
+      this.#map.set(key, s);
+    }
+    s.add(value);
+  }
+  get(key) {
+    return this.#map.get(key);
+  }
+  remove(key, value) {
+    const s = this.#map.get(key);
+    if (s) {
+      s.delete(value);
+      if (s.size === 0) {
+        this.#map.delete(key);
+      }
+    }
+  }
+  delete(key) {
+    return this.#map.delete(key);
+  }
+};
 var FauxDataStoreBatch = class {
   #fauxDataStore;
   objectEdits = {
@@ -1500,15 +1542,15 @@ function isValidDecimalString(value) {
 
 // src/FauxFoundry/FauxDataStore.ts
 var FauxDataStore = class {
-  #objects = new mnemonist.DefaultMap((key) => /* @__PURE__ */ new Map());
-  #objectsWithSecurities = new mnemonist.DefaultMap((key) => /* @__PURE__ */ new Map());
-  #singleLinks = new mnemonist.DefaultMap((_objectLocator) => /* @__PURE__ */ new Map());
-  #manyLinks = new mnemonist.DefaultMap((_objectLocator) => new mnemonist.MultiMap(Set));
+  #objects = new DefaultMap((key) => /* @__PURE__ */ new Map());
+  #objectsWithSecurities = new DefaultMap((key) => /* @__PURE__ */ new Map());
+  #singleLinks = new DefaultMap((_objectLocator) => /* @__PURE__ */ new Map());
+  #manyLinks = new DefaultMap((_objectLocator) => new SetMultiMap());
   #fauxOntology;
   #attachments;
-  #timeSeriesData = new mnemonist.DefaultMap((_objectType) => new mnemonist.DefaultMap((_pk) => new mnemonist.DefaultMap((_property) => [])));
-  #propertySecurities = new mnemonist.DefaultMap((_objectLocator) => [{}]);
-  #media = new mnemonist.DefaultMap((_objectType) => new mnemonist.DefaultMap((_propName) => {
+  #timeSeriesData = new DefaultMap((_objectType) => new DefaultMap((_pk) => new DefaultMap((_property) => [])));
+  #propertySecurities = new DefaultMap((_objectLocator) => [{}]);
+  #media = new DefaultMap((_objectType) => new DefaultMap((_propName) => {
     return /* @__PURE__ */ new Map();
   }));
   #strict;
@@ -3143,9 +3185,57 @@ var createObjectSetHandlers = (baseUrl, fauxFoundry) => [
    * Aggregate Objects in ObjectSet
    */
   OntologiesV2_exports2.OntologyObjectSets.aggregate(baseUrl, async ({
-    request
+    request,
+    params
   }) => {
-    throw new Error("Not implemented");
+    const body = await request.json();
+    const ds = fauxFoundry.getDataStore(params.ontologyApiName);
+    const objects = getObjectsFromSet(ds, body.objectSet, void 0);
+    const exactGroupBys = body.groupBy.filter((g) => g.type === "exact");
+    if (exactGroupBys.length !== body.groupBy.length) {
+      throw new Error("FauxFoundry aggregate: only 'exact' groupBy type is supported");
+    }
+    if (exactGroupBys.length === 0) {
+      return {
+        accuracy: "ACCURATE",
+        data: [{
+          group: {},
+          metrics: [{
+            name: "count",
+            value: objects.length
+          }]
+        }]
+      };
+    }
+    if (exactGroupBys.length > 1) {
+      throw new Error(`FauxFoundry aggregate: multi-dimensional groupBy not yet implemented (got ${exactGroupBys.length} fields)`);
+    }
+    const {
+      field,
+      includeNullValues
+    } = exactGroupBys[0];
+    const groups = /* @__PURE__ */ new Map();
+    for (const obj of objects) {
+      const rawValue = obj[field];
+      const key = rawValue == null ? null : String(rawValue);
+      if (key == null && !includeNullValues) {
+        continue;
+      }
+      groups.set(key, (groups.get(key) ?? 0) + 1);
+    }
+    const data = Array.from(groups.entries()).map(([key, count2]) => ({
+      group: {
+        [field]: key
+      },
+      metrics: [{
+        name: "count",
+        value: count2
+      }]
+    }));
+    return {
+      accuracy: "ACCURATE",
+      data
+    };
   }),
   /**
    * Load interface objectset Objects