@osdk/generator 1.4.0 → 1.6.0

package/build/js/index.mjs

@@ -2,6 +2,7 @@ import * as path15 from 'path';
 import path15__default, { join } from 'path';
 import { format } from 'prettier';
 import organizeImports from 'prettier-plugin-organize-imports';
+import { wireObjectTypeFullMetadataToSdkObjectTypeDefinition, wirePropertyV2ToSdkPropertyDefinition } from '@osdk/generator-converters';
 
 // src/v1.1/generateClientSdkVersionOneDotOne.ts
 
@@ -780,32 +781,12 @@ function wireActionTypeV2ToSdkActionDefinition(input) {
   };
 }
 function wireActionParameterV2ToSdkParameterDefinition(value) {
-  switch (value.dataType.type) {
-    case "string":
-    case "boolean":
-    case "object":
-    case "attachment":
-    case "date":
-    case "double":
-    case "integer":
-    case "long":
-    case "objectSet":
-    case "timestamp":
-    case "marking":
-      return {
-        multiplicity: false,
-        type: actionPropertyToSdkPropertyDefinition(value.dataType),
-        nullable: value.required ? false : true,
-        description: value.description
-      };
-    case "array":
-      return {
-        multiplicity: true,
-        type: actionPropertyToSdkPropertyDefinition(value.dataType.subType),
-        nullable: value.required ? false : true,
-        description: value.description
-      };
-  }
+  return {
+    multiplicity: value.dataType.type === "array",
+    type: actionPropertyToSdkPropertyDefinition(value.dataType.type === "array" ? value.dataType.subType : value.dataType),
+    nullable: !value.required,
+    description: value.description
+  };
 }
 function actionPropertyToSdkPropertyDefinition(parameterType) {
   switch (parameterType.type) {
@@ -860,6 +841,78 @@ function deleteUndefineds(obj) {
   return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
 }
 
+// src/util/stringify.ts
+var defaultCustomizer = (value, defaultValueFormatter, key, defaultKeyFormatter) => {
+  return [defaultKeyFormatter(key), defaultValueFormatter(value)];
+};
+function stringify(obj, customizer = {}, separator = ",\n") {
+  const defaultKeyFormatter = (key) => `${JSON.stringify(key)}`;
+  const entries = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const res = (customizer[key] ?? customizer["*"] ?? defaultCustomizer)(value, (value2) => JSON.stringify(value2, null, 2), key, defaultKeyFormatter);
+    if (res) {
+      if (typeof res === "string") {
+        entries.push(`${defaultKeyFormatter(key)}: ${res}`);
+      } else {
+        entries.push(`${res[0]}: ${res[1]}`);
+      }
+    }
+  }
+  return entries.join(separator);
+}
+
+// src/shared/wireObjectTypeV2ToSdkObjectConst.ts
+function getObjectDefIdentifier(name, v2) {
+  return v2 ? name : `${name}Def`;
+}
+function wireObjectTypeV2ToSdkObjectConst(object, importExt, v2 = false) {
+  const uniqueLinkTargetTypes = new Set(object.linkTypes.map((a) => a.objectTypeApiName));
+  const definition = deleteUndefineds(wireObjectTypeFullMetadataToSdkObjectTypeDefinition(object, v2));
+  const objectDefIdentifier = getObjectDefIdentifier(object.objectType.apiName, v2);
+  function getV1Types() {
+    return `
+      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}> {
+        ${stringify(definition, {
+      links: (_value) => `{
+          ${stringify(definition.links, {
+        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
+      })}
+        }`
+    })}
+      }
+    `;
+  }
+  function getV2Types() {
+    return `
+      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}> {
+        ${stringify(definition, {
+      type: () => void 0,
+      apiName: () => void 0,
+      links: (_value) => `{
+          ${stringify(definition.links, {
+        "*": (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"}">`
+      })}
+        }`
+    })}
+      }
+
+    `;
+  }
+  const imports = Array.from(uniqueLinkTargetTypes).filter((type) => type !== definition.apiName).map((type) => `import type { ${getObjectDefIdentifier(type, v2)} } from "./${type}${importExt}";`);
+  return `${imports.join("\n")}
+
+    ${v2 ? getV2Types() : getV1Types()}
+
+    export const ${object.objectType.apiName}: ${objectDefIdentifier} = {
+      ${stringify(definition)}
+    };`;
+}
+
 // src/util/reservedKeywords.ts
 var reservedKeywords = /* @__PURE__ */ new Set(["break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "import", "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"]);
 function isReservedKeyword(name) {
@@ -942,9 +995,6 @@ function getDescriptionIfPresent(description, includeNewline) {
 }
 
 // src/v1.1/generatePerActionDataFiles.ts
-function stringifyWithoutOuterBraces(obj) {
-  return JSON.stringify(obj, null, 2).replace(/^\{\n/, "").replace(/\n\}$/, "");
-}
 async function generatePerActionDataFiles(ontology, fs, outDir, importExt, v2) {
   await fs.mkdir(outDir, {
     recursive: true
@@ -969,23 +1019,22 @@ async function generatePerActionDataFiles(ontology, fs, outDir, importExt, v2) {
       return `// Represents the definition of the parameters for the action
         export type ${paramsDefIdentifier} = {
           ${Object.entries(parameters).map(([key, value]) => {
-        const {
-          type,
-          ...remain
-        } = value;
-        let q;
-        if (typeof type === "string") {
-          q = JSON.stringify(type);
-        } else if (type.type === "object") {
-          q = `ObjectActionDataType<"${type.object}", ${type.object}Def>`;
-        } else if (type.type === "objectSet") {
-          q = `ObjectSetActionDataType<"${type.objectSet}", ${type.objectSet}Def>`;
-        }
         return `"${key}": {
-              type: ${q};
-              ${stringifyWithoutOuterBraces(remain)}
+                ${stringify(value, {
+          description: (value2, d) => value2 ? d(value2) : void 0,
+          // trick to remove undefineds
+          type: (type) => {
+            if (typeof type === "string") {
+              return JSON.stringify(type);
+            } else if (type.type === "object") {
+              return `ObjectActionDataType<"${type.object}", ${getObjectDefIdentifier(type.object, v2)}>`;
+            } else if (type.type === "objectSet") {
+              return `ObjectSetActionDataType<"${type.objectSet}", ${getObjectDefIdentifier(type.objectSet, v2)}>`;
             }
-            `;
+            return void 0;
+          }
+        })}
+            }`;
       }).join(";\n")}
         }`;
     }
@@ -1023,8 +1072,8 @@ async function generatePerActionDataFiles(ontology, fs, outDir, importExt, v2) {
     const referencedObjectDefs = /* @__PURE__ */ new Set();
     for (const p of Object.values(action.parameters)) {
       if (p.dataType.type === "object" || p.dataType.type === "objectSet") {
-        referencedObjectDefs.add(p.dataType.objectApiName + "Def");
-        referencedObjectDefs.add(p.dataType.objectTypeApiName + "Def");
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectApiName, v2));
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectTypeApiName, v2));
       }
     }
     const importObjects = referencedObjectDefs.size > 0 ? `import type {${[...referencedObjectDefs].join(",")}} from "../objects${importExt}";` : "";
@@ -1082,157 +1131,6 @@ function extractReferencedObjectsFromActionParameter(actionParameter) {
       return void 0;
   }
 }
-
-// src/shared/wirePropertyV2ToSdkPrimaryKeyTypeDefinition.ts
-function wirePropertyV2ToSdkPrimaryKeyTypeDefinition(input) {
-  switch (input.dataType.type) {
-    case "integer":
-    case "double":
-    case "string":
-    case "boolean":
-    case "attachment":
-    case "byte":
-    case "decimal":
-    case "float":
-    case "geopoint":
-    case "geoshape":
-    case "long":
-    case "short": {
-      return input.dataType.type;
-    }
-    case "date": {
-      return "datetime";
-    }
-    case "timestamp": {
-      return "timestamp";
-    }
-    case "timeseries":
-    case "array":
-    case "marking":
-      throw new Error(`Type not supported for primaryKey: ${input.dataType.type}`);
-    default:
-      input.dataType;
-      throw new Error(`Unknown type encountered for primaryKey: ${input.dataType}`);
-  }
-}
-
-// src/shared/wirePropertyV2ToSdkPropertyDefinition.ts
-function wirePropertyV2ToSdkPropertyDefinition(input, isNullable = true) {
-  switch (input.dataType.type) {
-    case "integer":
-    case "string":
-    case "byte":
-    case "decimal":
-    case "double":
-    case "float":
-    case "long":
-    case "short":
-    case "boolean":
-    case "date":
-    case "attachment":
-    case "geopoint":
-    case "geoshape":
-    case "timestamp":
-    case "timeseries":
-    case "marking":
-      return {
-        multiplicity: false,
-        description: input.description,
-        type: objectPropertyTypeToSdkPropertyDefinition(input.dataType),
-        nullable: isNullable
-      };
-    case "array": {
-      return {
-        multiplicity: true,
-        description: input.description,
-        type: objectPropertyTypeToSdkPropertyDefinition(input.dataType),
-        nullable: true
-      };
-    }
-    default:
-      input.dataType;
-      throw new Error(`Unexpected data type ${JSON.stringify(input.dataType)}`);
-  }
-}
-function objectPropertyTypeToSdkPropertyDefinition(propertyType) {
-  switch (propertyType.type) {
-    case "integer":
-    case "string":
-    case "byte":
-    case "decimal":
-    case "double":
-    case "float":
-    case "long":
-    case "short":
-    case "boolean":
-    case "attachment":
-    case "geopoint":
-    case "geoshape":
-    case "timestamp":
-    case "marking":
-      return propertyType.type;
-    case "date":
-      return "datetime";
-    case "array":
-      return objectPropertyTypeToSdkPropertyDefinition(propertyType.subType);
-    case "timeseries":
-      if (propertyType.itemType.type === "string") {
-        return "stringTimeseries";
-      }
-      return "numericTimeseries";
-    default:
-      throw new Error(`Unexecpected data type ${propertyType}`);
-  }
-}
-
-// src/shared/wireObjectTypeV2ToSdkObjectDefinition.ts
-function wireObjectTypeV2ToSdkObjectDefinition(objectTypeWithLink, v2) {
-  if (objectTypeWithLink.objectType.properties[objectTypeWithLink.objectType.primaryKey] === void 0) {
-    throw new Error(`Primary key ${objectTypeWithLink.objectType.primaryKey} not found in ${objectTypeWithLink.objectType.apiName}`);
-  }
-  return {
-    type: "object",
-    apiName: objectTypeWithLink.objectType.apiName,
-    description: objectTypeWithLink.objectType.description,
-    primaryKeyType: wirePropertyV2ToSdkPrimaryKeyTypeDefinition(objectTypeWithLink.objectType.properties[objectTypeWithLink.objectType.primaryKey]),
-    links: Object.fromEntries(objectTypeWithLink.linkTypes.map((linkType) => {
-      return [linkType.apiName, {
-        multiplicity: linkType.cardinality === "MANY",
-        targetType: linkType.objectTypeApiName
-      }];
-    })),
-    properties: Object.fromEntries(Object.entries(objectTypeWithLink.objectType.properties).map(([key, value]) => [key, wirePropertyV2ToSdkPropertyDefinition(value, !(v2 && objectTypeWithLink.objectType.primaryKey === key))]))
-  };
-}
-
-// src/shared/wireObjectTypeV2ToSdkObjectConst.ts
-function wireObjectTypeV2ToSdkObjectConst(object, importExt, v2 = false) {
-  const uniqueLinkTargetTypes = new Set(object.linkTypes.map((a) => a.objectTypeApiName));
-  const definition = wireObjectTypeV2ToSdkObjectDefinition(object, v2);
-  const imports = Array.from(uniqueLinkTargetTypes).filter((type) => type !== definition.apiName).map((type) => `import type { ${type}Def } from "./${type}${importExt}";`);
-  return `
-  ${imports.join("\n")}
-    export interface ${object.objectType.apiName}Def extends ObjectTypeDefinition<"${object.objectType.apiName}"> {
-      type: "${definition.type}",
-      apiName: "${definition.apiName}",
-      ${definition.description != null ? `description: ${JSON.stringify(definition.description)},` : ""}
-      primaryKeyType: ${JSON.stringify(definition.primaryKeyType)},
-      links: {${Object.entries(definition.links).map(([linkApiName, definition2]) => `${linkApiName}: ObjectTypeLinkDefinition<${definition2.targetType}Def, ${definition2.multiplicity}>`).join(",\n")}
-  },
-      properties: ${JSON.stringify(definition.properties, null, 2)},
-    }
-
-    export const ${object.objectType.apiName}: ${object.objectType.apiName}Def = {
-      type: "${definition.type}",
-      apiName: "${definition.apiName}",
-      ${definition.description != null ? `description: ${JSON.stringify(definition.description)},` : ""}
-      primaryKeyType: ${JSON.stringify(definition.primaryKeyType)},
-      links: ${JSON.stringify(definition.links, null, 2)},
-      properties: ${JSON.stringify(definition.properties, null, 2)},
-    };`;
-}
-
-// src/v1.1/generatePerObjectInterfaceAndDataFiles.ts
 async function generatePerObjectInterfaceAndDataFiles(ontology, fs, outDir, importExt = "") {
   await fs.mkdir(outDir, {
     recursive: true
@@ -1240,7 +1138,7 @@ async function generatePerObjectInterfaceAndDataFiles(ontology, fs, outDir, impo
   await Promise.all(Object.values(ontology.objectTypes).map(async (object) => {
     object.linkTypes;
     await fs.writeFile(path15__default.join(outDir, `${object.objectType.apiName}.ts`), await formatTs(`
-        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition } from "@osdk/api";
+        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
         ${wireObjectTypeV2ToObjectInterfaceStringV1(object, importExt)}
 
         ${wireObjectTypeV2ToSdkObjectConst(object, importExt)}
@@ -1638,8 +1536,6 @@ async function generateClientSdkVersionOneDotOne(ontology, userAgent, fs, outDir
   await generateIndexFile(fs, outDir, importExt);
   await generateBackCompatDeprecatedExports(fs, outDir, importExt);
 }
-
-// src/shared/UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst.ts
 function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceType, v2 = false) {
   return `
     export const ${interfaceType.apiName} = ${JSON.stringify(wireInterfaceTypeV2ToSdkObjectDefinition(interfaceType), null, 2)} satisfies InterfaceDefinition<"${interfaceType.apiName}", "">;`;
@@ -1678,6 +1574,9 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs, out
   });
   fs.writeFile(path15__default.join(outDir, "index.ts"), await formatTs(`
         export { Ontology } from "./Ontology${importExt}";
+        export * from "./ontology/actions/index${importExt}";
+        export * from "./ontology/objects${importExt}";
+        export * from "./ontology/interfaces${importExt}";
     `));
   await generateOntologyMetadataFile(sanitizedOntology, userAgent, fs, outDir);
   await fs.writeFile(path15__default.join(outDir, "Ontology.ts"), await formatTs(`
@@ -1721,18 +1620,11 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs, out
   for (const name of objectNames) {
     const obj = ontology.objectTypes[name];
     await fs.writeFile(path15__default.join(outDir, "ontology", `objects`, `${name}.ts`), await formatTs(`
-    
-      import type { ObjectTypeDefinition, ObjectTypeLinkDefinition } from "@osdk/api";
-
-      ${wireObjectTypeV2ToSdkObjectConst(obj, importExt, true)}
+        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
+        import { Osdk } from "@osdk/client";
 
-      ${/* TODO: FIXME
-    //   wireObjectTypeV2ToObjectDefinitionInterfaceString(
-    //     obj,
-    //   )
-    */
-    ""}
-    `));
+        ${wireObjectTypeV2ToSdkObjectConst(obj, importExt, true)}
+      `));
   }
   await generateOntologyInterfaces(fs, outDir, interfaceNames, ontology, importExt);
   const actionsDir = path15__default.join(outDir, "ontology", "actions");
@@ -1767,6 +1659,7 @@ async function generateOntologyInterfaces(fs, outDir, interfaceNames, ontology,
   }
   await fs.writeFile(interfacesDir + ".ts", await formatTs(`
     ${Object.keys(ontology.interfaceTypes ?? {}).map((apiName) => `export * from "./interfaces/${apiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.interfaceTypes ?? {}).length === 0 ? "export {}" : ""}
     `));
 }