pycharter 0.0.18__py3-none-any.whl → 0.0.19__py3-none-any.whl

api/main.py

@@ -147,11 +147,31 @@ def create_application() -> FastAPI:
         request: Request, exc: RequestValidationError
     ) -> JSONResponse:
         """Handle request validation errors."""
+        # Convert errors to JSON-serializable format
+        def serialize_error(error: dict) -> dict:
+            """Recursively serialize error dict, converting exceptions to strings."""
+            serialized = {}
+            for key, value in error.items():
+                if isinstance(value, Exception):
+                    serialized[key] = str(value)
+                elif isinstance(value, dict):
+                    serialized[key] = serialize_error(value)
+                elif isinstance(value, (list, tuple)):
+                    serialized[key] = [
+                        serialize_error(item) if isinstance(item, dict) else str(item) if isinstance(item, Exception) else item
+                        for item in value
+                    ]
+                else:
+                    serialized[key] = value
+            return serialized
+        
+        errors = [serialize_error(err) for err in exc.errors()]
+        
         return JSONResponse(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             content={
                 "error": "Validation error",
-                "details": exc.errors(),
+                "details": errors,
             },
         )
     

api/models/contracts.py

@@ -4,7 +4,9 @@ Request/Response models for contract endpoints.
 
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+from pycharter.shared.name_validator import validate_name
 
 
 class ContractParseRequest(BaseModel):
@@ -68,8 +70,14 @@ class ContractParseResponse(BaseModel):
 class ContractBuildRequest(BaseModel):
     """Request model for building a contract from store."""
     
-    schema_id: str = Field(..., description="Schema identifier")
-    version: Optional[str] = Field(None, description="Schema version (default: latest)")
+    schema_title: str = Field(..., description="Schema title/identifier")
+    schema_version: Optional[str] = Field(None, description="Schema version (default: latest)")
+    coercion_rules_title: Optional[str] = Field(None, description="Coercion rules title/identifier (default: schema_title)")
+    coercion_rules_version: Optional[str] = Field(None, description="Coercion rules version (default: latest or schema_version)")
+    validation_rules_title: Optional[str] = Field(None, description="Validation rules title/identifier (default: schema_title)")
+    validation_rules_version: Optional[str] = Field(None, description="Validation rules version (default: latest or schema_version)")
+    metadata_title: Optional[str] = Field(None, description="Metadata title/identifier (default: schema_title)")
+    metadata_version: Optional[str] = Field(None, description="Metadata version (default: latest or schema_version)")
     include_metadata: bool = Field(True, description="Include metadata in contract")
     include_ownership: bool = Field(True, description="Include ownership in contract")
     include_governance: bool = Field(True, description="Include governance rules in contract")
@@ -77,8 +85,14 @@ class ContractBuildRequest(BaseModel):
     class Config:
         json_schema_extra = {
             "example": {
-                "schema_id": "user_schema",
-                "version": "1.0.0",
+                "schema_title": "user_schema",
+                "schema_version": "1.0.0",
+                "coercion_rules_title": "user_schema",
+                "coercion_rules_version": "1.0.0",
+                "validation_rules_title": "user_schema",
+                "validation_rules_version": "1.0.0",
+                "metadata_title": "user_schema",
+                "metadata_version": "1.0.0",
                 "include_metadata": True,
                 "include_ownership": True,
                 "include_governance": True
@@ -163,6 +177,134 @@ class ContractListResponse(BaseModel):
         }
 
 
+class ContractCreateFromArtifactsRequest(BaseModel):
+    """Request model for creating a contract from existing artifacts."""
+    
+    name: str = Field(..., description="Contract name")
+    version: str = Field(..., description="Contract version")
+    schema_title: str = Field(..., description="Schema artifact title")
+    schema_version: str = Field(..., description="Schema artifact version")
+    coercion_rules_title: Optional[str] = Field(None, description="Coercion rules artifact title (optional)")
+    coercion_rules_version: Optional[str] = Field(None, description="Coercion rules artifact version (optional)")
+    validation_rules_title: Optional[str] = Field(None, description="Validation rules artifact title (optional)")
+    validation_rules_version: Optional[str] = Field(None, description="Validation rules artifact version (optional)")
+    metadata_title: Optional[str] = Field(None, description="Metadata artifact title (optional)")
+    metadata_version: Optional[str] = Field(None, description="Metadata artifact version (optional)")
+    status: Optional[str] = Field("active", description="Contract status")
+    description: Optional[str] = Field(None, description="Contract description")
+    
+    @field_validator('name')
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        """Validate contract name follows naming convention."""
+        return validate_name(v, field_name="name")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "name": "user_contract",
+                "version": "2.0.0",
+                "schema_title": "user_schema",
+                "schema_version": "1.0.0",
+                "coercion_rules_title": "user_schema_coercion_rules",
+                "coercion_rules_version": "1.0.0",
+                "validation_rules_title": "user_schema_validation_rules",
+                "validation_rules_version": "1.0.0",
+                "metadata_title": "user_metadata",
+                "metadata_version": "1.0.0",
+                "status": "active",
+                "description": "User data contract"
+            }
+        }
+
+
+class ContractCreateMixedRequest(BaseModel):
+    """Request model for creating a contract with mixed artifacts (some new, some existing)."""
+    
+    name: str = Field(..., description="Contract name")
+    version: str = Field(..., description="Contract version")
+    
+    # Schema: either new data or existing title+version
+    schema: Optional[Dict[str, Any]] = Field(None, description="New schema definition (if creating new schema)")
+    schema_title: Optional[str] = Field(None, description="Existing schema title (if using existing schema)")
+    schema_version: Optional[str] = Field(None, description="Existing schema version (if using existing schema)")
+    
+    # Coercion rules: either new data or existing title+version
+    coercion_rules: Optional[Dict[str, Any]] = Field(None, description="New coercion rules (if creating new)")
+    coercion_rules_title: Optional[str] = Field(None, description="Existing coercion rules title (if using existing)")
+    coercion_rules_version: Optional[str] = Field(None, description="Existing coercion rules version (if using existing)")
+    
+    # Validation rules: either new data or existing title+version
+    validation_rules: Optional[Dict[str, Any]] = Field(None, description="New validation rules (if creating new)")
+    validation_rules_title: Optional[str] = Field(None, description="Existing validation rules title (if using existing)")
+    validation_rules_version: Optional[str] = Field(None, description="Existing validation rules version (if using existing)")
+    
+    # Metadata: either new data or existing title+version
+    metadata: Optional[Dict[str, Any]] = Field(None, description="New metadata (if creating new)")
+    metadata_title: Optional[str] = Field(None, description="Existing metadata title (if using existing)")
+    metadata_version: Optional[str] = Field(None, description="Existing metadata version (if using existing)")
+    
+    status: Optional[str] = Field("active", description="Contract status")
+    description: Optional[str] = Field(None, description="Contract description")
+    
+    @field_validator('name')
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        """Validate contract name follows naming convention."""
+        return validate_name(v, field_name="name")
+    
+    @model_validator(mode='after')
+    def validate_artifacts(self):
+        """Validate that each artifact is either new or existing, but not both or neither (for schema)."""
+        # Schema must be provided (either new or existing)
+        has_new_schema = self.schema is not None
+        has_existing_schema = self.schema_title is not None and self.schema_version is not None
+        
+        if not has_new_schema and not has_existing_schema:
+            raise ValueError("Schema must be provided either as new data (schema) or existing artifact (schema_title + schema_version)")
+        if has_new_schema and has_existing_schema:
+            raise ValueError("Cannot specify both new schema and existing schema. Choose one.")
+        
+        # Coercion rules: either new or existing, but not both
+        has_new_coercion = self.coercion_rules is not None and len(self.coercion_rules) > 0
+        has_existing_coercion = self.coercion_rules_title is not None and self.coercion_rules_version is not None
+        
+        if has_new_coercion and has_existing_coercion:
+            raise ValueError("Cannot specify both new coercion rules and existing coercion rules. Choose one.")
+        
+        # Validation rules: either new or existing, but not both
+        has_new_validation = self.validation_rules is not None and len(self.validation_rules) > 0
+        has_existing_validation = self.validation_rules_title is not None and self.validation_rules_version is not None
+        
+        if has_new_validation and has_existing_validation:
+            raise ValueError("Cannot specify both new validation rules and existing validation rules. Choose one.")
+        
+        # Metadata: either new or existing, but not both
+        has_new_metadata = self.metadata is not None and len(self.metadata) > 0
+        has_existing_metadata = self.metadata_title is not None and self.metadata_version is not None
+        
+        if has_new_metadata and has_existing_metadata:
+            raise ValueError("Cannot specify both new metadata and existing metadata. Choose one.")
+        
+        return self
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "name": "user_contract",
+                "version": "1.0.0",
+                "schema": {"type": "object", "properties": {}},
+                "coercion_rules_title": "existing_coercion_rules",
+                "coercion_rules_version": "1.0.0",
+                "validation_rules": {"rules": {}},
+                "metadata_title": "existing_metadata",
+                "metadata_version": "1.0.0",
+                "status": "active",
+                "description": "User data contract"
+            }
+        }
+
+
 class ContractUpdateRequest(BaseModel):
     """Request model for updating a contract."""
     
@@ -171,6 +313,14 @@ class ContractUpdateRequest(BaseModel):
     status: Optional[str] = Field(None, description="Contract status (e.g., 'active', 'deprecated', 'draft')")
     description: Optional[str] = Field(None, description="Contract description")
     
+    @field_validator('name')
+    @classmethod
+    def validate_name(cls, v: Optional[str]) -> Optional[str]:
+        """Validate contract name follows naming convention."""
+        if v is not None:
+            return validate_name(v, field_name="name")
+        return v
+    
     class Config:
         json_schema_extra = {
             "example": {

api/models/metadata.py

@@ -4,7 +4,9 @@ Request/Response models for metadata store endpoints.
 
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
+
+from pycharter.shared.name_validator import validate_name
 
 
 class SchemaStoreRequest(BaseModel):
@@ -14,6 +16,20 @@ class SchemaStoreRequest(BaseModel):
     schema: Dict[str, Any] = Field(..., description="JSON Schema definition")
     version: str = Field(..., description="Schema version")
     
+    @field_validator('schema_name')
+    @classmethod
+    def validate_schema_name(cls, v: str) -> str:
+        """Validate schema name follows naming convention."""
+        return validate_name(v, field_name="schema_name")
+    
+    @field_validator('schema')
+    @classmethod
+    def validate_schema_title(cls, v: Dict[str, Any], info) -> Dict[str, Any]:
+        """Validate schema title if present in schema."""
+        if isinstance(v, dict) and 'title' in v and v['title']:
+            v['title'] = validate_name(str(v['title']), field_name="schema.title")
+        return v
+    
     class Config:
         json_schema_extra = {
             "example": {
@@ -90,6 +106,14 @@ class MetadataStoreRequest(BaseModel):
     metadata: Dict[str, Any] = Field(..., description="Metadata dictionary")
     version: Optional[str] = Field(None, description="Version string (default: uses schema version)")
     
+    @field_validator('metadata')
+    @classmethod
+    def validate_metadata_title(cls, v: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate metadata title if present."""
+        if isinstance(v, dict) and 'title' in v and v['title']:
+            v['title'] = validate_name(str(v['title']), field_name="metadata.title")
+        return v
+    
     class Config:
         json_schema_extra = {
             "example": {