@osdk/client 0.20.0-beta.3 → 0.20.0-beta.4

package/build/cjs/{chunk-EP4KLU3N.cjs → chunk-4FXEPHWC.cjs}

@@ -1250,6 +1250,7 @@ function createObjectSet(objectType, clientCtx, objectSet = {
         const result = await base.fetchPage({
           $nextPageToken
         });
+        $nextPageToken = result.nextPageToken;
         for (const obj of result.data) {
           yield obj;
         }
@@ -1606,7 +1607,7 @@ function applyFetchArgs(args, body) {
 async function fetchObjectPage(client, objectType, args, objectSet) {
   const r = await esm_exports2.OntologyObjectSets.loadObjectSetV2(addUserAgent(client, objectType), await client.ontologyRid, applyFetchArgs(args, {
     objectSet,
-    // We have to do the following case because LoadObjectSetRequestV2 isnt readonly
+    // We have to do the following case because LoadObjectSetRequestV2 isn't readonly
     select: args?.$select ?? [],
     // FIXME?
     excludeRid: !args?.$includeRid
@@ -1635,6 +1636,11 @@ function isOntologyObjectV2(o) {
   return o && typeof o === "object" && typeof o.__apiName === "string" && o.__primaryKey != null;
 }
 
+// src/util/isOsdkObject.ts
+function isOsdkBaseObject(o) {
+  return o && typeof o === "object" && typeof o.$apiName === "string" && o.$primaryKey != null;
+}
+
 // src/util/toDataValue.ts
 async function toDataValue(value, client) {
   if (value == null) {
@@ -1656,6 +1662,9 @@ async function toDataValue(value, client) {
   if (isOntologyObjectV2(value)) {
     return await toDataValue(value.__primaryKey, client);
   }
+  if (isOsdkBaseObject(value)) {
+    return await toDataValue(value.$primaryKey, client);
+  }
   if (isWireObjectSet(value)) {
     return value;
   }
@@ -1717,19 +1726,19 @@ async function remapBatchActionParams(params, client) {
   }));
   return remappedParams;
 }
-async function loadFullObjectMetadata(client, objtype) {
-  const full = await esm_exports2.OntologyObjectsV2.getObjectTypeFullMetadata(client, await client.ontologyRid, objtype, {
+async function loadFullObjectMetadata(client, objectType) {
+  const full = await esm_exports2.OntologyObjectsV2.getObjectTypeFullMetadata(client, await client.ontologyRid, objectType, {
     preview: true
   });
   const ret = generatorConverters.wireObjectTypeFullMetadataToSdkObjectTypeDefinition(full, true);
-  client.logger?.debug(`END loadFullObjectMetadata(${objtype})`);
+  client.logger?.debug(`END loadFullObjectMetadata(${objectType})`);
   return {
     ...ret,
     rid: full.objectType.rid
   };
 }
-async function loadInterfaceDefinition(client, objtype) {
-  const r = await esm_exports2.OntologyObjectsV2.getInterfaceType(client, await client.ontologyRid, objtype, {
+async function loadInterfaceDefinition(client, objectType) {
+  const r = await esm_exports2.OntologyObjectsV2.getInterfaceType(client, await client.ontologyRid, objectType, {
     preview: true
   });
   return generatorConverters.__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(r, true);
@@ -1770,7 +1779,7 @@ var createStandardOntologyProviderFactory = (client) => {
 };
 
 // src/util/UserAgent.ts
-var USER_AGENT = `osdk-client/${"0.20.0-beta.3"}`;
+var USER_AGENT = `osdk-client/${"0.20.0-beta.4"}`;
 
 // src/createMinimalClient.ts
 function createMinimalClient(metadata, baseUrl, tokenProvider, options = {}, fetchFn = global.fetch, objectSetFactory = createObjectSet) {
@@ -1794,6 +1803,277 @@ function createMinimalClient(metadata, baseUrl, tokenProvider, options = {}, fet
   });
 }
 
+// src/util/isOsdkBaseObject.ts
+function isOsdkBaseObject2(o) {
+  return o && typeof o === "object" && typeof o.$apiName === "string" && o.$primaryKey != null;
+}
+
+// src/util/toDataValueQueries.ts
+async function toDataValueQueries(value, client, desiredType) {
+  if (value == null) {
+    return value;
+  }
+  if (Array.isArray(value) && desiredType.multiplicity) {
+    const promiseArray = Array.from(value, async (innerValue) => await toDataValueQueries(innerValue, client, desiredType));
+    return Promise.all(promiseArray);
+  }
+  switch (desiredType.type) {
+    case "attachment": {
+      if (isAttachmentUpload(value)) {
+        const attachment = await esm_exports.Attachments.uploadAttachment(client, value, {
+          filename: value.name
+        }, {
+          "Content-Length": value.size.toString(),
+          "Content-Type": value.type
+        });
+        return attachment.rid;
+      }
+      return value;
+    }
+    case "twoDimensionalAggregation": {
+      return {
+        groups: value
+      };
+    }
+    case "threeDimensionalAggregation": {
+      return {
+        groups: value
+      };
+    }
+    case "set": {
+      if (value instanceof Set) {
+        const promiseArray = Array.from(value, async (innerValue) => await toDataValueQueries(innerValue, client, desiredType["set"]));
+        return Promise.all(promiseArray);
+      }
+      break;
+    }
+    case "object": {
+      if (isOsdkBaseObject2(value)) {
+        return value.$primaryKey;
+      }
+      break;
+    }
+    case "objectSet": {
+      if (isWireObjectSet(value)) {
+        return value;
+      }
+      if (isObjectSet(value)) {
+        return getWireObjectSet(value);
+      }
+      break;
+    }
+    case "struct": {
+      if (typeof value === "object") {
+        const structMap = {};
+        for (const [key, structValue] of Object.entries(value)) {
+          structMap[key] = await toDataValueQueries(structValue, client, desiredType["struct"][key]);
+        }
+        return structMap;
+      }
+    }
+    case "boolean":
+    case "date":
+    case "double":
+    case "float":
+    case "integer":
+    case "long":
+    case "string":
+    case "timestamp":
+      return value;
+  }
+  return value;
+}
+
+// src/queries/applyQuery.ts
+async function applyQuery(client, query, params) {
+  const response = await esm_exports2.QueryTypes.executeQueryV2(addUserAgent(client, query), await client.ontologyRid, query.apiName, {
+    parameters: params ? await remapQueryParams(params, client, query.parameters) : {}
+  });
+  const objectOutputDefs = await getRequiredDefinitions(query.output, client);
+  const remappedResponse = await remapQueryResponse(client, query.output, response.value, objectOutputDefs);
+  return remappedResponse;
+}
+async function remapQueryParams(params, client, paramTypes) {
+  const parameterMap = {};
+  for (const [key, value] of Object.entries(params)) {
+    parameterMap[key] = await toDataValueQueries(value, client, paramTypes[key]);
+  }
+  return parameterMap;
+}
+async function remapQueryResponse(client, responseDataType, responseValue, definitions) {
+  if (responseValue == null) {
+    if (responseDataType.nullable) {
+      return void 0;
+    } else {
+      throw new Error("Got null response when nullable was not allowed");
+    }
+  }
+  if (responseDataType.multiplicity != null && responseDataType.multiplicity !== false) {
+    const withoutMultiplicity = {
+      ...responseDataType,
+      multiplicity: false
+    };
+    for (let i = 0; i < responseValue.length; i++) {
+      responseValue[i] = await remapQueryResponse(responseValue[i], withoutMultiplicity, client, definitions);
+    }
+    return responseValue;
+  }
+  switch (responseDataType.type) {
+    case "union": {
+      throw new Error("Union return types are not yet supported");
+    }
+    case "set": {
+      for (let i = 0; i < responseValue.length; i++) {
+        responseValue[i] = await remapQueryResponse(responseValue[i], responseDataType.set, client, definitions);
+      }
+      return responseValue;
+    }
+    case "attachment": {
+      return createAttachmentFromRid(client, responseValue);
+    }
+    case "object": {
+      const def = definitions.get(responseDataType.object);
+      if (!def) {
+        throw new Error(`Missing definition for ${responseDataType.object}`);
+      }
+      return createQueryObjectResponse(responseValue, def);
+    }
+    case "objectSet": {
+      const def = definitions.get(responseDataType.objectSet);
+      if (!def) {
+        throw new Error(`Missing definition for ${responseDataType.objectSet}`);
+      }
+      if (typeof responseValue === "string") {
+        return createObjectSet(def, client, {
+          type: "intersect",
+          objectSets: [{
+            type: "base",
+            objectType: responseDataType.objectSet
+          }, {
+            type: "reference",
+            reference: responseValue
+          }]
+        });
+      }
+      return createObjectSet(def, client, responseValue);
+    }
+    case "struct": {
+      for (const [key, subtype] of Object.entries(responseDataType.struct)) {
+        if (requiresConversion(subtype)) {
+          responseValue[key] = await remapQueryResponse(responseValue[key], subtype, client, definitions);
+        }
+      }
+      return responseValue;
+    }
+    case "twoDimensionalAggregation": {
+      const result = [];
+      for (const {
+        key,
+        value
+      } of responseValue.groups) {
+        result.push({
+          key,
+          value
+        });
+      }
+      return result;
+    }
+    case "threeDimensionalAggregation": {
+      const result = [];
+      for (const {
+        key,
+        groups
+      } of responseValue.groups) {
+        const subResult = [];
+        for (const {
+          key: subKey,
+          value
+        } of groups) {
+          subResult.push({
+            key: subKey,
+            value
+          });
+        }
+        result.push({
+          key,
+          groups: subResult
+        });
+      }
+      return result;
+    }
+  }
+  return responseValue;
+}
+async function getRequiredDefinitions(dataType, client) {
+  const result = /* @__PURE__ */ new Map();
+  switch (dataType.type) {
+    case "objectSet": {
+      const objectDef = await client.ontologyProvider.getObjectDefinition(dataType.objectSet);
+      result.set(dataType.objectSet, objectDef);
+      break;
+    }
+    case "object": {
+      const objectDef = await client.ontologyProvider.getObjectDefinition(dataType.object);
+      result.set(dataType.object, objectDef);
+      break;
+    }
+    case "set": {
+      return getRequiredDefinitions(dataType.set, client);
+    }
+    case "struct": {
+      for (const value of Object.values(dataType.struct)) {
+        for (const [type, objectDef] of await getRequiredDefinitions(value, client)) {
+          result.set(type, objectDef);
+        }
+      }
+      break;
+    }
+  }
+  return result;
+}
+function requiresConversion(dataType) {
+  switch (dataType.type) {
+    case "boolean":
+    case "date":
+    case "double":
+    case "float":
+    case "integer":
+    case "long":
+    case "object":
+    case "string":
+    case "timestamp":
+      return false;
+    case "union":
+      return true;
+    case "struct":
+      return Object.values(dataType.struct).some(requiresConversion);
+    case "set":
+      return requiresConversion(dataType.set);
+    case "attachment":
+    case "objectSet":
+    case "twoDimensionalAggregation":
+    case "threeDimensionalAggregation":
+      return true;
+    default:
+      return false;
+  }
+}
+function createQueryObjectResponse(primaryKey, objectDef) {
+  return {
+    $apiName: objectDef.apiName,
+    $title: void 0,
+    $objectType: objectDef.apiName,
+    $primaryKey: primaryKey
+  };
+}
+
+// src/queries/createQueryInvoker.ts
+function createQueryInvoker(client, query) {
+  return function(...args) {
+    return applyQuery(client, query, ...args);
+  };
+}
+
 // src/createClient.ts
 var ActionInvoker = class {
   constructor(clientCtx, actionDef) {
@@ -1811,6 +2091,8 @@ function createClientInternal(objectSetFactory, baseUrl, ontologyRid, tokenProvi
     } else if (o.type === "action") {
       clientCtx.ontologyProvider.maybeSeed(o);
       return new ActionInvoker(clientCtx, o);
+    } else if (o.type === "query") {
+      return createQueryInvoker(clientCtx, o);
     } else {
       throw new Error("not implemented");
     }
@@ -1835,4 +2117,4 @@ exports.createObjectSet = createObjectSet;
 exports.createSimpleAsyncCache = createSimpleAsyncCache;
 exports.esm_exports = esm_exports2;
 //# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-EP4KLU3N.cjs.map
+//# sourceMappingURL=chunk-4FXEPHWC.cjs.map