@osdk/client 0.11.0 → 0.13.0

package/build/js/{chunk-GOBQUVQZ.mjs → chunk-SNGUDELK.mjs}

@@ -1,4 +1,4 @@
-import { aggregateObjectSetV2, loadObjectSetV2, getObjectTypeV2 } from '@osdk/gateway/requests';
+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';
@@ -303,6 +303,12 @@ function aggregationToCountResult(entry) {
     }
   }
 }
+
+// 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);
 }
@@ -784,8 +790,7 @@ async function convertFoundryToOsdkObjects(client, ctx, objects) {
     }), [propertyMapping?.propertyIdToApiNameMapping[Object.entries(object.key)[0][0]], Object.entries(object.key)[0][1]], ["__apiName", propertyMapping?.apiName], ["$apiName", propertyMapping?.apiName]]);
     return convertedObject;
   }));
-  await convertWireToOsdkObjectsInPlace(client, osdkObjects);
-  return osdkObjects;
+  return await convertWireToOsdkObjects(client, osdkObjects, void 0);
 }
 var objectTypeMapping = /* @__PURE__ */ new WeakMap();
 var objectApiNameToRid = /* @__PURE__ */ new Map();
@@ -840,25 +845,22 @@ async function getOntologyPropertyMappingForRid(ctx, ontologyRid, objectRid) {
 function isObjectTypeDefinition(def) {
   return def.type === "object";
 }
-var searchAroundPrefix = "searchAround_";
+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 = {
-    definition: objectSet,
-    aggregate: (req) => {
-      return aggregate(clientCtx, objectType, objectSet, req);
-    },
-    aggregateOrThrow: (req) => {
-      return aggregate(clientCtx, objectType, objectSet, req);
-    },
-    fetchPage: async (args) => {
-      return fetchPage(clientCtx, objectType, args ?? {}, objectSet);
-    },
-    fetchPageOrThrow: async (args) => {
-      return fetchPage(clientCtx, objectType, args ?? {}, objectSet);
-    },
+    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",
@@ -872,19 +874,19 @@ function createObjectSet2(objectType, clientCtx, objectSet = {
     union: (...objectSets) => {
       return createObjectSet2(objectType, clientCtx, {
         type: "union",
-        objectSets: [objectSet, ...objectSets.map((os) => os.definition)]
+        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
       });
     },
     intersect: (...objectSets) => {
       return createObjectSet2(objectType, clientCtx, {
         type: "intersect",
-        objectSets: [objectSet, ...objectSets.map((os) => os.definition)]
+        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
       });
     },
     subtract: (...objectSets) => {
       return createObjectSet2(objectType, clientCtx, {
         type: "subtract",
-        objectSets: [objectSet, ...objectSets.map((os) => os.definition)]
+        objectSets: [objectSet, ...objectSets.map((os) => objectSetDefinitions.get(os))]
       });
     },
     subscribe(listener) {
@@ -897,48 +899,35 @@ function createObjectSet2(objectType, clientCtx, objectSet = {
         const result = await base.fetchPage({
           nextPageToken
         });
-        await convertWireToOsdkObjectsInPlace(clientCtx, result.data);
-        for (const obj of result.data) {
+        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 createBaseObjectSet(objectType, clientCtx, {
+      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];
-    }
-  });
-}
-function createBaseObjectSet(objectType, clientCtx, objectSet = {
-  type: "base",
-  objectType: objectType["apiName"]
-}) {
-  return {
-    ...createObjectSet2(objectType, clientCtx, objectSet),
-    get: isObjectTypeDefinition(objectType) ? async (primaryKey, options) => {
-      const withPk = {
-        type: "filter",
-        objectSet,
-        where: modernToLegacyWhereClause({
-          [objectType.primaryKeyApiName]: primaryKey
-        })
-      };
-      return await fetchSingle(clientCtx, objectType, options, withPk);
-    } : void 0
-  };
+  objectSetDefinitions.set(base, objectSet);
+  return base;
 }
 
 // src/object/Attachment.ts
@@ -972,48 +961,71 @@ function createCache(fn) {
     cache.get(client).set(key, value);
     return value;
   }
-  return {
-    get,
-    set
-  };
-}
-function createAsyncCache(fn) {
-  const cache = createCache();
-  function getOrUndefined(client, key) {
-    return cache.get(client, key);
-  }
-  async function get(client, key) {
-    return cache.get(client, key) ?? set(client, key, fn(client, key));
-  }
-  async function set(client, k, v) {
-    return cache.set(client, k, await v);
+  function remove(client, key) {
+    if (cache.get(client) == null)
+      return false;
+    return cache.get(client).delete(key);
   }
   return {
     get,
     set,
-    getOrUndefined
+    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();
 function createPrototype(objDef, client) {
-  const proto = {};
-  Object.defineProperty(proto, "$link", {
+  const interfaceProto = {};
+  Object.defineProperties(interfaceProto, {
+    $as: {
+      value: $as,
+      writable: false,
+      configurable: false
+    }
+  });
+  const objectProto = {};
+  Object.defineProperty(objectProto, "$link", {
     get: function() {
-      const primaryKey = this["__primaryKey"];
+      const primaryKey = this["$primaryKey"];
       return new Proxy({}, {
         get(_target, p, _receiver) {
           const linkDef = objDef.links[p];
           if (linkDef == null) {
             return;
           }
-          const objectSet = createBaseObjectSet(objDef, client).where({
+          const objectSet = createObjectSet2(objDef, client).where({
             [objDef.primaryKeyApiName]: primaryKey
           }).pivotTo(p);
           if (!linkDef.multiplicity) {
             return {
-              get: (options) => fetchSingle(client, objDef, options ?? {}, objectSet.definition)
+              get: (options) => fetchSingle(client, objDef, options ?? {}, getWireObjectSet(objectSet))
             };
           } else {
             return objectSet;
@@ -1024,7 +1036,46 @@ function createPrototype(objDef, client) {
     enumerable: false,
     configurable: false
   });
-  return proto;
+  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];
+    }
+    !(newDef.type === "interface") ? process.env.NODE_ENV !== "production" ? invariant2(false) : invariant2(false) : void 0;
+    const ret = {
+      $apiName: newDef.apiName,
+      $objectType: objDef.apiName,
+      $primaryKey: this["$primaryKey"]
+    };
+    for (const p of Object.keys(newDef.properties)) {
+      const value = this[objDef.spts[p]];
+      Object.defineProperty(ret, p, {
+        value,
+        configurable: false,
+        enumerable: value !== void 0
+      });
+    }
+    Object.defineProperty(ret, UnderlyingObject, {
+      value: this,
+      configurable: false,
+      enumerable: false
+    });
+    Object.setPrototypeOf(ret, interfaceProto);
+    return ret;
+  }
+  Object.defineProperty(objectProto, "$as", {
+    value: $as,
+    configurable: false
+  });
+  return objectProto;
 }
 function createConverter(objDef) {
   const steps = [];
@@ -1055,7 +1106,58 @@ var protoConverterCache = createCache((client, objectDef) => {
     converter
   };
 });
-async function convertWireToOsdkObjectsInPlace(client, objs) {
+async function convertWireToOsdkObjects(client, objects, interfaceApiName) {
+  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);
+    if (objectDef[InterfaceDefinitions] == null) {
+      const interfaceDefs = Object.fromEntries((await Promise.all(objectDef.implements?.map((i) => localInterfaceCache.get(client2, i)) ?? [])).map((i) => [i.apiName, i]));
+      Object.defineProperty(objectDef, InterfaceDefinitions, {
+        value: interfaceDefs,
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+    }
+    return objectDef;
+  });
+  const uniqueApiNames = /* @__PURE__ */ new Set();
+  for (const {
+    $apiName
+  } of objects) {
+    uniqueApiNames.add($apiName);
+  }
+  Array.from(uniqueApiNames).map((n) => localObjectCache.get(client, n).then((a) => a.implements?.map((i) => localInterfaceCache.get(client, i))));
+  return localObjectCache;
+}
+function fixObjectPropertiesInline(objs) {
   for (const obj of objs) {
     if (obj.__rid) {
       obj.$rid = obj.__rid;
@@ -1075,45 +1177,73 @@ async function convertWireToOsdkObjectsInPlace(client, objs) {
       });
     }
   }
-  const localObjectCache = createAsyncCache((client2, apiName) => client2.ontology.provider.getObjectOrInterfaceDefinition(apiName));
-  const uniqueApiNames = new Set(objs.map((o) => o.$apiName));
-  await Promise.all(Array.from(uniqueApiNames).map((n) => localObjectCache.get(client, n)));
-  for (const obj of objs) {
-    const objectDef = await localObjectCache.get(client, obj.$apiName);
-    if (objectDef == null) {
-      throw new Error(`Failed to find ontology definition for '${obj.$apiName}'`);
-    } else if (objectDef.type === "interface") {
-      throw new Error("Interface objects are not supported currently");
-    }
-    const {
-      proto,
-      converter
-    } = protoConverterCache.get(client, objectDef);
-    Object.setPrototypeOf(obj, proto);
-    Object.defineProperty(obj, OriginClient, {
-      value: client,
-      enumerable: false,
-      configurable: false,
-      writable: false
-    });
-    if (converter) {
-      converter(obj);
-    }
+}
+function internalConvertObjectInPlace(objectDef, client, obj) {
+  const {
+    proto,
+    converter
+  } = protoConverterCache.get(client, objectDef);
+  Object.setPrototypeOf(obj, proto);
+  Object.defineProperty(obj, OriginClient, {
+    value: client,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  if (converter) {
+    converter(obj);
   }
 }
 
 // src/object/fetchPage.ts
+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: {},
+    augmentedSharedPropertyTypes: {},
+    otherInterfaceTypes: [],
+    selectedObjectTypes: [],
+    selectedSharedPropertyTypes: args.select ?? [],
+    where: objectSetToSearchJsonV2(objectSet, interfaceType.apiName)
+  }), {
+    preview: true
+  });
+  result.data = await convertWireToOsdkObjects(
+    client,
+    result.data,
+    // drop readonly
+    interfaceType.apiName
+  );
+  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"]
 }) {
-  const body = {
-    objectSet,
-    // We have to do the following case because LoadObjectSetRequestV2 isnt readonly
-    select: args?.select ?? [],
-    // FIXME?
-    excludeRid: !args?.includeRid
-  };
+  return fetchPageInternal(client, objectType, objectSet, args);
+}
+function applyFetchArgs(args, body) {
   if (args?.nextPageToken) {
     body.pageToken = args.nextPageToken;
   }
@@ -1128,11 +1258,22 @@ async function fetchPage(client, objectType, args, objectSet = {
       }))
     };
   }
-  const r = await loadObjectSetV2(createOpenApiRequest(client.stack, client.fetch), client.ontology.metadata.ontologyApiName, body);
-  await convertWireToOsdkObjectsInPlace(client, r.data);
-  return r;
+  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, createAsyncCache, createBaseObjectSet, createObjectSet2 as createObjectSet, fetchPage, isAttachment, object_exports };
+export { aggregate, createAsyncCache, createObjectSet2 as createObjectSet, fetchPage, getWireObjectSet, isAttachment, isObjectSet, isWireObjectSet, loadAllOntologies, loadOntologyEntities, object_exports };
 //# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-GOBQUVQZ.mjs.map
+//# sourceMappingURL=chunk-SNGUDELK.mjs.map