salesforce-data-customcode 6.1.0.dev3__py3-none-any.whl → 6.1.0.dev5__py3-none-any.whl

datacustomcode/named_credential/base.py

@@ -1,54 +0,0 @@
-# Copyright (c) 2025, Salesforce, Inc.
-# SPDX-License-Identifier: Apache-2
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Optional
-
-from datacustomcode.mixin import UserExtendableNamedConfigMixin
-
-if TYPE_CHECKING:
-    from datacustomcode.named_credential.types.http_request import HTTPRequest
-    from datacustomcode.named_credential.types.http_response import HTTPResponse
-
-
-class NamedCredential(ABC, UserExtendableNamedConfigMixin):
-    CONFIG_NAME: str
-
-    def __init__(self, **kwargs):
-        pass
-
-    @abstractmethod
-    def request(
-        self,
-        request: HTTPRequest,
-        body: Optional[str] = None,
-    ) -> HTTPResponse:
-        """Make an external callout through a Named Credential.
-
-        The endpoint and its authentication are resolved server-side from the
-        Named Credential referenced by ``request.url``; the function never sees
-        the external credential.
-
-        Args:
-            request: The callout request
-            body: Optional request body. Set the
-                ``Content-Type`` header to match the format; the SDK
-                does not assume or inject one.
-
-        Returns:
-            The external service's response.
-        """
-        ...

datacustomcode/named_credential/default.py

@@ -1,93 +0,0 @@
-# Copyright (c) 2025, Salesforce, Inc.
-# SPDX-License-Identifier: Apache-2
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from typing import (
-    Any,
-    Dict,
-    Optional,
-)
-
-from datacustomcode.named_credential.base import NamedCredential
-from datacustomcode.named_credential.types.http_request import HTTPRequest
-from datacustomcode.named_credential.types.http_response import HTTPResponse
-from datacustomcode.named_credential.types.http_response_builder import (
-    HTTPResponseBuilder,
-)
-
-
-class DefaultNamedCredential(NamedCredential):
-    """
-    Executes the callout directly via :class:`DirectCalloutTransport`, resolving
-    the URL from the Named Credential Connect API (falling back to
-    ``external_callout_config.json``) and injecting auth from the same file.
-    """
-
-    CONFIG_NAME = "DefaultNamedCredential"
-
-    def __init__(
-        self,
-        credentials_profile: str = "default",
-        sf_cli_org: Optional[str] = None,
-        credential_file: Optional[str] = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(**kwargs)
-        self._credentials_profile = credentials_profile
-        self._sf_cli_org = sf_cli_org
-        self._credential_file = credential_file
-        self._transport: Optional[Any] = None
-
-    def request(
-        self,
-        request: HTTPRequest,
-        body: Optional[str] = None,
-    ) -> HTTPResponse:
-        # Body and response are treated as opaque strings; the SDK makes no
-        # assumption about their format (JSON, XML, text, ...).
-        callout_request = {
-            "path": request.url,
-            "method": request.method,
-            "headers": dict(request.headers),
-            "body": body if body is not None else "",
-        }
-        callout_response = self._callout(callout_request)
-        return HTTPResponseBuilder.build(
-            {
-                "status_code": callout_response.get("status_code"),
-                "headers": callout_response.get("headers", {}),
-                "body": callout_response.get("body") or "",
-            }
-        )
-
-    def _callout(self, callout_request: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute the callout via the transport.
-
-        Returns a dict with ``status_code``, ``headers``, and ``body``.
-        """
-        result: Dict[str, Any] = self._get_transport().callout(callout_request)
-        return result
-
-    def _get_transport(self) -> Any:
-        if self._transport is None:
-            from datacustomcode.named_credential.direct.transport import (
-                DirectCalloutTransport,
-            )
-
-            self._transport = DirectCalloutTransport(
-                credentials_profile=self._credentials_profile,
-                sf_cli_org=self._sf_cli_org,
-                credential_file=self._credential_file,
-            )
-        return self._transport

datacustomcode/named_credential/direct/__init__.py

@@ -1,19 +0,0 @@
-# Copyright (c) 2025, Salesforce, Inc.
-# SPDX-License-Identifier: Apache-2
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Named Credential callout path.
-
-This resolves the endpoint via the NamedCredential Connect API
-and injects auth from a developer-provided ``external_callout_config.json``
-"""

datacustomcode/named_credential/direct/auth.py

@@ -1,63 +0,0 @@
-# Copyright (c) 2025, Salesforce, Inc.
-# SPDX-License-Identifier: Apache-2
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Inject external credential auth into an outgoing request.
-"""
-
-from __future__ import annotations
-
-import base64
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-)
-
-from requests.auth import AuthBase
-
-from datacustomcode.named_credential.direct.credentials import AuthType
-
-if TYPE_CHECKING:
-    from requests.models import PreparedRequest
-
-
-class DynamicAuthHandler(AuthBase):
-    def __init__(self, cred_config: Dict[str, Any]) -> None:
-        self.config = cred_config
-        self.auth_type = cred_config.get("auth_type")
-
-    def __call__(self, request: PreparedRequest) -> PreparedRequest:
-        if self.auth_type == AuthType.BASIC.value:
-            user = self.config.get("username", "")
-            pwd = self.config.get("password", "")
-            token = base64.b64encode(f"{user}:{pwd}".encode()).decode()
-            request.headers["Authorization"] = f"Basic {token}"
-
-        elif self.auth_type == AuthType.CUSTOM.value:
-            for name, value in self.config.get("custom_headers", {}).items():
-                request.headers[name] = value
-
-        elif self.auth_type in (AuthType.OAUTH.value, AuthType.JWT.value):
-            bearer = self.config.get("access_token") or self.config.get("token")
-            if not bearer:
-                raise ValueError(
-                    f"'{self.auth_type}' auth requires an 'access_token' or 'token'."
-                )
-            request.headers["Authorization"] = f"Bearer {bearer}"
-
-        else:
-            raise ValueError(f"Unsupported auth_type '{self.auth_type}'.")
-
-        return request

datacustomcode/named_credential/direct/credentials.py

@@ -1,121 +0,0 @@
-# Copyright (c) 2025, Salesforce, Inc.
-# SPDX-License-Identifier: Apache-2
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Load developer credentials for direct callouts from ``external_callout_config.json``.
-
-The file lives in the parent of the payload folder so it is never packaged in
-the deployment zip. Its ``credentials`` section is keyed by callout reference
-(``callout:<NamedCredential>``); each value carries a mandatory ``auth_type``
-and an optional ``target_url``.
-"""
-
-from __future__ import annotations
-
-from enum import Enum
-import json
-import os
-from pathlib import Path
-from typing import (
-    Any,
-    Dict,
-    Optional,
-)
-
-# Default file name; discovered in the parent of the payload folder.
-EXTERNAL_CALLOUT_CREDENTIAL = "external_callout_config.json"
-# Absolute-path override, primarily for tests and non-standard layouts.
-CREDENTIAL_FILE_ENV_VAR = "DATACUSTOMCODE_EXTERNAL_CALLOUT_CONFIG"
-
-
-class AuthType(str, Enum):
-    """External Credential auth types supported by External Services."""
-
-    BASIC = "Basic"
-    CUSTOM = "Custom"
-    JWT = "Jwt"
-    OAUTH = "OAuth"
-
-
-class CredentialError(RuntimeError):
-    """Raised when credentials cannot be found or are invalid."""
-
-
-def _discover_credential_file() -> Optional[Path]:
-    """Find the config file via env override, then by walking up from cwd."""
-    override = os.environ.get(CREDENTIAL_FILE_ENV_VAR)
-    if override:
-        return Path(override)
-
-    for directory in (Path.cwd(), *Path.cwd().parents):
-        candidate = directory / EXTERNAL_CALLOUT_CREDENTIAL
-        if candidate.is_file():
-            return candidate
-    return None
-
-
-class CredentialStore:
-    """Reads ``external_callout_config.json`` and returns per-callout config."""
-
-    def __init__(self, credential_file: Optional[str] = None) -> None:
-        self._explicit_path = Path(credential_file) if credential_file else None
-        self._credentials: Optional[Dict[str, Dict[str, Any]]] = None
-
-    def _load(self) -> Dict[str, Dict[str, Any]]:
-        if self._credentials is not None:
-            return self._credentials
-
-        path = self._explicit_path or _discover_credential_file()
-        if path is None or not path.is_file():
-            raise CredentialError(
-                f"Could not find '{EXTERNAL_CALLOUT_CREDENTIAL}'. Place it in the "
-                f"parent of your payload folder, or set "
-                f"${CREDENTIAL_FILE_ENV_VAR} to its path."
-            )
-        try:
-            with open(path, "r") as f:
-                data = json.load(f)
-        except (OSError, json.JSONDecodeError) as exc:
-            raise CredentialError(f"Failed to read '{path}': {exc}") from exc
-
-        # Per-callout entries live under the ``credentials`` section, leaving
-        # room for other config sections alongside them in the future.
-        credentials = data.get("credentials") if isinstance(data, dict) else None
-        if not isinstance(credentials, dict):
-            raise CredentialError(
-                f"'{path}' must be a JSON object with a 'credentials' section "
-                f"keyed by callout reference."
-            )
-        self._credentials = credentials
-        return credentials
-
-    def get(self, callout_key: str) -> Dict[str, Any]:
-        """Return the config for a callout key (e.g. ``callout:AWS_S3_Service``).
-
-        Raises:
-            CredentialError: if the key is missing or has no ``auth_type``.
-        """
-        credentials = self._load()
-        config = credentials.get(callout_key)
-        if config is None:
-            raise CredentialError(
-                f"No credential configuration found for '{callout_key}'. "
-                f"Add it to the 'credentials' section of "
-                f"'{EXTERNAL_CALLOUT_CREDENTIAL}'."
-            )
-        if not isinstance(config, dict) or not config.get("auth_type"):
-            raise CredentialError(
-                f"Credential for '{callout_key}' is missing the mandatory "
-                f"'auth_type' field."
-            )
-        return config

datacustomcode/named_credential/direct/transport.py

@@ -1,110 +0,0 @@
-# Copyright (c) 2025, Salesforce, Inc.
-# SPDX-License-Identifier: Apache-2
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Send a Named Credential callout over HTTP.
-
-Resolves the ``callout:<NamedCredential>/<path>`` reference to a real endpoint
-(via the Named Credential Connect API, falling back to ``target_url`` in
-``external_callout_config.json``), attaches the credential's auth, and returns the raw
-``{status_code, headers, body}`` response.
-"""
-
-from __future__ import annotations
-
-from typing import (
-    Any,
-    Dict,
-    Optional,
-)
-
-import requests
-
-from datacustomcode.named_credential.direct.auth import DynamicAuthHandler
-from datacustomcode.named_credential.direct.credentials import CredentialStore
-from datacustomcode.named_credential.direct.url_resolver import resolve_base_url
-from datacustomcode.named_credential.errors import NamedCredentialCallError
-from datacustomcode.token_provider import (
-    CredentialsTokenProvider,
-    SFCLITokenProvider,
-    TokenProvider,
-)
-
-
-class DirectCalloutTransport:
-    def __init__(
-        self,
-        credentials_profile: str = "default",
-        sf_cli_org: Optional[str] = None,
-        credential_file: Optional[str] = None,
-    ) -> None:
-        self._store = CredentialStore(credential_file)
-        self._token_provider = self._build_token_provider(
-            credentials_profile, sf_cli_org
-        )
-        # Resolved base URL per callout key. Stable for the transport's life, so
-        # cache it to avoid a token fetch + Connect API call on every row
-        self._base_url_cache: Dict[str, str] = {}
-
-    @staticmethod
-    def _build_token_provider(
-        credentials_profile: str, sf_cli_org: Optional[str]
-    ) -> TokenProvider:
-        if sf_cli_org:
-            return SFCLITokenProvider(sf_cli_org)
-        return CredentialsTokenProvider(credentials_profile)
-
-    def callout(self, callout_request: Dict[str, Any]) -> Dict[str, Any]:
-        raw_url = callout_request["path"]
-        if not raw_url.startswith("callout:"):
-            raise NamedCredentialCallError(
-                f"Callout URL must start with 'callout:', got '{raw_url}'."
-            )
-
-        # Split the named credential reference at the first '/' or '?'; the remainder
-        # path or query string is appended to the resolved base URL verbatim.
-        sep_idx = min(
-            (i for i in (raw_url.find("/"), raw_url.find("?")) if i != -1),
-            default=len(raw_url),
-        )
-        callout_key = raw_url[:sep_idx]
-        path_suffix = raw_url[sep_idx:]
-
-        if callout_key == "callout:":
-            raise NamedCredentialCallError(
-                f"Named Credential name is empty in URL '{raw_url}'."
-            )
-
-        cred_config = self._store.get(callout_key)
-        base_url = self._base_url_cache.get(callout_key)
-        if base_url is None:
-            base_url = resolve_base_url(callout_key, cred_config, self._token_provider)
-            self._base_url_cache[callout_key] = base_url
-
-        body = callout_request.get("body") or None
-        # Headers are passed; the SDK assumes no Content-Type.
-        headers = dict(callout_request.get("headers", {}))
-
-        response = requests.request(
-            method=callout_request["method"],
-            url=base_url + path_suffix,
-            headers=headers,
-            data=body,
-            auth=DynamicAuthHandler(cred_config),
-            timeout=30,
-        )
-        return {
-            "status_code": response.status_code,
-            "headers": dict(response.headers),
-            "body": response.text,
-        }

datacustomcode/named_credential/direct/url_resolver.py

@@ -1,112 +0,0 @@
-# Copyright (c) 2025, Salesforce, Inc.
-# SPDX-License-Identifier: Apache-2
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Resolve a ``callout:<NamedCredential>`` reference to a real base URL.
-
-Prefers the NamedCredential Connect API ``calloutUrl``; falls back to the
-developer-supplied ``target_url`` when the API is unavailable or the Named
-Credential is not yet onboarded.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Optional,
-)
-
-import requests
-
-from datacustomcode.named_credential.direct.credentials import CredentialError
-
-if TYPE_CHECKING:
-    from datacustomcode.token_provider import TokenProvider
-
-logger = logging.getLogger(__name__)
-
-NAMED_CREDENTIAL_PATH = (
-    "services/data/v63.0/named-credentials/named-credential-setup/{name}"
-)
-
-
-def _callout_url_from_connect_api(
-    developer_name: str, token_provider: TokenProvider
-) -> Optional[str]:
-    """Fetch ``calloutUrl`` for a Named Credential, or None on any failure."""
-    try:
-        token = token_provider.get_token()
-    except Exception as exc:
-        # No usable token (e.g. not logged in) — expected; fall back quietly.
-        logger.debug("Could not obtain a token for %s: %s", developer_name, exc)
-        return None
-
-    try:
-        path = NAMED_CREDENTIAL_PATH.format(name=developer_name)
-        url = f"{token.instance_url.rstrip('/')}/{path}"
-        response = requests.get(
-            url,
-            headers={"Authorization": f"Bearer {token.access_token}"},
-            timeout=30,
-        )
-        response.raise_for_status()
-        callout_url = response.json().get("calloutUrl")
-        return callout_url or None
-    except Exception as exc:
-        # A token was obtained but the Connect API call failed — likely a
-        # misconfiguration (named credential not onboarded, missing
-        # permission, wrong org). Surface it before falling back to target_url.
-        logger.warning(
-            "Connect API URL resolution failed for %s: %s. "
-            "Falling back to 'target_url' from external_callout_config.json if set.",
-            developer_name,
-            exc,
-        )
-        return None
-
-
-def resolve_base_url(
-    callout_key: str,
-    cred_config: Dict[str, Any],
-    token_provider: Optional[TokenProvider],
-) -> str:
-    """Resolve the base URL for a callout key.
-
-    Args:
-        callout_key: e.g. ``callout:Nominatim_Geocoding``.
-        cred_config: The callout's ``external_callout_config.json`` entry.
-        token_provider: Provides a token/instance URL for the Connect API; when
-            None, only ``target_url`` is used.
-
-    Raises:
-        CredentialError: if no URL can be resolved.
-    """
-    developer_name = callout_key.split(":", 1)[1] if ":" in callout_key else callout_key
-
-    base_url: Optional[str] = None
-    if token_provider is not None:
-        base_url = _callout_url_from_connect_api(developer_name, token_provider)
-
-    if not base_url:
-        base_url = cred_config.get("target_url") or None
-
-    if not base_url:
-        raise CredentialError(
-            f"Could not resolve a URL for '{callout_key}'. Ensure the Named "
-            f"Credential exists (sf login) or set 'target_url' in "
-            f"external_callout_config.json."
-        )
-    return base_url.rstrip("/")

datacustomcode/named_credential/errors.py

@@ -1,36 +0,0 @@
-# Copyright (c) 2025, Salesforce, Inc.
-# SPDX-License-Identifier: Apache-2
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Exceptions raised by Named Credential implementations."""
-
-from __future__ import annotations
-
-from typing import Optional
-
-
-class NamedCredentialCallError(RuntimeError):
-    """Raised when a Named Credential external callout fails."""
-
-    def __init__(
-        self,
-        message: str,
-        *,
-        status: Optional[object] = None,
-        error_code: Optional[str] = None,
-        error_message: Optional[str] = None,
-    ) -> None:
-        super().__init__(message)
-        self.status = status
-        self.error_code = error_code
-        self.error_message = error_message