swallowkit 1.0.0-beta.22 → 1.0.0-beta.24

package/dist/core/scaffold/native-schema-generator.js

@@ -0,0 +1,677 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PYTHON_SCHEMA_CODEGEN_REQUIREMENT = exports.NSWAG_CONSOLECORE_VERSION = void 0;
+exports.buildCSharpCodegenToolManifestSource = buildCSharpCodegenToolManifestSource;
+exports.buildPythonCodegenRequirementsSource = buildPythonCodegenRequirementsSource;
+exports.getCSharpSchemaModelPath = getCSharpSchemaModelPath;
+exports.getCSharpSchemaOptionPath = getCSharpSchemaOptionPath;
+exports.getPythonSchemaModelPath = getPythonSchemaModelPath;
+exports.getCSharpNativeGeneratorArgs = getCSharpNativeGeneratorArgs;
+exports.getPythonNativeGeneratorArgs = getPythonNativeGeneratorArgs;
+exports.generateLanguageSchemaArtifacts = generateLanguageSchemaArtifacts;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const model_parser_1 = require("./model-parser");
+const openapi_generator_1 = require("./openapi-generator");
+const python_uv_1 = require("../../utils/python-uv");
+exports.NSWAG_CONSOLECORE_VERSION = "14.7.1";
+exports.PYTHON_SCHEMA_CODEGEN_REQUIREMENT = "datamodel-code-generator>=0.44.0,<1.0.0";
+const PYTHON_OUTPUT_MODEL_TYPE = "pydantic_v2.BaseModel";
+function getMachineAwareStdio() {
+    return process.env.SWALLOWKIT_MACHINE_OUTPUT === "1" ? "pipe" : "inherit";
+}
+function canRun(command, args, cwd, env) {
+    const result = (0, child_process_1.spawnSync)(command, args, {
+        cwd,
+        env,
+        stdio: "ignore",
+    });
+    return !result.error && result.status === 0;
+}
+async function runCommand(command, args, cwd, errorMessage, env) {
+    await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd,
+            env,
+            stdio: getMachineAwareStdio(),
+        });
+        child.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`${errorMessage} (${command} ${args.join(" ")}) exited with code ${code}`));
+        });
+        child.on("error", (error) => reject(new Error(`${errorMessage}: ${error.message}`)));
+    });
+}
+function buildCSharpCodegenToolManifestSource() {
+    return `${JSON.stringify({
+        version: 1,
+        isRoot: true,
+        tools: {
+            "nswag.consolecore": {
+                version: exports.NSWAG_CONSOLECORE_VERSION,
+                commands: ["nswag"],
+            },
+        },
+    }, null, 2)}\n`;
+}
+function buildPythonCodegenRequirementsSource() {
+    return `${exports.PYTHON_SCHEMA_CODEGEN_REQUIREMENT}\n`;
+}
+function toSnakeCase(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[-\s]+/g, "_")
+        .toLowerCase();
+}
+function toPascalIdentifier(value) {
+    if (value.includes("-") || value.includes("_")) {
+        return value
+            .split(/[-_]/)
+            .filter(Boolean)
+            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+            .join("");
+    }
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function isDateLikeField(field) {
+    return field.type === "date" || (field.type === "string" && field.name.toLowerCase().endsWith("at"));
+}
+function getCSharpSchemaModelPath(outputDir, modelName) {
+    return path.join(outputDir, "src", "SwallowKitBackendModels", "Model", `${modelName}.cs`);
+}
+function getCSharpSchemaOptionPath(outputDir) {
+    return path.join(outputDir, "src", "SwallowKitBackendModels", "Client", "Option.cs");
+}
+function getPythonSchemaModelPath(outputDir, modelName) {
+    return path.join(outputDir, "backend_models", "models", `${toSnakeCase(modelName)}.py`);
+}
+function getCSharpNativeGeneratorArgs(specPath, outputPath) {
+    return [
+        "tool",
+        "run",
+        "nswag",
+        "openapi2csclient",
+        `/input:${specPath}`,
+        `/output:${outputPath}`,
+        "/namespace:SwallowKitBackendModels",
+        "/GenerateClientClasses:false",
+        "/GenerateClientInterfaces:false",
+        "/GenerateResponseClasses:false",
+        "/GenerateExceptionClasses:false",
+        "/GenerateDtoTypes:true",
+        "/GenerateNullableReferenceTypes:true",
+        "/GenerateOptionalPropertiesAsNullable:true",
+        "/JsonLibrary:SystemTextJson",
+    ];
+}
+function getPythonNativeGeneratorArgs(specPath, outputPath) {
+    return [
+        "-m",
+        "datamodel_code_generator",
+        "--input",
+        specPath,
+        "--input-file-type",
+        "openapi",
+        "--output",
+        outputPath,
+        "--output-model-type",
+        PYTHON_OUTPUT_MODEL_TYPE,
+        "--target-python-version",
+        "3.11",
+        "--disable-timestamp",
+        "--use-union-operator",
+        "--collapse-root-models",
+    ];
+}
+function getCSharpFieldBaseType(field) {
+    if (field.isNestedSchema && field.nestedModelName) {
+        return field.nestedModelName;
+    }
+    if (field.enumValues?.length) {
+        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";
+    }
+}
+function getCSharpArrayElementType(field) {
+    if (field.isNestedSchema && field.nestedModelName) {
+        return field.nestedModelName;
+    }
+    if (field.enumValues?.length) {
+        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";
+    }
+}
+function getCSharpPropertyType(field) {
+    const baseType = getCSharpFieldBaseType(field);
+    return field.isOptional ? `${baseType}?` : baseType;
+}
+function getCSharpOptionType(field) {
+    return `Option<${getCSharpPropertyType(field)}>`;
+}
+function generateLegacyCompatibleOptionSource() {
+    return `// <auto-generated>
+// Minimal Option<T> for OpenAPI Generator model compatibility.
+// Full client supporting files are excluded to avoid Polly version conflicts.
+// </auto-generated>
+
+#nullable enable
+
+namespace SwallowKitBackendModels.Client
+{
+    /// <summary>
+    /// A wrapper for nullable/optional properties generated by OpenAPI Generator.
+    /// Tracks whether a value has been explicitly set (distinguishing null from absent).
+    /// </summary>
+    public readonly struct Option<TValue>
+    {
+        /// <summary>Whether this option has been explicitly set.</summary>
+        public bool IsSet { get; }
+
+        /// <summary>The contained value (may be default if not set).</summary>
+        public TValue Value { get; }
+
+        /// <summary>Create an Option with an explicit value.</summary>
+        public Option(TValue value)
+        {
+            IsSet = true;
+            Value = value;
+        }
+
+        /// <summary>Implicit conversion from Option to its inner value.</summary>
+        public static implicit operator TValue(Option<TValue> option) => option.Value;
+    }
+}
+`;
+}
+function buildCSharpEnumMembers(values) {
+    return values
+        .map((value, index) => `            ${toPascalIdentifier(value)} = ${index + 1}`)
+        .join(",\n\n");
+}
+function buildCSharpEnumFromStringCases(field, nullable) {
+    const enumType = `${toPascalIdentifier(field.name)}Enum`;
+    return field.enumValues
+        .map((value) => `            if (value.Equals("${value}", StringComparison.Ordinal))\n                return ${enumType}.${toPascalIdentifier(value)};`)
+        .join("\n\n") + (nullable ? `\n\n            return null;` : `\n\n            throw new NotImplementedException($"Could not convert value to type ${enumType}: '{value}'");`);
+}
+function buildCSharpEnumToJsonCases(field) {
+    const enumType = `${toPascalIdentifier(field.name)}Enum`;
+    return field.enumValues
+        .map((value) => `            if (value == ${enumType}.${toPascalIdentifier(value)})\n                return "${value}";`)
+        .join("\n\n");
+}
+function generateLegacyCompatibleCSharpModelSource(model) {
+    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}`),
+        ...optionalFields.map((field) => `${getCSharpOptionType(field)} ${field.name} = default`),
+    ].join(", ");
+    const constructorAssignments = [
+        ...requiredFields.map((field) => `            ${toPascalIdentifier(field.name)} = ${field.name};`),
+        ...optionalFields.map((field) => `            ${toPascalIdentifier(field.name)}Option = ${field.name};`),
+        "            OnCreated();",
+    ].join("\n");
+    const enumBlocks = model.fields
+        .filter((field) => field.enumValues?.length)
+        .map((field) => {
+        const enumType = `${toPascalIdentifier(field.name)}Enum`;
+        return `        /// <summary>
+        /// Defines ${toPascalIdentifier(field.name)}
+        /// </summary>
+        [JsonConverter(typeof(JsonStringEnumConverter))]
+        public enum ${enumType}
+        {
+${buildCSharpEnumMembers(field.enumValues)}
+        }
+
+        public static ${enumType} ${enumType}FromString(string value)
+        {
+${buildCSharpEnumFromStringCases(field, false)}
+        }
+
+        public static ${enumType}? ${enumType}FromStringOrDefault(string value)
+        {
+${buildCSharpEnumFromStringCases(field, true)}
+        }
+
+        public static string ${enumType}ToJsonValue(${enumType}? value)
+        {
+${buildCSharpEnumToJsonCases(field)}
+
+            throw new NotImplementedException($"Value could not be handled: '{value}'");
+        }`;
+    })
+        .join("\n\n");
+    const propertyBlocks = model.fields
+        .map((field) => {
+        const propertyName = toPascalIdentifier(field.name);
+        const propertyType = getCSharpPropertyType(field);
+        if (!field.isOptional) {
+            return `        /// <summary>
+        /// Gets or Sets ${propertyName}
+        /// </summary>
+        [JsonPropertyName("${field.name}")]
+        public ${propertyType} ${propertyName} { get; set; }`;
+        }
+        return `        /// <summary>
+        /// Used to track the state of ${propertyName}
+        /// </summary>
+        [JsonIgnore]
+        [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+        public ${getCSharpOptionType(field)} ${propertyName}Option { get; private set; }
+
+        /// <summary>
+        /// Gets or Sets ${propertyName}
+        /// </summary>
+        [JsonPropertyName("${field.name}")]
+        public ${propertyType} ${propertyName} { get { return this.${propertyName}Option; } set { this.${propertyName}Option = new(value); } }`;
+    })
+        .join("\n\n");
+    const toStringBody = model.fields
+        .map((field) => `            sb.Append("  ${toPascalIdentifier(field.name)}: ").Append(${toPascalIdentifier(field.name)}).Append("\\n");`)
+        .join("\n");
+    return `// <auto-generated>
+/*
+ * ${model.name} API
+ *
+ * Generated from SwallowKit Zod model metadata.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Generated by native SwallowKit schema compatibility layer
+ */
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Text;
+using System.Text.Json.Serialization;
+using SwallowKitBackendModels.Client;
+
+namespace SwallowKitBackendModels.Model
+{
+    /// <summary>
+    /// ${model.name}
+    /// </summary>
+    public partial class ${model.name} : IValidatableObject
+    {
+        [JsonConstructor]
+        public ${model.name}(${constructorParams})
+        {
+${constructorAssignments}
+        }
+
+        partial void OnCreated();
+${enumBlocks ? `\n\n${enumBlocks}` : ""}
+
+${propertyBlocks}
+
+        public override string ToString()
+        {
+            var sb = new StringBuilder();
+            sb.Append("class ${model.name} {\\n");
+${toStringBody}
+            sb.Append("}\\n");
+            return sb.ToString();
+        }
+
+        IEnumerable<ValidationResult> IValidatableObject.Validate(ValidationContext validationContext)
+        {
+            yield break;
+        }
+    }
+}
+`;
+}
+function getPythonTypeName(field) {
+    if (field.isNestedSchema && field.nestedModelName) {
+        return field.nestedModelName;
+    }
+    if (field.isArray) {
+        return `List[${getPythonArrayElementType(field)}]`;
+    }
+    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";
+    }
+}
+function getPythonArrayElementType(field) {
+    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";
+    }
+}
+function buildPythonFieldDeclaration(field) {
+    const pythonName = toSnakeCase(field.name);
+    const typeName = field.isOptional ? `Optional[${getPythonTypeName(field)}]` : getPythonTypeName(field);
+    const aliasSuffix = pythonName !== field.name ? `, alias="${field.name}"` : "";
+    if (field.isOptional) {
+        return `${pythonName}: ${typeName} = Field(default=None${aliasSuffix})`;
+    }
+    if (aliasSuffix) {
+        return `${pythonName}: ${typeName} = Field(${aliasSuffix.slice(2)})`;
+    }
+    return `${pythonName}: ${typeName}`;
+}
+function buildPythonEnumValidators(model) {
+    return model.fields
+        .filter((field) => field.enumValues?.length)
+        .map((field) => {
+        const pythonName = toSnakeCase(field.name);
+        const enumSet = field.enumValues.map((value) => `'${value}'`).join(", ");
+        return `    @field_validator('${pythonName}')
+    def ${pythonName}_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set([${enumSet}]):
+            raise ValueError("must be one of enum values (${field.enumValues.map((value) => `'${value}'`).join(", ")})")
+        return value`;
+    })
+        .join("\n\n");
+}
+function buildPythonModelImports(model) {
+    const nestedImports = Array.from(new Set(model.fields
+        .filter((field) => field.isNestedSchema && field.nestedModelName)
+        .map((field) => field.nestedModelName)))
+        .map((modelName) => `from .${toSnakeCase(modelName)} import ${modelName}`)
+        .join("\n");
+    return nestedImports ? `${nestedImports}\n\n` : "";
+}
+function generateLegacyCompatiblePythonModelSource(model) {
+    const fieldDeclarations = model.fields.map((field) => `    ${buildPythonFieldDeclaration(field)}`).join("\n");
+    const propertyNames = model.fields.map((field) => `"${field.name}"`).join(", ");
+    const validators = buildPythonEnumValidators(model);
+    const dictAssignments = model.fields
+        .map((field) => `            "${field.name}": obj.get("${field.name}")`)
+        .join(",\n");
+    return `# coding: utf-8
+
+"""
+    ${model.name} API
+
+    Generated from SwallowKit Zod model metadata.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by native SwallowKit schema compatibility layer
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import 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_extensions import Self
+
+${buildPythonModelImports(model)}class ${model.name}(BaseModel):
+    """
+    ${model.name}
+    """ # noqa: E501
+${fieldDeclarations}
+    __properties: ClassVar[List[str]] = [${propertyNames}]
+${validators ? `\n\n${validators}` : ""}
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ${model.name} from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias."""
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ${model.name} from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+${dictAssignments}
+        })
+        return _obj
+
+
+`;
+}
+function buildGeneratedPythonPackageInitSource(models) {
+    return models.map((model) => `from .models.${toSnakeCase(model.name)} import ${model.name}`).join("\n") + "\n";
+}
+function buildGeneratedPythonModelsInitSource(models) {
+    return models.map((model) => `from .${toSnakeCase(model.name)} import ${model.name}`).join("\n") + "\n";
+}
+function ensureCSharpCodegenProjectFiles(functionsRoot) {
+    const toolManifestPath = path.join(functionsRoot, ".config", "dotnet-tools.json");
+    fs.mkdirSync(path.dirname(toolManifestPath), { recursive: true });
+    if (!fs.existsSync(toolManifestPath)) {
+        fs.writeFileSync(toolManifestPath, buildCSharpCodegenToolManifestSource(), "utf-8");
+    }
+}
+function ensurePythonCodegenProjectFiles(functionsRoot) {
+    const requirementsPath = path.join(functionsRoot, "requirements.codegen.txt");
+    if (!fs.existsSync(requirementsPath)) {
+        fs.writeFileSync(requirementsPath, buildPythonCodegenRequirementsSource(), "utf-8");
+    }
+    return requirementsPath;
+}
+function getVirtualEnvPythonPath(venvDir) {
+    return process.platform === "win32"
+        ? path.join(venvDir, "Scripts", "python.exe")
+        : path.join(venvDir, "bin", "python");
+}
+async function ensureProjectLocalUvCommand(projectRoot) {
+    const uvEnv = (0, python_uv_1.buildProjectLocalUvEnv)(process.env, projectRoot);
+    const { localUvExecutable } = (0, python_uv_1.getProjectLocalUvPaths)(projectRoot);
+    if (canRun("uv", ["--version"], projectRoot)) {
+        return { command: "uv", env: uvEnv };
+    }
+    if (fs.existsSync(localUvExecutable) && canRun(localUvExecutable, ["--version"], projectRoot)) {
+        return { command: localUvExecutable, env: uvEnv };
+    }
+    const installer = (0, python_uv_1.getProjectLocalUvInstallerCommand)();
+    await runCommand(installer.command, installer.args, projectRoot, "Failed to install project-local uv.", (0, python_uv_1.buildProjectLocalUvInstallerEnv)(process.env, projectRoot));
+    if (!(fs.existsSync(localUvExecutable) && canRun(localUvExecutable, ["--version"], projectRoot))) {
+        throw new Error("Failed to install project-local uv.");
+    }
+    return { command: localUvExecutable, env: uvEnv };
+}
+async function ensurePythonCodegenEnvironment(functionsRoot) {
+    const requirementsPath = ensurePythonCodegenProjectFiles(functionsRoot);
+    const projectRoot = (0, python_uv_1.getPythonProjectRoot)(functionsRoot);
+    const { command: uvCommand, env: uvEnv } = await ensureProjectLocalUvCommand(projectRoot);
+    const venvDir = path.join(functionsRoot, ".codegen-venv");
+    const venvPython = getVirtualEnvPythonPath(venvDir);
+    if (!canRun(venvPython, ["--version"], functionsRoot, uvEnv)) {
+        const venvArgs = (0, python_uv_1.buildUvVenvArgs)(venvDir);
+        if (fs.existsSync(venvDir)) {
+            venvArgs.push("--clear");
+        }
+        await runCommand(uvCommand, venvArgs, functionsRoot, "Failed to create the Python schema code generation virtual environment.", uvEnv);
+    }
+    if (!canRun(venvPython, ["-c", "import datamodel_code_generator"], functionsRoot, uvEnv)) {
+        await runCommand(uvCommand, (0, python_uv_1.buildUvPipInstallArgs)(venvPython, requirementsPath), functionsRoot, "Failed to install Python schema generation dependencies.", uvEnv);
+    }
+    return venvPython;
+}
+async function generateCSharpSchemaArtifacts(models, specPath, outputDir, functionsRoot) {
+    ensureCSharpCodegenProjectFiles(functionsRoot);
+    if (!canRun("dotnet", ["--version"], functionsRoot)) {
+        throw new Error("The .NET SDK is required to generate C# backend schema assets.\n" +
+            "Install the .NET 8 SDK and retry.");
+    }
+    const tempContractsPath = path.join(outputDir, ".native-temp", "Contracts.cs");
+    fs.mkdirSync(path.dirname(tempContractsPath), { recursive: true });
+    await runCommand("dotnet", ["tool", "restore"], functionsRoot, "Failed to restore the NSwag dotnet tool.");
+    await runCommand("dotnet", getCSharpNativeGeneratorArgs(specPath, tempContractsPath), functionsRoot, "NSwag failed to generate C# backend schema assets.");
+    fs.rmSync(path.dirname(tempContractsPath), { recursive: true, force: true });
+    const optionPath = getCSharpSchemaOptionPath(outputDir);
+    fs.mkdirSync(path.dirname(optionPath), { recursive: true });
+    fs.writeFileSync(optionPath, generateLegacyCompatibleOptionSource(), "utf-8");
+    for (const model of models) {
+        const modelPath = getCSharpSchemaModelPath(outputDir, model.name);
+        fs.mkdirSync(path.dirname(modelPath), { recursive: true });
+        fs.writeFileSync(modelPath, generateLegacyCompatibleCSharpModelSource(model), "utf-8");
+    }
+}
+async function generatePythonSchemaArtifacts(models, specPath, outputDir, functionsRoot) {
+    const pythonExecutable = await ensurePythonCodegenEnvironment(functionsRoot);
+    const tempModelsPath = path.join(outputDir, ".native-temp", "models.py");
+    fs.mkdirSync(path.dirname(tempModelsPath), { recursive: true });
+    await runCommand(pythonExecutable, getPythonNativeGeneratorArgs(specPath, tempModelsPath), functionsRoot, "datamodel-code-generator failed to generate Python backend schema assets.");
+    fs.rmSync(path.dirname(tempModelsPath), { recursive: true, force: true });
+    const packageRoot = path.join(outputDir, "backend_models");
+    const modelsRoot = path.join(packageRoot, "models");
+    fs.mkdirSync(modelsRoot, { recursive: true });
+    fs.writeFileSync(path.join(packageRoot, "__init__.py"), buildGeneratedPythonPackageInitSource(models), "utf-8");
+    fs.writeFileSync(path.join(modelsRoot, "__init__.py"), buildGeneratedPythonModelsInitSource(models), "utf-8");
+    for (const model of models) {
+        const modelPath = getPythonSchemaModelPath(outputDir, model.name);
+        fs.mkdirSync(path.dirname(modelPath), { recursive: true });
+        fs.writeFileSync(modelPath, generateLegacyCompatiblePythonModelSource(model), "utf-8");
+    }
+}
+async function generateLanguageSchemaArtifacts(models, rootModel, functionsDir, backendLanguage) {
+    console.log("\n🧬 Generating OpenAPI export and native schema assets...");
+    const projectRoot = process.cwd();
+    const functionsRoot = path.join(projectRoot, functionsDir);
+    const openApiDir = path.join(functionsRoot, "openapi");
+    fs.mkdirSync(openApiDir, { recursive: true });
+    const specPath = path.join(openApiDir, `${(0, model_parser_1.toKebabCase)(rootModel.name)}.openapi.json`);
+    fs.writeFileSync(specPath, (0, openapi_generator_1.generateOpenApiDocument)(models, rootModel), "utf-8");
+    console.log(`✅ Created: ${specPath}`);
+    const outputDir = path.join(functionsRoot, "generated", backendLanguage === "csharp" ? "csharp-models" : "python-models");
+    fs.rmSync(outputDir, { recursive: true, force: true });
+    fs.mkdirSync(outputDir, { recursive: true });
+    if (backendLanguage === "csharp") {
+        await generateCSharpSchemaArtifacts(models, specPath, outputDir, functionsRoot);
+    }
+    else {
+        await generatePythonSchemaArtifacts(models, specPath, outputDir, functionsRoot);
+    }
+    console.log(`✅ Generated ${backendLanguage} schema assets: ${outputDir}`);
+}
+//# sourceMappingURL=native-schema-generator.js.map