@fern-api/fern-api-dev 4.47.0-1-g896fe739eb8 → 4.47.0-10-g2986d12db6e

package/cli.cjs

@@ -601952,7 +601952,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "4.47.0-1-g896fe739eb8",
+          version: "4.47.0-10-g2986d12db6e",
           usingAccessToken: true
         }
       });
@@ -602003,7 +602003,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "4.47.0-1-g896fe739eb8",
+        version: "4.47.0-10-g2986d12db6e",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -825858,7 +825858,7 @@ var import_path54 = __toESM(require("path"), 1);
 var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 function getCliSource() {
-  const version7 = "4.47.0-1-g896fe739eb8";
+  const version7 = "4.47.0-10-g2986d12db6e";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -836825,7 +836825,7 @@ var LegacyDocsPublisher = class {
         previewId: void 0,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "4.47.0-1-g896fe739eb8"
+        cliVersion: "4.47.0-10-g2986d12db6e"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
         return { success: false };
@@ -877838,6 +877838,8 @@ var DynamicTypeLiteralMapper5 = class {
         extendsInfo
       });
     }
+    const hasAdditionalProperties = objectType2.additionalProperties === true;
+    const useDefault = hasAdditionalProperties || this.context.canObjectTypeUseDefault(objectType2);
     const structFields = [];
     for (const property22 of objectType2.properties) {
       this.context.scopeError(property22.name.wireValue);
@@ -877865,7 +877867,11 @@ var DynamicTypeLiteralMapper5 = class {
           if (!hasValue) {
             const isOptional = this.context.isNullable(property22.typeReference);
             if (isOptional) {
-              propertyValue = rust_exports.Expression.none();
+              if (useDefault) {
+                propertyValue = void 0;
+              } else {
+                propertyValue = rust_exports.Expression.none();
+              }
             } else {
               this.context.addScopedError(`Required field '${wireValue}' is missing`, Severity.Critical);
               propertyValue = rust_exports.Expression.raw("Default::default()");
@@ -877877,15 +877883,17 @@ var DynamicTypeLiteralMapper5 = class {
             });
           }
         }
-        structFields.push({
-          name: propertyName,
-          value: propertyValue
-        });
+        if (propertyValue !== void 0) {
+          structFields.push({
+            name: propertyName,
+            value: propertyValue
+          });
+        }
       } finally {
         this.context.unscopeError();
       }
     }
-    return rust_exports.Expression.structConstruction(structName, structFields);
+    return rust_exports.Expression.structConstruction(structName, structFields, useDefault);
   }
   // Check if object extends another object (for flattening)
   getObjectExtensionInfo(objectType2) {
@@ -877924,31 +877932,40 @@ var DynamicTypeLiteralMapper5 = class {
   // Convert object that extends another object (handles flattening)
   convertExtendedObject({ objectType: objectType2, value, structName, extendsInfo }) {
     const structFields = [];
-    const baseStructFields = extendsInfo.baseObjectType.properties.map((property22) => {
+    const baseHasAdditionalProperties = extendsInfo.baseObjectType.additionalProperties === true;
+    const baseUseDefault = baseHasAdditionalProperties || this.context.canObjectTypeUseDefault(extendsInfo.baseObjectType);
+    const baseStructFields = [];
+    for (const property22 of extendsInfo.baseObjectType.properties) {
       this.context.scopeError(property22.name.wireValue);
       try {
         const propertyValue = value[property22.name.wireValue];
-        let fieldValue;
         if (propertyValue !== void 0) {
-          fieldValue = this.convert({
-            typeReference: property22.typeReference,
-            value: propertyValue
+          baseStructFields.push({
+            name: this.context.getPropertyName(property22.name.name),
+            value: this.convert({
+              typeReference: property22.typeReference,
+              value: propertyValue
+            })
           });
         } else if (property22.typeReference.type === "optional" || property22.typeReference.type === "nullable") {
-          fieldValue = rust_exports.Expression.raw("None");
+          if (!baseUseDefault) {
+            baseStructFields.push({
+              name: this.context.getPropertyName(property22.name.name),
+              value: rust_exports.Expression.raw("None")
+            });
+          }
         } else {
-          fieldValue = rust_exports.Expression.raw("Default::default()");
+          baseStructFields.push({
+            name: this.context.getPropertyName(property22.name.name),
+            value: rust_exports.Expression.raw("Default::default()")
+          });
         }
-        return {
-          name: this.context.getPropertyName(property22.name.name),
-          value: fieldValue
-        };
       } finally {
         this.context.unscopeError();
       }
-    });
+    }
     const baseStructName = this.context.getStructName(extendsInfo.baseObjectType.declaration.name);
-    const baseStruct = rust_exports.Expression.structConstruction(baseStructName, baseStructFields);
+    const baseStruct = rust_exports.Expression.structConstruction(baseStructName, baseStructFields, baseUseDefault);
     structFields.push({
       name: extendsInfo.baseFieldName,
       value: baseStruct
@@ -877972,7 +877989,9 @@ var DynamicTypeLiteralMapper5 = class {
         this.context.unscopeError();
       }
     });
-    return rust_exports.Expression.structConstruction(structName, structFields);
+    const outerHasAdditionalProperties = objectType2.additionalProperties === true;
+    const outerUseDefault = outerHasAdditionalProperties || this.context.canObjectTypeUseDefault(objectType2);
+    return rust_exports.Expression.structConstruction(structName, structFields, outerUseDefault);
   }
   // Generate the field name for the flattened base object
   getBaseFieldName(baseName) {
@@ -878053,6 +878072,10 @@ var DynamicTypeLiteralMapper5 = class {
           this.context.addScopedError("Referenced union type not found or not an object", Severity.Critical);
           return rust_exports.Expression.reference(`${unionName}::${variantName}`);
         }
+        if (referencedType.properties.length === 0) {
+          const methodName = this.context.getPropertyName(unionVariant.discriminantValue.name);
+          return rust_exports.Expression.raw(`${unionName}::${methodName}()`);
+        }
         const convertedObject = this.convertObjectType({
           objectType: referencedType,
           value: discriminatedUnionTypeInstance.value
@@ -878797,6 +878820,69 @@ var DynamicSnippetsGeneratorContext7 = class _DynamicSnippetsGeneratorContext ex
     }
     return this.allParametersAreOptional(allProperties);
   }
+  /**
+   * Check if a dynamic IR object type will have Default derived by the model generator.
+   * Mirrors the logic in StructGenerator.canDeriveDefault():
+   * - All property types must support Default
+   * - Extended types must support Default
+   */
+  canObjectTypeUseDefault(objectType2) {
+    const extendsProperty = objectType2.extends;
+    if (extendsProperty != null && extendsProperty.length > 0) {
+      for (const baseTypeId of extendsProperty) {
+        const baseType = this.ir.types[baseTypeId];
+        if (!baseType || baseType.type !== "object" || !this.canObjectTypeUseDefault(baseType)) {
+          return false;
+        }
+      }
+    }
+    return objectType2.properties.every((prop) => this.typeSupportsDefault(prop.typeReference));
+  }
+  /**
+   * Check if a type reference maps to a Rust type that implements Default.
+   * Mirrors the model generator's typeSupportsDefault logic.
+   */
+  typeSupportsDefault(typeRef, visited = /* @__PURE__ */ new Set()) {
+    switch (typeRef.type) {
+      case "primitive":
+        return true;
+      // All Rust primitives implement Default
+      case "optional":
+      case "nullable":
+        return true;
+      // Option<T> defaults to None
+      case "list":
+      case "map":
+      case "set":
+        return true;
+      // Vec, HashMap, HashSet all implement Default
+      case "unknown":
+        return true;
+      // serde_json::Value implements Default
+      case "literal":
+        return false;
+      case "named": {
+        const typeId = typeRef.value;
+        if (visited.has(typeId)) {
+          return false;
+        }
+        visited.add(typeId);
+        const namedType = this.ir.types[typeId];
+        if (!namedType) {
+          return false;
+        }
+        if (namedType.type === "object") {
+          return this.canObjectTypeUseDefault(namedType);
+        }
+        if (namedType.type === "alias") {
+          return this.typeSupportsDefault(namedType.typeReference, visited);
+        }
+        return false;
+      }
+      default:
+        return false;
+    }
+  }
 };
 
 // ../../../generators/rust/dynamic-snippets/lib/EndpointSnippetGenerator.js
@@ -879340,24 +879426,27 @@ var EndpointSnippetGenerator8 = class {
     }
     this.context.errors.unscope();
     const structName = this.getCorrectRequestStructName(endpoint3, request7);
-    const useDefault = false;
+    const useDefault = this.context.canRequestUseDefault(request7);
     this.addMissingFields({
       request: request7,
       structFields,
-      providedFieldNames
+      providedFieldNames,
+      useDefault
     });
     return this.createStructExpression(structName, structFields, useDefault);
   }
-  addMissingFields({ request: request7, structFields, providedFieldNames }) {
+  addMissingFields({ request: request7, structFields, providedFieldNames, useDefault }) {
     const allQueryParams = request7.queryParameters ?? [];
     for (const param of allQueryParams) {
       const fieldName = this.context.getPropertyName(param.name.name);
       if (!providedFieldNames.has(fieldName)) {
         if (this.context.isOptionalType(param.typeReference)) {
-          structFields.push({
-            name: fieldName,
-            value: rust_exports.Expression.raw("None")
-          });
+          if (!useDefault) {
+            structFields.push({
+              name: fieldName,
+              value: rust_exports.Expression.raw("None")
+            });
+          }
         } else {
           structFields.push({
             name: fieldName,
@@ -879371,10 +879460,12 @@ var EndpointSnippetGenerator8 = class {
         const fieldName = this.context.getPropertyName(param.name.name);
         if (!providedFieldNames.has(fieldName)) {
           if (this.context.isOptionalType(param.typeReference)) {
-            structFields.push({
-              name: fieldName,
-              value: rust_exports.Expression.raw("None")
-            });
+            if (!useDefault) {
+              structFields.push({
+                name: fieldName,
+                value: rust_exports.Expression.raw("None")
+              });
+            }
           } else {
             structFields.push({
               name: fieldName,
@@ -909849,7 +909940,7 @@ var CliContext = class {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "4.47.0-1-g896fe739eb8";
+    return "4.47.0-10-g2986d12db6e";
   }
   getCliName() {
     if (false) {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.47.0-1-g896fe739eb8",
+  "version": "4.47.0-10-g2986d12db6e",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",