@fern-api/fern-api-dev 5.121.1 → 5.121.2

package/cli.cjs

@@ -158473,7 +158473,7 @@ var init_ExampleTypeFactory = __esm({
         let requiredProperties = {};
         for (const property24 of object23.properties) {
           const resolvedSchema = this.getResolvedSchema(property24.schema);
-          if (resolvedSchema.type !== "optional" && resolvedSchema.type !== "nullable") {
+          if (resolvedSchema.type !== "optional") {
             requiredProperties[property24.key] = property24.schema;
           }
         }
@@ -268220,256 +268220,6 @@ var init_isTypeReferenceOptional = __esm({
   }
 });
 
-// ../../commons/ir-utils/lib/examples/v1/generateContainerExample.js
-function generateContainerExample({ fieldName, containerType, maxDepth, currentDepth, typeDeclarations, skipOptionalProperties, visitedTypes }) {
-  if (currentDepth >= maxDepth) {
-    return generateEmptyContainerExample({ containerType });
-  }
-  switch (containerType.type) {
-    case "list": {
-      const example = generateTypeReferenceExample({
-        fieldName,
-        typeReference: containerType.list,
-        maxDepth,
-        currentDepth: currentDepth + 1,
-        typeDeclarations,
-        skipOptionalProperties,
-        visitedTypes
-      });
-      if (example.type === "failure") {
-        return generateEmptyContainerExample({ containerType });
-      }
-      return {
-        type: "success",
-        example: ExampleContainer.list({
-          list: [example.example, example.example],
-          itemType: containerType.list
-        }),
-        jsonExample: [example.jsonExample, example.jsonExample]
-      };
-    }
-    case "literal": {
-      return {
-        type: "success",
-        example: ExampleContainer.literal({
-          literal: containerType.literal._visit({
-            boolean: (value2) => ExamplePrimitive.boolean(value2),
-            string: (value2) => ExamplePrimitive.string({ original: value2 }),
-            _other: () => {
-              throw new Error("Encountered unknown literal type");
-            }
-          })
-        }),
-        jsonExample: containerType.literal._visit({
-          boolean: (value2) => value2,
-          string: (value2) => value2,
-          _other: () => {
-            throw new Error("Encountered unknown literal type");
-          }
-        })
-      };
-    }
-    case "optional": {
-      if (skipOptionalProperties) {
-        return generateEmptyContainerExample({ containerType });
-      }
-      const example = generateTypeReferenceExample({
-        fieldName,
-        typeReference: containerType.optional,
-        maxDepth,
-        currentDepth: currentDepth + 1,
-        typeDeclarations,
-        skipOptionalProperties,
-        visitedTypes
-      });
-      if (example.type === "failure") {
-        return generateEmptyContainerExample({ containerType });
-      }
-      return {
-        type: "success",
-        example: ExampleContainer.optional({
-          optional: example.example,
-          valueType: containerType.optional
-        }),
-        jsonExample: example.jsonExample
-      };
-    }
-    case "nullable": {
-      if (skipOptionalProperties) {
-        return generateEmptyContainerExample({ containerType });
-      }
-      const example = generateTypeReferenceExample({
-        fieldName,
-        typeReference: containerType.nullable,
-        maxDepth,
-        currentDepth: currentDepth + 1,
-        typeDeclarations,
-        skipOptionalProperties,
-        visitedTypes
-      });
-      if (example.type === "failure") {
-        return generateEmptyContainerExample({ containerType });
-      }
-      return {
-        type: "success",
-        example: ExampleContainer.nullable({
-          nullable: example.example,
-          valueType: containerType.nullable
-        }),
-        jsonExample: example.jsonExample
-      };
-    }
-    case "set": {
-      const example = generateTypeReferenceExample({
-        fieldName,
-        typeReference: containerType.set,
-        maxDepth,
-        currentDepth: currentDepth + 1,
-        typeDeclarations,
-        skipOptionalProperties,
-        visitedTypes
-      });
-      if (example.type === "failure") {
-        return generateEmptyContainerExample({ containerType });
-      }
-      return {
-        type: "success",
-        example: ExampleContainer.set({
-          set: [example.example],
-          itemType: containerType.set
-        }),
-        jsonExample: [example.jsonExample]
-      };
-    }
-    case "map": {
-      const keyExample = generateTypeReferenceExample({
-        fieldName,
-        typeReference: containerType.keyType,
-        maxDepth,
-        currentDepth: currentDepth + 1,
-        typeDeclarations,
-        skipOptionalProperties,
-        visitedTypes
-      });
-      const valueExample = generateTypeReferenceExample({
-        fieldName,
-        typeReference: containerType.valueType,
-        maxDepth,
-        currentDepth: currentDepth + 1,
-        typeDeclarations,
-        skipOptionalProperties,
-        visitedTypes
-      });
-      if (keyExample.type === "failure" || valueExample.type === "failure") {
-        return generateEmptyContainerExample({ containerType });
-      }
-      return {
-        type: "success",
-        example: ExampleContainer.map({
-          map: [
-            {
-              key: keyExample.example,
-              value: valueExample.example
-            }
-          ],
-          keyType: containerType.keyType,
-          valueType: containerType.valueType
-        }),
-        // biome-ignore lint/suspicious/noExplicitAny: allow explicit any
-        jsonExample: { [keyExample.jsonExample]: valueExample.jsonExample }
-      };
-    }
-    default:
-      assertNever(containerType);
-  }
-}
-function generateEmptyContainerExample({ containerType }) {
-  switch (containerType.type) {
-    case "list": {
-      return {
-        type: "success",
-        example: ExampleContainer.list({
-          list: [],
-          itemType: containerType.list
-        }),
-        jsonExample: []
-      };
-    }
-    case "literal": {
-      return {
-        type: "success",
-        example: ExampleContainer.literal({
-          literal: containerType.literal._visit({
-            boolean: (value2) => ExamplePrimitive.boolean(value2),
-            string: (value2) => ExamplePrimitive.string({ original: value2 }),
-            _other: () => {
-              throw new Error("Encountered unknown literal type");
-            }
-          })
-        }),
-        jsonExample: containerType.literal._visit({
-          boolean: (value2) => value2,
-          string: (value2) => value2,
-          _other: () => {
-            throw new Error("Encountered unknown literal type");
-          }
-        })
-      };
-    }
-    case "optional": {
-      return {
-        type: "success",
-        example: ExampleContainer.optional({
-          optional: void 0,
-          valueType: containerType.optional
-        }),
-        jsonExample: void 0
-      };
-    }
-    case "nullable": {
-      return {
-        type: "success",
-        example: ExampleContainer.nullable({
-          nullable: void 0,
-          valueType: containerType.nullable
-        }),
-        jsonExample: void 0
-      };
-    }
-    case "set": {
-      return {
-        type: "success",
-        example: ExampleContainer.set({
-          set: [],
-          itemType: containerType.set
-        }),
-        jsonExample: []
-      };
-    }
-    case "map": {
-      return {
-        type: "success",
-        example: ExampleContainer.map({
-          map: [],
-          keyType: containerType.keyType,
-          valueType: containerType.valueType
-        }),
-        jsonExample: {}
-      };
-    }
-    default:
-      assertNever(containerType);
-  }
-}
-var init_generateContainerExample = __esm({
-  "../../commons/ir-utils/lib/examples/v1/generateContainerExample.js"() {
-    "use strict";
-    init_lib4();
-    init_lib9();
-    init_generateTypeReferenceExample();
-  }
-});
-
 // ../../commons/ir-utils/lib/examples/v1/generatePrimitiveExample.js
 function generatePrimitiveExample({ fieldName, primitiveType: primitiveType2 }) {
   switch (primitiveType2.v1) {
@@ -269386,6 +269136,263 @@ var init_generateTypeReferenceExample = __esm({
   }
 });
 
+// ../../commons/ir-utils/lib/examples/v1/generateContainerExample.js
+function generateContainerExample({ fieldName, containerType, maxDepth, currentDepth, typeDeclarations, skipOptionalProperties, visitedTypes }) {
+  if (currentDepth >= maxDepth) {
+    return generateEmptyContainerExample({ containerType });
+  }
+  switch (containerType.type) {
+    case "list": {
+      const example = generateTypeReferenceExample({
+        fieldName,
+        typeReference: containerType.list,
+        maxDepth,
+        currentDepth: currentDepth + 1,
+        typeDeclarations,
+        skipOptionalProperties,
+        visitedTypes
+      });
+      if (example.type === "failure") {
+        return generateEmptyContainerExample({ containerType });
+      }
+      return {
+        type: "success",
+        example: ExampleContainer.list({
+          list: [example.example, example.example],
+          itemType: containerType.list
+        }),
+        jsonExample: [example.jsonExample, example.jsonExample]
+      };
+    }
+    case "literal": {
+      return {
+        type: "success",
+        example: ExampleContainer.literal({
+          literal: containerType.literal._visit({
+            boolean: (value2) => ExamplePrimitive.boolean(value2),
+            string: (value2) => ExamplePrimitive.string({ original: value2 }),
+            _other: () => {
+              throw new Error("Encountered unknown literal type");
+            }
+          })
+        }),
+        jsonExample: containerType.literal._visit({
+          boolean: (value2) => value2,
+          string: (value2) => value2,
+          _other: () => {
+            throw new Error("Encountered unknown literal type");
+          }
+        })
+      };
+    }
+    case "optional": {
+      if (skipOptionalProperties) {
+        return generateEmptyContainerExample({ containerType });
+      }
+      const example = generateTypeReferenceExample({
+        fieldName,
+        typeReference: containerType.optional,
+        maxDepth,
+        currentDepth: currentDepth + 1,
+        typeDeclarations,
+        skipOptionalProperties,
+        visitedTypes
+      });
+      if (example.type === "failure") {
+        return generateEmptyContainerExample({ containerType });
+      }
+      return {
+        type: "success",
+        example: ExampleContainer.optional({
+          optional: example.example,
+          valueType: containerType.optional
+        }),
+        jsonExample: example.jsonExample
+      };
+    }
+    case "nullable": {
+      if (skipOptionalProperties) {
+        return {
+          type: "success",
+          example: ExampleContainer.nullable({
+            nullable: void 0,
+            valueType: containerType.nullable
+          }),
+          jsonExample: null
+        };
+      }
+      const example = generateTypeReferenceExample({
+        fieldName,
+        typeReference: containerType.nullable,
+        maxDepth,
+        currentDepth: currentDepth + 1,
+        typeDeclarations,
+        skipOptionalProperties,
+        visitedTypes
+      });
+      if (example.type === "failure") {
+        return generateEmptyContainerExample({ containerType });
+      }
+      return {
+        type: "success",
+        example: ExampleContainer.nullable({
+          nullable: example.example,
+          valueType: containerType.nullable
+        }),
+        jsonExample: example.jsonExample
+      };
+    }
+    case "set": {
+      const example = generateTypeReferenceExample({
+        fieldName,
+        typeReference: containerType.set,
+        maxDepth,
+        currentDepth: currentDepth + 1,
+        typeDeclarations,
+        skipOptionalProperties,
+        visitedTypes
+      });
+      if (example.type === "failure") {
+        return generateEmptyContainerExample({ containerType });
+      }
+      return {
+        type: "success",
+        example: ExampleContainer.set({
+          set: [example.example],
+          itemType: containerType.set
+        }),
+        jsonExample: [example.jsonExample]
+      };
+    }
+    case "map": {
+      const keyExample = generateTypeReferenceExample({
+        fieldName,
+        typeReference: containerType.keyType,
+        maxDepth,
+        currentDepth: currentDepth + 1,
+        typeDeclarations,
+        skipOptionalProperties,
+        visitedTypes
+      });
+      const valueExample = generateTypeReferenceExample({
+        fieldName,
+        typeReference: containerType.valueType,
+        maxDepth,
+        currentDepth: currentDepth + 1,
+        typeDeclarations,
+        skipOptionalProperties,
+        visitedTypes
+      });
+      if (keyExample.type === "failure" || valueExample.type === "failure") {
+        return generateEmptyContainerExample({ containerType });
+      }
+      return {
+        type: "success",
+        example: ExampleContainer.map({
+          map: [
+            {
+              key: keyExample.example,
+              value: valueExample.example
+            }
+          ],
+          keyType: containerType.keyType,
+          valueType: containerType.valueType
+        }),
+        // biome-ignore lint/suspicious/noExplicitAny: allow explicit any
+        jsonExample: { [keyExample.jsonExample]: valueExample.jsonExample }
+      };
+    }
+    default:
+      assertNever(containerType);
+  }
+}
+function generateEmptyContainerExample({ containerType }) {
+  switch (containerType.type) {
+    case "list": {
+      return {
+        type: "success",
+        example: ExampleContainer.list({
+          list: [],
+          itemType: containerType.list
+        }),
+        jsonExample: []
+      };
+    }
+    case "literal": {
+      return {
+        type: "success",
+        example: ExampleContainer.literal({
+          literal: containerType.literal._visit({
+            boolean: (value2) => ExamplePrimitive.boolean(value2),
+            string: (value2) => ExamplePrimitive.string({ original: value2 }),
+            _other: () => {
+              throw new Error("Encountered unknown literal type");
+            }
+          })
+        }),
+        jsonExample: containerType.literal._visit({
+          boolean: (value2) => value2,
+          string: (value2) => value2,
+          _other: () => {
+            throw new Error("Encountered unknown literal type");
+          }
+        })
+      };
+    }
+    case "optional": {
+      return {
+        type: "success",
+        example: ExampleContainer.optional({
+          optional: void 0,
+          valueType: containerType.optional
+        }),
+        jsonExample: void 0
+      };
+    }
+    case "nullable": {
+      return {
+        type: "success",
+        example: ExampleContainer.nullable({
+          nullable: void 0,
+          valueType: containerType.nullable
+        }),
+        jsonExample: void 0
+      };
+    }
+    case "set": {
+      return {
+        type: "success",
+        example: ExampleContainer.set({
+          set: [],
+          itemType: containerType.set
+        }),
+        jsonExample: []
+      };
+    }
+    case "map": {
+      return {
+        type: "success",
+        example: ExampleContainer.map({
+          map: [],
+          keyType: containerType.keyType,
+          valueType: containerType.valueType
+        }),
+        jsonExample: {}
+      };
+    }
+    default:
+      assertNever(containerType);
+  }
+}
+var init_generateContainerExample = __esm({
+  "../../commons/ir-utils/lib/examples/v1/generateContainerExample.js"() {
+    "use strict";
+    init_lib4();
+    init_lib9();
+    init_generateTypeReferenceExample();
+  }
+});
+
 // ../../commons/ir-utils/lib/examples/v1/generateParameterExamples.js
 function generatePathParameterExamples2(pathParameters, options2) {
   const result = [];
@@ -269619,11 +269626,22 @@ function generateEndpointExample({ ir: ir3, endpoint: endpoint3, service, typeDe
         break;
       }
       case "reference": {
+        const requestBodyType = endpoint3.requestBody.requestBodyType;
+        if (skipOptionalRequestProperties && requestBodyType.type === "container" && requestBodyType.container.type === "nullable") {
+          const { example: emptyExample } = generateEmptyContainerExample({
+            containerType: requestBodyType.container
+          });
+          result.request = ExampleRequestBody.reference({
+            jsonExample: void 0,
+            shape: ExampleTypeReferenceShape.container(emptyExample)
+          });
+          break;
+        }
         const generatedExample = generateTypeReferenceExample({
           currentDepth: 0,
           maxDepth: 10,
           typeDeclarations,
-          typeReference: endpoint3.requestBody.requestBodyType,
+          typeReference: requestBodyType,
           skipOptionalProperties: skipOptionalRequestProperties
         });
         if (generatedExample.type === "failure") {
@@ -269836,6 +269854,7 @@ var init_generateEndpointExample = __esm({
     init_hashJSON();
     init_isTypeReferenceOptional();
     init_namesUtils();
+    init_generateContainerExample();
     init_generateParameterExamples();
     init_generateTypeDeclarationExample();
     init_generateTypeReferenceExample();
@@ -706764,7 +706783,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "5.121.1",
+          version: "5.121.2",
           usingAccessToken: true,
           ...getRunIdProperties()
         }
@@ -706830,7 +706849,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "5.121.1",
+        version: "5.121.2",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -888533,7 +888552,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.121.1";
+  const version7 = "5.121.2";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -915883,7 +915902,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "5.121.1",
+        cliVersion: "5.121.2",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -967003,6 +967022,10 @@ var TypescriptCustomConfigSchema = external_exports2.strictObject({
   // Workers, Deno). Node behavior is unchanged.
   guardProcessEnvAccess: external_exports2.optional(external_exports2.boolean()),
   generateReactQueryHooks: external_exports2.optional(external_exports2.boolean()),
+  // Controls how generated WebSocket socket classes store handlers registered via `on()`.
+  // `replace` (default): a second `on()` for the same event replaces the previous handler.
+  // `accumulate`: handlers accumulate and run in registration order.
+  websocketHandlerMode: external_exports2.optional(external_exports2.enum(["replace", "accumulate"])),
   // beta (not in docs)
   includeContentHeadersOnFileDownloadResponse: external_exports2.optional(external_exports2.boolean()),
   includeUtilsOnUnionMembers: external_exports2.optional(external_exports2.boolean()),
@@ -983308,7 +983331,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.121.1"
+    cli_version: "5.121.2"
   };
 }
 function isAutomationMode() {
@@ -984140,7 +984163,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "5.121.1";
+    return "5.121.2";
   }
   getCliName() {
     if (false) {

package/package.json

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