feat: add str handling for ElasticsearchDocumentStore api_key (#2934)

* feat: add str handling for ElasticsearchDocumentStore api_key

* apply feedback: don't serialize api_key as str

Author: tstadel

integrations/elasticsearch/src/haystack_integrations/document_stores/elasticsearch/document_store.py

@@ -16,7 +16,7 @@
 from haystack.dataclasses import Document
 from haystack.document_stores.errors import DocumentStoreError, DuplicateDocumentError
 from haystack.document_stores.types import DuplicatePolicy
-from haystack.utils import Secret, deserialize_secrets_inplace
+from haystack.utils import Secret
 from haystack.version import __version__ as haystack_version
 
 from elasticsearch import AsyncElasticsearch, Elasticsearch, helpers
@@ -82,8 +82,8 @@ def __init__(
         hosts: Hosts | None = None,
         custom_mapping: dict[str, Any] | None = None,
         index: str = "default",
-        api_key: Secret = Secret.from_env_var("ELASTIC_API_KEY", strict=False),
-        api_key_id: Secret = Secret.from_env_var("ELASTIC_API_KEY_ID", strict=False),
+        api_key: Secret | str | None = Secret.from_env_var("ELASTIC_API_KEY", strict=False),
+        api_key_id: Secret | str | None = Secret.from_env_var("ELASTIC_API_KEY_ID", strict=False),
         embedding_similarity_function: Literal["cosine", "dot_product", "l2_norm", "max_inner_product"] = "cosine",
         **kwargs: Any,
     ):
@@ -217,8 +217,10 @@ def _handle_auth(self) -> str | tuple[str, str] | None:
 
         api_key: str | tuple[str, str] | None  # make the type checker happy
 
-        api_key_resolved = self._api_key.resolve_value()
-        api_key_id_resolved = self._api_key_id.resolve_value()
+        api_key_resolved = self._api_key.resolve_value() if isinstance(self._api_key, Secret) else self._api_key
+        api_key_id_resolved = (
+            self._api_key_id.resolve_value() if isinstance(self._api_key_id, Secret) else self._api_key_id
+        )
 
         # Scenario 1: both are found, use them
         if api_key_id_resolved and api_key_resolved:
@@ -271,8 +273,8 @@ def to_dict(self) -> dict[str, Any]:
             hosts=self._hosts,
             custom_mapping=self._custom_mapping,
             index=self._index,
-            api_key=self._api_key.to_dict(),
-            api_key_id=self._api_key_id.to_dict(),
+            api_key=self._api_key.to_dict() if isinstance(self._api_key, Secret) else None,
+            api_key_id=self._api_key_id.to_dict() if isinstance(self._api_key_id, Secret) else None,
             embedding_similarity_function=self._embedding_similarity_function,
             **self._kwargs,
         )
@@ -287,7 +289,10 @@ def from_dict(cls, data: dict[str, Any]) -> "ElasticsearchDocumentStore":
         :returns:
             Deserialized component.
         """
-        deserialize_secrets_inplace(data, keys=["api_key", "api_key_id"], recursive=True)
+        if (api_key := data.get("api_key")) is not None and isinstance(api_key, dict):
+            data["api_key"] = Secret.from_dict(api_key)
+        if (api_key_id := data.get("api_key_id")) is not None and isinstance(api_key_id, dict):
+            data["api_key_id"] = Secret.from_dict(api_key_id)
         return default_from_dict(cls, data)
 
     def count_documents(self) -> int:

integrations/elasticsearch/tests/test_document_store.py

@@ -108,6 +108,15 @@ def test_to_dict_with_api_keys_as_secret():
         _ = document_store.to_dict()
 
 
+def test_to_dict_with_api_keys_str():
+    document_store = ElasticsearchDocumentStore(
+        hosts="https://localhost:9200", api_key="my_api_key", api_key_id="my_api_key_id"
+    )
+    res = document_store.to_dict()
+    assert res["init_parameters"]["api_key"] is None
+    assert res["init_parameters"]["api_key_id"] is None
+
+
 def test_from_dict_with_api_keys_env_vars():
     data = {
         "type": "haystack_integrations.document_stores.elasticsearch.document_store.ElasticsearchDocumentStore",
@@ -126,6 +135,24 @@ def test_from_dict_with_api_keys_env_vars():
     assert document_store._api_key_id == Secret.from_env_var("ELASTIC_API_KEY_ID", strict=False)
 
 
+def test_from_dict_with_api_keys_str():
+    data = {
+        "type": "haystack_integrations.document_stores.elasticsearch.document_store.ElasticsearchDocumentStore",
+        "init_parameters": {
+            "hosts": "some hosts",
+            "custom_mapping": None,
+            "index": "default",
+            "api_key": "my_api_key",
+            "api_key_id": "my_api_key_id",
+            "embedding_similarity_function": "cosine",
+        },
+    }
+
+    document_store = ElasticsearchDocumentStore.from_dict(data)
+    assert document_store._api_key == "my_api_key"
+    assert document_store._api_key_id == "my_api_key_id"
+
+
 def test_api_key_validation_only_api_key():
     api_key = Secret.from_token("test_api_key")
     document_store = ElasticsearchDocumentStore(hosts="https://localhost:9200", api_key=api_key)
@@ -173,7 +200,7 @@ def test_client_initialization_with_api_key_tuple(_mock_async_es, _mock_es):
 @patch("haystack_integrations.document_stores.elasticsearch.document_store.Elasticsearch")
 @patch("haystack_integrations.document_stores.elasticsearch.document_store.AsyncElasticsearch")
 def test_client_initialization_with_api_key_string(_mock_async_es, _mock_es):
-    api_key = Secret.from_token("test_api_key")
+    api_key = "test_api_key"
 
     # Mock the client.info() call to avoid actual connection
     mock_client = Mock()