@fern-api/fern-api-dev 5.92.1 → 5.92.2

package/cli.cjs

@@ -350095,6 +350095,23 @@ var init_x_fern_discriminated = __esm({
 });
 
 // ../api-importers/v3-importer-commons/lib/converters/schema/OneOfSchemaConverter.js
+function isUnionWithoutVariants(type7) {
+  return type7.type === "union" && type7.types.length === 0;
+}
+function getLiteralDiscriminant({ schema, discriminantProperty }) {
+  const discriminantSchema = schema.properties?.[discriminantProperty];
+  if (discriminantSchema == null || "$ref" in discriminantSchema) {
+    return void 0;
+  }
+  const constValue = discriminantSchema.const;
+  if (typeof constValue === "string") {
+    return constValue;
+  }
+  if (discriminantSchema.enum?.length === 1 && typeof discriminantSchema.enum[0] === "string") {
+    return discriminantSchema.enum[0];
+  }
+  return void 0;
+}
 var OneOfSchemaConverter;
 var init_OneOfSchemaConverter = __esm({
   "../api-importers/v3-importer-commons/lib/converters/schema/OneOfSchemaConverter.js"() {
@@ -350130,7 +350147,11 @@ var init_OneOfSchemaConverter = __esm({
           return this.convertAsUndiscriminatedUnion();
         }
         if (this.schema.discriminator != null) {
-          return this.convertAsDiscriminatedUnion();
+          const discriminatedUnion2 = this.convertAsDiscriminatedUnion();
+          if (discriminatedUnion2 != null && !isUnionWithoutVariants(discriminatedUnion2.type)) {
+            return discriminatedUnion2;
+          }
+          return this.convertAsUndiscriminatedUnion() ?? discriminatedUnion2;
         }
         if (this.context.settings.inferForwardCompatible) {
           const openEndedEnum = this.convertAsOpenEndedEnum();
@@ -350217,44 +350238,80 @@ var init_OneOfSchemaConverter = __esm({
         };
       }
       /**
-       * When `discriminator.mapping` is absent, infers the mapping from the `oneOf`/`anyOf` $ref schemas.
+       * The variants of the union, from `discriminator.mapping` when it is declared and otherwise
+       * inferred from the `oneOf`/`anyOf` members.
        *
        * Per the OpenAPI 3.x spec, if no mapping is provided the discriminant values are derived from
-       * the schema names in the $ref paths. We also check the resolved schema's discriminant property
-       * for `const` or single-element `enum` values, which take precedence over the schema name.
-       */
-      inferDiscriminatorMapping(discriminantProperty) {
+       * the schema names in the $ref paths. We also check the discriminant property of each member
+       * for `const` or single-element `enum` values, which take precedence over the schema name and
+       * are the only way to name a member that is inlined rather than $ref'd.
+       *
+       * Returns no variants when a member's discriminant value cannot be determined, since a union
+       * missing that member is worse than an undiscriminated one.
+       */
+      getVariants(discriminantProperty) {
+        const mapping = this.schema.discriminator?.mapping;
+        if (mapping != null) {
+          const variants2 = [];
+          for (const [discriminant22, ref2] of Object.entries(mapping)) {
+            const typeId = this.context.getTypeIdFromSchemaReference({ $ref: ref2 });
+            if (typeId == null) {
+              continue;
+            }
+            variants2.push({
+              discriminant: discriminant22,
+              typeId,
+              ref: ref2,
+              schema: this.resolveVariantSchema({ $ref: ref2 }),
+              breadcrumbs: [...this.breadcrumbs, "discriminator", "mapping", discriminant22]
+            });
+          }
+          return variants2;
+        }
         const subSchemas = this.schema.oneOf ?? this.schema.anyOf ?? [];
-        const mapping = {};
-        for (const subSchema of subSchemas) {
+        const variants = [];
+        for (const [index3, subSchema] of subSchemas.entries()) {
+          const schema = this.resolveVariantSchema(subSchema);
+          const literalDiscriminant = schema != null ? getLiteralDiscriminant({ schema, discriminantProperty }) : void 0;
           if (!this.context.isReferenceObject(subSchema)) {
+            if (literalDiscriminant == null) {
+              return [];
+            }
+            variants.push({
+              discriminant: literalDiscriminant,
+              typeId: this.context.convertBreadcrumbsToName([`${this.id}_${index3}`]),
+              schema,
+              breadcrumbs: [...this.breadcrumbs, `oneOf[${index3}]`]
+            });
             continue;
           }
           const ref2 = subSchema.$ref;
           const schemaName = ref2.split("/").pop();
-          if (schemaName == null) {
-            continue;
+          const typeId = this.context.getTypeIdFromSchemaReference(subSchema);
+          const discriminant22 = literalDiscriminant ?? schemaName;
+          if (typeId == null || discriminant22 == null) {
+            return [];
           }
-          const resolved = this.context.resolveReference({
-            reference: subSchema,
-            breadcrumbs: this.breadcrumbs,
-            skipErrorCollector: true
+          variants.push({
+            discriminant: discriminant22,
+            typeId,
+            ref: ref2,
+            schema,
+            breadcrumbs: [...this.breadcrumbs, "discriminator", "mapping", discriminant22]
           });
-          let discriminantValue = schemaName;
-          if (resolved.resolved) {
-            const discriminantPropSchema = resolved.value.properties?.[discriminantProperty];
-            if (discriminantPropSchema != null && !this.context.isReferenceObject(discriminantPropSchema)) {
-              const constValue = discriminantPropSchema.const;
-              if (typeof constValue === "string") {
-                discriminantValue = constValue;
-              } else if (discriminantPropSchema.enum != null && discriminantPropSchema.enum.length === 1 && typeof discriminantPropSchema.enum[0] === "string") {
-                discriminantValue = discriminantPropSchema.enum[0];
-              }
-            }
-          }
-          mapping[discriminantValue] = ref2;
         }
-        return mapping;
+        return variants;
+      }
+      resolveVariantSchema(schemaOrReference) {
+        if (!this.context.isReferenceObject(schemaOrReference)) {
+          return schemaOrReference;
+        }
+        const resolved = this.context.resolveReference({
+          reference: schemaOrReference,
+          breadcrumbs: this.breadcrumbs,
+          skipErrorCollector: true
+        });
+        return resolved.resolved ? resolved.value : void 0;
       }
       convertAsDiscriminatedUnion() {
         if (this.schema.discriminator == null) {
@@ -350264,18 +350321,13 @@ var init_OneOfSchemaConverter = __esm({
         const unionTypes = [];
         let referencedTypes = /* @__PURE__ */ new Set();
         let inlinedTypes = {};
-        const effectiveMapping = this.schema.discriminator.mapping ?? this.inferDiscriminatorMapping(discriminantProperty);
-        for (const [discriminant22, reference4] of Object.entries(effectiveMapping)) {
-          const typeId = this.context.getTypeIdFromSchemaReference({ $ref: reference4 });
-          const breadcrumbs = [...this.breadcrumbs, "discriminator", "mapping", discriminant22];
-          const resolvedSchema = this.context.resolveReference({
-            reference: { $ref: reference4 },
-            breadcrumbs
-          });
-          let schemaOrReference = { $ref: reference4 };
-          if (resolvedSchema.resolved && resolvedSchema.value.properties != null && discriminantProperty in resolvedSchema.value.properties) {
-            const filteredSchema = this.filterDiscriminantFromSchema(resolvedSchema.value, discriminantProperty);
-            schemaOrReference = filteredSchema;
+        for (const { discriminant: discriminant22, typeId, ref: ref2, schema: variantSchema, breadcrumbs } of this.getVariants(discriminantProperty)) {
+          let schemaOrReference = ref2 != null ? { $ref: ref2 } : variantSchema;
+          if (variantSchema?.properties != null && discriminantProperty in variantSchema.properties) {
+            schemaOrReference = this.filterDiscriminantFromSchema(variantSchema, discriminantProperty);
+          }
+          if (schemaOrReference == null) {
+            continue;
           }
           const singleUnionTypeSchemaConverter = new SchemaOrReferenceConverter({
             context: this.context,
@@ -350298,9 +350350,9 @@ var init_OneOfSchemaConverter = __esm({
               name: discriminant22,
               wireValue: discriminant22
             });
-            const rawSchemaName = reference4.split("/").pop() ?? typeId;
-            const schemaTitle = resolvedSchema.resolved ? resolvedSchema.value.title : void 0;
-            const schemaDescription = resolvedSchema.resolved ? resolvedSchema.value.description : void 0;
+            const rawSchemaName = ref2?.split("/").pop() ?? typeId;
+            const schemaTitle = variantSchema?.title;
+            const schemaDescription = variantSchema?.description;
             const variantDisplayName = schemaTitle ?? discriminant22 ?? rawSchemaName;
             if (convertedSchema.schema?.typeDeclaration != null && schemaTitle != null) {
               convertedSchema.schema.typeDeclaration.name.displayName = schemaTitle;
@@ -702677,7 +702729,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "5.92.1",
+          version: "5.92.2",
           usingAccessToken: true,
           ...getRunIdProperties()
         }
@@ -702743,7 +702795,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "5.92.1",
+        version: "5.92.2",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -883909,7 +883961,7 @@ var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 var MAX_LOGS_DIR_SIZE_BYTES = 100 * 1024 * 1024;
 function getCliSource() {
-  const version7 = "5.92.1";
+  const version7 = "5.92.2";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -909225,7 +909277,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "5.92.1",
+        cliVersion: "5.92.2",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -976141,7 +976193,7 @@ function getAutomationContextFromEnv() {
     config_branch: process.env.FERN_CONFIG_BRANCH,
     config_pr_number: process.env.FERN_CONFIG_PR_NUMBER,
     trigger: process.env.GITHUB_EVENT_NAME,
-    cli_version: "5.92.1"
+    cli_version: "5.92.2"
   };
 }
 function isAutomationMode() {
@@ -976973,7 +977025,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "5.92.1";
+    return "5.92.2";
   }
   getCliName() {
     if (false) {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.92.1",
+  "version": "5.92.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",