@osdk/client 0.1.0 → 0.2.0

package/build/js/index.mjs

@@ -1,14 +1,686 @@
-import { b as b$1, d, a, c } from './chunk-7KB3ITVZ.mjs';
-export { e as Objects } from './chunk-7KB3ITVZ.mjs';
+import { aggregateOrThrow, fetchPageOrThrow, modernToLegacyWhereClause, convertWireToOsdkObjects } from './chunk-MT2HE6AQ.mjs';
+export { object_exports as Objects } from './chunk-MT2HE6AQ.mjs';
 import { createClientContext, createOpenApiRequest } from '@osdk/shared.net';
 export { createClientContext, isOk } from '@osdk/shared.net';
 import { applyActionV2, getObjectTypeV2 } from '@osdk/gateway/requests';
-import d$1 from 'isomorphic-ws';
-import E from 'tiny-invariant';
+import WebSocket from 'isomorphic-ws';
+import invariant from 'tiny-invariant';
 import { conjureFetch } from 'conjure-lite';
 
-async function F(t,e,o,r){let s=await applyActionV2(createOpenApiRequest(t.stack,t.fetch),t.ontology.metadata.ontologyApiName,e,{parameters:o,options:{mode:r?.validateOnly?"VALIDATE_ONLY":"VALIDATE_AND_EXECUTE",returnEdits:r?.returnEdits?"ALL":"NONE"}}),a=s.edits?.type=="largeScaleEdits"?s.edits.editedObjectTypes:void 0,n=s.edits?.type=="edits"?s.edits:void 0;n?.edits[0];return {__unstable:{bulkEdits:a,addedLinksCount:n?.addedLinksCount,addedObjectCount:n?.addedObjectCount,modifiedObjectsCount:n?.modifiedObjectsCount,edits:n?.edits}}}function w(t){return new Proxy({},{get:(e,o,r)=>{if(typeof o=="string")return function(...s){return F(t,o,...s)}}})}async function g(t,e){return conjureFetch(t,"/objectSets/temporary","POST",e)}async function h(t,e){return conjureFetch(t,"/object-set-watcher/batchEnableWatcher","POST",e)}async function O(t,e){return conjureFetch(t,"/ontology/ontology/loadEntities","POST",e)}function u(t,e){switch(t.type){case"base":return {type:"base",base:{objectTypeId:e.id}};case"static":return {type:"static",static:{objectRids:t.objects,provenance:void 0}};case"reference":return {type:"referenced",referenced:{objectSetRid:t.reference}};case"filter":return {type:"filtered",filtered:{objectSet:u(t.objectSet,e),runtimeDerivedProperties:void 0,filter:y(t.where,e)}};case"union":return {type:"unioned",unioned:{objectSets:t.objectSets.map(o=>u(o,e))}};case"intersect":return {type:"intersected",intersected:{objectSets:t.objectSets.map(o=>u(o,e))}};case"subtract":return {type:"subtracted",subtracted:{objectSets:t.objectSets.map(o=>u(o,e))}};case"searchAround":throw new Error("not implemented")}}async function p(t){switch(t.type){case"base":return t.objectType;case"static":throw new Error("not implemented");case"reference":throw new Error("not implemented");case"filter":return p(t.objectSet);case"union":return p(t.objectSets[0]);case"intersect":return p(t.objectSets[0]);case"subtract":return p(t.objectSets[0]);case"searchAround":throw new Error("not implemented")}}function y(t,e){switch(t.type){case"lt":return {type:"range",range:{propertyId:e.propertyApiNameToIdMapping[t.field],lt:t.value,lte:void 0,gt:void 0,gte:void 0}};case"gt":return {type:"range",range:{propertyId:e.propertyApiNameToIdMapping[t.field],gt:t.value,lte:void 0,lt:void 0,gte:void 0}};case"lte":return {type:"range",range:{propertyId:e.propertyApiNameToIdMapping[t.field],lte:t.value,lt:void 0,gt:void 0,gte:void 0}};case"gte":return {type:"range",range:{propertyId:e.propertyApiNameToIdMapping[t.field],gte:t.value,lt:void 0,lte:void 0,gt:void 0}};case"eq":return {type:"exactMatch",exactMatch:{propertyId:e.propertyApiNameToIdMapping[t.field],terms:[]}};case"and":return {type:"and",and:{filters:t.value.map(o=>y(o,e))}};case"or":return {type:"or",or:{filters:t.value.map(o=>y(o,e))}};case"isNull":return {type:"not",not:{filter:{type:"hasProperty",hasProperty:{propertyId:e.propertyApiNameToIdMapping[t.field]}}}};case"not":return {type:"not",not:{filter:y(t.value,e)}};case"contains":case"startsWith":case"containsAllTermsInOrder":case"containsAnyTerm":case"containsAllTerms":case"withinDistanceOf":case"withinBoundingBox":case"intersectsBoundingBox":case"doesNotIntersectBoundingBox":case"withinPolygon":case"intersectsPolygon":case"doesNotIntersectPolygon":throw new Error("not implemented")}}var B=24*60*60*1e3,R=5*1e3,f=class t{static#u=new WeakMap;static getInstance(e){let o=t.#u.get(e);return o==null&&(o=new t(e),t.#u.set(e,o)),o}#e;#l=0;#o;#t=new Map;#r=new Map;#y;#s;#d;constructor(e){this.#o=e;let o=new URL(e.stack);this.#y={baseUrl:o.origin,servicePath:"/object-set-watcher/api",fetchFn:e.fetch,tokenProvider:async()=>await e.tokenProvider()},this.#d={baseUrl:o.origin,servicePath:"/object-set-service/api",fetchFn:e.fetch,tokenProvider:async()=>await e.tokenProvider()},this.#s={baseUrl:o.origin,servicePath:"/ontology-metadata/api",fetchFn:e.fetch,tokenProvider:async()=>await e.tokenProvider()};}subscribe(e,o){let r=crypto.randomUUID(),s=setTimeout(()=>{this.#O(r);},B);return this.#t.set(r,{listener:o,objectSet:e,expiry:s}),this.#a(r,e),()=>{this.#f(r);}}async#a(e,o){try{let[r]=await Promise.all([this.#T(o),this.#i(),p(o).then(a=>getObjectTypeV2(createOpenApiRequest(this.#o.stack,this.#o.fetch),this.#o.ontology.metadata.ontologyApiName,a)).then(a=>this.#b([a.rid]))]);if(!this.#t.has(e))return;let s={id:e,requests:[{objectSet:r.objectSetRid,objectSetContext:{objectSetFilterContext:{parameterOverrides:{}}},watchAllLinks:!1}]};this.#e?.send(JSON.stringify(s));}catch(r){this.#n(e,"onError")?.(r);}}#O(e){let o=this.#t.get(e);if(o){let{subscriptionId:r,objectSet:s}=o;r&&this.#r.delete(r),this.#a(e,s);}}#f(e){let o=this.#t.get(e);if(o==null)return;this.#t.delete(e),clearTimeout(o.expiry);let{subscriptionId:r}=o;r!=null&&this.#r.delete(r),this.#t.size===0&&this.#c();}async#i(){if(this.#e==null){let{stack:e,tokenProvider:o}=this.#o,s=`wss://${new URL(e).host}/object-set-watcher/ws/subscriptions`,a=await o();if(this.#e==null){let n=(this.#l??0)+R;n>Date.now()&&await new Promise(i=>{setTimeout(i,n-Date.now());}),this.#l=Date.now(),this.#e==null&&(this.#e=new d$1(s,[`Bearer-${a}`]),this.#e.addEventListener("close",this.#h),this.#e.addEventListener("message",this.#g),this.#e.addEventListener("open",this.#m));}if(this.#e.readyState===d$1.CONNECTING)return new Promise((n,i)=>{this.#e.addEventListener("open",()=>{n();}),this.#e.addEventListener("error",c=>{i(new Error(c.toString()));});})}}#m=()=>{for(let[e,o]of this.#t)this.#a(e,o.objectSet);};#g=async e=>{let o=JSON.parse(e.data.toString());switch(o.type){case"objectSetChanged":{if(o.objectSetChanged.confidenceValue){this.#p(o.objectSetChanged.id,"onOutOfDate")?.();break}let{id:s,objects:a}=o.objectSetChanged,n=this.#p(s,"onChange");n&&n(await W(this.#o,this.#s,a));break}case"refreshObjectSet":{let{id:s}=o.refreshObjectSet;this.#p(s,"onOutOfDate")?.();break}case"subscribeResponses":{let{id:s,responses:a}=o.subscribeResponses,n=this.#t.get(s);if(n==null)return;if(a.length!==1)throw new Error("Got more than one response but we only expect a single one");let i=a[0];switch(i.type){case"error":this.#n(s,"onError")?.(i.error),this.#f(s);return;case"qos":this.#c(),this.#i();return;case"success":let{id:c}=i.success;n.subscriptionId=c,this.#r.set(c,s),this.#n(s,"onOutOfDate")?.();break;default:this.#n(s,"onError")?.(i);}break}}};#h=()=>{this.#c();};async#b(e){return h(this.#y,{requests:e})}async#T(e){let o=await p(e),r=await $(this.#o,this.#s,o);return {objectSetRid:(await g(this.#d,{objectSet:u(e,r),timeToLive:"ONE_DAY",objectSetFilterContext:{parameterOverrides:{}}})).objectSetRid}}#c=()=>{this.#e&&(this.#e.removeEventListener("open",this.#m),this.#e.removeEventListener("message",this.#g),this.#e.removeEventListener("close",this.#h),this.#e.readyState!==d$1.CLOSING&&this.#e.readyState!==d$1.CLOSED&&this.#e.close(),this.#e=void 0),this.#r.clear();for(let e of this.#t.values())e.subscriptionId=void 0;this.#t.size>0&&this.#i();};#n(e,o){return this.#t.get(e)?.listener?.[o]}#p(e,o){let r=this.#r.get(e);if(r)return this.#n(r,o)}};async function W(t,e,o){return await Promise.all(o.map(async s=>{let a=await k(e,s.type),n=Object.fromEntries([...Object.entries(s.properties).map(([i,c])=>[a?.propertyIdToApiNameMapping[i],c]),[a?.propertyIdToApiNameMapping[Object.entries(s.key)[0][0]],Object.entries(s.key)[0][1]],["__apiName",a?.apiName]]);return c(t,a?.apiName,[n])}))}var l=new WeakMap,b=new Map;async function $(t,e,o){if(b.has(o))return l.get(e)?.get(b.get(o));let r=await getObjectTypeV2(createOpenApiRequest(t.stack,t.fetch),t.ontology.metadata.ontologyApiName,o);return k(e,r.rid)}async function k(t,e){if(l.has(t)||l.set(t,new Map),!l.get(t).has(e)){let o={objectTypeVersions:{[e]:"0000000a-0692-bbe3-af23-ddbb6c020392"},linkTypeVersions:{},loadRedacted:!1,includeObjectTypesWithoutSearchableDatasources:!0},r=await O(t,o);r.objectTypes[e]||(process.env.NODE_ENV!=="production"?E(!1,"object type should be loaded"):E(!1));let s=Object.fromEntries(Object.values(r.objectTypes[e].propertyTypes).map(n=>[n.id,n.apiName])),a=Object.fromEntries(Object.values(r.objectTypes[e].propertyTypes).map(n=>[n.id,n.apiName]));l.get(t)?.set(e,{apiName:r.objectTypes[e].apiName,id:r.objectTypes[e].id,propertyIdToApiNameMapping:s,propertyApiNameToIdMapping:a}),b.set(r.objectTypes[e].apiName,e);}return l.get(t)?.get(e)}var v="searchAround_";function m(t,e,o,r={type:"base",objectType:t}){let s={aggregateOrThrow:async n=>b$1(e,t,n),fetchPageOrThrow:async n=>d(e,t,n??{},r),where:n=>m(t,e,o,{type:"filter",objectSet:r,where:a(n)}),pivotTo:function(n,i){return a$1(n)().where(i?.$where??{})},subscribe(n){return f.getInstance(e).subscribe(r,n)}};function a$1(n){return ()=>m(t,e,{},{type:"searchAround",objectSet:r,link:n})}return new Proxy(s,{get(n,i,c){return typeof i=="string"&&i.startsWith(v)?a$1(i.substring(v.length)):n[i]}})}function I(t){return new Proxy({},{get:(e,o,r)=>{if(typeof o=="string")return t.objectSet(o)}})}function G(t,e,o,r=fetch){let s=createClientContext(t,e,o,"@osdk/client/0.0.0 ()",r),a=(i,c)=>m(i,s,c),n=Object.defineProperties({},{objectSet:{get:()=>a},objects:{get:()=>I(n)},actions:{get:()=>w(s)}});return n}
+async function applyAction(client, actionApiName, parameters, options) {
+  const response = await applyActionV2(createOpenApiRequest(client.stack, client.fetch), client.ontology.metadata.ontologyApiName, actionApiName, {
+    parameters,
+    options: {
+      mode: options?.validateOnly ? "VALIDATE_ONLY" : "VALIDATE_AND_EXECUTE",
+      returnEdits: options?.returnEdits ? "ALL" : "NONE"
+    }
+  });
+  const bulkEdits = response.edits?.type == "largeScaleEdits" ? response.edits.editedObjectTypes : void 0;
+  const edits = response.edits?.type == "edits" ? response.edits : void 0;
+  edits?.edits[0];
+  return {
+    __unstable: {
+      bulkEdits,
+      addedLinksCount: edits?.addedLinksCount,
+      addedObjectCount: edits?.addedObjectCount,
+      modifiedObjectsCount: edits?.modifiedObjectsCount,
+      edits: edits?.edits
+    }
+  };
+}
 
-export { G as createClient };
+// src/actions/createActionInvoker.ts
+function createActionInvoker(client) {
+  return new Proxy({}, {
+    get: (target, p, receiver) => {
+      if (typeof p === "string") {
+        return function(...args) {
+          return applyAction(client, p, ...args);
+        };
+      }
+      return void 0;
+    }
+  });
+}
+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":
+      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();
+  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]]);
+    return convertWireToOsdkObjects(client, propertyMapping?.apiName, [convertedObject]);
+  }));
+  return osdkObjects;
+}
+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" ? invariant(false, "ontology should be loaded") : invariant(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" ? invariant(false, "object type should be loaded") : invariant(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
+var searchAroundPrefix = "searchAround_";
+function createObjectSet2(objectType, clientCtx, opts, objectSet = {
+  type: "base",
+  objectType
+}) {
+  const base = {
+    // aggregate: <
+    //   AC extends AggregationClause<O, K>,
+    //   GBC extends GroupByClause<O, K> | undefined = undefined,
+    // >(req: {
+    //   select: AC;
+    //   where?: WhereClause<ObjectTypeDefinitionFrom<O, K>>;
+    //   groupBy?: GBC;
+    // }) => {
+    //   throw "TODO";
+    // },
+    aggregateOrThrow: async (req) => {
+      return aggregateOrThrow(clientCtx, objectType, req);
+    },
+    // fetchPage: async (args?: { nextPageToken?: string }) => {
+    //   throw "TODO";
+    // },
+    fetchPageOrThrow: async (args) => {
+      return fetchPageOrThrow(clientCtx, objectType, args ?? {}, objectSet);
+    },
+    // asyncIter: () => {
+    //   throw "";
+    // },
+    where: (clause) => {
+      return createObjectSet2(objectType, clientCtx, opts, {
+        type: "filter",
+        objectSet,
+        where: modernToLegacyWhereClause(clause)
+      });
+    },
+    // [Symbol.asyncIterator]: () => {
+    //   throw "";
+    // },
+    pivotTo: function(type, opts2) {
+      return createSearchAround(type)().where(opts2?.$where ?? {});
+    },
+    subscribe(listener) {
+      const instance = ObjectSetListenerWebsocket.getInstance(clientCtx);
+      return instance.subscribe(objectSet, listener);
+    }
+  };
+  function createSearchAround(link) {
+    return () => {
+      return createObjectSet2(objectType, clientCtx, {}, {
+        type: "searchAround",
+        objectSet,
+        link
+      });
+    };
+  }
+  return new Proxy(base, {
+    get(target, p, receiver) {
+      if (typeof p === "string" && p.startsWith(searchAroundPrefix)) {
+        return createSearchAround(p.substring(searchAroundPrefix.length));
+      }
+      return target[p];
+    }
+  });
+}
+
+// src/ObjectSetCreator.ts
+function createObjectSetCreator(client) {
+  return new Proxy({}, {
+    get: (target, p, receiver) => {
+      if (typeof p === "string")
+        return client.objectSet(p);
+      return void 0;
+    }
+  });
+}
+
+// src/createClient.ts
+function createClient(ontology, stack, tokenProvider, fetchFn = fetch) {
+  const clientCtx = createClientContext(ontology, stack, tokenProvider, "@osdk/client/0.0.0 ()", fetchFn);
+  const objectSetFactory = (type, opts) => createObjectSet2(type, clientCtx, opts);
+  const client = Object.defineProperties({}, {
+    objectSet: {
+      get: () => objectSetFactory
+    },
+    objects: {
+      get: () => createObjectSetCreator(client)
+    },
+    actions: {
+      get: () => createActionInvoker(clientCtx)
+    },
+    __UNSTABLE_preexistingObjectSet: {
+      get: () => (objectType, rid) => {
+        return createObjectSet2(objectType, clientCtx, {}, {
+          type: "intersect",
+          objectSets: [{
+            type: "base",
+            objectType
+          }, {
+            type: "reference",
+            reference: rid
+          }]
+        });
+      }
+    }
+  });
+  return client;
+}
+
+export { createClient };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map