cascade-cms-rest 3.2.0__tar.gz → 3.2.2__tar.gz

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to this project will be documented in this file.
 
+## [3.2.2]
+
+### Added
+- `create()` and `delete()` accept a callable, like `edit()`: it receives the previous node's result and returns the `NewAsset`(s) / identifier(s), so `read → then → create → delete` can be one chain.
+
+### Fixed
+- `ListElements` now accepts the `audits` key, so `readAudits` responses parse.
+- `WorkflowAction.next_id` now validates from the `nextId` key Cascade sends.
+- A deferred (callable-payload) node that resolves to several requests now keeps every result instead of only the first, so partial failures no longer stop the chain (also applies to `edit`).
+
+### Changed
+- **`ChainResults.ok` renamed to `ChainResults.success`** (`.failed` is unchanged; no `.ok` alias is kept). The batch console line still reports `N/M succeeded`, where N is the number of chains without a failure, i.e. `len(results.success)` for single-result chains.
+- **Snake_case field names on every Pydantic model.** camelCase is now only the wire name: accepted when validating (`validation_alias`) and still written on requests (`serialization_alias`), so request bodies are unchanged. Renamed: `PageConfiguration.pageRegions` → `page_regions`; `CheckedOutAsset.workingCopyIdentifier` → `working_copy_identifier`; `SearchInformation` `siteName`/`searchTerms`/`searchFields`/`searchTypes` → `site_name`/`search_terms`/`search_fields`/`search_types`; `auditParameters` `auditType`/`startDate`/`endDate` → `audit_type`/`start_date`/`end_date`; `workflowSettingsPayload` `apply*ToChildren` → `apply_*_to_children`. Existing `alias=` fields moved to explicit validation/serialization aliases so type checkers see the snake_case constructor names. `NewAsset` now validates by alias as well as by name (`site_id=` and `siteId=` both work). The former `TypedDict` shapes are now frozen/validated Pydantic models with snake_case attributes: `PathBase`/`Path` (`site_id`, `site_name`; `Path` also exposes `get_id`/`get_type`/`get_path`), `WorkflowSettingsModel`, `Entries`, `AccessRightsModel` (`all_level`), `WorkflowAction`, `WorkflowSteps`, `Audit`. Dict-style access (`path["siteName"]`, `payload.body["identifier"]`) becomes attribute access, and `PathBase.site_id` now serializes as bare hex like `IdentifierType`.
+- **`auditParameters` no longer takes an `IdentifierType`.** `readAudits` now takes plain strings via `username`, `groupname`, or `rolename`; at least one is required. Auditing by entity identifier is no longer supported through this payload.
+
+**Files changed:** `src/cascade_cms/cmstypes.py`, `src/cascade_cms/operations.py`, `src/cascade_cms/failures.py`, `src/cascade_cms/wrapper.py`, `README.md`, `tests/test_cmstypes.py`, `tests/test_operation_chains.py`, `tests/test_wrapper.py`, `pyproject.toml`
+
+## [3.2.1]
+
+### Fixed
+- `OperationLogger.log_python_error()`'s console `[ERROR]` line now also
+  carries the `[NETWORK]`/`[CASCADE-REST-CMS]` prefix for a batch-level
+  failure — per A1, the prefix was already applied to the logfile's
+  `!ERROR:` line in 3.2.0, but not to the console line.
+
+**Files changed:** `src/cascade_cms/operation_logger.py`,
+`tests/test_operation_logger.py`, `tests/test_wrapper.py`
+
 ## [3.2.0]
 
 Failure handling moves out of user scripts and into the library. No more

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cascade-cms-rest
-Version: 3.2.0
+Version: 3.2.2
 Summary: A typed, async REST client for Hannon Hill Cascade CMS
 Project-URL: Homepage, https://github.com/Sharkdroid/py-cascade-cms
 Author: Keith Shark
@@ -84,7 +84,7 @@ with CascadeWrapperBase(environment_variables, configuration_variables) as casca
 - **Failures are values, not gaps.** A chain stops at its first failure and that object lands in
   the results: a `CascadeError` when the API rejects a request, or the exception a callback
   raised. Other chains are unaffected. `submit_requests()` returns a `ChainResults` — still a
-  list, in that same chain-creation order — with `.ok` (results from chains that didn't fail)
+  list, in that same chain-creation order — with `.success` (results from chains that didn't fail)
   and `.failed` (a `ChainFailure` per failed chain, naming the exact step and its category) added.
   There's no need for an `isinstance(result, CascadeError)` check or a `try/except` around
   `submit_requests()` — `CascadeWrapperBase` owns whether a failure ends the script; see
@@ -102,7 +102,7 @@ Failure handling lives in the library, not in your script. `CascadeWrapperBase`'
 manager owns it end to end:
 
 - No `try/except` around `submit_requests()`, and no `isinstance()` checks in your script —
-  read `.ok`/`.failed` off the `ChainResults` it returns instead.
+  read `.success`/`.failed` off the `ChainResults` it returns instead.
 - If the batch itself breaks (not an individual chain — e.g. the driver's event loop fails),
   `submit_requests()` raises `CascadeBatchError` rather than returning an empty list.
 - At `with`-block exit, with `exit_on_failure=True` (the default), any recorded failure ends the
@@ -111,7 +111,7 @@ manager owns it end to end:
   `CascadeError`/network/library-side failure raises `SystemExit(1)` with no extra traceback,
   since it was already logged.
 - Pass `exit_on_failure=False` to embed the wrapper in a longer-lived process (e.g. an MCP
-  server) — `__exit__` then never raises; read `.ok`/`.failed` off the results yourself.
+  server) — `__exit__` then never raises; read `.success`/`.failed` off the results yourself.
 - The logfile's `!ERROR:` line is prefixed `[NETWORK]` for a network-layer failure or
   `[CASCADE-REST-CMS]` for any other library-side failure; a `CascadeError` or a callback
   exception gets no prefix.
@@ -124,7 +124,7 @@ manager owns it end to end:
 with CascadeWrapperBase(environment_variables, configuration_variables) as cascade:
     cascade.operations.read(identifier)
     results = cascade.submit_requests(Asset)
-    for asset in results.ok:
+    for asset in results.success:
         ...  # only successful reads
 # If anything failed, execution never reaches here — the with block already
 # raised (or exited) on the way out.

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/README.md

@@ -63,7 +63,7 @@ with CascadeWrapperBase(environment_variables, configuration_variables) as casca
 - **Failures are values, not gaps.** A chain stops at its first failure and that object lands in
   the results: a `CascadeError` when the API rejects a request, or the exception a callback
   raised. Other chains are unaffected. `submit_requests()` returns a `ChainResults` — still a
-  list, in that same chain-creation order — with `.ok` (results from chains that didn't fail)
+  list, in that same chain-creation order — with `.success` (results from chains that didn't fail)
   and `.failed` (a `ChainFailure` per failed chain, naming the exact step and its category) added.
   There's no need for an `isinstance(result, CascadeError)` check or a `try/except` around
   `submit_requests()` — `CascadeWrapperBase` owns whether a failure ends the script; see
@@ -81,7 +81,7 @@ Failure handling lives in the library, not in your script. `CascadeWrapperBase`'
 manager owns it end to end:
 
 - No `try/except` around `submit_requests()`, and no `isinstance()` checks in your script —
-  read `.ok`/`.failed` off the `ChainResults` it returns instead.
+  read `.success`/`.failed` off the `ChainResults` it returns instead.
 - If the batch itself breaks (not an individual chain — e.g. the driver's event loop fails),
   `submit_requests()` raises `CascadeBatchError` rather than returning an empty list.
 - At `with`-block exit, with `exit_on_failure=True` (the default), any recorded failure ends the
@@ -90,7 +90,7 @@ manager owns it end to end:
   `CascadeError`/network/library-side failure raises `SystemExit(1)` with no extra traceback,
   since it was already logged.
 - Pass `exit_on_failure=False` to embed the wrapper in a longer-lived process (e.g. an MCP
-  server) — `__exit__` then never raises; read `.ok`/`.failed` off the results yourself.
+  server) — `__exit__` then never raises; read `.success`/`.failed` off the results yourself.
 - The logfile's `!ERROR:` line is prefixed `[NETWORK]` for a network-layer failure or
   `[CASCADE-REST-CMS]` for any other library-side failure; a `CascadeError` or a callback
   exception gets no prefix.
@@ -103,7 +103,7 @@ manager owns it end to end:
 with CascadeWrapperBase(environment_variables, configuration_variables) as cascade:
     cascade.operations.read(identifier)
     results = cascade.submit_requests(Asset)
-    for asset in results.ok:
+    for asset in results.success:
         ...  # only successful reads
 # If anything failed, execution never reaches here — the with block already
 # raised (or exited) on the way out.

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cascade-cms-rest"
-version = "3.2.0"
+version = "3.2.2"
 description = "A typed, async REST client for Hannon Hill Cascade CMS"
 readme = "README.md"
 license = "MIT"

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/src/cascade_cms/cmstypes.py

@@ -8,9 +8,7 @@ from typing import (
     ClassVar,
     Literal,
     NamedTuple,
-    NotRequired,
     Self,
-    TypedDict,
     TypeVar,
     cast,
 )
@@ -198,20 +196,30 @@ def set_checkedout(key: str):
 # ----- PATH TYPES -----
 
 
-class PathBase(TypedDict):
+class PathBase(BaseModel):
     """
     Base class for Path object
 
     Attributes:
         path (str): The path string
-        siteId (uuid_string): unique identifier string
-                              of the site associated with it
-        siteName (str):
+        site_id (uuid): unique identifier of the site associated with it (optional)
+        site_name (str): name of the site associated with it (optional)
     """
 
+    model_config = ConfigDict(frozen=True, populate_by_name=True)
+
     path: str
-    siteId: NotRequired[uuid.UUID]
-    siteName: Annotated[str | None, Field(default=None)]
+    site_id: uuid.UUID | None = Field(
+        default=None, validation_alias="siteId", serialization_alias="siteId"
+    )
+    site_name: str | None = Field(
+        default=None, validation_alias="siteName", serialization_alias="siteName"
+    )
+
+    # Cascade rejects dashed UUIDs for identifiers - serialize as bare hex.
+    @field_serializer("site_id")
+    def serialize_site_id(self, value: uuid.UUID | None) -> str | None:
+        return value.hex if value is not None else None
 
 
 class Path(PathBase):
@@ -222,7 +230,20 @@ class Path(PathBase):
         asset_type (AssetTypes): (Required) the type of the asset
     """
 
-    asset_type: Literal[AssetTypes]
+    asset_type: AssetTypes
+
+    # Duck-typed surface shared with IdentifierType (logging reads these).
+    @property
+    def get_id(self) -> None:
+        return None
+
+    @property
+    def get_type(self) -> str:
+        return str(self.asset_type)
+
+    @property
+    def get_path(self) -> str:
+        return self.path
 
 
 # ===== PAYLOAD MODELS (Request Data) =====
@@ -277,7 +298,7 @@ class SimplePayload(BaseModel):
             return value
 
         aliased = {
-            (fields_info[name].alias or name): dump(value)
+            (fields_info[name].serialization_alias or fields_info[name].alias or name): dump(value)
             for name, value in self.__dict__.items()
             if name in fields_info
         }
@@ -296,15 +317,15 @@ class NewAsset(SimplePayload):
     model_config = ConfigDict(
         extra="allow",
         validate_by_name=True,
-        validate_by_alias=False,
+        validate_by_alias=True,
     )
 
     name: str
     asset_type: AssetTypes
-    site_name: str | None = Field(default=None, alias="siteName")
-    site_id: uuid.UUID | None = Field(default=None, alias="siteId")
-    parent_folder_path: str | None = Field(default=None, alias="parentFolderPath")
-    parent_folder_id: uuid.UUID | None = Field(default=None, alias="parentFolderId")
+    site_name: str | None = Field(default=None, validation_alias="siteName", serialization_alias="siteName")
+    site_id: uuid.UUID | None = Field(default=None, validation_alias="siteId", serialization_alias="siteId")
+    parent_folder_path: str | None = Field(default=None, validation_alias="parentFolderPath", serialization_alias="parentFolderPath")
+    parent_folder_id: uuid.UUID | None = Field(default=None, validation_alias="parentFolderId", serialization_alias="parentFolderId")
 
     @field_serializer("site_id", "parent_folder_id")
     def serialize_uuid_as_hex(self, value: uuid.UUID | None) -> str | None:
@@ -350,8 +371,8 @@ class IdentifierType(BaseModel):
         populate_by_name=True,
     )
 
-    identifier: Annotated[uuid.UUID, Field(alias='id')]
-    asset_type: Annotated[AssetTypes, Field(default=..., alias="type")]
+    identifier: Annotated[uuid.UUID, Field(validation_alias='id', serialization_alias='id')]
+    asset_type: Annotated[AssetTypes, Field(default=..., validation_alias="type", serialization_alias="type")]
     recycled: Annotated[bool | None, Field(default=None)] = None
     path: Annotated[PathBase | None, Field(default=None)] = None
 
@@ -364,20 +385,18 @@ class IdentifierType(BaseModel):
     @property
     def get_path(self):
         if self.path is not None:
-            return self.path["path"]
+            return self.path.path
 
     @property
     def get_sitename(self):
         if self.path is not None:
-            return self.path["siteName"]
+            return self.path.site_name
 
     @property
     def get_site_id(self):
-        # siteId is NotRequired (unlike siteName, it has no Field default),
-        # so pydantic may not populate the key at all — plain indexing would
-        # KeyError on that legitimate case.
+        # site_id is optional and defaults to None when the response omits it.
         if self.path is not None:
-            return self.path.get("siteId")
+            return self.path.site_id
 
     @property
     def get_id(self):
@@ -416,9 +435,9 @@ def resolve_identifier(identifier: "IdentifierType | Path") -> tuple[str, ...]:
     """
     if isinstance(identifier, IdentifierType):
         return (str(identifier.get_type), str(identifier.get_id))
-    if identifier.get("siteName") is None:
-        raise ValueError("Path identifiers require siteName to build the request URL")
-    return (str(identifier["asset_type"]), str(identifier["siteName"]), str(identifier["path"]))
+    if identifier.site_name is None:
+        raise ValueError("Path identifiers require site_name to build the request URL")
+    return (str(identifier.asset_type), identifier.site_name, identifier.path)
 
 
 class AssetLogIdentifier(NamedTuple):
@@ -484,7 +503,9 @@ class PageConfiguration(BaseModel):
     )
 
     name: str
-    pageRegions: list[PageRegion]
+    page_regions: list[PageRegion] = Field(
+        validation_alias="pageRegions", serialization_alias="pageRegions"
+    )
 
 
 """
@@ -492,50 +513,68 @@ Used to retrieve the workflow deinitions on assets
 """
 
 
-class WorkflowSettingsModel(TypedDict):
+class WorkflowSettingsModel(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
+
     identifier: IdentifierType
-    workflowDefinitions: list[IdentifierType]
-    inheritedWorkflowDefinitions: list[IdentifierType]
-    inheritWorkflows: bool
-    requireWorkflow: bool
+    workflow_definitions: list[IdentifierType] = Field(
+        validation_alias="workflowDefinitions", serialization_alias="workflowDefinitions"
+    )
+    inherited_workflow_definitions: list[IdentifierType] = Field(
+        validation_alias="inheritedWorkflowDefinitions", serialization_alias="inheritedWorkflowDefinitions"
+    )
+    inherit_workflows: bool = Field(validation_alias="inheritWorkflows", serialization_alias="inheritWorkflows")
+    require_workflow: bool = Field(validation_alias="requireWorkflow", serialization_alias="requireWorkflow")
 
 
 class workflowSettingsPayload(SimplePayload):
 
-    body: WorkflowSettingsModel = Field(..., alias="workflowSettings")
-    applyInheritWorkflowsToChildren: bool | None = False
-    applyRequireWorkflowToChildren: bool | None = False
+    body: WorkflowSettingsModel = Field(..., validation_alias="workflowSettings", serialization_alias="workflowSettings")
+    apply_inherit_workflows_to_children: bool | None = Field(
+        default=False, validation_alias="applyInheritWorkflowsToChildren", serialization_alias="applyInheritWorkflowsToChildren"
+    )
+    apply_require_workflow_to_children: bool | None = Field(
+        default=False, validation_alias="applyRequireWorkflowToChildren", serialization_alias="applyRequireWorkflowToChildren"
+    )
     # __model__ = WorkflowSettingsModel
 
 
-class Entries(TypedDict):
+class Entries(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
+
     level: Literal["none", "read", "write"]
-    entry_type: Annotated[IdentityTypes, Field(alias="type")]
+    entry_type: IdentityTypes = Field(validation_alias="type", serialization_alias="type")
     name: str
 
 
-class AccessRightsModel(TypedDict):
-    user_id: Annotated[IdentifierType, Field(alias="identifier")]
-    acl_entries: Annotated[list[Entries], Field(alias="aclEntries")]
-    allLevel: Literal["none", "read", "write"]
+class AccessRightsModel(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
+
+    user_id: IdentifierType = Field(validation_alias="identifier", serialization_alias="identifier")
+    acl_entries: list[Entries] = Field(validation_alias="aclEntries", serialization_alias="aclEntries")
+    all_level: Literal["none", "read", "write"] = Field(validation_alias="allLevel", serialization_alias="allLevel")
 
 
 class accessRightsInformationPayload(SimplePayload):
-    body: AccessRightsModel = Field(default=..., alias="accessRightsInformation")
-    apply_to_children: bool | None = Field(default=False, alias="applyToChildren")
+    body: AccessRightsModel = Field(default=..., validation_alias="accessRightsInformation", serialization_alias="accessRightsInformation")
+    apply_to_children: bool | None = Field(default=False, validation_alias="applyToChildren", serialization_alias="applyToChildren")
 
 
-class WorkflowAction(TypedDict):
-    action_identifier: Annotated[str, Field(alias="identifier")]
+class WorkflowAction(BaseModel):
+    model_config = ConfigDict(frozen=True, populate_by_name=True)
+
+    action_identifier: str = Field(validation_alias="identifier", serialization_alias="identifier")
     label: str
-    action_type: Annotated[str, Field(alias="actionType")]
-    next_id: uuid.UUID
+    action_type: str = Field(validation_alias="actionType", serialization_alias="actionType")
+    next_id: uuid.UUID = Field(validation_alias="nextId", serialization_alias="nextId")
+
 
+class WorkflowSteps(BaseModel):
+    model_config = ConfigDict(frozen=True, populate_by_name=True)
 
-class WorkflowSteps(TypedDict):
-    step_identifier: Annotated[str, Field(alias="identifier")]
+    step_identifier: str = Field(validation_alias="identifier", serialization_alias="identifier")
     label: str
-    step_type: Annotated[str, Field(alias="stepType")]
+    step_type: str = Field(validation_alias="stepType", serialization_alias="stepType")
     actions: list[WorkflowAction]
     owner: str | None
 
@@ -546,17 +585,19 @@ class workflowInformation(BaseModel):
 
     model_config = ConfigDict(frozen=True)
 
-    related_entity: Annotated[IdentifierType, Field(alias="relatedEntity")]
-    current_step: Annotated[str, Field(alias="currentStep")]
+    related_entity: Annotated[IdentifierType, Field(validation_alias="relatedEntity", serialization_alias="relatedEntity")]
+    current_step: Annotated[str, Field(validation_alias="currentStep", serialization_alias="currentStep")]
     ordered_steps: list[WorkflowSteps]
     unordered_steps: list[WorkflowSteps]
     start_date: datetime
     end_date: datetime
     name: str
-    workflow_info_id: Annotated[uuid.UUID, Field(alias="workflowInfoId")]
+    workflow_info_id: Annotated[uuid.UUID, Field(validation_alias="workflowInfoId", serialization_alias="workflowInfoId")]
 
 
-class Audit(TypedDict):
+class Audit(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
     user: str
     action: AuditTypes
     identifier: IdentifierType
@@ -726,7 +767,7 @@ class Asset:
             return config
 
         try:
-            region = next((r for r in config.pageRegions if r.name == page_region), None)
+            region = next((r for r in config.page_regions if r.name == page_region), None)
         except (KeyError, AttributeError) as e:
             raise KeyError(f"Missing required field 'pageRegions' or 'name' in PageRegion: {e}")
 
@@ -761,12 +802,12 @@ class Message(SimplePayload):
 
     model_config = ConfigDict(populate_by_name=True)
 
-    m_from: Annotated[str, Field(alias="from", exclude=True)]
-    m_to: Annotated[str, Field(alias="to", exclude=True)]
-    m_subject: Annotated[str, Field(alias="subject", exclude=True)]
-    m_date: Annotated[datetime, Field(alias="date", exclude=True)]
-    m_id: Annotated[uuid.UUID, Field(alias="id", exclude=True)]
-    marked: str = Field("unread", alias="markType")
+    m_from: Annotated[str, Field(validation_alias="from", serialization_alias="from", exclude=True)]
+    m_to: Annotated[str, Field(validation_alias="to", serialization_alias="to", exclude=True)]
+    m_subject: Annotated[str, Field(validation_alias="subject", serialization_alias="subject", exclude=True)]
+    m_date: Annotated[datetime, Field(validation_alias="date", serialization_alias="date", exclude=True)]
+    m_id: Annotated[uuid.UUID, Field(validation_alias="id", serialization_alias="id", exclude=True)]
+    marked: str = Field("unread", validation_alias="markType", serialization_alias="markType")
 
     @field_validator("m_date", mode="after")
     @classmethod
@@ -782,7 +823,7 @@ class CheckedOutAsset(BaseModel):
 
     model_config = ConfigDict(frozen=True)
 
-    workingCopyIdentifier: IdentifierType
+    working_copy_identifier: IdentifierType = Field(validation_alias="workingCopyIdentifier", serialization_alias="workingCopyIdentifier")
 
 
 class ListElements(BaseModel):
@@ -798,6 +839,7 @@ class ListElements(BaseModel):
             "messages",
             "relationships",
             "sites",
+            "audits",
         )
     )
 
@@ -827,12 +869,14 @@ class CascadeSuccess(BaseModel):
 class SearchInformation(SimplePayload):
     """Payload for the `search` operation."""
 
-    siteName: str
-    searchTerms: str
-    searchFields: list[FieldsSearchTypes] | list[Literal[""]] = Field(
+    site_name: str = Field(validation_alias="siteName", serialization_alias="siteName")
+    search_terms: str = Field(validation_alias="searchTerms", serialization_alias="searchTerms")
+    search_fields: list[FieldsSearchTypes] | list[Literal[""]] = Field(
+        validation_alias="searchFields", serialization_alias="searchFields",
         default_factory=lambda: [cast(Literal[""], "")]
     )
-    searchTypes: list[AssetTypes] | list[Literal[""]] = Field(
+    search_types: list[AssetTypes] | list[Literal[""]] = Field(
+        validation_alias="searchTypes", serialization_alias="searchTypes",
         default_factory=lambda: [cast(Literal[""], "")]
     )
 
@@ -847,18 +891,18 @@ class preference(SimplePayload):
 class deleteParameters(SimplePayload):
     """Payload for the `delete` operation."""
 
-    do_workflow: bool = Field(alias="doWorkflow")
-    destinations_identifiers: list[IdentifierType] = Field(alias="destinations")
+    do_workflow: bool = Field(validation_alias="doWorkflow", serialization_alias="doWorkflow")
+    destinations_identifiers: list[IdentifierType] = Field(validation_alias="destinations", serialization_alias="destinations")
     unpublish: bool = True
 
 
 class copyParameters(SimplePayload):
     """Payload for the `copy` operation."""
 
-    do_workflow: Annotated[bool, Field(alias="doWorkflow")]
-    new_name: Annotated[str, Field(default=..., alias="newName")]
+    do_workflow: Annotated[bool, Field(validation_alias="doWorkflow", serialization_alias="doWorkflow")]
+    new_name: Annotated[str, Field(default=..., validation_alias="newName", serialization_alias="newName")]
     destination_container_identifier: Annotated[
-        IdentifierType, Field(alias="destinationContainerIdentifier")  # required
+        IdentifierType, Field(validation_alias="destinationContainerIdentifier", serialization_alias="destinationContainerIdentifier")  # required
     ]
 
 
@@ -866,11 +910,11 @@ class moveParameters(SimplePayload):
     """Payload for the `move` operation."""
 
     destinations: list[IdentifierType]
-    do_workflow: bool = Field(alias="doWorkflow")
+    do_workflow: bool = Field(validation_alias="doWorkflow", serialization_alias="doWorkflow")
     destination_container_identifier: IdentifierType = Field(
-        alias="destinationContainerIdentifier"
+        validation_alias="destinationContainerIdentifier", serialization_alias="destinationContainerIdentifier"
     )
-    new_name: str = Field(default="", alias="newName")  # empty new name means no rename
+    new_name: str = Field(default="", validation_alias="newName", serialization_alias="newName")  # empty new name means no rename
     unpublish: bool = True
 
 
@@ -889,36 +933,34 @@ class Comment(SimplePayload):
 class SiteCopyParameter(SimplePayload):
     """Payload for the `siteCopy` operation."""
 
-    original_sitename: str | IdentifierType = Field(alias="originalSiteName")
-    new_sitename: str = Field(alias="newSiteName")
+    original_sitename: str | IdentifierType = Field(validation_alias="originalSiteName", serialization_alias="originalSiteName")
+    new_sitename: str = Field(validation_alias="newSiteName", serialization_alias="newSiteName")
 
 
 class workflowTransitionInformation(SimplePayload):
     """Payload for the `performWorkflowTransition` operation."""
 
-    workflow_identifier: Annotated[uuid.UUID, Field(alias="workflowId")]
-    action_identifier: Annotated[str, Field(alias="actionIdentifier")]
-    transition_comment: str | None = Field(alias="transitionComment")
+    workflow_identifier: Annotated[uuid.UUID, Field(validation_alias="workflowId", serialization_alias="workflowId")]
+    action_identifier: Annotated[str, Field(validation_alias="actionIdentifier", serialization_alias="actionIdentifier")]
+    transition_comment: str | None = Field(validation_alias="transitionComment", serialization_alias="transitionComment")
 
 
 class auditParameters(SimplePayload):
     """Payload for the `readAudits` operation."""
 
-    auditType: AuditTypes
-    by_identifier: IdentifierType = Field(alias="identifier")
-    by_username: str | None = Field(default=None, alias="username")
-    by_group: str | None = Field(default=None, alias="groupname")
-    by_role: str | None = Field(default=None, alias="rolename")
-    startDate: datetime | None = Field(default=None)
-    endDate: datetime | None = Field(default=None)
+    audit_type: AuditTypes = Field(validation_alias="auditType", serialization_alias="auditType")
+    by_username: str | None = Field(default=None, validation_alias="username", serialization_alias="username")
+    by_group: str | None = Field(default=None, validation_alias="groupname", serialization_alias="groupname")
+    by_role: str | None = Field(default=None, validation_alias="rolename", serialization_alias="rolename")
+    start_date: datetime | None = Field(default=None, validation_alias="startDate", serialization_alias="startDate")
+    end_date: datetime | None = Field(default=None, validation_alias="endDate", serialization_alias="endDate")
 
-    # make sure its only user, group, role
-    @field_validator("by_identifier", mode="after")
-    @classmethod
-    def is_admin_entity(cls, identifier: IdentifierType) -> IdentifierType:
-        if identifier.get_type not in {"user", "role", "group"}:
-            raise ValueError("Identifier needs to be either user, role, or group.")
-        return identifier
+    # Cascade needs at least one of username / groupname / rolename
+    @model_validator(mode="after")
+    def requires_username_group_or_role(self) -> Self:
+        if not (self.by_username or self.by_group or self.by_role):
+            raise ValueError("Provide at least one of username, groupname, or rolename.")
+        return self
 
     """
     def toJson(self) -> str:

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/src/cascade_cms/failures.py

@@ -84,7 +84,7 @@ class ChainResults[T](list[T]):
     broken out.
 
     Indexing, iteration, and `len()` behave exactly like a plain list —
-    `.ok` and `.failed` are added properties computed from the failure
+    `.success` and `.failed` are added properties computed from the failure
     record recorded for each chain at execution time.
     """
 
@@ -97,7 +97,7 @@ class ChainResults[T](list[T]):
         self._failures: list[ChainFailure | None] = list(failures or [])
 
     @property
-    def ok(self) -> list[T]:
+    def success(self) -> list[T]:
         """Results from chains that did not fail, typed from `result_type`."""
         return [
             result

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/src/cascade_cms/operation_logger.py

@@ -423,13 +423,14 @@ class OperationLogger:
     def log_python_error(self, exc: Exception, prefix: str = "") -> None:
         """Log a Python exception outside of chain context. See `log_cascade_error`.
 
-        `prefix` (e.g. `"[CASCADE-REST-CMS] "`) is prepended to the
-        `!ERROR:` message — used for a batch-level failure (D6/A1), left
-        empty for a cleanup-time error, which isn't a classified failure.
+        `prefix` (e.g. `"[CASCADE-REST-CMS] "`) is prepended to both the
+        console `[ERROR]` line and the logfile's `!ERROR:` message — used
+        for a batch-level failure (D6/A1), left empty for a cleanup-time
+        error, which isn't a classified failure.
         """
         exc_type = type(exc).__name__
         exc_msg = str(exc)
-        self._console(f"[ERROR]: {exc_type} — check log")
+        self._console(f"[ERROR]: {prefix}{exc_type} — check log")
 
         tb = traceback.extract_tb(exc.__traceback__)
         frame_info = tb[-1] if tb else None

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/src/cascade_cms/operations.py

@@ -255,11 +255,28 @@ class OperationChain:
 
     def delete(
         self,
-        identifier: IdentifierType | Path,
+        identifier: IdentifierType
+        | Path
+        | Callable[[Any], IdentifierType | Path | list[IdentifierType | Path]],
         payload: deleteParameters | None = None,
         parser=parse_success,
     ) -> Self:
-        """Append a POST `delete/{type}/{id-or-path}` step for an asset."""
+        """Append a POST `delete/{type}/{id-or-path}` step for an asset.
+
+        `identifier` may be a callable, in which case it is invoked with the
+        previous node's result when the chain runs and returns the
+        identifier (or list of identifiers) to delete — that is how
+        `read → then(...) → create → delete` works in one chain. A list from
+        a callable is one multi-request node (partial failures stay in the
+        result list instead of stopping the chain, like a multi `create`).
+        """
+        if callable(identifier):
+            builder = partial(
+                self._build_delete_requests, parser=parser, payload=payload, resolver=identifier
+            )
+            return self._add_operation(
+                "delete", None, payload=payload, parser=parser, builder=builder
+            )
         return self._identifier_operation(
             op_name="delete",
             method="POST",
@@ -268,9 +285,55 @@ class OperationChain:
             parser=parser,
         )
 
-    def create(self, payload: list[NewAsset] | NewAsset, parser=None) -> Self:
-        """Append a POST `create` step for one or more new assets."""
+    def _build_delete_requests(
+        self,
+        previous: Any,
+        *,
+        parser: Any,
+        payload: deleteParameters | None,
+        resolver: Callable[[Any], Any],
+    ) -> list[RequestExecutor]:
+        """Build the delete requests from a callable's resolved identifier(s)."""
+        resolved = resolver(previous)
+        identifiers = resolved if isinstance(resolved, list) else [resolved]
+        if self._asset_identifier is None and identifiers:
+            self._asset_identifier = identifiers[0]
+        return [
+            RequestExecutor(
+                self._driver._build_url("delete", *resolve_identifier(ident)),
+                "POST",
+                parser,
+                payload=payload,
+                identifier=ident,
+            )
+            for ident in identifiers
+        ]
+
+    def create(
+        self,
+        payload: list[NewAsset] | NewAsset | Callable[[Any], NewAsset | list[NewAsset]],
+        parser=None,
+    ) -> Self:
+        """Append a POST `create` step for one or more new assets.
+
+        `payload` may be a callable, in which case it is invoked with the
+        previous node's result when the chain runs and returns the new
+        asset(s) to create.
+        """
+        if callable(payload):
+            builder = partial(self._build_create_requests, resolver=payload)
+            return self._add_operation(
+                "create", None, payload=payload, parser=parser, builder=builder
+            )
         multi = isinstance(payload, list)
+        requests = self._build_create_requests(None, resolver=payload)
+        return self._add_operation(
+            "create", requests, payload=payload, parser=parser, multi=multi
+        )
+
+    def _build_create_requests(self, previous: Any, *, resolver: Any) -> list[RequestExecutor]:
+        """Build the create requests, resolving a callable payload if needed."""
+        payload = resolver(previous) if callable(resolver) else resolver
         assets: list[NewAsset] = payload if isinstance(payload, list) else [payload]
 
         requests: list[RequestExecutor] = []
@@ -286,10 +349,7 @@ class OperationChain:
                     parser=bound_parser,  # This now only expects (raw)
                 )
             )
-
-        return self._add_operation(
-            "create", requests, payload=payload, parser=parser, multi=multi
-        )
+        return requests
 
     def edit(
         self,
@@ -488,7 +548,6 @@ class OperationChain:
         return self._add_operation(
             "readAudits",
             [request],
-            identifier=payload.by_identifier,
             payload=payload,
             parser=parser,
         )
@@ -559,7 +618,7 @@ class OperationChain:
         parser=parse_success,
     ) -> Self:
         """Append a POST `editWorkflowSettings/{type}/{id}` step for an asset."""
-        id_fields = payload.body["identifier"]
+        id_fields = payload.body.identifier
         url = self._driver._build_url(
             "editWorkflowSettings",
             id_fields.get_type,
@@ -653,6 +712,10 @@ class OperationChain:
         if requests is None:
             builder = data["builder"]
             requests = builder(previous)
+            # A callable payload only reveals its size now: several requests
+            # means a multi node (keep every result, never stop on one error).
+            if len(requests) > 1 and node.operation_data is not None:
+                node.operation_data["multi"] = True
         return requests
 
     def _resolve_operation_result(self, node: Node, raw: Any, step: int) -> tuple[Any, bool]:

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/src/cascade_cms/wrapper.py

@@ -34,13 +34,13 @@ class CascadeWrapperBase:
     code — code written after the `with` block does NOT run in that case.
     Pass `exit_on_failure=False` (e.g. when embedding this in a longer-lived
     process, such as an MCP server) to have `__exit__` never raise; results
-    stay available to the caller as values via `.ok`/`.failed`.
+    stay available to the caller as values via `.success`/`.failed`.
 
     Use as:
         with CascadeWrapperBase(env_vars, config_vars) as cascade:
             cascade.operations.read(identifier)
             results = cascade.submit_requests()
-            # results.ok / results.failed — no isinstance() checks needed.
+            # results.success / results.failed — no isinstance() checks needed.
     """
 
     def __enter__(self):
@@ -158,7 +158,7 @@ class CascadeWrapperBase:
         other chain.
 
         Returns a `ChainResults` — a list, in **chain-creation order** (so
-        `results[0]` belongs to the first chain built), with `.ok` (results
+        `results[0]` belongs to the first chain built), with `.success` (results
         from chains that didn't fail) and `.failed` (a `ChainFailure` per
         failed chain, naming the exact step and its category) added. Raw
         values (a `CascadeError`, or the exception a callback raised) stay

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/tests/test_cmstypes.py

@@ -232,3 +232,135 @@ def test_asset_root_container_id_known_and_unknown_types():
     )
     assert site.root_container_id("sharedfield") is None
     assert site.root_container_id("template") is None
+
+
+def test_audit_parameters_accept_plain_strings():
+    from cascade_cms.cmstypes import auditParameters
+
+    for kw, key in (("username", "username"), ("groupname", "groupname"), ("rolename", "rolename")):
+        params = auditParameters(audit_type="login", **{kw: "x"})
+        assert params.model_dump(by_alias=True)["auditParameters"][key] == "x"
+
+
+def test_audit_parameters_require_a_name():
+    import pytest
+    from pydantic import ValidationError
+
+    from cascade_cms.cmstypes import auditParameters
+
+    with pytest.raises(ValidationError):
+        auditParameters(audit_type="login")
+
+
+def test_new_asset_accepts_snake_and_camel_and_serializes_camel():
+    import json
+
+    from cascade_cms.cmstypes import NewAsset
+
+    sid = "8b320f55ac1001062545a6d2562cee4b"
+    snake = NewAsset(name="n", asset_type="page", site_id=sid, parent_folder_path="/")
+    camel = NewAsset(name="n", asset_type="page", siteId=sid, parentFolderPath="/")
+    for asset in (snake, camel):
+        body = json.loads(asset.dump_json())["asset"]["page"]
+        assert body["siteId"] == sid
+        assert body["parentFolderPath"] == "/"
+        assert "site_id" not in body
+
+
+def test_search_information_snake_fields_serialize_camel():
+    from cascade_cms.cmstypes import SearchInformation
+
+    dumped = SearchInformation(site_name="s", search_terms="t").model_dump(by_alias=True)
+    body = dumped["searchInformation"]
+    assert body["siteName"] == "s" and body["searchTerms"] == "t"
+
+
+def test_path_accepts_snake_and_camel_and_stays_hashable():
+    from cascade_cms.cmstypes import Path as CascadePath
+
+    camel = CascadePath(path="/a", siteName="s", asset_type="page")
+    snake = CascadePath(path="/a", site_name="s", asset_type="page")
+    assert camel == snake and hash(camel) == hash(snake)
+    assert camel.get_type == "page" and camel.get_id is None
+
+
+def test_identifier_type_nested_path_is_model():
+    ident = IdentifierType(
+        id="8b320f55ac1001062545a6d2562cee4b",
+        type="page",
+        path={"path": "a/b", "siteName": "s", "siteId": "9c431066bd21120736f6b7e3673dff5c"},
+    )
+    assert ident.get_path == "a/b" and ident.get_sitename == "s"
+    dumped = ident.model_dump(by_alias=True)["path"]
+    assert dumped["siteName"] == "s"
+    assert dumped["siteId"] == "9c431066bd21120736f6b7e3673dff5c"
+
+
+def test_workflow_settings_payload_roundtrip():
+    from cascade_cms.cmstypes import workflowSettingsPayload
+
+    ident = {"id": "8b320f55ac1001062545a6d2562cee4b", "type": "folder"}
+    payload = workflowSettingsPayload.model_validate(
+        {
+            "workflowSettings": {
+                "identifier": ident,
+                "workflowDefinitions": [],
+                "inheritedWorkflowDefinitions": [],
+                "inheritWorkflows": True,
+                "requireWorkflow": False,
+            },
+            "applyInheritWorkflowsToChildren": True,
+        }
+    )
+    assert payload.body.identifier.get_type == "folder"
+    assert payload.body.inherit_workflows is True
+    body = payload.model_dump(by_alias=True)["workflowSettingsPayload"]
+    assert body["workflowSettings"]["inheritWorkflows"] is True
+    assert body["applyInheritWorkflowsToChildren"] is True
+
+
+def test_access_rights_and_audit_models_validate():
+    from cascade_cms.cmstypes import AccessRightsModel, Audit
+
+    rights = AccessRightsModel.model_validate(
+        {
+            "identifier": {"id": "8b320f55ac1001062545a6d2562cee4b", "type": "user"},
+            "aclEntries": [{"level": "read", "type": "group", "name": "g"}],
+            "allLevel": "none",
+        }
+    )
+    assert rights.acl_entries[0].entry_type == "group" and rights.all_level == "none"
+    audit = Audit.model_validate(
+        {
+            "user": "u",
+            "action": "login",
+            "identifier": {"id": "8b320f55ac1001062545a6d2562cee4b", "type": "user"},
+            "date": "2026-01-01T00:00:00Z",
+        }
+    )
+    assert audit.user == "u"
+
+
+def test_list_elements_accepts_audits_key():
+    from cascade_cms.cmstypes import Audit
+
+    ident = {"id": "8b320f55ac1001062545a6d2562cee4b", "type": "user"}
+    result = ListElements.model_validate(
+        {
+            "audits": [
+                {"user": "u", "action": "login", "identifier": ident, "date": "2026-01-01T00:00:00Z"}
+            ]
+        }
+    )
+    assert isinstance(result.elements[0], Audit)
+
+
+def test_workflow_action_next_id_alias():
+    from cascade_cms.cmstypes import WorkflowAction
+
+    nid = "9c431066bd21120736f6b7e3673dff5c"
+    for key in ("nextId", "next_id"):
+        action = WorkflowAction.model_validate(
+            {"identifier": "a", "label": "l", "actionType": "t", key: nid}
+        )
+        assert action.next_id.hex == nid

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/tests/test_operation_chains.py

@@ -1120,3 +1120,58 @@ class TestEndToEndLoggedOutput:
         assert expected_line in lines
         assert f"{expected_line} -> Asset" not in lines
         assert "1/1 succeeded" in lines
+
+
+# ============================================================================
+# Callable create()/delete() payloads
+# ============================================================================
+
+class TestCallableCreateDelete:
+    """read → create(fn) → delete(fn) in one chain."""
+
+    def test_create_then_delete_resolve_from_previous_result(self, operations, mock_driver):
+        mock_driver._build_url.return_value = "http://cascade/api/x"
+        operations._logger.is_debug = False
+        read_id = IdentifierType(id=ID_ONE, type="page")
+        new_asset = MagicMock(asset_type="page")
+        created = make_asset(id=ID_TWO)
+        source = make_asset(id=ID_ONE, name="src")
+        seen = {}
+        mock_driver._submitRequests.side_effect = [
+            [source],
+            [created],
+            [CascadeSuccess()],
+        ]
+
+        def build_create(previous):
+            seen["create"] = previous
+            return new_asset
+
+        def pick_delete(previous):
+            seen["delete"] = previous
+            return read_id
+
+        chain = operations.read(read_id).create(build_create).delete(pick_delete)
+        result = chain.execute(mock_driver)
+
+        assert [n.operation_type for n in walk(chain)] == ["read", "create", "delete"]
+        assert seen["create"] is source
+        assert seen["delete"] is created
+        assert isinstance(result, CascadeSuccess)
+        delete_requests = mock_driver._submitRequests.call_args_list[2].args[0]
+        assert len(delete_requests) == 1
+        assert delete_requests[0].method == "POST"
+
+    def test_callable_returning_list_keeps_every_result(self, operations, mock_driver):
+        ids = [IdentifierType(id=ID_ONE, type="page"), IdentifierType(id=ID_TWO, type="page")]
+        err = CascadeError(success=False, message="nope")
+        mock_driver._submitRequests.side_effect = [
+            [make_asset(id=ID_ONE)],
+            [CascadeSuccess(), err],
+        ]
+
+        chain = operations.read(ids[0]).delete(lambda previous: ids)
+        result = chain.execute(mock_driver)
+
+        assert len(mock_driver._submitRequests.call_args_list[1].args[0]) == 2
+        assert result == [CascadeSuccess(), err]

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/tests/test_operation_logger.py

@@ -347,6 +347,41 @@ class TestBatchFraming:
         assert logger._failed_count == 1
 
 
+class TestExitTallyLine:
+    """D9: log_exit()'s printed tally line, exact strings."""
+
+    def _console(self, logger: OperationLogger) -> io.StringIO:
+        buffer = io.StringIO()
+        logger._console_logger.handlers[0].stream = buffer
+        return buffer
+
+    def test_all_succeeded(self, tmp_path):
+        logger = OperationLogger(server="test", debug_config={"log_dir": str(tmp_path)})
+        buffer = self._console(logger)
+        logger.log_batch_start()
+        logger.log_batch_end(succeeded=5, total=5, has_reportable_failure=False)
+        logger.log_exit()
+        assert "0 failed, 5 succeeded" in buffer.getvalue()
+        assert "reference log for details" not in buffer.getvalue()
+
+    def test_reportable_failure_appends_suffix(self, tmp_path):
+        logger = OperationLogger(server="test", debug_config={"log_dir": str(tmp_path)})
+        buffer = self._console(logger)
+        logger.log_batch_start()
+        logger.log_batch_end(succeeded=3, total=5, has_reportable_failure=True)
+        logger.log_exit()
+        assert "2 failed, 3 succeeded: reference log for details" in buffer.getvalue()
+
+    def test_callback_only_failure_has_no_suffix(self, tmp_path):
+        logger = OperationLogger(server="test", debug_config={"log_dir": str(tmp_path)})
+        buffer = self._console(logger)
+        logger.log_batch_start()
+        logger.log_batch_end(succeeded=4, total=5, has_reportable_failure=False)
+        logger.log_exit()
+        assert "1 failed, 4 succeeded" in buffer.getvalue()
+        assert "reference log for details" not in buffer.getvalue()
+
+
 # ============================================================================
 # Normal (non-debug) mode
 # ============================================================================

{cascade_cms_rest-3.2.0 → cascade_cms_rest-3.2.2}/tests/test_wrapper.py

@@ -4,6 +4,7 @@ Test suite for the D5/D8/D9 error-handling redesign: failure classification,
 """
 
 import asyncio
+import io
 import subprocess
 import sys
 import textwrap
@@ -114,13 +115,13 @@ class TestChainResults:
             message="nope",
         )
         results = ChainResults(["good", failure.error], [None, failure])
-        assert results.ok == ["good"]
+        assert results.success == ["good"]
         assert results.failed == [failure]
 
     def test_empty_results(self):
         results = ChainResults()
         assert list(results) == []
-        assert results.ok == []
+        assert results.success == []
         assert results.failed == []
 
 
@@ -180,7 +181,7 @@ class TestSubmitRequestsChainResults:
 
         assert isinstance(results, ChainResults)
         assert len(results) == 2
-        assert results.ok == [asset1]
+        assert results.success == [asset1]
         assert len(results.failed) == 1
         assert results.failed[0].category == FailureCategory.CASCADE
 
@@ -203,6 +204,51 @@ class TestSubmitRequestsChainResults:
         assert wrapper._callback_failures == [results.failed[0]]
         assert wrapper._has_reportable_failure is False
 
+    def test_other_chains_finish_before_callback_exception_is_raised(self):
+        """Chain 1's callback raises; chain 2 has no callback and should
+        still complete and land in `.success` — a callback exception stops only
+        its own chain."""
+        driver = StubDriver([[make_asset(id=ID_ONE)], [make_asset(id=ID_TWO)]])
+        wrapper = make_wrapper(driver)
+
+        def boom(_asset):
+            raise ValueError("bad asset")
+
+        wrapper.operations.read(IdentifierType(id=ID_ONE, type="page")).then(boom)
+        wrapper.operations.read(IdentifierType(id=ID_TWO, type="page"))
+
+        try:
+            results = wrapper.submit_requests()
+        finally:
+            driver.eventLoop.close()
+
+        assert len(results.success) == 1
+        assert results.success[0].get("id") == ID_TWO
+        assert len(results.failed) == 1
+        assert results.failed[0].category == FailureCategory.CALLBACK
+
+    def test_batch_error_console_line_carries_prefix(self, tmp_path):
+        logger = OperationLogger(server="TESTSRV", debug_config={"log_dir": str(tmp_path)})
+        buffer = io.StringIO()
+        logger._console_logger.handlers[0].stream = buffer
+
+        driver = StubDriver([])
+        wrapper = make_wrapper(driver, logger=logger)
+        wrapper.operations.read(IdentifierType(id=ID_ONE, type="page"))
+
+        async def _broken_execute_chains(chains, executor=None):
+            raise RuntimeError("event loop broke")
+
+        wrapper._execute_chains = _broken_execute_chains
+
+        try:
+            with pytest.raises(CascadeBatchError):
+                wrapper.submit_requests()
+        finally:
+            driver.eventLoop.close()
+
+        assert "[ERROR]: [CASCADE-REST-CMS] RuntimeError — check log" in buffer.getvalue()
+
     def test_empty_queue_returns_empty_chain_results(self):
         driver = StubDriver([])
         wrapper = make_wrapper(driver)