@osdk/foundry-sdk-generator 2.0.2-rc.3 → 2.0.3

package/build/esm/index.js

@@ -20,6 +20,99 @@ var getFilename = () => fileURLToPath(import.meta.url);
 var getDirname = () => path2__default.dirname(getFilename());
 var __dirname = /* @__PURE__ */ getDirname();
 
+// ../../node_modules/.pnpm/conjure-lite@0.4.4/node_modules/conjure-lite/dist/index.mjs
+async function conjureFetch({
+  fetchFn,
+  baseUrl,
+  servicePath,
+  tokenProvider
+}, url, method, body, params, contentType, accept) {
+  const queryParams = Object.entries({}).flatMap(([key, value]) => {
+    if (value == null) {
+      return [];
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => [key, item]);
+    }
+    const stringValue = "" + value;
+    return stringValue.length === 0 ? [] : [[key, stringValue]];
+  });
+  const query = Object.keys(queryParams).length === 0 ? "" : `?${new URLSearchParams(queryParams).toString()}`;
+  const response = await (fetchFn ?? fetch)(`${baseUrl}${servicePath}${url}${query}`, {
+    method,
+    credentials: "same-origin",
+    headers: {
+      "Fetch-User-Agent": "conjure-lite",
+      "Content-Type": "application/json",
+      accept: "application/json",
+      ...tokenProvider ? {
+        "Authorization": `Bearer ${await tokenProvider()}`
+      } : {}
+    },
+    ...{}
+  });
+  try {
+    if (response.status === 204) {
+      return void 0;
+    }
+    const body2 = await readBody(response);
+    if (!response.ok) {
+      throw new ConjureError("STATUS", void 0, response.status, body2);
+    }
+    return body2;
+  } catch (error) {
+    if (error instanceof ConjureError) {
+      throw error;
+    } else if (error instanceof TypeError) {
+      throw new ConjureError("NETWORK", error);
+    } else {
+      throw new ConjureError("OTHER", error);
+    }
+  }
+}
+async function readBody(response) {
+  const contentType = response.headers.get("Content-Type") != null ? response.headers.get("Content-Type") : "";
+  try {
+    if (contentType.includes("application/json")) {
+      return await response.json();
+    } else if (contentType.includes("application/octet-stream")) {
+      return await response.blob();
+    } else {
+      return await response.text();
+    }
+  } catch (error) {
+    throw new ConjureError("PARSE", error, response.status);
+  }
+}
+var ConjureError = class {
+  type;
+  originalError;
+  status;
+  body;
+  constructor(errorType, originalError, status, body) {
+    this.type = errorType;
+    this.originalError = originalError;
+    this.status = status;
+    this.body = body;
+  }
+  toString() {
+    return JSON.stringify({
+      body: this.body,
+      originalError: this.originalError && this.originalError.toString(),
+      status: this.status,
+      type: this.type
+    }, null, "  ");
+  }
+};
+
+// ../client.unstable.tpsa/build/esm/index.js
+async function getSdk(ctx, repositoryRid, packageName, sdkVersion) {
+  return conjureFetch(ctx, `/sdks/${repositoryRid}/${packageName}/${sdkVersion}`, "GET");
+}
+async function getSdkPackage(ctx, sdkPackageRid) {
+  return conjureFetch(ctx, `/sdks/packages/${sdkPackageRid}`, "GET");
+}
+
 // src/ontologyMetadata/Result.ts
 var Ok = class {
   constructor(value) {
@@ -101,24 +194,41 @@ var OntologyMetadataResolver = class {
   getClientContext() {
     return createClientContext(this.stackName.match(/^https?:\/\//) ? this.stackName : `https://${this.stackName}`, () => this.#authToken, `foundry-typescript-osdk-generator/${process.env.npm_package_version}`);
   }
-  filterMetadata(ontologyFullMetadata, expectedEntities) {
-    const filteredObjectTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.objectTypes).filter(([objectTypeApiName]) => expectedEntities.objectTypes.has(objectTypeApiName.toLowerCase())));
-    const filteredInterfaceTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.interfaceTypes).filter(([interfaceApiName]) => expectedEntities.interfaceTypes.has(interfaceApiName.toLowerCase())));
+  filterMetadataByApiName(ontologyFullMetadata, expectedEntities, pkgInfo) {
+    const filteredObjectTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.objectTypes).filter(([, {
+      objectType
+    }]) => {
+      for (const {
+        sdk: {
+          inputs: {
+            dataScope
+          }
+        }
+      } of pkgInfo.values()) {
+        for (const objectTypeRid of dataScope.ontologyV2.objectTypes) {
+          if (objectTypeRid === objectType.rid) {
+            return true;
+          }
+        }
+      }
+      return expectedEntities.objectTypes.has(objectType.apiName);
+    }));
+    const filteredInterfaceTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.interfaceTypes).filter(([interfaceApiName]) => expectedEntities.interfaceTypes.has(interfaceApiName)));
     Object.values(filteredObjectTypes).forEach((objectType) => {
-      const linkTypesToKeep = expectedEntities.linkTypes.get(objectType.objectType.apiName.toLowerCase());
+      const linkTypesToKeep = expectedEntities.linkTypes.get(objectType.objectType.apiName);
       if (!linkTypesToKeep) {
         objectType.linkTypes = [];
         return;
       }
-      objectType.linkTypes = objectType.linkTypes.filter((linkType) => linkTypesToKeep.has(linkType.apiName.toLowerCase()));
+      objectType.linkTypes = objectType.linkTypes.filter((linkType) => linkTypesToKeep.has(linkType.apiName));
     });
     const filteredActionTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.actionTypes).filter(([actionApiName]) => {
-      if (expectedEntities.actionTypes.has(this.camelize(actionApiName).toLowerCase())) {
+      if (expectedEntities.actionTypes.has(this.camelize(actionApiName))) {
         return true;
       }
       return false;
     }));
-    const filteredQueryTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.queryTypes).filter(([queryApiName]) => expectedEntities.queryTypes.has(queryApiName.toLowerCase())));
+    const filteredQueryTypes = Object.fromEntries(Object.entries(ontologyFullMetadata.queryTypes).filter(([queryApiName]) => expectedEntities.queryTypes.has(queryApiName)));
     return {
       ontology: ontologyFullMetadata.ontology,
       objectTypes: filteredObjectTypes,
@@ -128,7 +238,25 @@ var OntologyMetadataResolver = class {
       sharedPropertyTypes: {}
     };
   }
-  async getWireOntologyDefinition(ontologyRid, entities) {
+  async getInfoForPackages(pkgs) {
+    const conjureCtx = {
+      baseUrl: `https://${this.stackName}`,
+      servicePath: "/third-party-application-service/api",
+      tokenProvider: () => Promise.resolve(this.#authToken)
+    };
+    const ret = /* @__PURE__ */ new Map();
+    for (const [packageRid, packageVersion] of pkgs) {
+      const sdkPackage = await getSdkPackage(conjureCtx, packageRid);
+      const sdk = await getSdk(conjureCtx, sdkPackage.repositoryRid, sdkPackage.packageName, packageVersion);
+      ret.set(packageRid, {
+        sdkPackage,
+        sdk,
+        packageVersion
+      });
+    }
+    return ret;
+  }
+  async getWireOntologyDefinition(ontologyRid, entities, extPackageInfo = /* @__PURE__ */ new Map()) {
     let ontology;
     const {
       Ontologies
@@ -146,40 +274,68 @@ var OntologyMetadataResolver = class {
       return Result.err([`Unable to load the specified Ontology metadata.
 ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
     }
+    const externalObjects = /* @__PURE__ */ new Map();
+    const externalInterfaces = /* @__PURE__ */ new Map();
+    for (const {
+      sdk
+    } of extPackageInfo.values()) {
+      if (sdk.npm?.npmPackageName == null) {
+        throw new Error("External package is not generated as an npm package");
+      }
+      const dataScope = sdk.inputs.dataScope.ontologyV2;
+      for (const rid of dataScope.objectTypes) {
+        const ot = Object.values(ontologyFullMetadata.objectTypes).find((ot2) => ot2.objectType.rid === rid);
+        if (!ot) {
+          throw new Error(`Could not find external object type with rid ${rid}`);
+        }
+        externalObjects.set(ot.objectType.apiName, sdk.npm.npmPackageName);
+      }
+      for (const rid of dataScope.interfaceTypes) {
+        const it = Object.values(ontologyFullMetadata.interfaceTypes).find((it2) => it2.rid === rid);
+        if (!it) {
+          throw new Error(`Could not find external interface type with rid ${rid}`);
+        }
+        externalInterfaces.set(it.apiName, sdk.npm.npmPackageName);
+      }
+    }
     const linkTypes = /* @__PURE__ */ new Map();
-    const objectTypes = new Set(entities.objectTypesApiNamesToLoad?.map((object) => object.toLowerCase()));
-    const queryTypes = new Set(entities.queryTypesApiNamesToLoad?.map((query) => query.toLowerCase()));
-    const actionTypes = new Set(entities.actionTypesApiNamesToLoad?.map((action) => this.camelize(action).toLowerCase()));
-    const interfaceTypes = new Set(entities.interfaceTypesApiNamesToLoad?.map((interfaceName) => interfaceName.toLowerCase()));
+    const objectTypes = new Set(entities.objectTypesApiNamesToLoad);
+    const queryTypes = new Set(entities.queryTypesApiNamesToLoad);
+    const actionTypes = new Set(entities.actionTypesApiNamesToLoad?.map((action) => this.camelize(action)));
+    const interfaceTypes = new Set(entities.interfaceTypesApiNamesToLoad);
     for (const linkType of entities.linkTypesApiNamesToLoad ?? []) {
-      const [objectTypeApiName, linkTypeApiName] = linkType.toLowerCase().split(".");
+      const [objectTypeApiName, linkTypeApiName] = linkType.split(".");
       if (!linkTypes.has(objectTypeApiName)) {
         linkTypes.set(objectTypeApiName, /* @__PURE__ */ new Set());
       }
       linkTypes.get(objectTypeApiName)?.add(linkTypeApiName);
     }
-    const filteredFullMetadata = this.filterMetadata(ontologyFullMetadata, {
+    const filteredFullMetadata = this.filterMetadataByApiName(ontologyFullMetadata, {
       objectTypes,
       linkTypes,
       actionTypes,
       queryTypes,
       interfaceTypes
-    });
+    }, extPackageInfo);
     const validData = this.validateLoadedOntologyMetadata(filteredFullMetadata, {
       objectTypes,
       linkTypes,
       actionTypes,
       queryTypes
-    });
+    }, ontologyFullMetadata, extPackageInfo);
     if (validData.isErr()) {
       return Result.err(validData.error);
     }
-    return Result.ok(filteredFullMetadata);
+    return Result.ok({
+      filteredFullMetadata,
+      externalInterfaces,
+      externalObjects
+    });
   }
-  validateLoadedOntologyMetadata(filteredFullMetadata, expectedEntities) {
+  validateLoadedOntologyMetadata(filteredFullMetadata, expectedEntities, fullOntology, packageInfo) {
     const errors = [];
-    const loadedObjectTypes = Object.fromEntries(Object.values(filteredFullMetadata.objectTypes).map((object) => [object.objectType.apiName.toLowerCase(), object]));
-    const loadedLinkTypes = Object.fromEntries(Object.values(filteredFullMetadata.objectTypes).map((object) => [object.objectType.apiName.toLowerCase(), Object.fromEntries(object.linkTypes.map((link) => [link.apiName.toLowerCase(), link]))]));
+    const loadedObjectTypes = Object.fromEntries(Object.values(filteredFullMetadata.objectTypes).map((object) => [object.objectType.apiName, object]));
+    const loadedLinkTypes = Object.fromEntries(Object.values(filteredFullMetadata.objectTypes).map((object) => [object.objectType.apiName, Object.fromEntries(object.linkTypes.map((link) => [link.apiName, link]))]));
     const missingObjectTypes = [];
     for (const object of expectedEntities.objectTypes) {
       if (!loadedObjectTypes[object]) {
@@ -192,15 +348,19 @@ ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
         }
       }
       for (const [, link] of Object.entries(loadedLinkTypes[object])) {
-        if (!expectedEntities.objectTypes.has(link.objectTypeApiName.toLowerCase())) {
+        if (!expectedEntities.objectTypes.has(link.objectTypeApiName)) {
+          const fromFull = fullOntology.objectTypes[link.objectTypeApiName];
+          if (fromFull && hasObjectType(packageInfo, fromFull)) {
+            continue;
+          }
           errors.push(`Unable to load link type ${link.apiName} for ${loadedObjectTypes[object].objectType.apiName}, because the target object type ${link.objectTypeApiName} is not loaded. Please specify the target Object type with --objectTypes ${link.objectTypeApiName}`);
         }
       }
     }
     if (missingObjectTypes.length > 0) {
-      errors.push(`Unable to find the following Object Types: ${missingObjectTypes.join()}`);
+      errors.push(`Unable to find the following Object Types: ${missingObjectTypes.join(", ")}`);
     }
-    const loadedQueryTypes = Object.fromEntries(Object.entries(filteredFullMetadata.queryTypes).map(([queryApiName, query]) => [queryApiName.toLowerCase(), query]));
+    const loadedQueryTypes = Object.fromEntries(Object.entries(filteredFullMetadata.queryTypes).map(([queryApiName, query]) => [queryApiName, query]));
     const missingQueryTypes = [];
     for (const queryApiName of expectedEntities.queryTypes) {
       if (!loadedQueryTypes[queryApiName]) {
@@ -218,7 +378,7 @@ ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
     if (missingQueryTypes.length > 0) {
       errors.push(`Unable to find the following Query Types: ${missingQueryTypes.join()}`);
     }
-    const loadedActionTypes = Object.fromEntries(Object.entries(filteredFullMetadata.actionTypes).map(([actionApiName, action]) => [this.camelize(actionApiName).toLowerCase(), action]));
+    const loadedActionTypes = Object.fromEntries(Object.entries(filteredFullMetadata.actionTypes).map(([actionApiName, action]) => [this.camelize(actionApiName), action]));
     const missingActionTypes = [];
     for (const actionApiName of expectedEntities.actionTypes) {
       if (!loadedActionTypes[actionApiName]) {
@@ -259,7 +419,7 @@ ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
         return this.visitSupportedQueryTypes(queryApiName, propertyName, baseType.subType, loadedObjectApiNames);
       case "objectSet":
       case "object":
-        if (loadedObjectApiNames.has(baseType.objectTypeApiName?.toLowerCase())) {
+        if (loadedObjectApiNames.has(baseType.objectTypeApiName)) {
           return Result.ok({});
         }
         return Result.err([`Unable to load query ${queryApiName} because it takes an unloaded object type as a parameter: ${baseType.objectTypeApiName} in parameter ${propertyName}. Make sure to specify it as an argument with --ontologyObjects ${baseType.objectTypeApiName}.}`]);
@@ -299,12 +459,12 @@ ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
       case "array":
         return this.isSupportedActionTypeParameter(actionApiName, actonTypeParameter.subType, loadedObjectApiNames);
       case "object":
-        if (loadedObjectApiNames.has(actonTypeParameter.objectTypeApiName?.toLowerCase())) {
+        if (loadedObjectApiNames.has(actonTypeParameter.objectTypeApiName)) {
           return Result.ok({});
         }
         return Result.err([`Unable to load action ${actionApiName} because it takes an unloaded object type as a parameter: ${actonTypeParameter.objectTypeApiName} make sure to specify it as an argument with --ontologyObjects ${actonTypeParameter.objectTypeApiName})`]);
       case "objectSet":
-        if (loadedObjectApiNames.has(actonTypeParameter.objectTypeApiName?.toLowerCase())) {
+        if (loadedObjectApiNames.has(actonTypeParameter.objectTypeApiName)) {
           return Result.ok({});
         }
         return Result.err([`Unable to load action ${actionApiName} because it takes an ObjectSet of unloaded object type as a parameter: ${actonTypeParameter.objectTypeApiName} make sure to specify it as an argument with --ontologyObjects ${actonTypeParameter.objectTypeApiName})`]);
@@ -325,6 +485,17 @@ ${JSON.stringify(ontologyFullMetadata, null, 2)}`]);
     return name.replace(/-./g, (segment) => segment[1].toUpperCase());
   }
 };
+function hasObjectType(z, fromFull) {
+  for (const q of z.values()) {
+    const {
+      objectTypes
+    } = q.sdk.inputs.dataScope.ontologyV2;
+    if (objectTypes.includes(fromFull.objectType.rid)) {
+      return true;
+    }
+  }
+  return false;
+}
 
 // src/utils/semverUtils.ts
 var semver = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
@@ -333,7 +504,7 @@ function isValidSemver(semverString) {
 }
 
 // src/utils/UserAgent.ts
-var USER_AGENT = `typescript-sdk-generator/${"2.0.2-rc.3"}`;
+var USER_AGENT = `typescript-sdk-generator/${"2.0.3"}`;
 async function createRollupBuild(absolutePackagePath, packageName) {
   const inputPath = `${absolutePackagePath}/${packageName}/index.js`;
   const {
@@ -626,7 +797,7 @@ var betaDependencies = {
 var betaPeerDependencies = {
   "@osdk/client": typeof __OSDK_CLIENT_VERSION__ !== "undefined" ? __OSDK_CLIENT_VERSION__ : void 0
 };
-async function generatePackage(ontology, options) {
+async function generatePackage(ontologyInfo, options) {
   const {
     consola
   } = await import('consola');
@@ -648,11 +819,7 @@ async function generatePackage(ontology, options) {
     },
     readdir: (path3) => readdir(path3)
   };
-  if (!options.beta) {
-    throw new Error("Only beta is supported in this version");
-  } else {
-    await generateClientSdkVersionTwoPointZero(ontology, `typescript-sdk/${options.packageVersion} ${USER_AGENT}`, hostFs, packagePath, "module");
-  }
+  await generateClientSdkVersionTwoPointZero(ontologyInfo.filteredFullMetadata, `typescript-sdk/${options.packageVersion} ${USER_AGENT}`, hostFs, packagePath, "module", ontologyInfo.externalObjects, ontologyInfo.externalInterfaces);
   const compilerOutput = compileInMemory(inMemoryFileSystem, {
     esm: options.beta
   });
@@ -814,7 +981,10 @@ var GeneratePackageCommand = class {
       array: true,
       string: true,
       // experimental for now
-      hidden: true
+      hidden: true,
+      coerce: (arg) => {
+        return new Map(arg.map((sdkPackage) => sdkPackage.split("=", 2)));
+      }
     }).strict();
   }
   handler = async (args) => {
@@ -828,6 +998,7 @@ var GeneratePackageCommand = class {
       consola.error(new Error(`Invalid argument provided for packageVersion: ${args.packageVersion}, expected valid semver`));
       exit(1);
     }
+    const packageInfo = await ontologyMetadataResolver.getInfoForPackages(args.sdkPackages ?? /* @__PURE__ */ new Map());
     const timeStart = Date.now();
     const wireOntologyDefinition = await ontologyMetadataResolver.getWireOntologyDefinition(ontologyRid, {
       objectTypesApiNamesToLoad: transformArrayArg(args.objectTypes),
@@ -835,7 +1006,7 @@ var GeneratePackageCommand = class {
       queryTypesApiNamesToLoad: transformArrayArg(args.queryTypes),
       interfaceTypesApiNamesToLoad: transformArrayArg(args.interfaceTypes),
       linkTypesApiNamesToLoad: transformArrayArg(args.linkTypes)
-    });
+    }, packageInfo);
     if (wireOntologyDefinition.isErr()) {
       wireOntologyDefinition.error.forEach((err) => {
         consola.error(err);