swallowkit 2.0.0-alpha.3 → 2.0.0-alpha.5

package/src/core/scaffold/native-schema-generator.ts

@@ -5,7 +5,7 @@ import { spawn, spawnSync } from "child_process";
 import { BackendLanguage } from "../../types";
 import { FileOperationSession } from "../operations/file-session";
 import { ModelInfo, toKebabCase } from "./model-parser";
-import { generateOpenApiDocument } from "./openapi-generator";
+import { expandInlineObjectModels, generateOpenApiDocument } from "./openapi-generator";
 import {
   buildProjectLocalUvInstallerEnv,
   buildUvPipInstallArgs,
@@ -154,8 +154,22 @@ function csharpStringLiteral(value: string): string {
   return JSON.stringify(value);
 }
 
-function isDateLikeField(field: Pick<ModelInfo["fields"][number], "name" | "type">): boolean {
-  return field.type === "date" || (field.type === "string" && field.name.toLowerCase().endsWith("at"));
+/** Date/time types are used only when the Zod schema declares them (z.iso.datetime(), z.iso.date(), z.date()). */
+function getCSharpScalarType(field: ModelInfo["fields"][number]): string {
+  switch (field.type) {
+    case "string":
+      return field.format === "date-time" ? "DateTime" : field.format === "date" ? "DateOnly" : "string";
+    case "number":
+      return field.isInteger ? "long" : "double";
+    case "boolean":
+      return "bool";
+    case "date":
+      return "DateTime";
+    case "object":
+      return "Dictionary<string, object>";
+    default:
+      return "object";
+  }
 }
 
 export function getCSharpSchemaModelPath(outputDir: string, modelName: string): string {
@@ -211,6 +225,11 @@ export function getPythonNativeGeneratorArgs(specPath: string, outputPath: strin
 }
 
 function getCSharpFieldBaseType(field: ModelInfo["fields"][number]): string {
+  // Arrays first: arrays of nested models or enums are lists of the element type.
+  if (field.isArray) {
+    return `List<${getCSharpArrayElementType(field)}>`;
+  }
+
   if (field.isNestedSchema && field.nestedModelName) {
     return field.nestedModelName;
   }
@@ -219,24 +238,7 @@ function getCSharpFieldBaseType(field: ModelInfo["fields"][number]): string {
     return `${toPascalIdentifier(field.name)}Enum`;
   }
 
-  if (field.isArray) {
-    return `List<${getCSharpArrayElementType(field)}>`;
-  }
-
-  switch (field.type) {
-    case "string":
-      return isDateLikeField(field) ? "DateTime" : "string";
-    case "number":
-      return "decimal";
-    case "boolean":
-      return "bool";
-    case "date":
-      return "DateTime";
-    case "object":
-      return "Dictionary<string, object>";
-    default:
-      return "object";
-  }
+  return getCSharpScalarType(field);
 }
 
 function getCSharpArrayElementType(field: ModelInfo["fields"][number]): string {
@@ -248,25 +250,12 @@ function getCSharpArrayElementType(field: ModelInfo["fields"][number]): string {
     return `${toPascalIdentifier(field.name)}Enum`;
   }
 
-  switch (field.type) {
-    case "string":
-      return isDateLikeField(field) ? "DateTime" : "string";
-    case "number":
-      return "decimal";
-    case "boolean":
-      return "bool";
-    case "date":
-      return "DateTime";
-    case "object":
-      return "Dictionary<string, object>";
-    default:
-      return "object";
-  }
+  return getCSharpScalarType(field);
 }
 
 function getCSharpPropertyType(field: ModelInfo["fields"][number]): string {
   const baseType = getCSharpFieldBaseType(field);
-  return field.isOptional ? `${baseType}?` : baseType;
+  return field.isOptional || field.isNullable ? `${baseType}?` : baseType;
 }
 
 function getCSharpOptionType(field: ModelInfo["fields"][number]): string {
@@ -333,12 +322,120 @@ function buildCSharpEnumToJsonCases(field: ModelInfo["fields"][number], members:
     .join("\n\n");
 }
 
+function csharpNumberLiteral(value: number): string {
+  return Number.isInteger(value) ? `${value}` : `${value}d`;
+}
+
+function csharpRegexOptions(flags: string | undefined): string {
+  const options = [
+    flags?.includes("i") ? "RegexOptions.IgnoreCase" : null,
+    flags?.includes("m") ? "RegexOptions.Multiline" : null,
+    flags?.includes("s") ? "RegexOptions.Singleline" : null,
+  ].filter(Boolean);
+  return options.length > 0 ? options.join(" | ") : "RegexOptions.None";
+}
+
+function isCSharpReferenceType(field: ModelInfo["fields"][number]): boolean {
+  if (field.isArray || field.isNestedSchema || field.type === "object") return true;
+  if (field.enumValues?.length) return false;
+  return field.type === "string" && field.format !== "date-time" && field.format !== "date";
+}
+
+/**
+ * Translate Zod constraints into IValidatableObject checks. Regexes use search semantics like
+ * Zod's RegExp.test. String formats (email/uuid/url) and value-type presence stay with Zod.
+ */
+function buildCSharpValueChecks(
+  field: ModelInfo["fields"][number],
+  accessor: string,
+  member: string,
+  optionalValue: boolean
+): string[] {
+  const constraints = field.constraints ?? {};
+  const checks: string[] = [];
+  const add = (condition: string, message: string) =>
+    checks.push(`if (${condition})\n                yield return new ValidationResult(${csharpStringLiteral(message)}, new[] { ${member} });`);
+
+  if (field.isNestedSchema && field.nestedModelName) {
+    // Pattern variables in an if condition stay in scope for the enclosing block, so keep names unique.
+    const variable = `validated${toPascalIdentifier(field.name)}${accessor === "item" ? "Item" : ""}`;
+    checks.push(`if (${accessor} is IValidatableObject ${variable})\n                foreach (var ${variable}Result in ${variable}.Validate(new ValidationContext(${accessor})))\n                    yield return new ValidationResult(${variable}Result.ErrorMessage, ${variable}Result.MemberNames.Select(name => ${member} + "." + name).ToArray());`);
+    return checks;
+  }
+  if (field.enumValues?.length) return checks;
+
+  if (field.type === "string" && field.format !== "date-time" && field.format !== "date") {
+    if (constraints.minLength !== undefined) add(`${accessor} != null && ${accessor}.Length < ${constraints.minLength}`, `${field.name} must contain at least ${constraints.minLength} character(s).`);
+    if (constraints.maxLength !== undefined) add(`${accessor} != null && ${accessor}.Length > ${constraints.maxLength}`, `${field.name} must contain at most ${constraints.maxLength} character(s).`);
+    if (constraints.pattern !== undefined) {
+      add(
+        `${accessor} != null && !Regex.IsMatch(${accessor}, ${csharpStringLiteral(constraints.pattern)}, ${csharpRegexOptions(constraints.patternFlags)})`,
+        `${field.name} must match /${constraints.pattern}/${constraints.patternFlags ?? ""}.`
+      );
+    }
+  }
+
+  if (field.type === "number") {
+    const value = optionalValue ? `${accessor}.Value` : accessor;
+    const guard = optionalValue ? `${accessor}.HasValue && ` : "";
+    if (constraints.minimum !== undefined) {
+      add(`${guard}${value} ${constraints.exclusiveMinimum ? "<=" : "<"} ${csharpNumberLiteral(constraints.minimum)}`,
+        `${field.name} must be ${constraints.exclusiveMinimum ? "greater than" : "greater than or equal to"} ${constraints.minimum}.`);
+    }
+    if (constraints.maximum !== undefined) {
+      add(`${guard}${value} ${constraints.exclusiveMaximum ? ">=" : ">"} ${csharpNumberLiteral(constraints.maximum)}`,
+        `${field.name} must be ${constraints.exclusiveMaximum ? "less than" : "less than or equal to"} ${constraints.maximum}.`);
+    }
+  }
+  return checks;
+}
+
+function buildCSharpValidationBody(model: ModelInfo): string {
+  const blocks: string[] = [];
+  for (const field of model.fields) {
+    const propertyName = toPascalIdentifier(field.name);
+    const member = csharpStringLiteral(field.name);
+    const constraints = field.constraints ?? {};
+
+    // .nullable() fields accept null in Zod, so only non-nullable required references are rejected.
+    if (!field.isOptional && !field.isNullable && isCSharpReferenceType(field)) {
+      blocks.push(`if (${propertyName} is null)\n                yield return new ValidationResult(${csharpStringLiteral(`${field.name} is required.`)}, new[] { ${member} });`);
+    }
+
+    if (field.isArray) {
+      if (constraints.minItems !== undefined) {
+        blocks.push(`if (${propertyName} != null && ${propertyName}.Count < ${constraints.minItems})\n                yield return new ValidationResult(${csharpStringLiteral(`${field.name} must contain at least ${constraints.minItems} item(s).`)}, new[] { ${member} });`);
+      }
+      if (constraints.maxItems !== undefined) {
+        blocks.push(`if (${propertyName} != null && ${propertyName}.Count > ${constraints.maxItems})\n                yield return new ValidationResult(${csharpStringLiteral(`${field.name} must contain at most ${constraints.maxItems} item(s).`)}, new[] { ${member} });`);
+      }
+      const itemChecks = buildCSharpValueChecks(
+        { ...field, isArray: false },
+        "item",
+        `${member} + "[" + index + "]"`,
+        false
+      );
+      if (itemChecks.length > 0) {
+        blocks.push(`if (${propertyName} != null)\n            {\n                for (var index = 0; index < ${propertyName}.Count; index++)\n                {\n                    var item = ${propertyName}[index];\n${itemChecks.map((check) => `                    ${check.replace(/\n {16}/g, "\n                        ").replace(/\n {20}/g, "\n                            ")}`).join("\n")}\n                }\n            }`);
+      }
+      continue;
+    }
+
+    const optionalValue = (field.isOptional || field.isNullable === true) && !isCSharpReferenceType(field);
+    blocks.push(...buildCSharpValueChecks(field, propertyName, member, optionalValue));
+  }
+
+  return blocks.length > 0
+    ? blocks.map((block) => `            ${block}`).join("\n\n")
+    : "            yield break;";
+}
+
 function generateLegacyCompatibleCSharpModelSource(model: ModelInfo): string {
   const requiredFields = model.fields.filter((field) => !field.isOptional);
   const optionalFields = model.fields.filter((field) => field.isOptional);
 
   const constructorParams = [
-    ...requiredFields.map((field) => `${getCSharpFieldBaseType(field)} ${field.name}`),
+    ...requiredFields.map((field) => `${getCSharpPropertyType(field)} ${field.name}`),
     ...optionalFields.map((field) => `${getCSharpOptionType(field)} ${field.name} = default`),
   ].join(", ");
 
@@ -356,7 +453,7 @@ function generateLegacyCompatibleCSharpModelSource(model: ModelInfo): string {
       return `        /// <summary>
         /// Defines ${toPascalIdentifier(field.name)}
         /// </summary>
-        [JsonConverter(typeof(JsonStringEnumConverter))]
+        [JsonConverter(typeof(${enumType}JsonConverter))]
         public enum ${enumType}
         {
 ${buildCSharpEnumMembers(enumMembers)}
@@ -377,6 +474,22 @@ ${buildCSharpEnumFromStringCases(field, enumMembers, true)}
 ${buildCSharpEnumToJsonCases(field, enumMembers)}
 
             throw new NotImplementedException($"Value could not be handled: '{value}'");
+        }
+
+        /// <summary>
+        /// Reads and writes ${enumType} with the exact Zod enum values.
+        /// </summary>
+        public sealed class ${enumType}JsonConverter : JsonConverter<${enumType}>
+        {
+            public override ${enumType} Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                var value = reader.GetString();
+                var parsed = value == null ? null : ${enumType}FromStringOrDefault(value);
+                return parsed ?? throw new JsonException($"Unsupported ${enumType} value: '{value}'");
+            }
+
+            public override void Write(Utf8JsonWriter writer, ${enumType} value, JsonSerializerOptions options)
+                => writer.WriteStringValue(${enumType}ToJsonValue(value));
         }`;
     })
     .join("\n\n");
@@ -404,7 +517,8 @@ ${buildCSharpEnumToJsonCases(field, enumMembers)}
         /// <summary>
         /// Gets or Sets ${propertyName}
         /// </summary>
-        [JsonPropertyName("${field.name}")]
+        [JsonPropertyName("${field.name}")]${field.isNullable ? "" : `
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]`}
         public ${propertyType} ${propertyName} { get { return this.${propertyName}Option; } set { this.${propertyName}Option = new(value); } }`;
     })
     .join("\n\n");
@@ -428,8 +542,11 @@ ${buildCSharpEnumToJsonCases(field, enumMembers)}
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using System.Linq;
 using System.Text;
+using System.Text.Json;
 using System.Text.Json.Serialization;
+using System.Text.RegularExpressions;
 using SwallowKitBackendModels.Client;
 
 namespace SwallowKitBackendModels.Model
@@ -439,12 +556,22 @@ namespace SwallowKitBackendModels.Model
     /// </summary>
     public partial class ${model.name} : IValidatableObject
     {
+        /// <summary>
+        /// Used by System.Text.Json. Optional values are marked as set only when present in the JSON.
+        /// </summary>
+#pragma warning disable CS8618
         [JsonConstructor]
+        public ${model.name}()
+        {
+            OnCreated();
+        }
+#pragma warning restore CS8618
+${constructorParams ? `
         public ${model.name}(${constructorParams})
         {
 ${constructorAssignments}
         }
-
+` : ""}
         partial void OnCreated();
 ${enumBlocks ? `\n\n${enumBlocks}` : ""}
 
@@ -461,27 +588,19 @@ ${toStringBody}
 
         IEnumerable<ValidationResult> IValidatableObject.Validate(ValidationContext validationContext)
         {
-            yield break;
+${buildCSharpValidationBody(model)}
         }
     }
 }
 `;
 }
 
-function getPythonTypeName(field: ModelInfo["fields"][number]): string {
-  if (field.isNestedSchema && field.nestedModelName) {
-    return field.nestedModelName;
-  }
-
-  if (field.isArray) {
-    return `List[${getPythonArrayElementType(field)}]`;
-  }
-
+function getPythonScalarType(field: ModelInfo["fields"][number]): string {
   switch (field.type) {
     case "string":
-      return isDateLikeField(field) ? "datetime" : "StrictStr";
+      return field.format === "date-time" ? "datetime" : field.format === "date" ? "date" : "StrictStr";
     case "number":
-      return "Union[StrictFloat, StrictInt]";
+      return field.isInteger ? "StrictInt" : "Union[StrictFloat, StrictInt]";
     case "boolean":
       return "StrictBool";
     case "date":
@@ -493,43 +612,137 @@ function getPythonTypeName(field: ModelInfo["fields"][number]): string {
   }
 }
 
+/** pydantic Field bounds for a scalar value (string length or numeric range). */
+function getPythonValueConstraintArgs(field: ModelInfo["fields"][number]): string[] {
+  const constraints = field.constraints ?? {};
+  if (field.enumValues?.length || field.isNestedSchema) return [];
+  const args: string[] = [];
+  if (field.type === "string" && field.format !== "date-time" && field.format !== "date") {
+    if (constraints.minLength !== undefined) args.push(`min_length=${constraints.minLength}`);
+    if (constraints.maxLength !== undefined) args.push(`max_length=${constraints.maxLength}`);
+  }
+  if (field.type === "number") {
+    if (constraints.minimum !== undefined) args.push(`${constraints.exclusiveMinimum ? "gt" : "ge"}=${constraints.minimum}`);
+    if (constraints.maximum !== undefined) args.push(`${constraints.exclusiveMaximum ? "lt" : "le"}=${constraints.maximum}`);
+  }
+  return args;
+}
+
 function getPythonArrayElementType(field: ModelInfo["fields"][number]): string {
   if (field.isNestedSchema && field.nestedModelName) {
     return field.nestedModelName;
   }
 
-  switch (field.type) {
-    case "string":
-      return isDateLikeField(field) ? "datetime" : "StrictStr";
-    case "number":
-      return "Union[StrictFloat, StrictInt]";
-    case "boolean":
-      return "StrictBool";
-    case "date":
-      return "datetime";
-    case "object":
-      return "Dict[str, Any]";
-    default:
-      return "Any";
+  const elementType = getPythonScalarType(field);
+  const elementArgs = getPythonValueConstraintArgs(field);
+  return elementArgs.length > 0 ? `Annotated[${elementType}, Field(${elementArgs.join(", ")})]` : elementType;
+}
+
+function getPythonTypeName(field: ModelInfo["fields"][number]): string {
+  if (field.isArray) {
+    return `List[${getPythonArrayElementType(field)}]`;
+  }
+
+  if (field.isNestedSchema && field.nestedModelName) {
+    return field.nestedModelName;
   }
+
+  return getPythonScalarType(field);
 }
 
 function buildPythonFieldDeclaration(field: ModelInfo["fields"][number]): string {
   const pythonName = toSnakeCase(field.name);
   const typeName = field.isOptional ? `Optional[${getPythonTypeName(field)}]` : getPythonTypeName(field);
-  const aliasSuffix = pythonName !== field.name ? `, alias="${field.name}"` : "";
+  const fieldArgs = [
+    ...(field.isOptional ? ["default=None"] : []),
+    ...(pythonName !== field.name ? [`alias="${field.name}"`] : []),
+    ...(field.isArray
+      ? [
+          ...(field.constraints?.minItems !== undefined ? [`min_length=${field.constraints.minItems}`] : []),
+          ...(field.constraints?.maxItems !== undefined ? [`max_length=${field.constraints.maxItems}`] : []),
+        ]
+      : getPythonValueConstraintArgs(field)),
+  ];
 
-  if (field.isOptional) {
-    return `${pythonName}: ${typeName} = Field(default=None${aliasSuffix})`;
-  }
+  return fieldArgs.length > 0
+    ? `${pythonName}: ${typeName} = Field(${fieldArgs.join(", ")})`
+    : `${pythonName}: ${typeName}`;
+}
+
+function buildPythonRegexFlags(flags: string | undefined): string {
+  const values = [
+    flags?.includes("i") ? "re.IGNORECASE" : null,
+    flags?.includes("m") ? "re.MULTILINE" : null,
+    flags?.includes("s") ? "re.DOTALL" : null,
+  ].filter(Boolean);
+  return values.length > 0 ? values.join(" | ") : "0";
+}
 
-  if (aliasSuffix) {
-    return `${pythonName}: ${typeName} = Field(${aliasSuffix.slice(2)})`;
+export type PythonRegexTranslation = { pattern: string } | { unsupported: string };
+
+/**
+ * Translates a JavaScript regex (as used by Zod) to Python `re` syntax. Constructs Python cannot
+ * express identically are reported as unsupported so the validator is skipped instead of breaking imports.
+ */
+export function toPythonRegex(pattern: string, flags = ""): PythonRegexTranslation {
+  const unsupportedFlags = [...flags].filter((flag) => !"imsgu".includes(flag));
+  if (unsupportedFlags.length > 0) return { unsupported: `flag(s) ${unsupportedFlags.join("")} have no Python equivalent` };
+  const checks: Array<[RegExp, string]> = [
+    [/\\[pP]\{/, "Unicode property escapes (\\p{...})"],
+    [/\\u\{/, "code point escapes (\\u{...})"],
+    [/\\c[A-Za-z]/, "control escapes (\\cX)"],
+    [/\(\?<[=!]/, "lookbehind (JavaScript allows variable width; Python does not)"],
+    [/\[\^?\]/, "empty character classes ([] / [^])"],
+  ];
+  for (const [construct, label] of checks) {
+    if (construct.test(pattern)) return { unsupported: label };
   }
+  return {
+    pattern: pattern
+      .replace(/\(\?<([A-Za-z_][A-Za-z0-9_]*)>/g, "(?P<$1>")
+      .replace(/\\k<([A-Za-z_][A-Za-z0-9_]*)>/g, "(?P=$1)"),
+  };
+}
+
+function pythonRegexFields(model: ModelInfo): Array<{ field: ModelInfo["fields"][number]; translation: PythonRegexTranslation }> {
+  return model.fields
+    .filter((field) => field.type === "string" && !field.enumValues?.length && field.constraints?.pattern !== undefined)
+    .map((field) => ({ field, translation: toPythonRegex(field.constraints!.pattern!, field.constraints!.patternFlags) }));
+}
 
-  return `${pythonName}: ${typeName}`;
+export function getPythonRegexWarnings(model: ModelInfo): string[] {
+  return pythonRegexFields(model)
+    .filter((entry): entry is { field: ModelInfo["fields"][number]; translation: { unsupported: string } } => "unsupported" in entry.translation)
+    .map(({ field, translation }) =>
+      `python-regex-not-enforced: ${model.name}.${field.name} uses ${translation.unsupported}; the Python model does not enforce /${field.constraints!.pattern}/. The BFF Zod schema still validates it.`);
 }
 
+/**
+ * Zod regex checks use RegExp.test (search), so validators use re.search instead of pydantic's anchored pattern.
+ * They run before type conversion so date/time strings are checked as the JSON text Zod sees; non-string
+ * values are left to the field's own type validation.
+ */
+function buildPythonPatternValidators(model: ModelInfo): string {
+  return pythonRegexFields(model)
+    .filter((entry): entry is { field: ModelInfo["fields"][number]; translation: { pattern: string } } => "pattern" in entry.translation)
+    .map(({ field, translation }) => {
+      const pythonName = toSnakeCase(field.name);
+      const pattern = JSON.stringify(translation.pattern);
+      const flags = buildPythonRegexFlags(field.constraints!.patternFlags);
+      const message = JSON.stringify(`${field.name} must match /${field.constraints!.pattern}/${field.constraints!.patternFlags ?? ""}`);
+      return `    @field_validator('${pythonName}', mode='before')
+    def ${pythonName}_validate_pattern(cls, value):
+        """Validates the Zod regex constraint"""
+        if value is None:
+            return value
+
+        for item in (value if isinstance(value, list) else [value]):
+            if isinstance(item, str) and not re.search(${pattern}, item, ${flags}):
+                raise ValueError(${message})
+        return value`;
+    })
+    .join("\n\n");
+}
 function buildPythonEnumValidators(model: ModelInfo): string {
   return model.fields
     .filter((field) => field.enumValues?.length)
@@ -566,7 +779,7 @@ function buildPythonModelImports(model: ModelInfo): string {
 function generateLegacyCompatiblePythonModelSource(model: ModelInfo): string {
   const fieldDeclarations = model.fields.map((field) => `    ${buildPythonFieldDeclaration(field)}`).join("\n");
   const propertyNames = model.fields.map((field) => `"${field.name}"`).join(", ");
-  const validators = buildPythonEnumValidators(model);
+  const validators = [buildPythonEnumValidators(model), buildPythonPatternValidators(model)].filter(Boolean).join("\n\n");
   const dictAssignments = model.fields
     .map((field) => `            "${field.name}": obj.get("${field.name}")`)
     .join(",\n");
@@ -590,9 +803,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from datetime import datetime
+from datetime import date, datetime
 from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List, Optional, Set, Union
+from typing import Annotated, Any, ClassVar, Dict, List, Optional, Set, Union
 from typing_extensions import Self
 
 ${buildPythonModelImports(model)}class ${model.name}(BaseModel):
@@ -616,7 +829,7 @@ ${validators ? `\n\n${validators}` : ""}
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        return self.model_dump_json(by_alias=True, exclude_none=True)
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
@@ -726,6 +939,21 @@ function ensurePythonCodegenProjectFiles(
   return requirementsPath;
 }
 
+/** Generated backend_models import pydantic v2 at runtime, so the deployed Functions app must install it. */
+export const PYTHON_SCHEMA_RUNTIME_REQUIREMENT = "pydantic>=2.6,<3";
+
+function ensurePythonRuntimeRequirement(functionsRoot: string, session: FileOperationSession): void {
+  const requirementsPath = path.join(functionsRoot, "requirements.txt");
+  const current = session.fileExists(requirementsPath) ? session.readFile(requirementsPath) : "";
+  const declared = current.split(/\r?\n/).some((line) => line.trim().split(/[<>=!~;[ ]/)[0].toLowerCase() === "pydantic");
+  if (declared) return;
+  const prefix = current && !current.endsWith("\n") ? `${current}\n` : current;
+  session.writeFile(requirementsPath, `${prefix}${PYTHON_SCHEMA_RUNTIME_REQUIREMENT}\n`, {
+    ownership: "extension-point",
+    generator: "native-schema",
+  });
+}
+
 async function ensureProjectLocalUvCommand(projectRoot: string): Promise<{ command: string; env: NodeJS.ProcessEnv }> {
   const uvEnv = { ...process.env };
   const { localUvExecutable } = getProjectLocalUvPaths(projectRoot);
@@ -869,6 +1097,7 @@ async function generatePythonSchemaArtifacts(
   sourceModel: string
 ): Promise<void> {
   ensurePythonCodegenProjectFiles(functionsRoot, session, sourceModel);
+  ensurePythonRuntimeRequirement(functionsRoot, session);
 
   const packageRoot = path.join(outputDir, "backend_models");
   const modelsRoot = path.join(packageRoot, "models");
@@ -886,6 +1115,10 @@ async function generatePythonSchemaArtifacts(
   );
 
   for (const model of models) {
+    for (const warning of getPythonRegexWarnings(model)) {
+      session.addWarning(warning);
+      console.warn(`⚠️  ${warning}`);
+    }
     const modelPath = getPythonSchemaModelPath(outputDir, model.name);
     session.writeFile(modelPath, generateLegacyCompatiblePythonModelSource(model), {
       ownership: "managed",
@@ -927,10 +1160,12 @@ export async function generateLanguageSchemaArtifacts(
     backendLanguage === "csharp" ? "csharp-models" : "python-models"
   );
 
+  // Inline z.object fields become named classes (e.g. ProbeItemNested) so their shape is preserved.
+  const nativeModels = expandInlineObjectModels(models);
   if (backendLanguage === "csharp") {
-    await generateCSharpSchemaArtifacts(models, outputDir, functionsRoot, session, rootModel.name);
+    await generateCSharpSchemaArtifacts(nativeModels, outputDir, functionsRoot, session, rootModel.name);
   } else {
-    await generatePythonSchemaArtifacts(models, outputDir, functionsRoot, session, rootModel.name);
+    await generatePythonSchemaArtifacts(nativeModels, outputDir, functionsRoot, session, rootModel.name);
   }
 
   console.log(

package/src/core/scaffold/openapi-generator.ts

@@ -1,4 +1,4 @@
-import { FieldInfo, ModelInfo, toCamelCase } from "./model-parser";
+import { FieldInfo, ModelInfo, toCamelCase, toPascalCase } from "./model-parser";
 
 type OpenApiSchema =
   | {
@@ -11,9 +11,59 @@ type OpenApiSchema =
       additionalProperties?: boolean;
       nullable?: boolean;
       $ref?: string;
+      minLength?: number;
+      maxLength?: number;
+      pattern?: string;
+      minimum?: number;
+      maximum?: number;
+      exclusiveMinimum?: boolean;
+      exclusiveMaximum?: boolean;
+      minItems?: number;
+      maxItems?: number;
     };
 
+/**
+ * Promote inline `z.object({...})` fields to named models (e.g. ProbeItem.nested -> ProbeItemNested)
+ * so OpenAPI components and native classes keep their shape. Expanded fields reference the new model.
+ */
+export function expandInlineObjectModels(models: ModelInfo[]): ModelInfo[] {
+  const names = new Set(models.map((model) => model.name));
+  const synthetic: ModelInfo[] = [];
+
+  const expand = (owner: ModelInfo): ModelInfo => ({
+    ...owner,
+    fields: owner.fields.map((field) => {
+      if (!field.objectFields || field.isNestedSchema) return field;
+      let name = `${owner.name}${toPascalCase(field.name)}`;
+      while (names.has(name)) name = `${name}Object`;
+      names.add(name);
+      const nested = expand({
+        ...owner,
+        name,
+        displayName: name,
+        schemaName: name,
+        fields: field.objectFields,
+        hasId: field.objectFields.some((child) => child.name === "id"),
+        hasCreatedAt: field.objectFields.some((child) => child.name === "createdAt"),
+        hasUpdatedAt: field.objectFields.some((child) => child.name === "updatedAt"),
+        nestedSchemaRefs: [],
+        partitionKey: "/id",
+        connectorConfig: undefined,
+        authPolicy: undefined,
+      });
+      synthetic.push(nested);
+      const rest = { ...field };
+      delete rest.objectFields;
+      return { ...rest, isNestedSchema: true, nestedModelName: name };
+    }),
+  });
+
+  const expanded = models.map(expand);
+  return [...expanded, ...synthetic];
+}
+
 function toScalarSchema(field: FieldInfo): OpenApiSchema {
+  const constraints = field.constraints ?? {};
   if (field.enumValues?.length) {
     return {
       type: "string",
@@ -25,7 +75,10 @@ function toScalarSchema(field: FieldInfo): OpenApiSchema {
     case "string":
       return {
         type: "string",
-        format: field.name.toLowerCase().endsWith("at") ? "date-time" : undefined,
+        ...(field.format && field.format !== "time" ? { format: field.format } : {}),
+        ...(constraints.minLength !== undefined ? { minLength: constraints.minLength } : {}),
+        ...(constraints.maxLength !== undefined ? { maxLength: constraints.maxLength } : {}),
+        ...(constraints.pattern !== undefined ? { pattern: constraints.pattern } : {}),
       };
     case "date":
       return {
@@ -34,7 +87,11 @@ function toScalarSchema(field: FieldInfo): OpenApiSchema {
       };
     case "number":
       return {
-        type: "number",
+        ...(field.isInteger ? { type: "integer", format: "int64" } : { type: "number", format: "double" }),
+        ...(constraints.minimum !== undefined ? { minimum: constraints.minimum } : {}),
+        ...(constraints.exclusiveMinimum ? { exclusiveMinimum: true } : {}),
+        ...(constraints.maximum !== undefined ? { maximum: constraints.maximum } : {}),
+        ...(constraints.exclusiveMaximum ? { exclusiveMaximum: true } : {}),
       };
     case "boolean":
       return {
@@ -59,6 +116,8 @@ function toFieldSchema(field: FieldInfo): OpenApiSchema {
     return {
       type: "array",
       items: schema,
+      ...(field.constraints?.minItems !== undefined ? { minItems: field.constraints.minItems } : {}),
+      ...(field.constraints?.maxItems !== undefined ? { maxItems: field.constraints.maxItems } : {}),
     };
   }
 
@@ -82,11 +141,10 @@ function createComponentSchema(model: ModelInfo): OpenApiSchema {
     required,
   };
 }
-
 export function generateOpenApiDocument(models: ModelInfo[], rootModel: ModelInfo): string {
   const rootModelRoute = toCamelCase(rootModel.name);
   const components = Object.fromEntries(
-    models.map((model) => [model.name, createComponentSchema(model)])
+    expandInlineObjectModels(models).map((model) => [model.name, createComponentSchema(model)])
   );
 
   const document = {