@osdk/client 0.14.0 → 0.15.0

package/build/js/chunk-Y7UBQD5N.mjs

@@ -1,1346 +0,0 @@
-import { aggregateObjectSetV2, loadObjectSetV2, getObjectTypeV2, searchObjectsForInterface } from '@osdk/gateway/requests';
-import { createOpenApiRequest, PalantirApiError } from '@osdk/shared.net';
-import invariant2 from 'tiny-invariant';
-import WebSocket from 'isomorphic-ws';
-import { conjureFetch } from 'conjure-lite';
-
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-function legacyToModernSingleAggregationResult(entry) {
-  return entry.metrics.reduce((accumulator, curValue) => {
-    const parts = curValue.name.split(".");
-    if (parts[0] === "count") {
-      return accumulator;
-    }
-    !(parts.length === 2) ? process.env.NODE_ENV !== "production" ? invariant2(false, "assumed we were getting a `${key}.${type}`") : invariant2(false) : void 0;
-    if (!(parts[0] in accumulator)) {
-      accumulator[parts[0]] = {};
-    }
-    accumulator[parts[0]][parts[1]] = curValue.value;
-    return accumulator;
-  }, {});
-}
-
-// src/internal/conversions/modernToLegacyAggregationClause.ts
-function modernToLegacyAggregationClause(select) {
-  return Object.entries(select).flatMap(([k, v]) => {
-    if (k === "$count") {
-      if (v)
-        return {
-          type: "count",
-          name: "count"
-        };
-      return [];
-    } else if (Array.isArray(v)) {
-      return v.map((v2) => {
-        return {
-          type: v2,
-          name: `${k}.${v2}`,
-          field: k
-        };
-      });
-    } else {
-      return [{
-        type: v,
-        // FIXME v has additional possible values
-        name: `${k}.${v}`,
-        field: k
-      }];
-    }
-  });
-}
-
-// src/query/aggregations/GroupByClause.ts
-var DurationMapping = {
-  "sec": "SECONDS",
-  "seconds": "SECONDS",
-  "min": "MINUTES",
-  "minute": "MINUTES",
-  "minutes": "MINUTES",
-  "hr": "HOURS",
-  "hrs": "HOURS",
-  "hour": "HOURS",
-  "hours": "HOURS",
-  "day": "DAYS",
-  "days": "DAYS",
-  "wk": "WEEKS",
-  "week": "WEEKS",
-  "weeks": "WEEKS",
-  "mos": "MONTHS",
-  "month": "MONTHS",
-  "months": "MONTHS",
-  "yr": "YEARS",
-  "year": "YEARS",
-  "years": "YEARS",
-  "quarter": "QUARTERS",
-  "quarters": "QUARTERS"
-};
-
-// src/internal/conversions/modernToLegacyGroupByClause.ts
-function modernToLegacyGroupByClause(groupByClause) {
-  if (!groupByClause)
-    return [];
-  return Object.entries(groupByClause).flatMap(([field, type]) => {
-    if (type === "exact") {
-      return [{
-        type,
-        field
-      }];
-    } else if ("exactWithLimit" in type) {
-      {
-        return [{
-          type: "exact",
-          field,
-          maxGroupCount: type.exactWithLimit
-        }];
-      }
-    } else if ("fixedWidth" in type) {
-      return [{
-        type: "fixedWidth",
-        field,
-        fixedWidth: type.fixedWidth
-      }];
-    } else if ("ranges" in type) {
-      return [{
-        type: "ranges",
-        field,
-        ranges: type.ranges.map((range) => convertRange(range))
-      }];
-    } else if ("duration" in type) {
-      return [{
-        type: "duration",
-        field,
-        value: type.duration[0],
-        unit: DurationMapping[type.duration[1]]
-      }];
-    } else
-      return [];
-  });
-}
-function convertRange(range) {
-  return {
-    startValue: range[0],
-    endValue: range[1]
-  };
-}
-
-// src/query/WhereClause.ts
-var DistanceUnitMapping = {
-  "centimeter": "CENTIMETERS",
-  "centimeters": "CENTIMETERS",
-  "cm": "CENTIMETERS",
-  "meter": "METERS",
-  "meters": "METERS",
-  "m": "METERS",
-  "kilometer": "KILOMETERS",
-  "kilometers": "KILOMETERS",
-  "km": "KILOMETERS",
-  "inch": "INCHES",
-  "inches": "INCHES",
-  "foot": "FEET",
-  "feet": "FEET",
-  "yard": "YARDS",
-  "yards": "YARDS",
-  "mile": "MILES",
-  "miles": "MILES",
-  "nautical_mile": "NAUTICAL_MILES",
-  "nauticalMile": "NAUTICAL_MILES",
-  "nautical miles": "NAUTICAL_MILES"
-};
-
-// src/internal/conversions/modernToLegacyWhereClause.ts
-function modernToLegacyWhereClause(whereClause) {
-  if ("$and" in whereClause) {
-    return {
-      type: "and",
-      value: whereClause.$and.map(modernToLegacyWhereClause)
-    };
-  } else if ("$or" in whereClause) {
-    return {
-      type: "or",
-      value: whereClause.$or.map(modernToLegacyWhereClause)
-    };
-  } else if ("$not" in whereClause) {
-    return {
-      type: "not",
-      value: modernToLegacyWhereClause(whereClause.$not)
-    };
-  }
-  const parts = Object.entries(whereClause);
-  if (parts.length === 1) {
-    return handleWherePair(parts[0]);
-  }
-  return {
-    type: "and",
-    value: parts.map(handleWherePair)
-  };
-}
-function makeGeoFilterBbox(field, bbox, filterType) {
-  return {
-    type: filterType === "$within" ? "withinBoundingBox" : "intersectsBoundingBox",
-    field,
-    value: {
-      topLeft: {
-        type: "Point",
-        coordinates: [bbox[0], bbox[3]]
-      },
-      bottomRight: {
-        type: "Point",
-        coordinates: [bbox[2], bbox[1]]
-      }
-    }
-  };
-}
-function makeGeoFilterPolygon(field, coordinates, filterType) {
-  return {
-    type: filterType,
-    field,
-    value: {
-      type: "Polygon",
-      coordinates
-    }
-  };
-}
-function handleWherePair([field, filter]) {
-  !(filter != null) ? process.env.NODE_ENV !== "production" ? invariant2(false, "Defined key values are only allowed when they are not undefined.") : invariant2(false) : void 0;
-  if (typeof filter === "string" || typeof filter === "number" || typeof filter === "boolean") {
-    return {
-      type: "eq",
-      field,
-      value: filter
-    };
-  }
-  const keysOfFilter = Object.keys(filter);
-  const hasDollarSign = keysOfFilter.some((key) => key.startsWith("$"));
-  !(!hasDollarSign || keysOfFilter.length === 1) ? process.env.NODE_ENV !== "production" ? invariant2(false, "WhereClause Filter with multiple clauses isn't allowed") : invariant2(false) : void 0;
-  if (!hasDollarSign) {
-    throw new Error(`Unsupported filter. Did you forget to use a $-prefixed filter? (${JSON.stringify(filter)})`);
-  }
-  const firstKey = keysOfFilter[0];
-  !(filter[firstKey] != null) ? process.env.NODE_ENV !== "production" ? invariant2(false) : invariant2(false) : void 0;
-  if (firstKey === "$ne") {
-    return {
-      type: "not",
-      value: {
-        type: "eq",
-        field,
-        value: filter[firstKey]
-      }
-    };
-  }
-  if (firstKey === "$within") {
-    const withinBody = filter[firstKey];
-    if (Array.isArray(withinBody)) {
-      return makeGeoFilterBbox(field, withinBody, firstKey);
-    } else if ("bbox" in withinBody && !("type" in withinBody)) {
-      return makeGeoFilterBbox(field, withinBody.bbox, firstKey);
-    } else if ("distance" in withinBody && "of" in withinBody) {
-      return {
-        type: "withinDistanceOf",
-        field,
-        value: {
-          center: Array.isArray(withinBody.of) ? {
-            type: "Point",
-            coordinates: withinBody.of
-          } : withinBody.of,
-          distance: {
-            value: withinBody.distance[0],
-            unit: DistanceUnitMapping[withinBody.distance[1]]
-          }
-        }
-      };
-    } else {
-      const coordinates = "polygon" in withinBody ? withinBody.polygon : withinBody.coordinates;
-      return makeGeoFilterPolygon(field, coordinates, "withinPolygon");
-    }
-  }
-  if (firstKey === "$intersects") {
-    const intersectsBody = filter[firstKey];
-    if (Array.isArray(intersectsBody)) {
-      return makeGeoFilterBbox(field, intersectsBody, firstKey);
-    } else if ("bbox" in intersectsBody && !("type" in intersectsBody)) {
-      return makeGeoFilterBbox(field, intersectsBody.bbox, firstKey);
-    } else {
-      const coordinates = "polygon" in intersectsBody ? intersectsBody.polygon : intersectsBody.coordinates;
-      return makeGeoFilterPolygon(field, coordinates, "intersectsPolygon");
-    }
-  }
-  return {
-    type: firstKey.substring(1),
-    field,
-    value: filter[firstKey]
-  };
-}
-async function fetchSingle(client, objectType, args, objectSet) {
-  const result = await fetchPage(client, objectType, {
-    ...args,
-    pageSize: 1
-  }, objectSet);
-  if (result.data.length !== 1 || result.nextPageToken != null) {
-    throw new PalantirApiError(`Expected a single result but got ${result.data.length} instead${result.nextPageToken != null ? " with nextPageToken set" : ""}`);
-  }
-  return result.data[0];
-}
-
-// src/object/index.ts
-var object_exports = {};
-__export(object_exports, {
-  aggregate: () => aggregate,
-  fetchPage: () => fetchPage
-});
-async function aggregate(clientCtx, objectType, objectSet = {
-  type: "base",
-  objectType: objectType["apiName"]
-}, req) {
-  const body = {
-    aggregation: modernToLegacyAggregationClause(req.select),
-    groupBy: [],
-    where: void 0
-  };
-  if (req.groupBy) {
-    body.groupBy = modernToLegacyGroupByClause(req.groupBy);
-  }
-  if (req.where) {
-    body.where = modernToLegacyWhereClause(req.where);
-  }
-  const result = await aggregateObjectSetV2(createOpenApiRequest(clientCtx.stack, clientCtx.fetch), clientCtx.ontology.metadata.ontologyApiName, {
-    objectSet,
-    groupBy: body.groupBy,
-    aggregation: body.aggregation
-  });
-  if (!req.groupBy) {
-    !(result.data.length === 1) ? process.env.NODE_ENV !== "production" ? invariant2(false, "no group by clause should mean only one data result") : invariant2(false) : void 0;
-    return {
-      ...aggregationToCountResult(result.data[0]),
-      ...legacyToModernSingleAggregationResult(result.data[0])
-    };
-  }
-  const ret = result.data.map((entry) => {
-    return {
-      $group: entry.group,
-      ...aggregationToCountResult(entry),
-      ...legacyToModernSingleAggregationResult(entry)
-    };
-  });
-  return ret;
-}
-function aggregationToCountResult(entry) {
-  for (const aggregateResult of entry.metrics) {
-    if (aggregateResult.name === "count") {
-      return {
-        $count: aggregateResult.value
-      };
-    }
-  }
-}
-
-// src/util/WireObjectSet.ts
-var WIRE_OBJECT_SET_TYPES = /* @__PURE__ */ new Set(["base", "filter", "intersect", "reference", "searchAround", "static", "subtract", "union"]);
-function isWireObjectSet(o) {
-  return o != null && typeof o === "object" && WIRE_OBJECT_SET_TYPES.has(o.type);
-}
-async function createTemporaryObjectSet(ctx, request) {
-  return conjureFetch(ctx, `/objectSets/temporary`, "POST", request);
-}
-async function batchEnableWatcher(ctx, request) {
-  return conjureFetch(ctx, `/object-set-watcher/batchEnableWatcher`, "POST", request);
-}
-async function loadAllOntologies(ctx, request) {
-  return conjureFetch(ctx, `/ontology/ontology/ontologies/load/all`, "POST", request);
-}
-async function loadOntologyEntities(ctx, request) {
-  return conjureFetch(ctx, `/ontology/ontology/loadEntities`, "POST", request);
-}
-
-// src/objectSet/toConjureObjectSet.ts
-function toConjureObjectSet(objectSet, objectPropertyMapping) {
-  switch (objectSet.type) {
-    case "base":
-      return {
-        type: "base",
-        base: {
-          objectTypeId: objectPropertyMapping.id
-        }
-      };
-    case "static":
-      return {
-        type: "static",
-        static: {
-          objectRids: objectSet.objects,
-          provenance: void 0
-        }
-      };
-    case "reference":
-      return {
-        type: "referenced",
-        referenced: {
-          objectSetRid: objectSet.reference
-        }
-      };
-    case "filter":
-      return {
-        type: "filtered",
-        filtered: {
-          objectSet: toConjureObjectSet(objectSet.objectSet, objectPropertyMapping),
-          runtimeDerivedProperties: void 0,
-          filter: mapWhereClauseToObjectSetFilter(objectSet.where, objectPropertyMapping)
-        }
-      };
-    case "union":
-      return {
-        type: "unioned",
-        unioned: {
-          objectSets: objectSet.objectSets.map((os) => toConjureObjectSet(os, objectPropertyMapping))
-        }
-      };
-    case "intersect":
-      return {
-        type: "intersected",
-        intersected: {
-          objectSets: objectSet.objectSets.map((os) => toConjureObjectSet(os, objectPropertyMapping))
-        }
-      };
-    case "subtract":
-      return {
-        type: "subtracted",
-        subtracted: {
-          objectSets: objectSet.objectSets.map((os) => toConjureObjectSet(os, objectPropertyMapping))
-        }
-      };
-    case "searchAround":
-      throw new Error("not implemented");
-  }
-}
-async function getObjectSetBaseType(objectSet) {
-  switch (objectSet.type) {
-    case "base":
-      return objectSet.objectType;
-    case "static":
-      throw new Error("not implemented");
-    case "reference":
-      throw new Error("not implemented");
-    case "filter":
-      return getObjectSetBaseType(objectSet.objectSet);
-    case "union":
-      return getObjectSetBaseType(objectSet.objectSets[0]);
-    case "intersect":
-      return getObjectSetBaseType(objectSet.objectSets[0]);
-    case "subtract":
-      return getObjectSetBaseType(objectSet.objectSets[0]);
-    case "searchAround":
-      throw new Error("not implemented");
-  }
-}
-function mapWhereClauseToObjectSetFilter(objectSetFilter, propertyMapping) {
-  switch (objectSetFilter.type) {
-    case "lt":
-      return {
-        type: "range",
-        range: {
-          propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
-          lt: objectSetFilter.value,
-          lte: void 0,
-          gt: void 0,
-          gte: void 0
-        }
-      };
-    case "gt":
-      return {
-        type: "range",
-        range: {
-          propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
-          gt: objectSetFilter.value,
-          lte: void 0,
-          lt: void 0,
-          gte: void 0
-        }
-      };
-    case "lte":
-      return {
-        type: "range",
-        range: {
-          propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
-          lte: objectSetFilter.value,
-          lt: void 0,
-          gt: void 0,
-          gte: void 0
-        }
-      };
-    case "gte":
-      return {
-        type: "range",
-        range: {
-          propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
-          gte: objectSetFilter.value,
-          lt: void 0,
-          lte: void 0,
-          gt: void 0
-        }
-      };
-    case "eq":
-      return {
-        type: "exactMatch",
-        exactMatch: {
-          propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field],
-          terms: []
-        }
-      };
-    case "and":
-      return {
-        type: "and",
-        and: {
-          filters: objectSetFilter.value.map((filter) => mapWhereClauseToObjectSetFilter(filter, propertyMapping))
-        }
-      };
-    case "or":
-      return {
-        type: "or",
-        or: {
-          filters: objectSetFilter.value.map((filter) => mapWhereClauseToObjectSetFilter(filter, propertyMapping))
-        }
-      };
-    case "isNull":
-      return {
-        type: "not",
-        not: {
-          filter: {
-            type: "hasProperty",
-            hasProperty: {
-              propertyId: propertyMapping.propertyApiNameToIdMapping[objectSetFilter.field]
-            }
-          }
-        }
-      };
-    case "not":
-      return {
-        type: "not",
-        not: {
-          filter: mapWhereClauseToObjectSetFilter(objectSetFilter.value, propertyMapping)
-        }
-      };
-    case "contains":
-    case "startsWith":
-    case "containsAllTermsInOrder":
-    case "containsAnyTerm":
-    case "containsAllTerms":
-    case "withinDistanceOf":
-    case "withinBoundingBox":
-    case "intersectsBoundingBox":
-    case "doesNotIntersectBoundingBox":
-    case "withinPolygon":
-    case "intersectsPolygon":
-    case "doesNotIntersectPolygon":
-    case "containsAllTermsInOrderPrefixLastTerm":
-      throw new Error("not implemented");
-  }
-}
-
-// src/objectSet/ObjectSetListenerWebsocket.ts
-var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var MINIMUM_RECONNECT_DELAY_MS = 5 * 1e3;
-var ObjectSetListenerWebsocket = class _ObjectSetListenerWebsocket {
-  static #instances = /* @__PURE__ */ new WeakMap();
-  // FIXME
-  static getInstance(client) {
-    let instance = _ObjectSetListenerWebsocket.#instances.get(client);
-    if (instance == null) {
-      instance = new _ObjectSetListenerWebsocket(client);
-      _ObjectSetListenerWebsocket.#instances.set(client, instance);
-    }
-    return instance;
-  }
-  #ws;
-  #lastWsConnect = 0;
-  #client;
-  /** map of listenerId to listener */
-  #listeners = /* @__PURE__ */ new Map();
-  /** map of subscriptionId to listenerId */
-  #subscriptionToRequestId = /* @__PURE__ */ new Map();
-  #conjureContext;
-  #metadataContext;
-  #ossContext;
-  constructor(client) {
-    this.#client = client;
-    const stackUrl = new URL(client.stack);
-    this.#conjureContext = {
-      baseUrl: stackUrl.origin,
-      servicePath: "/object-set-watcher/api",
-      fetchFn: client.fetch,
-      tokenProvider: async () => await client.tokenProvider()
-    };
-    this.#ossContext = {
-      baseUrl: stackUrl.origin,
-      servicePath: "/object-set-service/api",
-      fetchFn: client.fetch,
-      tokenProvider: async () => await client.tokenProvider()
-    };
-    this.#metadataContext = {
-      baseUrl: stackUrl.origin,
-      servicePath: "/ontology-metadata/api",
-      fetchFn: client.fetch,
-      tokenProvider: async () => await client.tokenProvider()
-    };
-  }
-  subscribe(objectSet, listener) {
-    const requestId = crypto.randomUUID();
-    const expiry = setTimeout(() => {
-      this.#expire(requestId);
-    }, ONE_DAY_MS);
-    this.#listeners.set(requestId, {
-      listener,
-      objectSet,
-      expiry
-    });
-    this.#subscribe(requestId, objectSet);
-    return () => {
-      this.#unsubscribe(requestId);
-    };
-  }
-  async #subscribe(requestId, objectSet) {
-    try {
-      const [temporaryObjectSet] = await Promise.all([
-        // create a time-bounded object set representation for watching
-        this.#createTemporaryObjectSet(objectSet),
-        this.#ensureWebsocket(),
-        // look up the object type's rid and ensure that we have enabled object set watcher for that rid
-        // TODO ???
-        getObjectSetBaseType(objectSet).then((baseType) => getObjectTypeV2(createOpenApiRequest(this.#client.stack, this.#client.fetch), this.#client.ontology.metadata.ontologyApiName, baseType)).then((objectType) => this.#enableObjectSetsWatcher([objectType.rid]))
-      ]);
-      if (!this.#listeners.has(requestId)) {
-        return;
-      }
-      const subscribe = {
-        id: requestId,
-        requests: [{
-          objectSet: temporaryObjectSet.objectSetRid,
-          objectSetContext: {
-            objectSetFilterContext: {
-              parameterOverrides: {}
-            }
-          },
-          watchAllLinks: false
-        }]
-      };
-      this.#ws?.send(JSON.stringify(subscribe));
-    } catch (error) {
-      this.#getCallbackByRequestId(requestId, "onError")?.(error);
-    }
-  }
-  #expire(requestId) {
-    const state = this.#listeners.get(requestId);
-    if (state) {
-      const {
-        subscriptionId,
-        objectSet
-      } = state;
-      if (subscriptionId) {
-        state.subscriptionId = void 0;
-        this.#subscriptionToRequestId.delete(subscriptionId);
-      }
-      this.#subscribe(requestId, objectSet);
-    }
-  }
-  #unsubscribe(requestId) {
-    const data = this.#listeners.get(requestId);
-    if (data == null) {
-      return;
-    }
-    this.#listeners.delete(requestId);
-    clearTimeout(data.expiry);
-    const {
-      subscriptionId
-    } = data;
-    if (subscriptionId != null) {
-      this.#subscriptionToRequestId.delete(subscriptionId);
-    }
-    if (this.#listeners.size === 0) {
-      this.#destroyWebsocket();
-    }
-  }
-  async #ensureWebsocket() {
-    if (this.#ws == null) {
-      const {
-        stack,
-        tokenProvider
-      } = this.#client;
-      const base = new URL(stack);
-      const url = `wss://${base.host}/object-set-watcher/ws/subscriptions`;
-      const token = await tokenProvider();
-      if (this.#ws == null) {
-        const nextConnectTime = (this.#lastWsConnect ?? 0) + MINIMUM_RECONNECT_DELAY_MS;
-        if (nextConnectTime > Date.now()) {
-          await new Promise((resolve) => {
-            setTimeout(resolve, nextConnectTime - Date.now());
-          });
-        }
-        this.#lastWsConnect = Date.now();
-        if (this.#ws == null) {
-          this.#ws = new WebSocket(url, [`Bearer-${token}`]);
-          this.#ws.addEventListener("close", this.#onClose);
-          this.#ws.addEventListener("message", this.#onMessage);
-          this.#ws.addEventListener("open", this.#onOpen);
-        }
-      }
-      if (this.#ws.readyState === WebSocket.CONNECTING) {
-        return new Promise((resolve, reject) => {
-          this.#ws.addEventListener("open", () => {
-            resolve();
-          });
-          this.#ws.addEventListener("error", (event) => {
-            reject(new Error(event.toString()));
-          });
-        });
-      }
-    }
-  }
-  #onOpen = () => {
-    for (const [requestId, state] of this.#listeners) {
-      this.#subscribe(requestId, state.objectSet);
-    }
-  };
-  #onMessage = async (message) => {
-    const data = JSON.parse(message.data.toString());
-    switch (data.type) {
-      case "objectSetChanged": {
-        if (data.objectSetChanged.confidenceValue) {
-          this.#getCallback(data.objectSetChanged.id, "onOutOfDate")?.();
-          break;
-        }
-        const {
-          id: subscriptionId,
-          objects
-        } = data.objectSetChanged;
-        const callback = this.#getCallback(subscriptionId, "onChange");
-        if (callback) {
-          callback(await convertFoundryToOsdkObjects(this.#client, this.#metadataContext, objects));
-        }
-        break;
-      }
-      case "refreshObjectSet": {
-        const {
-          id: subscriptionId
-        } = data.refreshObjectSet;
-        this.#getCallback(subscriptionId, "onOutOfDate")?.();
-        break;
-      }
-      case "subscribeResponses": {
-        const {
-          id: requestId,
-          responses
-        } = data.subscribeResponses;
-        const listenerData = this.#listeners.get(requestId);
-        if (listenerData == null) {
-          return;
-        }
-        if (responses.length !== 1) {
-          throw new Error("Got more than one response but we only expect a single one");
-        }
-        const response = responses[0];
-        switch (response.type) {
-          case "error":
-            this.#getCallbackByRequestId(requestId, "onError")?.(response.error);
-            this.#unsubscribe(requestId);
-            return;
-          case "qos":
-            this.#destroyWebsocket();
-            this.#ensureWebsocket();
-            return;
-          case "success":
-            const {
-              id: subscriptionId
-            } = response.success;
-            listenerData.subscriptionId = subscriptionId;
-            this.#subscriptionToRequestId.set(subscriptionId, requestId);
-            this.#getCallbackByRequestId(requestId, "onOutOfDate")?.();
-            break;
-          default:
-            this.#getCallbackByRequestId(requestId, "onError")?.(response);
-        }
-        break;
-      }
-    }
-  };
-  #onClose = () => {
-    this.#destroyWebsocket();
-  };
-  async #enableObjectSetsWatcher(objectTypeRids) {
-    return batchEnableWatcher(this.#conjureContext, {
-      requests: objectTypeRids
-    });
-  }
-  async #createTemporaryObjectSet(objectSet) {
-    const objectSetBaseType = await getObjectSetBaseType(objectSet);
-    const mapping = await getOntologyPropertyMappingForApiName(this.#client, this.#metadataContext, objectSetBaseType);
-    const temporaryObjectSet = await createTemporaryObjectSet(this.#ossContext, {
-      objectSet: toConjureObjectSet(objectSet, mapping),
-      timeToLive: "ONE_DAY",
-      objectSetFilterContext: {
-        parameterOverrides: {}
-      }
-    });
-    return {
-      objectSetRid: temporaryObjectSet.objectSetRid
-    };
-  }
-  #destroyWebsocket = () => {
-    if (this.#ws) {
-      this.#ws.removeEventListener("open", this.#onOpen);
-      this.#ws.removeEventListener("message", this.#onMessage);
-      this.#ws.removeEventListener("close", this.#onClose);
-      if (this.#ws.readyState !== WebSocket.CLOSING && this.#ws.readyState !== WebSocket.CLOSED) {
-        this.#ws.close();
-      }
-      this.#ws = void 0;
-    }
-    this.#subscriptionToRequestId.clear();
-    for (const state of this.#listeners.values()) {
-      state.subscriptionId = void 0;
-    }
-    if (this.#listeners.size > 0) {
-      this.#ensureWebsocket();
-    }
-  };
-  #getCallbackByRequestId(requestId, type) {
-    const maybeListener = this.#listeners.get(requestId);
-    return maybeListener?.listener?.[type];
-  }
-  #getCallback(subscriptionId, type) {
-    const requestId = this.#subscriptionToRequestId.get(subscriptionId);
-    if (requestId) {
-      return this.#getCallbackByRequestId(requestId, type);
-    }
-    return;
-  }
-};
-async function convertFoundryToOsdkObjects(client, ctx, objects) {
-  const osdkObjects = await Promise.all(objects.map(async (object) => {
-    const propertyMapping = await getOntologyPropertyMappingForRid(ctx, client.ontology.metadata.ontologyRid, object.type);
-    const convertedObject = Object.fromEntries([...Object.entries(object.properties).map(([key, value]) => {
-      return [propertyMapping?.propertyIdToApiNameMapping[key], value];
-    }), [propertyMapping?.propertyIdToApiNameMapping[Object.entries(object.key)[0][0]], Object.entries(object.key)[0][1]], ["__apiName", propertyMapping?.apiName], ["$apiName", propertyMapping?.apiName]]);
-    return convertedObject;
-  }));
-  return await convertWireToOsdkObjects(client, osdkObjects, void 0);
-}
-var objectTypeMapping = /* @__PURE__ */ new WeakMap();
-var objectApiNameToRid = /* @__PURE__ */ new Map();
-async function getOntologyPropertyMappingForApiName(client, ctx, objectApiName) {
-  if (objectApiNameToRid.has(objectApiName)) {
-    return objectTypeMapping.get(ctx)?.get(objectApiNameToRid.get(objectApiName));
-  }
-  const wireObjectType = await getObjectTypeV2(createOpenApiRequest(client.stack, client.fetch), client.ontology.metadata.ontologyApiName, objectApiName);
-  return getOntologyPropertyMappingForRid(ctx, client.ontology.metadata.ontologyRid, wireObjectType.rid);
-}
-var cachedAllOntologies;
-async function getOntologyVersionForRid(ctx, ontologyRid) {
-  cachedAllOntologies ??= await loadAllOntologies(ctx, {});
-  !cachedAllOntologies.ontologies[ontologyRid] ? process.env.NODE_ENV !== "production" ? invariant2(false, "ontology should be loaded") : invariant2(false) : void 0;
-  return cachedAllOntologies.ontologies[ontologyRid].currentOntologyVersion;
-}
-async function getOntologyPropertyMappingForRid(ctx, ontologyRid, objectRid) {
-  if (!objectTypeMapping.has(ctx)) {
-    objectTypeMapping.set(ctx, /* @__PURE__ */ new Map());
-  }
-  if (!objectTypeMapping.get(ctx).has(objectRid)) {
-    const ontologyVersion = await getOntologyVersionForRid(ctx, ontologyRid);
-    const body = {
-      objectTypeVersions: {
-        // TODO: Undefined drops this in the body
-        [objectRid]: ontologyVersion
-      },
-      linkTypeVersions: {},
-      loadRedacted: false,
-      includeObjectTypesWithoutSearchableDatasources: true
-    };
-    const entities = await loadOntologyEntities(ctx, body);
-    !entities.objectTypes[objectRid] ? process.env.NODE_ENV !== "production" ? invariant2(false, "object type should be loaded") : invariant2(false) : void 0;
-    const propertyIdToApiNameMapping = Object.fromEntries(Object.values(entities.objectTypes[objectRid].propertyTypes).map((property) => {
-      return [property.id, property.apiName];
-    }));
-    const propertyApiNameToIdMapping = Object.fromEntries(Object.values(entities.objectTypes[objectRid].propertyTypes).map((property) => {
-      return [property.id, property.apiName];
-    }));
-    objectTypeMapping.get(ctx)?.set(objectRid, {
-      apiName: entities.objectTypes[objectRid].apiName,
-      id: entities.objectTypes[objectRid].id,
-      propertyIdToApiNameMapping,
-      propertyApiNameToIdMapping
-    });
-    objectApiNameToRid.set(entities.objectTypes[objectRid].apiName, objectRid);
-  }
-  return objectTypeMapping.get(ctx)?.get(objectRid);
-}
-
-// src/objectSet/createObjectSet.ts
-function isObjectTypeDefinition(def) {
-  return def.type === "object";
-}
-function isObjectSet(o) {
-  return o != null && typeof o === "object" && isWireObjectSet(objectSetDefinitions.get(o));
-}
-function getWireObjectSet(objectSet) {
-  return objectSetDefinitions.get(objectSet);
-}
-var objectSetDefinitions = /* @__PURE__ */ new WeakMap();
-function createObjectSet2(objectType, clientCtx, objectSet = {
-  type: "base",
-  objectType: objectType["apiName"]
-}) {
-  const base = {
-    aggregate: aggregate.bind(globalThis, clientCtx, objectType, objectSet),
-    aggregateOrThrow: aggregate.bind(globalThis, clientCtx, objectType, objectSet),
-    fetchPage: fetchPageInternal.bind(globalThis, clientCtx, objectType, objectSet),
-    fetchPageOrThrow: fetchPageInternal.bind(globalThis, clientCtx, objectType, objectSet),
-    where: (clause) => {
-      return createObjectSet2(objectType, clientCtx, {
-        type: "filter",
-        objectSet,
-        where: modernToLegacyWhereClause(clause)
-      });
-    },
-    pivotTo: function(type) {
-      return createSearchAround(type)();
-    },
-    union: (...objectSets) => {
-      return createObjectSet2(objectType, clientCtx, {
-        type: "union",
-        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
-      });
-    },
-    intersect: (...objectSets) => {
-      return createObjectSet2(objectType, clientCtx, {
-        type: "intersect",
-        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
-      });
-    },
-    subtract: (...objectSets) => {
-      return createObjectSet2(objectType, clientCtx, {
-        type: "subtract",
-        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
-      });
-    },
-    subscribe(listener) {
-      const instance = ObjectSetListenerWebsocket.getInstance(clientCtx);
-      return instance.subscribe(objectSet, listener);
-    },
-    asyncIter: async function* () {
-      let nextPageToken = void 0;
-      do {
-        const result = await base.fetchPage({
-          nextPageToken
-        });
-        for (const obj of await convertWireToOsdkObjects(clientCtx, result.data, void 0)) {
-          yield obj;
-        }
-      } while (nextPageToken != null);
-    },
-    get: isObjectTypeDefinition(objectType) ? async (primaryKey, options) => {
-      const withPk = {
-        type: "filter",
-        objectSet,
-        where: {
-          type: "eq",
-          field: objectType.primaryKeyApiName,
-          value: primaryKey
-        }
-      };
-      return await fetchSingle(clientCtx, objectType, options, withPk);
-    } : void 0
-  };
-  function createSearchAround(link) {
-    return () => {
-      return createObjectSet2(objectType, clientCtx, {
-        type: "searchAround",
-        objectSet,
-        link
-      });
-    };
-  }
-  objectSetDefinitions.set(base, objectSet);
-  return base;
-}
-
-// src/object/Attachment.ts
-var Attachment = class {
-  constructor(rid) {
-    this.rid = rid;
-  }
-};
-function isAttachment(o) {
-  return o instanceof Attachment;
-}
-
-// src/object/Cache.ts
-function createCache(fn) {
-  const cache = /* @__PURE__ */ new WeakMap();
-  function get(client, key) {
-    if (cache.get(client) == null) {
-      cache.set(client, /* @__PURE__ */ new Map());
-    }
-    let r = cache.get(client).get(key);
-    if (r === void 0 && fn !== void 0) {
-      return set(client, key, fn(client, key));
-    } else {
-      return r;
-    }
-  }
-  function set(client, key, value) {
-    if (cache.get(client) == null) {
-      cache.set(client, /* @__PURE__ */ new Map());
-    }
-    cache.get(client).set(key, value);
-    return value;
-  }
-  function remove(client, key) {
-    if (cache.get(client) == null)
-      return false;
-    return cache.get(client).delete(key);
-  }
-  return {
-    get,
-    set,
-    remove
-  };
-}
-function createAsyncCache(fn, createCacheLocal = createCache) {
-  const cache = createCacheLocal();
-  const inProgress = createCacheLocal();
-  const ret = {
-    getOrUndefined: function getOrUndefined(client, key) {
-      return cache.get(client, key);
-    },
-    get: async function get(client, key) {
-      return cache.get(client, key) ?? inProgress.get(client, key) ?? ret.set(client, key, fn(client, key));
-    },
-    set: async function set(client, k, v) {
-      try {
-        const r = await inProgress.set(client, k, v);
-        cache.set(client, k, r);
-        inProgress.remove(client, k);
-        return r;
-      } catch (e) {
-        inProgress.remove(client, k);
-        throw e;
-      }
-    }
-  };
-  return ret;
-}
-
-// src/object/convertWireToOsdkObjects.ts
-var OriginClient = Symbol();
-var UnderlyingObject = Symbol();
-var InterfaceDefinitions = Symbol();
-var LinkFetcherProxyHandler = class {
-  constructor(objDef, primaryKey, client) {
-    this.objDef = objDef;
-    this.primaryKey = primaryKey;
-    this.client = client;
-  }
-  get(_target, p) {
-    const linkDef = this.objDef.links[p];
-    if (linkDef == null) {
-      return;
-    }
-    const objectSet = createObjectSet2(this.objDef, this.client).where({
-      [this.objDef.primaryKeyApiName]: this.primaryKey
-    }).pivotTo(p);
-    if (!linkDef.multiplicity) {
-      return {
-        get: (options) => fetchSingle(this.client, this.objDef, options ?? {}, getWireObjectSet(objectSet))
-      };
-    } else {
-      return objectSet;
-    }
-  }
-  ownKeys() {
-    return Object.keys(this.objDef.links);
-  }
-  getOwnPropertyDescriptor(target, p) {
-    return {
-      enumerable: true,
-      configurable: true,
-      get: () => {
-        return this.get(target, p);
-      }
-    };
-  }
-};
-function createPrototype(objDef, client) {
-  if (process.env.NODE_ENV !== "production") {
-    !(objDef.type === "object") ? process.env.NODE_ENV !== "production" ? invariant2(false, "Expected object definition") : invariant2(false) : void 0;
-  }
-  const sharedPropertyDefs = {
-    $as: {
-      value: $as
-    }
-  };
-  const interfaceProto = Object.defineProperties({}, sharedPropertyDefs);
-  const objectProto = Object.defineProperties({}, {
-    $link: {
-      get: function() {
-        return new Proxy({}, new LinkFetcherProxyHandler(objDef, this["$primaryKey"], client));
-      }
-    },
-    ...sharedPropertyDefs
-  });
-  function $as(newDef) {
-    if (typeof newDef === "string") {
-      if (newDef === objDef.apiName) {
-        return this[UnderlyingObject];
-      }
-      const def = objDef[InterfaceDefinitions][newDef];
-      if (!def) {
-        throw new Error(`Object does not implement interface '${newDef}'.`);
-      }
-      newDef = def;
-    } else if (newDef.apiName === objDef.apiName) {
-      return this[UnderlyingObject];
-    }
-    if (newDef.type !== "interface" && newDef.apiName !== this.$apiName) {
-      throw new Error(`'${newDef.apiName}' is not an interface of '${this.$objectType}'.`);
-    }
-    const underlying = this[UnderlyingObject];
-    const common = {
-      enumerable: true,
-      configurable: true
-    };
-    return Object.create(interfaceProto, {
-      $apiName: {
-        value: newDef.apiName,
-        ...common
-      },
-      $objectType: {
-        value: objDef.apiName,
-        ...common
-      },
-      $primaryKey: {
-        value: this["$primaryKey"],
-        ...common
-      },
-      ...Object.fromEntries(Object.keys(newDef.properties).map((p) => {
-        const value = underlying[objDef.spts[p]];
-        return [p, {
-          value,
-          enumerable: value !== void 0
-        }];
-      })),
-      [UnderlyingObject]: {
-        value: underlying
-      }
-    });
-  }
-  return objectProto;
-}
-function createConverter(objDef) {
-  const steps = [];
-  for (const [key, value] of Object.entries(objDef.properties)) {
-    if (value.type === "attachment") {
-      steps.push((o) => {
-        if (o[key] != null) {
-          if (Array.isArray(o[key])) {
-            o[key] = o[key].map((a) => new Attachment(a.rid));
-          } else {
-            o[key] = new Attachment(o[key].rid);
-          }
-        }
-      });
-    }
-  }
-  return steps.length > 0 ? (o) => {
-    for (const step of steps) {
-      step(o);
-    }
-  } : void 0;
-}
-var protoConverterCache = createCache((client, objectDef) => {
-  const proto = createPrototype(objectDef, client);
-  const converter = createConverter(objectDef);
-  return [proto, converter];
-});
-async function convertWireToOsdkObjects(client, objects, interfaceApiName, forceRemoveRid = false) {
-  if (forceRemoveRid) {
-    for (const obj of objects) {
-      delete obj.__rid;
-    }
-  }
-  fixObjectPropertiesInline(objects);
-  const localObjectCache = createLocalObjectCacheAndInitiatePreseed(objects, client);
-  for (const obj of objects) {
-    const objectDef = await localObjectCache.get(client, obj.$apiName);
-    if (objectDef == null) {
-      throw new Error(`Failed to find ontology definition for '${obj.$apiName}'`);
-    }
-    if (interfaceApiName !== void 0) {
-      for (const [sptProp, regularProp] of Object.entries(objectDef.spts)) {
-        if (sptProp in obj) {
-          const value = obj[sptProp];
-          delete obj[sptProp];
-          if (value !== void 0) {
-            obj[regularProp] = value;
-          }
-        }
-      }
-    }
-    internalConvertObjectInPlace(objectDef, client, obj);
-  }
-  if (interfaceApiName) {
-    return objects.map((o) => o.$as(interfaceApiName));
-  } else {
-    return objects;
-  }
-}
-function createLocalObjectCacheAndInitiatePreseed(objects, client) {
-  const localInterfaceCache = createAsyncCache((client2, apiName) => client2.ontology.provider.getInterfaceDefinition(apiName));
-  const localObjectCache = createAsyncCache(async (client2, apiName) => {
-    const objectDef = await client2.ontology.provider.getObjectDefinition(apiName);
-    const interfaceDefs = Object.fromEntries((await Promise.all(objectDef.implements?.map((i) => localInterfaceCache.get(client2, i)) ?? [])).map((i) => [i.apiName, i]));
-    if (objectDef[InterfaceDefinitions] == null) {
-      Object.defineProperty(objectDef, InterfaceDefinitions, {
-        value: interfaceDefs,
-        enumerable: false,
-        configurable: false,
-        writable: false
-      });
-    }
-    return objectDef;
-  });
-  const uniqueApiNames = /* @__PURE__ */ new Set();
-  for (const {
-    $apiName
-  } of objects) {
-    if (uniqueApiNames.has($apiName))
-      continue;
-    uniqueApiNames.add($apiName);
-    localObjectCache.get(client, $apiName);
-  }
-  return localObjectCache;
-}
-function fixObjectPropertiesInline(objs) {
-  for (const obj of objs) {
-    if (obj.__rid) {
-      obj.$rid = obj.__rid;
-      delete obj.__rid;
-    }
-    obj.$apiName = obj.__apiName;
-    obj.$objectType = obj.__apiName;
-    obj.$primaryKey = obj.__primaryKey;
-    {
-      Object.defineProperties(obj, {
-        "__apiName": {
-          enumerable: false
-        },
-        "__primaryKey": {
-          enumerable: false
-        }
-      });
-    }
-  }
-}
-function internalConvertObjectInPlace(objectDef, client, obj) {
-  const [proto, converter] = protoConverterCache.get(client, objectDef);
-  Object.setPrototypeOf(obj, proto);
-  Object.defineProperties(obj, {
-    [OriginClient]: {
-      value: client
-    },
-    [UnderlyingObject]: {
-      value: obj
-    }
-  });
-  if (converter) {
-    converter(obj);
-  }
-}
-
-// src/object/fetchPage.ts
-function augment(type, ...properties) {
-  return {
-    [type.apiName]: properties
-  };
-}
-function objectSetToSearchJsonV2(objectSet, expectedApiName, existingWhere = void 0) {
-  if (objectSet.type === "base") {
-    if (objectSet.objectType !== expectedApiName) {
-      throw new Error(`Expected objectSet.objectType to be ${expectedApiName}, but got ${objectSet.objectType}`);
-    }
-    return existingWhere;
-  }
-  if (objectSet.type === "filter") {
-    return objectSetToSearchJsonV2(objectSet.objectSet, expectedApiName, existingWhere == null ? objectSet.where : {
-      type: "and",
-      value: [existingWhere, objectSet.where]
-    });
-  }
-  throw new Error(`Unsupported objectSet type: ${objectSet.type}`);
-}
-async function fetchInterfacePage(client, interfaceType, args, objectSet) {
-  const result = await searchObjectsForInterface(createOpenApiRequest(client.stack, client.fetch), client.ontology.metadata.ontologyApiName, interfaceType.apiName, applyFetchArgs(args, {
-    augmentedProperties: args.augment ?? {},
-    augmentedSharedPropertyTypes: {},
-    otherInterfaceTypes: [],
-    selectedObjectTypes: [],
-    selectedSharedPropertyTypes: args.select ?? [],
-    where: objectSetToSearchJsonV2(objectSet, interfaceType.apiName)
-  }), {
-    preview: true
-  });
-  result.data = await convertWireToOsdkObjects(
-    client,
-    result.data,
-    // drop readonly
-    interfaceType.apiName,
-    !args.includeRid
-  );
-  return result;
-}
-async function fetchPageInternal(client, objectType, objectSet, args = {}) {
-  if (objectType.type === "interface") {
-    return await fetchInterfacePage(client, objectType, args, objectSet);
-  } else {
-    return await fetchObjectPage(client, objectType, args, objectSet);
-  }
-}
-async function fetchPage(client, objectType, args, objectSet = {
-  type: "base",
-  objectType: objectType["apiName"]
-}) {
-  return fetchPageInternal(client, objectType, objectSet, args);
-}
-function applyFetchArgs(args, body) {
-  if (args?.nextPageToken) {
-    body.pageToken = args.nextPageToken;
-  }
-  if (args?.pageSize != null) {
-    body.pageSize = args.pageSize;
-  }
-  if (args?.orderBy != null) {
-    body.orderBy = {
-      fields: Object.entries(args.orderBy).map(([field, direction]) => ({
-        field,
-        direction
-      }))
-    };
-  }
-  return body;
-}
-async function fetchObjectPage(client, objectType, args, objectSet) {
-  const r = await loadObjectSetV2(createOpenApiRequest(client.stack, client.fetch), client.ontology.metadata.ontologyApiName, applyFetchArgs(args, {
-    objectSet,
-    // We have to do the following case because LoadObjectSetRequestV2 isnt readonly
-    select: args?.select ?? [],
-    // FIXME?
-    excludeRid: !args?.includeRid
-  }));
-  return Promise.resolve({
-    data: await convertWireToOsdkObjects(client, r.data, void 0),
-    nextPageToken: r.nextPageToken
-  });
-}
-
-export { aggregate, augment, createAsyncCache, createObjectSet2 as createObjectSet, fetchPage, getWireObjectSet, isAttachment, isObjectSet, isWireObjectSet, loadAllOntologies, loadOntologyEntities, object_exports };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-Y7UBQD5N.mjs.map