matrx-orm 3.1.53__tar.gz → 3.1.55__tar.gz

{matrx_orm-3.1.53 → matrx_orm-3.1.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: matrx-orm
-Version: 3.1.53
+Version: 3.1.55
 Summary: Async-first PostgreSQL ORM with bidirectional migrations, schema introspection, many-to-many relationships, and built-in state caching
 Project-URL: Homepage, https://github.com/AI-Matrix-Engine/aidream-current
 Project-URL: Repository, https://github.com/AI-Matrix-Engine/aidream-current

{matrx_orm-3.1.53 → matrx_orm-3.1.55}/matrx_orm/catalog.py

@@ -292,6 +292,37 @@ async def first_party_function_bodies(
     return [{"name": str(row["name"]), "source": str(row["source"] or "")} for row in rows]
 
 
+async def first_party_view_definitions(
+    database: str,
+    *,
+    exclude_schemas: list[str],
+) -> list[dict[str, str]]:
+    """Return live view names and definitions outside excluded schemas.
+
+    The view twin of :func:`first_party_function_bodies`. Together they are the
+    whole surface a "does any live SQL object still inline this rule?" drift
+    guard needs — a rule that is COPIED into a view drifts exactly as fast as
+    one copied into a function.
+    """
+    rows = await _query(
+        database,
+        """
+        SELECT n.nspname || '.' || c.relname AS name,
+               pg_get_viewdef(c.oid, true) AS definition
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relkind IN ('v', 'm')
+          AND n.nspname <> ALL($1::text[])
+        ORDER BY n.nspname, c.relname
+        """,
+        exclude_schemas,
+    )
+    return [
+        {"name": str(row["name"]), "definition": str(row["definition"] or "")}
+        for row in rows
+    ]
+
+
 async def relation_privileges(
     database: str,
     *,

{matrx_orm-3.1.53 → matrx_orm-3.1.55}/matrx_orm/secrets_battery/FEATURE.md

@@ -26,6 +26,16 @@ charset-validated here — `provider_key`, `display_name`, `tags`, `status`,
 alias (nullable). A DB trigger (`trg_user_secrets_owner_match`) rejects any field
 row whose owner columns don't match its item's owner.
 
+Items may also own N encrypted **file attachments**
+(`users.credential_attachments`). An attachment has its own stable id,
+human label/purpose, filename, media type, byte size, handling mode, version,
+and audit lifecycle; ownership, grants, transfer, fork, and deletion always
+come from the parent item. The bytes are encrypted directly with the same
+Fernet singleton and `CREDENTIALS_ENCRYPTION_KEY` as fields—there is no object
+store copy and no second crypto primitive. Credential files are capped at
+25 MiB; this is for signing keys, certificates, recovery exports, and similar
+artifacts, not general document storage.
+
 **Handling doctrine** — every field has `handling` + `editable` + `inject_into_sandbox`:
 
 | handling | human-facing read | trusted execution |
@@ -68,6 +78,14 @@ soft, atomic across item + fields + grants) · `add_credential_field` ·
 `fork_credential_item` (independent copy) · `resolve_legacy_env_key` (compat
 read that SCREAMS in logs until call sites migrate to stable references).
 
+Attachment surface (`attachments.py`): add/list/get/update metadata/replace/
+soft-delete; `reveal_credential_attachment` is the audited human download and
+refuses sealed bytes; `resolve_credential_attachment` is the trusted in-process
+path. Parent delete soft-deletes attachments atomically; fork decrypts and
+re-encrypts independent child rows; transfer needs no child rewrite because
+the parent is the sole ownership authority. Browser-facing list shapes never
+contain ciphertext or plaintext.
+
 **Grants: use the single-grant operations.** `add_item_grant` /
 `update_item_grant` / `remove_item_grant` change ONE recipient and leave the
 rest alone. `set_item_grants` REPLACES the whole set (delete + recreate) and
@@ -238,6 +256,10 @@ create, reveal, sealed denial, editable gate, rotate, item grants, soft delete).
 
 ## Change Log
 
+- **2026-08-11** — Added first-class encrypted credential-file attachments with
+  parent-owned access/lifecycle, a 25 MiB cap, one-way sealing, audited human
+  download, trusted execution resolution, and fork/delete inheritance.
+
 - 2026-07-26 — Closed the silent sandbox-injection gap: `SandboxInjectionWithoutEnvKeyError` at every field write path, a loud ERROR-and-skip in `for_sandbox` bulk resolution, and DB CHECK `user_secrets_sandbox_injection_needs_key` (+ column default `true`→`false`). Live at the time of the fix: 0 broken rows, but 61 keyless item fields were one toggle away from it.
 - 2026-07-23 — `update_field_metadata` primitive (metadata-only, version-preserving; `users.bump_user_secret_value_version` verified value-conditional live — no trigger change needed).
 - 2026-07-23 — Adversarial-review hardening: include_sealed-aware bulk env resolution (+ keyless-row exclusion), ItemManagedSecretError legacy-write guards + legacy audit rows, ItemGrantSpec per-grantee grants, reveal liveness filters, rotate liveness re-check + audits inside owning transactions.

{matrx_orm-3.1.53 → matrx_orm-3.1.55}/matrx_orm/secrets_battery/__init__.py

@@ -24,11 +24,27 @@ Contract details: ``FEATURE.md`` beside this module.
 
 from __future__ import annotations
 
+from .attachments import (
+    MAX_VAULT_ATTACHMENT_BYTES,
+    CredentialAttachmentRow,
+    add_credential_attachment,
+    copy_item_attachments,
+    delete_credential_attachment,
+    get_credential_attachment,
+    list_credential_attachments,
+    replace_credential_attachment,
+    resolve_credential_attachment,
+    reveal_credential_attachment,
+    soft_delete_item_attachments,
+    update_credential_attachment_metadata,
+)
 from .crypto import (
     configure_encryption,
+    decrypt_bytes,
     decrypt_payload,
     decrypt_value,
     encrypt_payload,
+    encrypt_bytes,
     encrypt_value,
     fernet_for_key,
     get_fernet,
@@ -75,7 +91,14 @@ from .items import (
     update_credential_item,
     update_field_metadata,
 )
-from .model import PACKAGE_DB_NAME, CredentialItem, UserSecret, UserSecretAudit, UserSecretGrant
+from .model import (
+    PACKAGE_DB_NAME,
+    CredentialAttachment,
+    CredentialItem,
+    UserSecret,
+    UserSecretAudit,
+    UserSecretGrant,
+)
 from .org_service import (
     ACCESS_MODES,
     OrgSecretRow,
@@ -139,6 +162,20 @@ __all__ = [
     "configure_encryption",
     "fernet_for_key",
     "multi_fernet_for_keys",
+    # attachment layer
+    "MAX_VAULT_ATTACHMENT_BYTES",
+    "CredentialAttachment",
+    "CredentialAttachmentRow",
+    "add_credential_attachment",
+    "copy_item_attachments",
+    "delete_credential_attachment",
+    "get_credential_attachment",
+    "list_credential_attachments",
+    "replace_credential_attachment",
+    "resolve_credential_attachment",
+    "reveal_credential_attachment",
+    "soft_delete_item_attachments",
+    "update_credential_attachment_metadata",
     # item layer
     "FIELD_KEY_RE",
     "HANDLING_MODES",
@@ -182,6 +219,8 @@ __all__ = [
     "get_fernet",
     "encrypt_value",
     "decrypt_value",
+    "encrypt_bytes",
+    "decrypt_bytes",
     "encrypt_payload",
     "decrypt_payload",
     "mask_value",

matrx_orm-3.1.55/matrx_orm/secrets_battery/attachments.py

@@ -0,0 +1,419 @@
+"""Encrypted file attachments for credential items.
+
+Attachments are child entities with their own identity and lifecycle, while
+ownership and sharing remain exclusively on the parent credential item. File
+bytes use the existing Vault Fernet primitive directly; no base64 wrapper,
+object-store plaintext, or second encryption path is introduced.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from typing import Any
+
+from .crypto import decrypt_bytes, encrypt_bytes
+from .items import CredentialItemNotFoundError, HANDLING_MODES, SealedFieldError
+from .model import CredentialAttachment, CredentialItem
+from .org_service import record_secret_audit
+from .service import SecretDecryptError
+
+MAX_VAULT_ATTACHMENT_BYTES = 25 * 1024 * 1024
+
+_ATTACHMENT_FIELDS = (
+    "id",
+    "credential_item_id",
+    "label",
+    "description",
+    "file_name",
+    "media_type",
+    "size_bytes",
+    "handling",
+    "value_version",
+    "last_used_at",
+    "created_at",
+    "updated_at",
+)
+
+
+@dataclass(frozen=True)
+class CredentialAttachmentRow:
+    """Masked attachment metadata. Never contains ciphertext or plaintext."""
+
+    id: str
+    credential_item_id: str
+    label: str
+    description: str | None
+    file_name: str
+    media_type: str
+    size_bytes: int
+    handling: str
+    value_version: int
+    last_used_at: str | None
+    created_at: str
+    updated_at: str
+
+    def to_dict(self) -> dict[str, Any]:
+        return dict(self.__dict__)
+
+
+def _iso(value: Any) -> str:
+    if isinstance(value, datetime):
+        return value.isoformat()
+    return str(value)
+
+
+def _row(raw: dict[str, Any]) -> CredentialAttachmentRow:
+    return CredentialAttachmentRow(
+        id=str(raw["id"]),
+        credential_item_id=str(raw["credential_item_id"]),
+        label=str(raw["label"]),
+        description=raw.get("description"),
+        file_name=str(raw["file_name"]),
+        media_type=str(raw.get("media_type") or "application/octet-stream"),
+        size_bytes=int(raw["size_bytes"]),
+        handling=str(raw.get("handling") or "revealable"),
+        value_version=int(raw.get("value_version") or 1),
+        last_used_at=_iso(raw["last_used_at"]) if raw.get("last_used_at") else None,
+        created_at=_iso(raw["created_at"]),
+        updated_at=_iso(raw["updated_at"]),
+    )
+
+
+async def _require_item(item_id: str) -> None:
+    if not await CredentialItem.filter(id=item_id, deleted_at__isnull=True).exists():
+        raise CredentialItemNotFoundError(f"credential item {item_id} not found")
+
+
+async def _require_raw(attachment_id: str) -> dict[str, Any]:
+    rows = await CredentialAttachment.filter(id=attachment_id, deleted_at__isnull=True).values(
+        *_ATTACHMENT_FIELDS, "value_encrypted"
+    )
+    if not rows:
+        raise LookupError(f"credential attachment {attachment_id} not found")
+    return rows[0]
+
+
+def _validate_text(value: str, *, name: str, maximum: int) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"{name} is required")
+    clean = value.strip()
+    if len(clean) > maximum:
+        raise ValueError(f"{name} must be at most {maximum} characters")
+    return clean
+
+
+def _validate_content(content: bytes) -> None:
+    if not isinstance(content, bytes):
+        raise TypeError("attachment content must be bytes")
+    if not content:
+        raise ValueError("attachment file is empty")
+    if len(content) > MAX_VAULT_ATTACHMENT_BYTES:
+        raise ValueError("attachment exceeds the 25 MiB credential-file limit")
+
+
+def _validate_handling(handling: str) -> None:
+    if handling not in HANDLING_MODES:
+        raise ValueError(f"handling must be one of {HANDLING_MODES}; got {handling!r}")
+
+
+def _media_type(value: str | None) -> str:
+    if not value:
+        return "application/octet-stream"
+    return _validate_text(value.split(";", 1)[0], name="media_type", maximum=255)
+
+
+async def list_credential_attachments(
+    item_ids: list[str],
+) -> dict[str, list[CredentialAttachmentRow]]:
+    """Return masked live attachments grouped by parent item id."""
+    if not item_ids:
+        return {}
+    rows = (
+        await CredentialAttachment.filter(credential_item_id__in=item_ids, deleted_at__isnull=True)
+        .order_by("created_at", "id")
+        .values(*_ATTACHMENT_FIELDS)
+    )
+    grouped: dict[str, list[CredentialAttachmentRow]] = {}
+    for raw in rows:
+        grouped.setdefault(str(raw["credential_item_id"]), []).append(_row(raw))
+    return grouped
+
+
+async def get_credential_attachment(attachment_id: str) -> CredentialAttachmentRow | None:
+    rows = await CredentialAttachment.filter(id=attachment_id, deleted_at__isnull=True).values(
+        *_ATTACHMENT_FIELDS
+    )
+    return _row(rows[0]) if rows else None
+
+
+async def add_credential_attachment(
+    item_id: str,
+    *,
+    label: str,
+    description: str | None,
+    file_name: str,
+    media_type: str | None,
+    content: bytes,
+    handling: str = "revealable",
+    actor_id: str | None = None,
+) -> CredentialAttachmentRow:
+    """Encrypt and attach one file to an existing credential item."""
+    await _require_item(item_id)
+    _validate_content(content)
+    _validate_handling(handling)
+    clean_label = _validate_text(label, name="label", maximum=200)
+    clean_name = _validate_text(file_name, name="file_name", maximum=512)
+    clean_description = (
+        _validate_text(description, name="description", maximum=2000)
+        if description and description.strip()
+        else None
+    )
+    instance = await CredentialAttachment.create(
+        credential_item_id=item_id,
+        label=clean_label,
+        description=clean_description,
+        file_name=clean_name,
+        media_type=_media_type(media_type),
+        size_bytes=len(content),
+        value_encrypted=encrypt_bytes(content),
+        handling=handling,
+        created_by=actor_id,
+        updated_by=actor_id,
+    )
+    await record_secret_audit(
+        action="attachment_added",
+        actor_id=actor_id,
+        metadata={
+            "credential_item_id": item_id,
+            "attachment_id": str(instance.id),
+            "file_name": clean_name,
+            "size_bytes": len(content),
+            "handling": handling,
+        },
+    )
+    row = await get_credential_attachment(str(instance.id))
+    if row is None:
+        raise RuntimeError(f"credential attachment {instance.id} vanished after create")
+    return row
+
+
+_UNSET: Any = object()
+
+
+async def update_credential_attachment_metadata(
+    attachment_id: str,
+    *,
+    label: str | None = None,
+    description: Any = _UNSET,
+    file_name: str | None = None,
+    handling: str | None = None,
+    actor_id: str | None = None,
+) -> CredentialAttachmentRow:
+    """Patch safe metadata without touching bytes or ``value_version``."""
+    raw = await _require_raw(attachment_id)
+    if handling is not None:
+        _validate_handling(handling)
+        if str(raw["handling"]) == "sealed" and handling != "sealed":
+            raise SealedFieldError(
+                f"attachment {raw['file_name']!r} is sealed — sealing is a one-way door"
+            )
+    updates: dict[str, Any] = {"updated_by": actor_id, "updated_at": datetime.now(UTC)}
+    if label is not None:
+        updates["label"] = _validate_text(label, name="label", maximum=200)
+    if description is not _UNSET:
+        updates["description"] = (
+            _validate_text(description, name="description", maximum=2000)
+            if isinstance(description, str) and description.strip()
+            else None
+        )
+    if file_name is not None:
+        updates["file_name"] = _validate_text(file_name, name="file_name", maximum=512)
+    if handling is not None:
+        updates["handling"] = handling
+    changed = sorted(set(updates) - {"updated_by", "updated_at"})
+    if not changed:
+        raise ValueError("no attachment metadata changes supplied")
+    await CredentialAttachment.update_where({"id": attachment_id}, **updates)
+    await record_secret_audit(
+        action="attachment_updated",
+        actor_id=actor_id,
+        metadata={
+            "credential_item_id": str(raw["credential_item_id"]),
+            "attachment_id": attachment_id,
+            "changed": changed,
+        },
+    )
+    row = await get_credential_attachment(attachment_id)
+    if row is None:
+        raise LookupError(f"credential attachment {attachment_id} not found")
+    return row
+
+
+async def replace_credential_attachment(
+    attachment_id: str,
+    *,
+    file_name: str,
+    media_type: str | None,
+    content: bytes,
+    actor_id: str | None = None,
+) -> CredentialAttachmentRow:
+    """Atomically replace the encrypted bytes and file metadata."""
+    raw = await _require_raw(attachment_id)
+    _validate_content(content)
+    clean_name = _validate_text(file_name, name="file_name", maximum=512)
+    await CredentialAttachment.update_where(
+        {"id": attachment_id, "deleted_at__isnull": True},
+        file_name=clean_name,
+        media_type=_media_type(media_type),
+        size_bytes=len(content),
+        value_encrypted=encrypt_bytes(content),
+        updated_by=actor_id,
+        updated_at=datetime.now(UTC),
+    )
+    await record_secret_audit(
+        action="attachment_replaced",
+        actor_id=actor_id,
+        metadata={
+            "credential_item_id": str(raw["credential_item_id"]),
+            "attachment_id": attachment_id,
+            "file_name": clean_name,
+            "size_bytes": len(content),
+        },
+    )
+    row = await get_credential_attachment(attachment_id)
+    if row is None:
+        raise LookupError(f"credential attachment {attachment_id} not found")
+    return row
+
+
+async def delete_credential_attachment(attachment_id: str, *, actor_id: str | None = None) -> bool:
+    raw = await _require_raw(attachment_id)
+    now = datetime.now(UTC)
+    result = await CredentialAttachment.update_where(
+        {"id": attachment_id, "deleted_at__isnull": True},
+        deleted_at=now,
+        updated_by=actor_id,
+        updated_at=now,
+    )
+    if result.rows_affected:
+        await record_secret_audit(
+            action="attachment_deleted",
+            actor_id=actor_id,
+            metadata={
+                "credential_item_id": str(raw["credential_item_id"]),
+                "attachment_id": attachment_id,
+                "file_name": str(raw["file_name"]),
+            },
+        )
+    return result.rows_affected > 0
+
+
+async def reveal_credential_attachment(
+    attachment_id: str, *, actor_id: str | None = None
+) -> tuple[CredentialAttachmentRow, bytes]:
+    """Human download path. Sealed bytes are structurally refused."""
+    raw = await _require_raw(attachment_id)
+    if str(raw["handling"]) == "sealed":
+        await record_secret_audit(
+            action="attachment_download_denied",
+            actor_id=actor_id,
+            metadata={
+                "credential_item_id": str(raw["credential_item_id"]),
+                "attachment_id": attachment_id,
+                "reason": "sealed",
+            },
+        )
+        raise SealedFieldError(
+            f"attachment {raw['file_name']!r} is sealed — no human-facing API may return it"
+        )
+    try:
+        content = decrypt_bytes(raw["value_encrypted"])
+    except Exception as exc:
+        raise SecretDecryptError(
+            f"credential attachment {attachment_id} does not decrypt with the configured key"
+        ) from exc
+    await CredentialAttachment.update_where({"id": attachment_id}, last_used_at=datetime.now(UTC))
+    await record_secret_audit(
+        action="attachment_downloaded",
+        actor_id=actor_id,
+        metadata={
+            "credential_item_id": str(raw["credential_item_id"]),
+            "attachment_id": attachment_id,
+            "file_name": str(raw["file_name"]),
+            "size_bytes": int(raw["size_bytes"]),
+        },
+    )
+    return _row(raw), content
+
+
+async def resolve_credential_attachment(
+    attachment_id: str,
+) -> tuple[CredentialAttachmentRow, bytes]:
+    """Trusted execution path, including sealed attachments."""
+    raw = await _require_raw(attachment_id)
+    try:
+        content = decrypt_bytes(raw["value_encrypted"])
+    except Exception as exc:
+        raise SecretDecryptError(
+            f"credential attachment {attachment_id} does not decrypt with the configured key"
+        ) from exc
+    await CredentialAttachment.update_where({"id": attachment_id}, last_used_at=datetime.now(UTC))
+    return _row(raw), content
+
+
+async def soft_delete_item_attachments(item_id: str, *, actor_id: str | None = None) -> int:
+    """Soft-delete every live attachment when its parent item is deleted."""
+    now = datetime.now(UTC)
+    result = await CredentialAttachment.update_where(
+        {"credential_item_id": item_id, "deleted_at__isnull": True},
+        deleted_at=now,
+        updated_by=actor_id,
+        updated_at=now,
+    )
+    return result.rows_affected
+
+
+async def copy_item_attachments(
+    source_item_id: str,
+    destination_item_id: str,
+    *,
+    actor_id: str | None = None,
+) -> int:
+    """Re-encrypt independent attachment rows for a forked item."""
+    rows = await CredentialAttachment.filter(
+        credential_item_id=source_item_id, deleted_at__isnull=True
+    ).values(*_ATTACHMENT_FIELDS, "value_encrypted")
+    copied = 0
+    for raw in rows:
+        content = decrypt_bytes(raw["value_encrypted"])
+        await CredentialAttachment.create(
+            credential_item_id=destination_item_id,
+            label=raw["label"],
+            description=raw.get("description"),
+            file_name=raw["file_name"],
+            media_type=raw["media_type"],
+            size_bytes=raw["size_bytes"],
+            value_encrypted=encrypt_bytes(content),
+            handling=raw["handling"],
+            created_by=actor_id,
+            updated_by=actor_id,
+        )
+        copied += 1
+    return copied
+
+
+__all__ = [
+    "MAX_VAULT_ATTACHMENT_BYTES",
+    "CredentialAttachmentRow",
+    "add_credential_attachment",
+    "copy_item_attachments",
+    "delete_credential_attachment",
+    "get_credential_attachment",
+    "list_credential_attachments",
+    "replace_credential_attachment",
+    "resolve_credential_attachment",
+    "reveal_credential_attachment",
+    "soft_delete_item_attachments",
+    "update_credential_attachment_metadata",
+]

{matrx_orm-3.1.53 → matrx_orm-3.1.55}/matrx_orm/secrets_battery/crypto.py

@@ -130,6 +130,21 @@ def decrypt_value(ciphertext: bytes) -> str:
     return get_fernet().decrypt(bytes(ciphertext)).decode("utf-8")
 
 
+# ── Binary secrets (users.credential_attachments) ────────────────────────
+
+
+def encrypt_bytes(plaintext: bytes) -> bytes:
+    if not isinstance(plaintext, bytes):
+        raise TypeError("plaintext must be bytes")
+    return get_fernet().encrypt(plaintext)
+
+
+def decrypt_bytes(ciphertext: bytes) -> bytes:
+    if not isinstance(ciphertext, bytes | bytearray | memoryview):
+        raise TypeError("ciphertext must be bytes-like")
+    return get_fernet().decrypt(bytes(ciphertext))
+
+
 # ── Dict payloads (tool.mcp_user_conn credential blobs) ──────────────────
 
 
@@ -165,6 +180,8 @@ __all__ = [
     "get_fernet",
     "encrypt_value",
     "decrypt_value",
+    "encrypt_bytes",
+    "decrypt_bytes",
     "encrypt_payload",
     "decrypt_payload",
     "mask_value",

{matrx_orm-3.1.53 → matrx_orm-3.1.55}/matrx_orm/secrets_battery/items.py

@@ -668,7 +668,10 @@ async def delete_credential_item(
     raw = await _require_item_raw(item_id)
     now = datetime.now(UTC)
     async with transaction(PACKAGE_DB_NAME):
+        from .attachments import soft_delete_item_attachments
+
         await UserSecretGrant.delete_where(credential_item_id=item_id)
+        await soft_delete_item_attachments(item_id, actor_id=actor_id)
         await UserSecret.update_where(
             {"credential_item_id": item_id, "deleted_at__isnull": True},
             deleted_at=now,
@@ -1197,9 +1200,9 @@ async def add_item_grant(
     if not user_id:
         raise ValueError("grant user_id is required")
     await _require_item_raw(item_id)
-    existing = await UserSecretGrant.filter(
-        credential_item_id=item_id, user_id=user_id
-    ).values("id")
+    existing = await UserSecretGrant.filter(credential_item_id=item_id, user_id=user_id).values(
+        "id"
+    )
     if existing:
         grant_id = str(existing[0]["id"])
         await UserSecretGrant.update_where(
@@ -1462,12 +1465,19 @@ async def fork_credential_item(
                 created_by=actor_id,
                 updated_by=actor_id,
             )
+        from .attachments import copy_item_attachments
+
+        attachment_count = await copy_item_attachments(item_id, str(new_item.id), actor_id=actor_id)
         await record_secret_audit(
             action="item_forked",
             actor_id=actor_id,
             organization_id=to_organization_id,
             user_id=to_user_id,
-            metadata={"credential_item_id": str(new_item.id), "forked_from": item_id},
+            metadata={
+                "credential_item_id": str(new_item.id),
+                "forked_from": item_id,
+                "attachment_count": attachment_count,
+            },
         )
     item = await get_credential_item(str(new_item.id))
     if item is None:  # pragma: no cover