@osdk/generator 1.12.0-beta.1 → 1.12.0-beta.2

package/build/cjs/index.cjs

@@ -5,6 +5,8 @@ var path16 = require('path');
 var prettier = require('prettier');
 var organizeImports = require('prettier-plugin-organize-imports');
 var generatorConverters = require('@osdk/generator-converters');
+var fastDeepEqual = require('fast-deep-equal');
+var invariant = require('tiny-invariant');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -29,6 +31,8 @@ function _interopNamespace(e) {
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path16__namespace = /*#__PURE__*/_interopNamespace(path16);
 var organizeImports__default = /*#__PURE__*/_interopDefault(organizeImports);
+var fastDeepEqual__default = /*#__PURE__*/_interopDefault(fastDeepEqual);
+var invariant__default = /*#__PURE__*/_interopDefault(invariant);
 
 // src/generateClientSdkPackage.ts
 
@@ -243,6 +247,38 @@ function createModifiedEntities(addedObjects, modifiedObjects) {
   }
   return entities;
 }
+
+// src/shared/propertyJsdoc.ts
+function propertyJsdoc(property, {
+  isInherited,
+  apiName
+}) {
+  let ret = `/**
+`;
+  const renderDisplayName = property.displayName && property.displayName !== apiName;
+  if (isInherited || renderDisplayName || property.description) {
+    if (isInherited) {
+      ret += ` * (inherited from parent)
+`;
+    }
+    if (renderDisplayName) {
+      ret += ` *   display name: '${property.displayName}'${property.description ? "," : ""}
+`;
+    }
+    if (property.description) {
+      ret += ` *   description: ${property.description}
+`;
+    }
+  } else {
+    ret += ` * (no ontology metadata)
+`;
+  }
+  ret += ` */
+`;
+  return ret;
+}
+
+// src/shared/wireObjectTypeV2ToSdkObjectConst.ts
 function getObjectDefIdentifier(name, v2) {
   return v2 ? name : `${name}Def`;
 }
@@ -281,7 +317,9 @@ function wireObjectTypeV2ToSdkObjectConst(object, importExt, v2 = false) {
         }`,
       properties: (_value) => `{
           ${stringify(definition.properties, {
-        "*": (propertyDefinition) => `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`
+        "*": (propertyDefinition, _, apiName) => [`${propertyJsdoc(propertyDefinition, {
+          apiName
+        })}${apiName}`, `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`]
       })}
         }`
     })}
@@ -471,8 +509,8 @@ function camelize(name) {
   return name.replace(/-./g, (segment) => segment[1].toUpperCase());
 }
 
-// src/util/verifyOutdir.ts
-async function verifyOutdir(outDir, fs2) {
+// src/util/verifyOutDir.ts
+async function verifyOutDir(outDir, fs2) {
   try {
     const contents = await fs2.readdir(outDir);
     if (contents.length !== 0) {
@@ -570,7 +608,7 @@ function reexportConsts(typesToExport) {
           import  { ${typesToExport.map((q) => `${q} as OG_${q}`).join(", ")}} from "@osdk/legacy-client";
       
           ${typesToExport.map((q) => `
-      /** @deprecated submodule imports arent public api **/
+      /** @deprecated submodule imports aren't public api **/
               export const ${q} = OG_${q};
           `).join("\n\n")}
       `;
@@ -620,7 +658,7 @@ function reexportTypes(typesToExport, genericArgsLeft = "", genericArgsRight = c
     import type { ${typesToExport.map((q) => `${q} as OG_${q}`).join(", ")}} from "@osdk/legacy-client";
     
         ${typesToExport.map((q) => `
-      /** @deprecated submodule imports arent public api **/
+      /** @deprecated submodule imports aren't public api **/
       export type ${q}${genericArgsLeft} = OG_${q}${genericArgsRight};
     `).join("\n\n")}
     `;
@@ -930,10 +968,7 @@ async function generateOntologyRuntimeDistDir(outDir, fs2, importExt = "") {
   await generateBaseTypesDir(runtimeDistDir, fs2, importExt);
   await generateClientDir(runtimeDistDir, fs2, importExt);
   await generateFiltersDir(runtimeDistDir, fs2, importExt);
-  await fs2.writeFile(
-    path16__namespace.join(runtimeDistDir, "index.ts"),
-    // TRASHFIXME
-    await formatTs(`
+  await fs2.writeFile(path16__namespace.join(runtimeDistDir, "index.ts"), await formatTs(`
       export * from "./aggregations/index${importExt}";
       export * from "./baseTypes/index${importExt}";
       ${""}
@@ -943,8 +978,7 @@ async function generateOntologyRuntimeDistDir(outDir, fs2, importExt = "") {
     
       export * from "./ontologyProvider/index${importExt}";
       export * from "./paging/index${importExt}";
-`)
-  );
+`));
 }
 
 // src/v1.1/generateBackCompatDeprecatedExports.ts
@@ -1307,10 +1341,10 @@ function wireQueryDataTypeToQueryDataTypeDefinition(input) {
     case "union":
       const allowNulls = isNullableQueryDataType(input);
       if (allowNulls && input.unionTypes.length === 2) {
-        const nonnull = input.unionTypes.find((t) => t.type != null);
-        if (nonnull) {
+        const nonNull = input.unionTypes.find((t) => t.type != null);
+        if (nonNull) {
           return {
-            ...wireQueryDataTypeToQueryDataTypeDefinition(nonnull),
+            ...wireQueryDataTypeToQueryDataTypeDefinition(nonNull),
             nullable: true
           };
         }
@@ -1335,12 +1369,14 @@ function wireQueryDataTypeToQueryDataTypeDefinition(input) {
     case "twoDimensionalAggregation":
       return {
         type: "twoDimensionalAggregation",
-        twoDimensionalAggregation: get2DQueryAggregationProps(input)
+        twoDimensionalAggregation: get2DQueryAggregationProps(input),
+        nullable: false
       };
     case "threeDimensionalAggregation":
       return {
         type: "threeDimensionalAggregation",
-        threeDimensionalAggregation: get3DQueryAggregationProps(input)
+        threeDimensionalAggregation: get3DQueryAggregationProps(input),
+        nullable: false
       };
     case "null":
     case "unsupported":
@@ -1399,6 +1435,15 @@ function wireQueryTypeV2ToSdkQueryDefinition(input) {
     output: wireQueryDataTypeToQueryDataTypeDefinition(input.output)
   };
 }
+function wireQueryTypeV2ToSdkQueryDefinitionNoParams(input) {
+  return {
+    type: "query",
+    apiName: input.apiName,
+    description: input.description,
+    displayName: input.displayName,
+    version: input.version
+  };
+}
 function wireQueryParameterV2ToQueryParameterDefinition(parameter) {
   return {
     description: parameter.description,
@@ -1407,19 +1452,36 @@ function wireQueryParameterV2ToQueryParameterDefinition(parameter) {
 }
 
 // src/v1.1/generatePerQueryDataFiles.ts
-async function generatePerQueryDataFiles(ontology, fs2, outDir, importExt = "") {
+async function generatePerQueryDataFiles(ontology, fs2, outDir, importExt = "", v2 = false) {
   await fs2.mkdir(outDir, {
     recursive: true
   });
   await Promise.all(Object.values(ontology.queryTypes).map(async (query) => {
     const objectTypes = getObjectTypesFromQuery(query);
-    await fs2.writeFile(path16__namespace.default.join(outDir, `${query.apiName}.ts`), await formatTs(`
-        import { QueryDefinition } from "@osdk/api";
-
-        export const ${query.apiName} = ${JSON.stringify(wireQueryTypeV2ToSdkQueryDefinition(query))} satisfies QueryDefinition<"${query.apiName}", ${objectTypes.length > 0 ? objectTypes.map((apiName) => `"${apiName}"`).join("|") : "never"}>;`));
+    const importObjects = objectTypes.length > 0 ? `import {${[...objectTypes].join(",")}} from "../objects${importExt}";` : "";
+    if (v2) {
+      await fs2.writeFile(path16__namespace.default.join(outDir, `${query.apiName}.ts`), await formatTs(`
+          import { QueryDefinition } from "@osdk/api";
+          ${importObjects}
+          export const ${query.apiName} = {
+            ${stringify(deleteUndefineds(wireQueryTypeV2ToSdkQueryDefinitionNoParams(query)))},
+              parameters: {${Object.entries(query.parameters).map(([name, parameter]) => {
+        return `${name} : {${stringify(deleteUndefineds(wireQueryParameterV2ToQueryParameterDefinition(parameter)))},
+            ${parameter.dataType.type === "object" || parameter.dataType.type === "objectSet" ? getOsdkTargetTypeIfPresent(parameter.dataType.objectTypeApiName, v2) : ``}}`;
+      })}},
+              output: {${stringify(deleteUndefineds(wireQueryDataTypeToQueryDataTypeDefinition(query.output)))},
+            ${query.output.type === "object" || query.output.type === "objectSet" ? getOsdkTargetTypeIfPresent(query.output.objectTypeApiName, v2) : ``}}
+          } ${getQueryDefSatisfies(query.apiName, objectTypes)}`));
+    } else {
+      await fs2.writeFile(path16__namespace.default.join(outDir, `${query.apiName}.ts`), await formatTs(`
+            import { QueryDefinition } from "@osdk/api";
+    
+            export const ${query.apiName} = ${JSON.stringify(wireQueryTypeV2ToSdkQueryDefinition(query))} ${getQueryDefSatisfies(query.apiName, objectTypes)}`));
+    }
   }));
   await fs2.writeFile(path16__namespace.default.join(outDir, "index.ts"), await formatTs(`
   ${Object.values(ontology.queryTypes).map((query) => `export * from "./${query.apiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.queryTypes).length === 0 ? "export {};" : ""}
   `));
 }
 function getObjectTypesFromQuery(query) {
@@ -1472,6 +1534,14 @@ function getObjectTypesFromDataType(dataType, types) {
       throw new Error(`Cannot find object types from unsupported QueryDataType ${dataType.type}`);
   }
 }
+function getQueryDefSatisfies(apiName, objectTypes) {
+  return `satisfies QueryDefinition<"${apiName}", ${objectTypes.length > 0 ? objectTypes.map((apiNameObj) => `"${apiNameObj}"`).join("|") : "never"}>;`;
+}
+function getOsdkTargetTypeIfPresent(objectTypeApiName, v2) {
+  return `
+      __OsdkTargetType: ${getObjectDefIdentifier(objectTypeApiName, v2)}
+    `;
+}
 async function generateQueries(ontology, fs2, outDir, importExt = "") {
   const importedObjects = /* @__PURE__ */ new Set();
   const signatures = [];
@@ -1621,7 +1691,7 @@ async function generateClientSdkVersionOneDotOne(ontology, userAgent, fs2, outDi
   const objectsDir = path16__namespace.join(outDir, "ontology", "objects");
   const actionsDir = path16__namespace.join(outDir, "ontology", "actions");
   const queriesDir = path16__namespace.join(outDir, "ontology", "queries");
-  await verifyOutdir(outDir, fs2);
+  await verifyOutDir(outDir, fs2);
   await fs2.mkdir(outDir, {
     recursive: true
   });
@@ -1641,9 +1711,37 @@ async function generateClientSdkVersionOneDotOne(ontology, userAgent, fs2, outDi
   await generateIndexFile(fs2, outDir, importExt);
   await generateBackCompatDeprecatedExports(fs2, outDir, importExt);
 }
-function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, v2 = false) {
+function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, ontology, v2 = false) {
   const definition = deleteUndefineds(generatorConverters.__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef, v2));
   const objectDefIdentifier = getObjectDefIdentifier(interfaceDef.apiName, v2);
+  const parents = definition.implements?.map((p) => {
+    !(ontology.interfaceTypes[p] != null) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Expected to find a parent interface named ${p} in the ontology and did not.`) : invariant__default.default(false) : void 0;
+    const it = deleteUndefineds(generatorConverters.__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(ontology.interfaceTypes[p], v2));
+    return it;
+  }) ?? [];
+  const mergedProperties = {
+    ...definition.properties
+  };
+  for (const parent of parents) {
+    for (const apiName of Object.keys(parent.properties)) {
+      if (definition.properties[apiName] != null) {
+        !fastDeepEqual__default.default(definition.properties[apiName], parent.properties[apiName]) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Interface ${definition.apiName} redefines property '${apiName}' from parent '${parent.apiName}' but the properties do not match`) : invariant__default.default(false) : void 0;
+      } else if (mergedProperties[apiName] != null) {
+        !fastDeepEqual__default.default(mergedProperties[apiName], parent.properties[apiName]) ? process.env.NODE_ENV !== "production" ? invariant__default.default(false, `Some interface defines a conflicting property '${apiName}' that does not match property from parent '${parent.apiName}'`) : invariant__default.default(false) : void 0;
+      }
+      mergedProperties[apiName] = parent.properties[apiName];
+    }
+  }
+  const ogProperties = definition.properties;
+  definition.properties = mergedProperties;
+  function localPropertyJsdoc(apiName) {
+    const property = definition.properties[apiName];
+    const isInherited = ogProperties[apiName] == null;
+    return propertyJsdoc(property, {
+      isInherited,
+      apiName
+    });
+  }
   function getV2Types() {
     return `
   export interface ${objectDefIdentifier} extends InterfaceDefinition<"${interfaceDef.apiName}", ${interfaceDef.apiName}>, VersionBound<$ExpectedClientVersion> {
@@ -1657,9 +1755,9 @@ function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, v2 = false
         "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
       })}
     }`,
-      properties: (_value) => `{
-      ${stringify(definition.properties, {
-        "*": (propertyDefinition) => `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`
+      properties: (properties) => `{
+      ${stringify(properties, {
+        "*": (propertyDefinition, _, key) => [`${localPropertyJsdoc(key)}${key}`, `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`]
       })}
     }`
     })}
@@ -1701,11 +1799,11 @@ async function generateOntologyMetadataFile(ontology, userAgent, fs2, outDir) {
 
 // src/v2.0/generateClientSdkVersionTwoPointZero.ts
 async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, outDir, packageType = "commonjs") {
-  await verifyOutdir(outDir, fs2);
+  await verifyOutDir(outDir, fs2);
   const sanitizedOntology = sanitizeMetadata(ontology);
   const objectNames = Object.keys(sanitizedOntology.objectTypes).sort((a, b) => a.localeCompare(b));
   const actionNames = Object.keys(sanitizedOntology.actionTypes).sort((a, b) => a.localeCompare(b));
-  Object.keys(sanitizedOntology.queryTypes).sort((a, b) => a.localeCompare(b));
+  const queryNames = Object.keys(sanitizedOntology.queryTypes).sort((a, b) => a.localeCompare(b));
   const interfaceNames = Object.keys(sanitizedOntology.interfaceTypes ?? {}).sort((a, b) => a.localeCompare(b));
   const importExt = packageType === "module" ? ".js" : "";
   await fs2.mkdir(outDir, {
@@ -1716,6 +1814,7 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, ou
         export * from "./ontology/actions/index${importExt}";
         export * from "./ontology/objects${importExt}";
         export * from "./ontology/interfaces${importExt}";
+        export * from "./ontology/queries/index${importExt}";
     `));
   await generateOntologyMetadataFile(sanitizedOntology, userAgent, fs2, outDir);
   await fs2.writeFile(path16__namespace.default.join(outDir, "Ontology.ts"), await formatTs(`
@@ -1723,6 +1822,7 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, ou
       import * as Actions from "./ontology/actions/index${importExt}";
       import * as Objects from "./ontology/objects${importExt}";
       import * as Interfaces from "./ontology/interfaces${importExt}";
+      import * as Queries from "./ontology/queries/index${importExt}";
       import { OntologyMetadata } from "./OntologyMetadata${importExt}";
       
       export interface Ontology extends OntologyDefinition<${stringUnionFrom2(objectNames)}> {
@@ -1738,7 +1838,9 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, ou
   }).join(",\n")}
         },
         queries: {
-          // TODO
+          ${queryNames.map((queryName) => {
+    return `${queryName}: typeof Queries.${queryName}`;
+  }).join(",\n")}
         },
         interfaces: {
           ${interfaceNames.map((objectName) => {
@@ -1761,7 +1863,9 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, ou
   }).join(",\n")}
         },
         queries: {
-          // TODO
+          ${queryNames.map((queryName) => {
+    return `${queryName}: Queries.${queryName}`;
+  }).join(",\n")}
         },
         interfaces: {
           ${interfaceNames.map((objectName) => {
@@ -1796,6 +1900,11 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs2, ou
     ${Object.keys(ontology.objectTypes).sort((a, b) => a.localeCompare(b)).map((apiName) => `export * from "./objects/${apiName}${importExt}";`).join("\n")}
     ${Object.keys(ontology.objectTypes).length === 0 ? "export {};" : ""}
     `));
+  const queriesDir = path16__namespace.default.join(outDir, "ontology", "queries");
+  await fs2.mkdir(queriesDir, {
+    recursive: true
+  });
+  await generatePerQueryDataFiles(sanitizedOntology, fs2, queriesDir, importExt, true);
 }
 function stringUnionFrom2(values) {
   if (values.length === 0) {
@@ -1817,7 +1926,7 @@ async function generateOntologyInterfaces(fs2, outDir, interfaceNames, ontology,
       import { $osdkMetadata, $expectedClientVersion } from "../../OntologyMetadata${importExt}";
       import type { $ExpectedClientVersion } from "../../OntologyMetadata${importExt}";
 
-      ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, true)}
+      ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, ontology, true)}
     `));
   }
   await fs2.writeFile(interfacesDir + ".ts", await formatTs(`