@osdk/client 0.10.0 → 0.11.0

package/build/js/index.mjs

@@ -1,11 +1,10 @@
-import { aggregateOrThrow, fetchPageOrThrow, modernToLegacyWhereClause, isAttachment, convertWireToOsdkObjects } from './chunk-XI2O777X.mjs';
-export { object_exports as Objects } from './chunk-XI2O777X.mjs';
+import { createObjectSet, createAsyncCache, createBaseObjectSet, isAttachment } from './chunk-GOBQUVQZ.mjs';
+export { object_exports as Objects } from './chunk-GOBQUVQZ.mjs';
+import { getObjectTypeV2, applyActionV2, listOutgoingLinkTypesV2 } from '@osdk/gateway/requests';
 import { createClientContext, createOpenApiRequest } from '@osdk/shared.net';
 export { createClientContext, isOk } from '@osdk/shared.net';
-import { applyActionV2, getObjectTypeV2 } from '@osdk/gateway/requests';
-import WebSocket from 'isomorphic-ws';
-import invariant from 'tiny-invariant';
-import { conjureFetch } from 'conjure-lite';
+import deepEqual from 'fast-deep-equal';
+import { wireObjectTypeFullMetadataToSdkObjectTypeDefinition } from '@osdk/generator-converters';
 
 // src/util/isOntologyObjectV2.ts
 function isOntologyObjectV2(o) {
@@ -88,23 +87,26 @@ function remapActionParams(params) {
 }
 
 // src/actions/createActionInvoker.ts
-function createActionInvoker(client) {
+function createActionInvoker(client, action) {
+  return function(...args) {
+    return applyAction(client, action, ...args);
+  };
+}
+function createOldActionInvoker(client, ontology) {
   const proxy = new Proxy({}, {
     get: (_target, p, _receiver) => {
       if (typeof p === "string") {
-        return function(...args) {
-          return applyAction(client, client.ontology.actions[p], ...args);
-        };
+        return createActionInvoker(client, ontology.actions[p]);
       }
       return void 0;
     },
     ownKeys(_target) {
-      return Object.keys(client.ontology.actions);
+      return Object.keys(ontology.actions);
     },
     getOwnPropertyDescriptor(_target, p) {
       if (typeof p === "string") {
         return {
-          enumerable: client.ontology.actions[p] != null,
+          enumerable: ontology.actions[p] != null,
           configurable: true,
           value: proxy[p]
         };
@@ -113,666 +115,129 @@ function createActionInvoker(client) {
   });
   return proxy;
 }
-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 loadAllOutgoingLinkTypes(client, objtype) {
+  const linkTypes = [];
+  let pageToken;
+  do {
+    const result = await listOutgoingLinkTypesV2(createOpenApiRequest(client.stack, client.fetch), client.ontology.metadata.ontologyApiName, objtype, {
+      pageToken
+    });
+    pageToken = result.nextPageToken;
+    linkTypes.push(...result.data);
+  } while (pageToken != null);
+  return linkTypes;
 }
-async function loadOntologyEntities(ctx, request) {
-  return conjureFetch(ctx, `/ontology/ontology/loadEntities`, "POST", request);
+async function loadFullObjectMetadata(client, objtype) {
+  const {
+    ontologyApiName
+  } = client.ontology.metadata;
+  const [objectType, linkTypes] = await Promise.all([getObjectTypeV2(createOpenApiRequest(client.stack, client.fetch), ontologyApiName, objtype), loadAllOutgoingLinkTypes(client, objtype)]);
+  const full = {
+    implementsInterfaces: [],
+    // FIXME
+    linkTypes,
+    objectType,
+    sharedPropertyTypeMapping: {}
+    // FIXME
+  };
+  return wireObjectTypeFullMetadataToSdkObjectTypeDefinition(full, true);
 }
 
-// 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]
-            }
+// src/ontology/providers/StandardOntologyProvider.ts
+var alwaysRevalidateDefault = false;
+var createStandardOntologyProviderFactory = (client) => {
+  const alwaysRevalidate = client.alwaysRevalidate ?? alwaysRevalidateDefault;
+  return (client2) => {
+    const objectCache = createAsyncCache(loadFullObjectMetadata);
+    return {
+      getObjectOrInterfaceDefinition: async (apiName) => {
+        const n = alwaysRevalidate ? await loadFullObjectMetadata(client2, apiName) : await objectCache.get(client2, apiName);
+        if (alwaysRevalidate) {
+          const og = objectCache.getOrUndefined(client2, apiName);
+          if (deepEqual(og, n)) {
+            return og;
+          } else {
+            return objectCache.set(client2, apiName, n);
           }
         }
-      };
-    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();
-  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 n;
+      },
+      maybeSeed(definition) {
       }
-    });
-    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;
-  }));
-  convertWireToOsdkObjects(client, osdkObjects);
-  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, objectSet = {
-  type: "base",
-  objectType: objectType["apiName"]
-}) {
-  const base = {
-    definition: objectSet,
-    // 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, objectSet, 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, {
-        type: "filter",
-        objectSet,
-        where: modernToLegacyWhereClause(clause)
-      });
-    },
-    // [Symbol.asyncIterator]: () => {
-    //   throw "";
-    // },
-    pivotTo: function(type) {
-      return createSearchAround(type)();
-    },
-    union: (...objectSets) => {
-      return createObjectSet2(objectType, clientCtx, {
-        type: "union",
-        objectSets: [objectSet, ...objectSets.map((os) => os.definition)]
-      });
-    },
-    intersect: (...objectSets) => {
-      return createObjectSet2(objectType, clientCtx, {
-        type: "intersect",
-        objectSets: [objectSet, ...objectSets.map((os) => os.definition)]
-      });
-    },
-    subtract: (...objectSets) => {
-      return createObjectSet2(objectType, clientCtx, {
-        type: "subtract",
-        objectSets: [objectSet, ...objectSets.map((os) => os.definition)]
-      });
-    },
-    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/util/UserAgent.ts
+var USER_AGENT = `osdk-client/${"0.11.0"}`;
+
+// src/createMinimalClient.ts
+function createMinimalClient(metadata, stack, tokenProvider, ontologyCachingOptions = {}, fetchFn = global.fetch) {
+  const clientCtx = createClientContext({
+    metadata,
+    provider: void 0
+  }, stack, tokenProvider, USER_AGENT, fetchFn);
+  clientCtx.ontology.provider = createStandardOntologyProviderFactory(ontologyCachingOptions)(clientCtx);
+  return clientCtx;
 }
 
 // src/ObjectSetCreator.ts
-function createObjectSetCreator(client, clientContext) {
+function createObjectSetCreator(client, ontology) {
   return new Proxy({}, {
     get: (target, p, receiver) => {
-      if (typeof p === "string")
-        return client.objectSet(p);
+      if (typeof p === "string") {
+        return client(ontology.objects[p] ?? ontology.interfaces?.[p]);
+      }
       return void 0;
     },
     ownKeys(target) {
-      return Object.keys(clientContext.ontology.objects);
+      return Object.keys(ontology.objects);
     },
     getOwnPropertyDescriptor(target, p) {
       if (typeof p === "string") {
         return {
-          enumerable: clientContext.ontology.objects[p] != null,
+          enumerable: ontology.objects[p] != null,
           configurable: true,
-          value: client.objectSet(p)
+          get: () => client(ontology.objects[p] ?? ontology.interfaces?.[p])
         };
       }
     }
   });
 }
 
-// src/util/UserAgent.ts
-var USER_AGENT = `osdk-client/${"0.10.0"}`;
-
 // src/createClient.ts
-function createClient(ontology, stack, tokenProvider, fetchFn = fetch) {
-  const clientCtx = createClientContext(ontology, stack, tokenProvider, USER_AGENT, fetchFn);
-  const objectSetFactory = (type) => createObjectSet2(ontology["objects"][type] ?? ontology["interfaces"]?.[type], clientCtx);
-  const client = Object.defineProperties({}, {
+function createFutureClientPlus(metadata, stack, tokenProvider, ontologyCachingOptions = {}, fetchFn = fetch) {
+  const clientCtx = createMinimalClient(metadata, stack, tokenProvider, ontologyCachingOptions, fetchFn);
+  function clientFn(o) {
+    if (o.type === "object" || o.type === "interface") {
+      clientCtx.ontology.provider.maybeSeed(o);
+      return createBaseObjectSet(o, clientCtx);
+    } else if (o.type === "action") {
+      clientCtx.ontology.provider.maybeSeed(o);
+      return createActionInvoker(clientCtx, o);
+    } else {
+      throw new Error("Unknown definition: " + JSON.stringify(o));
+    }
+  }
+  return [clientCtx, clientFn];
+}
+function createClient(ontology, stack, tokenProvider, ontologyCachingOptions = {}, fetchFn = fetch) {
+  const [clientCtx, clientFn] = createFutureClientPlus(ontology.metadata, stack, tokenProvider, ontologyCachingOptions, fetchFn);
+  const objectSetFactory = (type) => createBaseObjectSet(ontology["objects"][type] ?? ontology["interfaces"]?.[type], clientCtx);
+  const oldActionInvoker = createOldActionInvoker(clientCtx, ontology);
+  const client = Object.defineProperties(clientFn, {
     objectSet: {
       get: () => objectSetFactory
     },
     objects: {
-      get: () => createObjectSetCreator(client, clientCtx)
+      get: () => createObjectSetCreator(client, ontology)
     },
     actions: {
-      get: () => createActionInvoker(clientCtx)
+      get: () => oldActionInvoker
     },
     __UNSTABLE_preexistingObjectSet: {
       get: () => (objectType, rid) => {
-        return createObjectSet2(ontology["interfaces"]?.[objectType] ?? ontology["objects"][objectType], clientCtx, {
+        return createObjectSet(ontology["interfaces"]?.[objectType] ?? ontology["objects"][objectType], clientCtx, {
           type: "intersect",
           objectSets: [{
             type: "base",
@@ -788,6 +253,6 @@ function createClient(ontology, stack, tokenProvider, fetchFn = fetch) {
   return client;
 }
 
-export { ActionValidationError, createClient };
+export { ActionValidationError, createClient, createMinimalClient };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map