@osdk/generator 2.4.0-beta.9 → 2.4.0

package/build/cjs/index.cjs

@@ -446,7 +446,7 @@ async function generatePerActionDataFiles({
         "*": (ogValue, _, ogKey) => {
           const key = `${getDescriptionIfPresent(ogValue.description)}
                   readonly "${ogKey}"${ogValue.nullable ? "?" : ""}`;
-          const value = (ogValue.multiplicity ? `ReadonlyArray<${getActionParamType(ogValue.type)}>` : `${getActionParamType(ogValue.type)}`) + (ogValue.nullable ? " | ActionParam.NullValueType" : "");
+          const value = ogValue.multiplicity ? `ReadonlyArray<${getActionParamType(ogValue.type)}>` : `${getActionParamType(ogValue.type)}`;
           jsDocBlock.push(`* @param {${getActionParamType(ogValue.type)}} ${ogValue.nullable ? `[${ogKey}]` : ogKey} ${ogValue.description ?? ""} `);
           return [key, value];
         }
@@ -814,8 +814,10 @@ function createDefinition(object, ontology, identifier, {
       strictProps: ${osdkObjectStrictPropsIdentifier};
       ${stringify(definition, {
     links: (_value) => `{
-        ${stringify(definition.links, {
-      "*": (definition2) => `$ObjectMetadata.Link<${ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(true)}, ${definition2.multiplicity}>`
+        ${definition.type === "interface" ? stringify(definition.links, {
+      "*": (linkDefinition) => `$InterfaceMetadata.Link<${linkDefinition.targetType === "interface" ? ontology.requireInterfaceType(linkDefinition.targetTypeApiName).getImportedDefinitionIdentifier(true) : ontology.requireObjectType(linkDefinition.targetTypeApiName).getImportedDefinitionIdentifier(true)}, ${linkDefinition.multiplicity}>`
+    }) : stringify(definition.links, {
+      "*": (linkDefinition) => `$ObjectMetadata.Link<${ontology.requireObjectType(linkDefinition.targetType).getImportedDefinitionIdentifier(true)}, ${linkDefinition.multiplicity}>`
     })}
       }`,
     properties: (_value) => `{
@@ -857,8 +859,9 @@ function remapStructType(structType) {
 }
 
 // src/v2.0/UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst.ts
-function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, ontology, v2 = false, forInternalUse = false) {
+function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, ontology, v2 = false, forInternalUse = false, currentFilePath = "") {
   const definition = deleteUndefineds(generatorConverters.__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef.raw, v2));
+  const uniqueLinkTargetTypes = new Set(definition.links ? Object.values(definition.links).map((a) => a.targetType === "object" ? ontology.requireObjectType(a.targetTypeApiName) : ontology.requireInterfaceType(a.targetTypeApiName)) : []);
   const objectDefIdentifier = interfaceDef.getDefinitionIdentifier(v2);
   const parents = definition.implements?.map((p) => {
     const parent = ontology.requireInterfaceType(p, true);
@@ -908,22 +911,23 @@ function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, ontology,
   function getV2Types(forInternalUse2 = false) {
     return `import type {
       InterfaceDefinition as $InterfaceDefinition,
+      InterfaceMetadata as $InterfaceMetadata,
       ObjectSet as $ObjectSet, 
       Osdk as $Osdk,
       PropertyValueWireToClient as $PropType,
     } from "${forInternalUse2 ? "@osdk/api" : "@osdk/client"}";
     
-        ${Object.keys(definition.links).length === 0 ? `export type ${osdkObjectLinksIdentifier} = {};` : `
+        ${definition.links ? Object.keys(definition.links).length > 0 ? `
         export interface ${osdkObjectLinksIdentifier}  {
 ${stringify(definition.links, {
       "*": (definition2) => {
-        const linkTarget = ontology.requireObjectType(definition2.targetType).getImportedDefinitionIdentifier(v2);
-        return `${definition2.multiplicity ? `${linkTarget}["objectSet"]` : `SingleLinkAccessor<${linkTarget}>`}
+        const linkTarget = definition2.targetType === "object" ? ontology.requireObjectType(definition2.targetTypeApiName).getImportedDefinitionIdentifier(v2) : ontology.requireInterfaceType(definition2.targetTypeApiName).getImportedDefinitionIdentifier(v2);
+        return `${definition2.multiplicity ? `${linkTarget}.ObjectSet` : `${linkTarget}.ObjectSet`}
           `;
       }
     })}
     }
-    `}
+    ` : `export type ${osdkObjectLinksIdentifier} = {};` : `export type ${osdkObjectLinksIdentifier} = {};`}
 
     export namespace ${interfaceDef.shortApiName} {
 
@@ -944,8 +948,8 @@ ${stringify(definition.links, {
 
 `;
   }
-  const imports = [];
-  return `${imports.join("\n")}
+  const imports = getObjectImports(uniqueLinkTargetTypes, definition.apiName, currentFilePath, true);
+  return `${imports}
     ${v2 ? getV2Types(forInternalUse) : ""}
 
     export const ${interfaceDef.shortApiName}: ${interfaceDef.shortApiName} = {
@@ -969,10 +973,11 @@ async function generatePerInterfaceDataFiles({
   });
   for (const obj of Object.values(ontology.interfaceTypes)) {
     if (obj instanceof ForeignType) continue;
+    const relPath = path8__namespace.default.join(".", "ontology", "interfaces", `${obj.shortApiName}.ts`);
     await fs2.writeFile(path8__namespace.default.join(interfacesDir, `${obj.shortApiName}.ts`), await formatTs(`
         import type { PropertyDef as $PropertyDef } from "${forInternalUse ? "@osdk/api" : "@osdk/client"}";
         import { $osdkMetadata } from "../../OntologyMetadata${importExt}";
-      ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, ontology, true, forInternalUse)}
+      ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, ontology, true, forInternalUse, relPath)}
     `));
   }
   await fs2.writeFile(interfacesDir + ".ts", await formatTs(`
@@ -1007,6 +1012,65 @@ async function generatePerObjectDataFiles(ctx) {
     `));
 }
 
+// src/shared/getInterfaceTypesFromQueryDataType.ts
+function getInterfaceTypesFromQueryDataType(dataType, types) {
+  switch (dataType.type) {
+    case "array":
+    case "set":
+      getInterfaceTypesFromQueryDataType(dataType.subType, types);
+      return;
+    case "interfaceObject":
+    case "interfaceObjectSet":
+      types.add(dataType.interfaceTypeApiName);
+      return;
+    case "struct":
+      for (const prop of Object.values(dataType.fields)) {
+        getInterfaceTypesFromQueryDataType(prop.fieldType, types);
+      }
+      return;
+    case "union":
+      for (const type of dataType.unionTypes) {
+        getInterfaceTypesFromQueryDataType(type, types);
+      }
+      return;
+    case "entrySet":
+      getInterfaceTypesFromQueryDataType(dataType.keyType, types);
+      getInterfaceTypesFromQueryDataType(dataType.valueType, types);
+      return;
+    case "attachment":
+    case "boolean":
+    case "date":
+    case "double":
+    case "float":
+    case "integer":
+    case "long":
+    case "null":
+    case "string":
+    case "threeDimensionalAggregation":
+    case "timestamp":
+    case "twoDimensionalAggregation":
+    case "entrySet":
+    case "unsupported":
+    case "object":
+    case "objectSet":
+      return;
+    default:
+      throw new Error(`Unknown query data type ${dataType.type}`);
+  }
+}
+
+// src/shared/getInterfaceTypeApiNamesFromQuery.ts
+function getInterfaceTypeApiNamesFromQuery(query) {
+  const types = /* @__PURE__ */ new Set();
+  for (const {
+    dataType
+  } of Object.values(query.parameters)) {
+    getInterfaceTypesFromQueryDataType(dataType, types);
+  }
+  getInterfaceTypesFromQueryDataType(query.output, types);
+  return Array.from(types);
+}
+
 // src/shared/getObjectTypesFromQueryDataType.ts
 function getObjectTypesFromQueryDataType(dataType, types) {
   switch (dataType.type) {
@@ -1094,8 +1158,9 @@ async function generatePerQueryDataFilesV2({
 async function generateV2QueryFile(fs2, outDir, relOutDir, query, importExt, ontology, forInternalUse, fixedVersionQueryTypes) {
   const relFilePath = path8__namespace.default.join(relOutDir, `${query.shortApiName}.ts`);
   const objectTypes = getObjectTypeApiNamesFromQuery(query);
-  const objectTypeObjects = new Set(objectTypes.map((o) => ontology.requireObjectType(o)));
-  const importObjects = getObjectImports(objectTypeObjects, "", relFilePath, true);
+  const interfaceTypes = getInterfaceTypeApiNamesFromQuery(query);
+  const interfaceAndObjectTypes = /* @__PURE__ */ new Set([...objectTypes.map((o) => ontology.requireObjectType(o)), ...interfaceTypes.map((o) => ontology.requireInterfaceType(o))]);
+  const importObjects = getObjectImports(interfaceAndObjectTypes, "", relFilePath, true);
   const baseProps = deleteUndefineds(generatorConverters.wireQueryTypeV2ToSdkQueryDefinitionNoParams(query.raw));
   const outputBase = deleteUndefineds(generatorConverters.wireQueryDataTypeToQueryDataTypeDefinition(query.output));
   const isUsingFixedVersion = fixedVersionQueryTypes.includes(query.fullApiName);
@@ -1246,9 +1311,15 @@ function getQueryParamType(enhancedOntology, input, type, isMapKey = false) {
       }
       inner = `Query${type}.ObjectType<${enhancedOntology.requireObjectType(input.object).getImportedDefinitionIdentifier(true)}>`;
       break;
+    case "interface":
+      inner = `Query${type}.InterfaceType<${enhancedOntology.requireInterfaceType(input.interface).getImportedDefinitionIdentifier(true)}>`;
+      break;
     case "objectSet":
       inner = `Query${type}.ObjectSetType<${enhancedOntology.requireObjectType(input.objectSet).getImportedDefinitionIdentifier(true)}>`;
       break;
+    case "interfaceObjectSet":
+      inner = `Query${type}.ObjectSetType<${enhancedOntology.requireInterfaceType(input.objectSet).getImportedDefinitionIdentifier(true)}>`;
+      break;
     case "set":
       inner = `${type === "Param" ? "Readonly" : ""}Set<${getQueryParamType(enhancedOntology, input.set, type)}>`;
       break;