@atomic-ehr/codegen 0.0.4 → 0.0.5-canary.20251226085624.be72273

package/assets/api/writer-generator/csharp/Client.cs

@@ -0,0 +1,333 @@
+using System.Net;
+using System.Text;
+using System.ComponentModel;
+using System.Net.Http.Headers;
+
+namespace CSharpSDK.Client;
+
+public enum AuthMethods
+{
+    [Description("Basic")]
+    BASIC,
+}
+
+public class AuthCredentials
+{
+    public required string Username { get; set; }
+    public required string Password { get; set; }
+}
+
+public class Auth
+{
+    public required AuthMethods Method { get; set; }
+    public required AuthCredentials Credentials { get; set; }
+}
+
+public class Client
+{
+    private HttpClient HttpClient;
+    private string Url;
+
+    public Client(string url, Auth auth)
+    {
+        var httpClient = new HttpClient();
+
+        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(GetMethodValue(auth.Method), EncodeCredentials(auth.Credentials));
+
+        this.HttpClient = httpClient;
+        this.Url = url;
+    }
+
+    public async Task<string> GetInfo()
+    {
+        UriBuilder resourcePath = new(this.Url) { Path = "$version" };
+
+        var httpClient = this.HttpClient;
+
+        var response = await httpClient.GetAsync(resourcePath.Uri);
+
+        if (!response.IsSuccessStatusCode)
+        {
+            throw new HttpRequestException($"Server returned error: {response.StatusCode}");
+        }
+
+        return await response.Content.ReadAsStringAsync() ?? throw new Exception("");
+    }
+
+    public async Task<(Bundle<T>? result, string? error)> Search<T>(string? queryString) where T : Resource
+    {
+        UriBuilder resourcePath = new(this.Url) { Path = Helper.ResourceMap[typeof(T)] };
+
+        if (queryString is not null)
+        {
+            resourcePath.Query = queryString;
+        }
+
+        try
+        {
+            var response = await this.HttpClient.GetAsync(resourcePath.Uri);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new HttpRequestException($"Server returned error: {response.StatusCode}");
+            }
+
+            var content = await response.Content.ReadAsStringAsync();
+
+            Bundle<T>? parsedContent = JsonSerializer.Deserialize<Bundle<T>>(content, Helper.JsonSerializerOptions);
+
+            return (parsedContent, default);
+        }
+        catch (HttpRequestException error)
+        {
+            return (default, error.Message);
+        }
+    }
+
+    public async Task<(T? result, string? error)> Read<T>(string id) where T : Resource
+    {
+        UriBuilder resourcePath = new(this.Url) { Path = Helper.ResourceMap[typeof(T)] };
+
+        var httpClient = this.HttpClient;
+
+        try
+        {
+            var response = await httpClient.GetAsync($"{resourcePath.Uri}/{id}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new HttpRequestException($"Server returned error: {response.StatusCode}");
+            }
+
+            var content = await response.Content.ReadAsStringAsync();
+
+            T? parsedContent = JsonSerializer.Deserialize<T>(content, Helper.JsonSerializerOptions);
+
+            return (parsedContent, default);
+        }
+
+        catch (HttpRequestException error)
+        {
+            return (default, error.Message);
+        }
+    }
+
+    public async Task<(T? result, string? error)> Create<T>(T data) where T : Resource
+    {
+        UriBuilder resourcePath = new(this.Url) { Path = Helper.ResourceMap[typeof(T)] };
+
+        string jsonBody = JsonSerializer.Serialize<T>(data, Helper.JsonSerializerOptions);
+
+        HttpContent requestData = new StringContent(jsonBody, Encoding.UTF8, "application/json");
+
+        try
+        {
+            var response = await this.HttpClient.PostAsync(resourcePath.Uri, requestData);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new HttpRequestException($"Server returned error: {response.StatusCode}");
+            }
+
+            var content = await response.Content.ReadAsStringAsync();
+
+            T? parsedContent = JsonSerializer.Deserialize<T>(content, Helper.JsonSerializerOptions);
+
+            return (parsedContent, default);
+        }
+
+        catch (HttpRequestException error)
+        {
+            return (default, error.Message);
+        }
+    }
+
+    public async Task<(T? result, string? error)> Delete<T>(string id) where T : Resource
+    {
+        UriBuilder resourcePath = new(this.Url) { Path = Helper.ResourceMap[typeof(T)] };
+
+        var httpClient = this.HttpClient;
+
+        try
+        {
+            var response = await httpClient.DeleteAsync($"{resourcePath.Uri}/{id}");
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new HttpRequestException($"Server returned error: {response.StatusCode}");
+            }
+
+            if (response.StatusCode == HttpStatusCode.NoContent)
+            {
+                throw new HttpRequestException($"The resource with id \"{id}\" does not exist");
+            }
+
+            var content = await response.Content.ReadAsStringAsync();
+
+            T? parsedContent = JsonSerializer.Deserialize<T>(content, Helper.JsonSerializerOptions);
+
+            return (parsedContent, default);
+        }
+
+        catch (HttpRequestException error)
+        {
+            return (default, error.Message);
+        }
+    }
+
+    public async Task<(T? result, string? error)> Update<T>(T resource) where T : Resource
+    {
+        UriBuilder resourcePath = new(this.Url) { Path = Helper.ResourceMap[typeof(T)] };
+
+        string jsonBody = JsonSerializer.Serialize<T>(resource, Helper.JsonSerializerOptions);
+
+        HttpContent requestData = new StringContent(jsonBody, Encoding.UTF8, "application/json");
+
+        var httpClient = this.HttpClient;
+
+        try
+        {
+            var response = await httpClient.PutAsync($"{resourcePath.Uri}/{resource.Id}", requestData);
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new HttpRequestException($"Server returned error: {response.StatusCode}");
+            }
+
+            var content = await response.Content.ReadAsStringAsync();
+
+            T? parsedContent = JsonSerializer.Deserialize<T>(content, Helper.JsonSerializerOptions);
+
+            return (parsedContent, default);
+        }
+
+        catch (HttpRequestException error)
+        {
+            return (default, error.Message);
+        }
+    }
+
+    private string EncodeCredentials(AuthCredentials credentials)
+    {
+        byte[] credentialsBytes = System.Text.Encoding.UTF8.GetBytes($"{credentials.Username}:{credentials.Password}");
+
+        return Convert.ToBase64String(credentialsBytes);
+    }
+
+    private string GetMethodValue(AuthMethods method)
+    {
+        var fieldInfo = method.GetType().GetField(method.ToString());
+
+        if (fieldInfo == null)
+        {
+            return method.ToString();
+        }
+
+        var attributes = (DescriptionAttribute[])fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);
+
+        return attributes.Length > 0 ? attributes[0].Description : method.ToString();
+    }
+}
+
+public class MetaResponse
+{
+    public string? LastUpdated { get; set; }
+    public string? CreatedAt { get; set; }
+    public required string VersionId { get; set; }
+}
+
+public class Link
+{
+    public required string Relation { get; set; }
+    public required string Url { get; set; }
+}
+
+public class Search
+{
+    public required string Mode { get; set; }
+}
+
+public class Entry<T>
+{
+    public required T Resource { get; set; }
+    public required Search Search { get; set; }
+    public required string FullUrl { get; set; }
+    public required Link[] Link { get; set; }
+}
+
+public class ApiResourcesResponse<T>
+{
+    [JsonPropertyName("query-time")]
+    public int? QueryTime { get; set; }
+
+    public MetaResponse? Meta { get; set; }
+    public string? Type { get; set; }
+    public string? ResourceType { get; set; }
+    public int? Total { get; set; }
+    public Link[]? Link { get; set; }
+
+    [JsonPropertyName("query-timeout")]
+    public int? QueryTimeout { get; set; }
+    public Entry<T>[]? Entry { get; set; }
+
+    [JsonPropertyName("query-sql")]
+    public object[]? QuerySql { get; set; }
+}
+
+public class Bundle<T> : Resource where T : Resource
+{
+    public BundleLink[]? Link { get; set; }
+    public required string Type { get; set; }
+    public BundleEntry[]? Entry { get; set; }
+    public uint? Total { get; set; }
+    public Signature? Signature { get; set; }
+    public string? Timestamp { get; set; }
+    public Identifier? Identifier { get; set; }
+
+    public class BundleLink : BackboneElement
+    {
+        public required string Url { get; set; }
+        public required string Relation { get; set; }
+    }
+
+    public class BundleEntryLink : BackboneElement
+    {
+        public required string Url { get; set; }
+        public required string Relation { get; set; }
+    }
+
+    public class BundleEntrySearch : BackboneElement
+    {
+        public string? Mode { get; set; }
+        public string? Score { get; set; }
+    }
+
+    public class BundleEntryRequest : BackboneElement
+    {
+        public required string Url { get; set; }
+        public required string Method { get; set; }
+        public string? IfMatch { get; set; }
+        public string? IfNoneExist { get; set; }
+        public string? IfNoneMatch { get; set; }
+        public string? IfModifiedSince { get; set; }
+    }
+
+    public class BundleEntryResponse : BackboneElement
+    {
+        public string? Etag { get; set; }
+        public required string Status { get; set; }
+        public Resource? Outcome { get; set; }
+        public string? Location { get; set; }
+        public string? LastModified { get; set; }
+    }
+
+    public class BundleEntry : BackboneElement
+    {
+        public BundleEntryLink[]? Link { get; set; }
+        public BundleEntrySearch? Search { get; set; }
+        public string? FullUrl { get; set; }
+        public BundleEntryRequest? Request { get; set; }
+        public T? Resource { get; set; }
+        public BundleEntryResponse? Response { get; set; }
+    }
+}

package/assets/api/writer-generator/csharp/Helper.cs

@@ -0,0 +1,19 @@
+namespace CSharpSDK;
+
+public class LowercaseNamingPolicy : JsonNamingPolicy
+{
+    public override string ConvertName(string name) => name.ToLower();
+}
+
+public class Helper
+{
+    public static readonly JsonSerializerOptions JsonSerializerOptions = new()
+    {
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        Converters = { new JsonStringEnumConverter(new LowercaseNamingPolicy()) },
+        WriteIndented = true
+    };
+
+    public static readonly Dictionary<Type, string> ResourceMap = ResourceDictionary.Map;
+}

package/assets/api/writer-generator/python/requirements.txt

@@ -0,0 +1,5 @@
+requests>=2.32.0,<3.0.0
+pytest>=8.3.0,<9.0.0
+pydantic>=2.11.0,<3.0.0
+mypy>=1.9.0,<2.0.0
+types-requests>=2.32.0,<3.0.0

package/assets/api/writer-generator/python/resource_family_validator.py

@@ -0,0 +1,92 @@
+import re
+import importlib
+import importlib.util
+from typing import Any, Annotated, List
+
+from pydantic import BeforeValidator, BaseModel, ValidationError
+from pydantic_core import ValidationError as PydanticCoreValidationError
+
+
+def to_snake_case(name: str) -> str:
+    s = re.sub(r"(?<!^)(?=[A-Z])", "_", name)
+    return s.lower()
+
+
+def module_exists(name: str) -> bool:
+    """Checks if a module exists without importing it"""
+    return importlib.util.find_spec(name) is not None
+
+
+def import_and_create_module(module_name: str, class_name: str) -> Any:
+    """
+    Dynamically import a module and create an instance of a specified class.
+
+    Args:
+        module_name: String name of the module (e.g., 'aidbox.hl7_fhir_r4_core.patient')
+        class_name: String name of the class (e.g., 'Patient')
+
+    Returns:
+        Instance of the specified class
+    """
+    try:
+        module = importlib.import_module(module_name)
+        class_obj = getattr(module, class_name)
+        return class_obj
+
+    except (ImportError, AttributeError) as e:
+        raise ImportError(f"Could not import {class_name} from {module_name}: {e}")
+
+
+def import_and_create_module_if_exists(package: str, class_name: str) -> Any:
+    """
+    Dynamically import a module and create an instance of a specified class if the module exists.
+
+    Args:
+        package: String name of the package (e.g., 'aidbox.hl7_fhir_r4_core')
+        class_name: String name of the class (e.g., 'Patient')
+
+    Returns:
+        Instance of the specified class or None if the module does not exist
+    """
+    module_name = package + "." + to_snake_case(class_name)
+    if module_exists(module_name):
+        return import_and_create_module(module_name, class_name)
+    else:
+        return None
+
+
+def validate_and_downcast(
+    resource_data: dict[str, Any], package_list: List[str], family: List[str]
+) -> Any:
+    """
+    Validates and downcasts ResourceFamily to the appropriate FHIR resource class
+
+    Args:
+        resource_data: Input value (dict)
+        package_list: List of package names to search for resource classes (e.g., ['aidbox.hl7_fhir_r4_core', 'aidbox.hl7_fhir_r4_extras'])
+        family: List of valid resource types (e.g., 'Group' or 'Patient')
+
+    Returns:
+        Instance of the appropriate FHIR resource class
+    """
+
+    # Extract and validate resource type
+    resource_type = resource_data.get("resourceType")
+    if not resource_type:
+        raise ValueError("Missing 'resourceType' field in resource")
+
+    if resource_type not in family:
+        raise ValueError(f"Invalid resourceType '{resource_type}'. ")
+
+    # Dynamically import and instantiate the appropriate class
+    target_class = None
+    for package in package_list:
+        target_class = import_and_create_module_if_exists(package, resource_type)
+        if target_class is not None:
+            break
+    if target_class is None:
+        raise ImportError(
+            f"Could not find class for resourceType '{resource_type}' in packages {package_list}"
+        )
+
+    return target_class.model_validate(resource_data)