@fern-api/fern-api-dev 5.75.2 → 5.75.4

package/cli.cjs

@@ -344223,13 +344223,28 @@ function getLiteralValueFromSchema(schema) {
   }
   return void 0;
 }
-var LITERAL_REGEX, ExampleConverter;
+var LITERAL_REGEX, EXAMPLE_CONVERTER_SHARED_STATE, MERGE_ONLY_OBJECT_SCHEMA_FIELDS, ExampleConverter;
 var init_ExampleConverter = __esm({
   "../api-importers/v3-importer-commons/lib/converters/ExampleConverter.js"() {
     "use strict";
     init_lib4();
     init_lib29();
     LITERAL_REGEX = /^literal<\s*(?:"(.*)"|(true|false))\s*>$/;
+    EXAMPLE_CONVERTER_SHARED_STATE = /* @__PURE__ */ new WeakMap();
+    MERGE_ONLY_OBJECT_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
+      "type",
+      "properties",
+      "required",
+      "allOf",
+      "description",
+      "title",
+      "deprecated",
+      "readOnly",
+      "writeOnly",
+      "xml",
+      "externalDocs",
+      "discriminator"
+    ]);
     ExampleConverter = class _ExampleConverter extends AbstractConverter {
       MAX_DEPTH = 12;
       EXAMPLE_STRING = examples_exports.STRING;
@@ -344244,6 +344259,7 @@ var init_ExampleConverter = __esm({
       exampleGenerationStrategy;
       generateOptionalProperties;
       seenRefs;
+      sharedState;
       constructor({ breadcrumbs, context: context3, schema, example, depth = 0, exampleGenerationStrategy, generateOptionalProperties = false, seenRefs = /* @__PURE__ */ new Set() }) {
         super({ breadcrumbs, context: context3 });
         this.example = example;
@@ -344252,6 +344268,16 @@ var init_ExampleConverter = __esm({
         this.exampleGenerationStrategy = exampleGenerationStrategy;
         this.generateOptionalProperties = generateOptionalProperties;
         this.seenRefs = seenRefs;
+        const existingSharedState = EXAMPLE_CONVERTER_SHARED_STATE.get(context3);
+        if (existingSharedState != null) {
+          this.sharedState = existingSharedState;
+        } else {
+          this.sharedState = {
+            mergedAllOfProperties: /* @__PURE__ */ new WeakMap(),
+            mergeOnlyAllOfSchemas: /* @__PURE__ */ new WeakMap()
+          };
+          EXAMPLE_CONVERTER_SHARED_STATE.set(context3, this.sharedState);
+        }
       }
       convert() {
         if (this.depth > this.MAX_DEPTH) {
@@ -344720,7 +344746,8 @@ var init_ExampleConverter = __esm({
           };
         }
         const exampleObj = typeof this.example !== "object" || this.example == null ? {} : this.example;
-        const { mergedProperties, mergedRequired } = this.mergeAllOfProperties(resolvedSchema);
+        const canGenerateFromMergedAllOf = this.example === void 0 && this.canGenerateFromMergedAllOf(resolvedSchema);
+        const { mergedProperties, mergedRequired } = this.mergeAllOfProperties(resolvedSchema, /* @__PURE__ */ new Set(), 0, canGenerateFromMergedAllOf);
         const resultsByKey = Object.entries(mergedProperties).map(([key2, property24]) => {
           if (typeof property24 !== "object") {
             return {
@@ -344830,7 +344857,7 @@ var init_ExampleConverter = __esm({
             return { key: key2, result };
           }
         });
-        const allOfResults = (resolvedSchema.allOf ?? []).map((subSchema, index3) => {
+        const allOfResults = canGenerateFromMergedAllOf ? [] : (resolvedSchema.allOf ?? []).map((subSchema, index3) => {
           const resolvedSubSchema = this.context.resolveMaybeReference({
             schemaOrReference: subSchema,
             breadcrumbs: [...this.breadcrumbs, `allOf[${index3}]`],
@@ -345212,11 +345239,21 @@ var init_ExampleConverter = __esm({
        *
        * Precedence: the override's fields win; the base's fields fill in anything missing.
        */
-      mergeAllOfProperties(resolvedSchema, visited = /* @__PURE__ */ new Set(), depth = 0) {
+      mergeAllOfProperties(resolvedSchema, visited = /* @__PURE__ */ new Set(), depth = 0, useCache = false) {
+        if (useCache) {
+          const cached2 = this.sharedState.mergedAllOfProperties.get(resolvedSchema)?.get(depth);
+          if (cached2 != null) {
+            return cached2;
+          }
+        }
         const directProps = resolvedSchema.properties ?? {};
         const directRequired = resolvedSchema.required ?? [];
         if (depth > this.MAX_DEPTH || resolvedSchema.allOf == null || resolvedSchema.allOf.length === 0) {
-          return { mergedProperties: directProps, mergedRequired: directRequired };
+          const result2 = { mergedProperties: directProps, mergedRequired: directRequired };
+          if (useCache) {
+            this.cacheMergedAllOfProperties(resolvedSchema, depth, result2);
+          }
+          return result2;
         }
         const baseProps = {};
         const baseRequired = new Set(directRequired);
@@ -345238,7 +345275,7 @@ var init_ExampleConverter = __esm({
             if (refKey != null) {
               childVisited.add(refKey);
             }
-            const nested = this.mergeAllOfProperties(resolved, childVisited, depth + 1);
+            const nested = this.mergeAllOfProperties(resolved, childVisited, depth + 1, useCache);
             for (const req of nested.mergedRequired) {
               baseRequired.add(req);
             }
@@ -345292,7 +345329,58 @@ var init_ExampleConverter = __esm({
             merged[key2] = baseProp;
           }
         }
-        return { mergedProperties: merged, mergedRequired: [...baseRequired] };
+        const result = { mergedProperties: merged, mergedRequired: [...baseRequired] };
+        if (useCache) {
+          this.cacheMergedAllOfProperties(resolvedSchema, depth, result);
+        }
+        return result;
+      }
+      cacheMergedAllOfProperties(schema, depth, mergedAllOfProperties) {
+        const cachedByDepth = this.sharedState.mergedAllOfProperties.get(schema);
+        if (cachedByDepth != null) {
+          cachedByDepth.set(depth, mergedAllOfProperties);
+        } else {
+          this.sharedState.mergedAllOfProperties.set(schema, /* @__PURE__ */ new Map([[depth, mergedAllOfProperties]]));
+        }
+      }
+      canGenerateFromMergedAllOf(resolvedSchema, visiting = /* @__PURE__ */ new WeakSet()) {
+        if (resolvedSchema.allOf == null || resolvedSchema.allOf.length === 0) {
+          return false;
+        }
+        if (!this.isMergeOnlyObjectSchema(resolvedSchema)) {
+          return false;
+        }
+        const cached2 = this.sharedState.mergeOnlyAllOfSchemas.get(resolvedSchema);
+        if (cached2 != null) {
+          return cached2;
+        }
+        if (visiting.has(resolvedSchema)) {
+          return false;
+        }
+        visiting.add(resolvedSchema);
+        const canGenerateFromMergedAllOf = resolvedSchema.allOf.every((subSchema) => {
+          const resolved = this.context.resolveMaybeReference({
+            schemaOrReference: subSchema,
+            breadcrumbs: this.breadcrumbs,
+            skipErrorCollector: true
+          });
+          if (resolved == null || !this.isMergeOnlyObjectSchema(resolved)) {
+            return false;
+          }
+          return resolved.allOf == null || resolved.allOf.length === 0 ? true : this.canGenerateFromMergedAllOf(resolved, visiting);
+        });
+        visiting.delete(resolvedSchema);
+        this.sharedState.mergeOnlyAllOfSchemas.set(resolvedSchema, canGenerateFromMergedAllOf);
+        return canGenerateFromMergedAllOf;
+      }
+      isMergeOnlyObjectSchema(schema) {
+        if (schema.type != null && schema.type !== "object") {
+          return false;
+        }
+        if (schema.type == null && schema.properties == null && schema.allOf == null) {
+          return false;
+        }
+        return Object.keys(schema).every((key2) => MERGE_ONLY_OBJECT_SCHEMA_FIELDS.has(key2));
       }
       /**
        * Checks if a schema is a "constraint-only" schema that only has validation constraints
@@ -691061,7 +691149,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "5.75.2",
+          version: "5.75.4",
           usingAccessToken: true,
           ...getRunIdProperties()
         }
@@ -691127,7 +691215,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "5.75.2",
+        version: "5.75.4",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -866427,7 +866515,9 @@ var ValidMarkdownRule = {
           const message = markdownParseResult.message != null ? `Markdown failed to parse: ${markdownParseResult.message}` : "Markdown failed to parse";
           return [
             {
-              severity: "fatal",
+              // Surfaced as a warning (not an error) so re-enabling this rule does not
+              // suddenly break existing `fern check` runs on repos with latent MDX issues.
+              severity: "warning",
               message
             }
           ];
@@ -868404,6 +868494,8 @@ var allRules = [
   // Check non-component references (will skip v2 files)
   ValidLocalReferencesRule,
   // Validate that local references actually exist
+  ValidMarkdownRule,
+  // Compile each page's MDX and surface syntax errors (e.g. unclosed components)
   NavigationConflicts,
   ValidateVersionFileRule,
   ValidateProductFileRule,
@@ -872228,7 +872320,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.75.2";
+  const version7 = "5.75.4";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -904817,7 +904909,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "5.75.2",
+        cliVersion: "5.75.4",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -929150,6 +929242,9 @@ var DynamicTypeInstantiationMapper = class {
             return this.convertLiteralToOptionalPrimitive(named.typeReference.value);
           }
         }
+        if (inner2.type === "literal") {
+          return this.convertLiteralToOptionalPrimitive(inner2.value);
+        }
         return go_exports.TypeInstantiation.optional(this.convert({ typeReference: inner2, value: args.value, as: args.as }));
       }
       case "optional": {
@@ -929174,6 +929269,9 @@ var DynamicTypeInstantiationMapper = class {
             return this.convertLiteralToOptionalPrimitive(named.typeReference.value);
           }
         }
+        if (inner2.type === "literal") {
+          return this.convertLiteralToOptionalPrimitive(inner2.value);
+        }
         return go_exports.TypeInstantiation.optional(this.convert({ typeReference: inner2, value: args.value, as: args.as }));
       }
       case "primitive":
@@ -941638,6 +941736,10 @@ var EndpointSnippetGenerator5 = class {
         assertNever(named);
     }
   }
+  // Whether a type resolves to a literal, treating optional/nullable literals AS literals.
+  // Used for request-body properties and path parameters, which omit ALL literals (required
+  // and optional alike) from the generated method call because they are set internally.
+  // Contrast with resolvesToNonOptionalLiteralType below, which keeps optional literals.
   resolvesToLiteralType(typeReference2) {
     switch (typeReference2.type) {
       case "literal":
@@ -941665,6 +941767,44 @@ var EndpointSnippetGenerator5 = class {
         assertNever(typeReference2);
     }
   }
+  // Whether a type resolves to a REQUIRED literal, i.e. a literal NOT wrapped in optional/nullable.
+  // Used to filter query parameters and headers: a required literal (e.g. response_type="code") is
+  // hardcoded inside the generated method and omitted from its signature, so passing it as a keyword
+  // argument raises TypeError. An optional literal, by contrast, stays in the signature, so it must
+  // remain a valid keyword argument and is kept.
+  //
+  // This deliberately differs from resolvesToLiteralType above in the optional/nullable cases: here
+  // they return false (keep the parameter) instead of recursing. The asymmetry is intentional and is
+  // validated by the literal fixture's wire tests. Note the two cannot be collapsed into a single
+  // guard like `t.type !== "optional" && resolvesToLiteralType(t)`: a named alias whose target is
+  // optional<literal> has top-level type "named", so such a guard would misclassify it as a required
+  // literal and wrongly drop it, whereas recursing through the alias here correctly returns false.
+  resolvesToNonOptionalLiteralType(typeReference2) {
+    switch (typeReference2.type) {
+      case "literal":
+        return true;
+      case "named": {
+        const named = this.context.resolveNamedType({ typeId: typeReference2.value });
+        if (named == null) {
+          return false;
+        }
+        if (named.type === "alias") {
+          return this.resolvesToNonOptionalLiteralType(named.typeReference);
+        }
+        return false;
+      }
+      case "optional":
+      case "nullable":
+      case "list":
+      case "map":
+      case "set":
+      case "primitive":
+      case "unknown":
+        return false;
+      default:
+        assertNever(typeReference2);
+    }
+  }
   getBodyRequestArgsForBytes({ body, value: value2 }) {
     const typeInstantiation = this.getBytesBodyRequestTypeInstantiation({ value: value2 });
     if (python_exports.TypeInstantiation.isNop(typeInstantiation)) {
@@ -941778,7 +941918,7 @@ var EndpointSnippetGenerator5 = class {
       parameters: request7.queryParameters ?? [],
       values: snippet.queryParameters ?? {}
     });
-    const queryParameterFields = queryParameters.map((queryParameter) => ({
+    const queryParameterFields = queryParameters.filter((queryParameter) => !this.resolvesToNonOptionalLiteralType(queryParameter.typeReference)).map((queryParameter) => ({
       name: this.context.getPropertyName(queryParameter.name.name),
       value: this.context.dynamicTypeLiteralMapper.convert(queryParameter)
     }));
@@ -941788,7 +941928,7 @@ var EndpointSnippetGenerator5 = class {
       parameters: request7.headers ?? [],
       values: snippet.headers ?? {}
     });
-    const headerFields = headers2.map((header) => ({
+    const headerFields = headers2.filter((header) => !this.resolvesToNonOptionalLiteralType(header.typeReference)).map((header) => ({
       name: this.context.getPropertyName(header.name.name),
       value: this.context.dynamicTypeLiteralMapper.convert(header)
     }));
@@ -971604,7 +971744,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.75.2"
+    cli_version: "5.75.4"
   };
 }
 function isAutomationMode() {
@@ -972436,7 +972576,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "5.75.2";
+    return "5.75.4";
   }
   getCliName() {
     if (false) {

package/package.json

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