ethyca-fides 2.73.2b0__py2.py3-none-any.whl → 2.76.0rc2__py2.py3-none-any.whl

fides/api/api/v1/endpoints/admin.py

@@ -8,7 +8,12 @@ from fides.api.api.v1.endpoints import API_PREFIX
 from fides.api.db.database import configure_db, migrate_db, reset_db
 from fides.api.oauth.utils import verify_oauth_client_prod
 from fides.api.util.api_router import APIRouter
+from fides.api.util.memory_watchdog import (
+    _capture_heap_dump,
+    get_memory_watchdog_enabled,
+)
 from fides.common.api import scope_registry
+from fides.common.api.scope_registry import HEAP_DUMP_EXEC
 from fides.config import CONFIG
 
 ADMIN_ROUTER = APIRouter(prefix=API_PREFIX, tags=["Admin"])
@@ -82,3 +87,37 @@ def db_action(action: DBActions, revision: Optional[str] = "head") -> Dict:
             "message": f"Fides database action performed successfully: {action_text}"
         }
     }
+
+
+@ADMIN_ROUTER.post(
+    "/admin/heap-dump",
+    tags=["Admin"],
+    dependencies=[Security(verify_oauth_client_prod, scopes=[HEAP_DUMP_EXEC])],
+    status_code=status.HTTP_200_OK,
+)
+def trigger_heap_dump() -> Dict:
+    """
+    Trigger a heap dump for memory diagnostics.
+
+    Captures and logs detailed memory profiling information including:
+    - Process memory stats (RSS, VMS)
+    - Top object type counts
+    - Garbage collector stats
+    - Uncollectable objects (memory leaks)
+
+    The full heap dump report is logged to error logs.
+    """
+    if not get_memory_watchdog_enabled():
+        raise HTTPException(
+            status_code=status.HTTP_405_METHOD_NOT_ALLOWED,
+            detail="Heap dump functionality is not enabled. Set memory_watchdog_enabled to true in application configuration.",
+        )
+
+    logger.warning("Manual heap dump triggered via API")
+    _capture_heap_dump()
+
+    return {
+        "data": {
+            "message": "Heap dump captured successfully. Check server logs for detailed report."
+        }
+    }

fides/api/api/v1/endpoints/connector_template_endpoints.py

@@ -0,0 +1,167 @@
+from io import BytesIO
+from typing import List
+from zipfile import BadZipFile, ZipFile
+
+from fastapi import Body, Depends, HTTPException
+from fastapi.params import Security
+from fastapi.responses import JSONResponse, Response
+from loguru import logger
+from sqlalchemy.orm import Session
+from starlette.status import HTTP_404_NOT_FOUND
+
+from fides.api.api import deps
+from fides.api.oauth.utils import verify_oauth_client
+from fides.api.schemas.saas.connector_template import ConnectorTemplateListResponse
+from fides.api.service.connectors.saas.connector_registry_service import (
+    ConnectorRegistry,
+    CustomConnectorTemplateLoader,
+)
+from fides.api.util.api_router import APIRouter
+from fides.common.api.scope_registry import (
+    CONNECTOR_TEMPLATE_READ,
+    CONNECTOR_TEMPLATE_REGISTER,
+)
+from fides.common.api.v1.urn_registry import (
+    CONNECTOR_TEMPLATES,
+    CONNECTOR_TEMPLATES_CONFIG,
+    CONNECTOR_TEMPLATES_DATASET,
+    CONNECTOR_TEMPLATES_REGISTER,
+    REGISTER_CONNECTOR_TEMPLATE,
+    V1_URL_PREFIX,
+)
+
+router = APIRouter(tags=["Connector Templates"], prefix=V1_URL_PREFIX)
+
+
+@router.get(
+    CONNECTOR_TEMPLATES,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_READ])],
+    response_model=List[ConnectorTemplateListResponse],
+)
+def get_all_connector_templates() -> List[ConnectorTemplateListResponse]:
+    """
+    Returns a list of all available connector templates with summary information.
+
+    Each template includes:
+    - **type**: The unique identifier for the connector (used in other endpoints)
+    - **name**: Human-readable name of the connector
+    - **supported_actions**: List of actions this connector supports (e.g., access, erasure)
+    - **category**: Optional category classification for the connector
+    - **custom**: Whether this is a custom connector (true) or built-in (false)
+    """
+    logger.info("Retrieving all connector templates")
+    return ConnectorRegistry.get_all_connector_templates_summary()
+
+
+@router.post(
+    CONNECTOR_TEMPLATES_REGISTER,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_REGISTER])],
+)
+def register_connector_template(
+    file: bytes = Body(..., media_type="application/zip"),
+    db: Session = Depends(deps.get_db),
+) -> JSONResponse:
+    """
+    Registers a custom connector template from a zip file uploaded by the user.
+
+    The endpoint performs the following steps:
+    1. Validates the uploaded file is a proper zip file.
+    2. Uses the CustomConnectorTemplateLoader to validate, register, and save the template to the database.
+
+    If the uploaded file is not a valid zip file or there are any validation errors
+    when creating the ConnectorTemplates an HTTP 400 status code with error details is returned.
+    """
+    try:
+        with ZipFile(BytesIO(file), "r") as zip_file:
+            CustomConnectorTemplateLoader.save_template(db=db, zip_file=zip_file)
+    except BadZipFile:
+        raise HTTPException(status_code=400, detail="Invalid zip file")
+    except Exception as exc:
+        logger.exception("Error loading connector template from zip file.")
+        raise HTTPException(status_code=400, detail=str(exc))
+
+    return JSONResponse(
+        content={"message": "Connector template successfully registered."}
+    )
+
+
+@router.post(
+    REGISTER_CONNECTOR_TEMPLATE,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_REGISTER])],
+    deprecated=True,
+)
+def register_custom_connector_template_deprecated(
+    file: bytes = Body(..., media_type="application/zip"),
+    db: Session = Depends(deps.get_db),
+) -> JSONResponse:
+    """
+    **DEPRECATED**: Use `POST /connector-templates/register` instead.
+
+    Registers a custom connector template from a zip file uploaded by the user.
+    This endpoint is maintained for backward compatibility only.
+    """
+    return register_connector_template(file=file, db=db)
+
+
+@router.get(
+    CONNECTOR_TEMPLATES_CONFIG,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_READ])],
+)
+def get_connector_template_config(
+    connector_template_type: str,
+) -> Response:
+    """
+    Retrieves the SaaS config YAML for a connector template by its type.
+
+    The `connector_template_type` parameter comes from the `type` field
+    returned by the `GET /connector-templates` endpoint.
+
+    Returns the raw YAML configuration that can be used to understand
+    or customize the connector template.
+    """
+    logger.info("Finding connector template with type '{}'", connector_template_type)
+    template = ConnectorRegistry.get_connector_template(connector_template_type)
+
+    if not template:
+        raise HTTPException(
+            status_code=HTTP_404_NOT_FOUND,
+            detail=f"No connector template found with type '{connector_template_type}'",
+        )
+
+    return Response(
+        content=template.config,
+        media_type="text/yaml",
+    )
+
+
+@router.get(
+    CONNECTOR_TEMPLATES_DATASET,
+    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_READ])],
+)
+def get_connector_template_dataset(
+    connector_template_type: str,
+) -> Response:
+    """
+    Retrieves the dataset YAML for a connector template by its type.
+
+    The `connector_template_type` parameter comes from the `type` field
+    returned by the `GET /connector-templates` endpoint.
+
+    Returns the raw dataset YAML configuration that defines the data structure
+    for the connector template.
+    """
+    logger.info(
+        "Finding connector template dataset with type '{}'", connector_template_type
+    )
+    template = ConnectorRegistry.get_connector_template(connector_template_type)
+
+    if not template:
+        raise HTTPException(
+            status_code=HTTP_404_NOT_FOUND,
+            detail=f"No connector template found with type '{connector_template_type}'",
+        )
+
+    return Response(
+        content=template.dataset,
+        media_type="text/yaml",
+    )

fides/api/api/v1/endpoints/generic_overrides.py

@@ -370,10 +370,10 @@ async def create_data_use(
         return taxonomy_service.create_or_update_element(
             "data_use", data_use.model_dump()
         )
-    except KeyOrNameAlreadyExists:
+    except KeyOrNameAlreadyExists as e:
         raise HTTPException(
             status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Data use with key {data_use.fides_key} or name {data_use.name} already exists.",
+            detail=str(e),
         )
     except (ValidationError, PydanticValidationError) as e:
         raise HTTPException(
@@ -401,10 +401,10 @@ async def create_data_category(
         return taxonomy_service.create_or_update_element(
             "data_category", data_category.model_dump()
         )
-    except KeyOrNameAlreadyExists:
+    except KeyOrNameAlreadyExists as e:
         raise HTTPException(
             status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Data category with key {data_category.fides_key} or name {data_category.name} already exists.",
+            detail=str(e),
         )
     except (ValidationError, PydanticValidationError) as e:
         raise HTTPException(
@@ -432,10 +432,10 @@ async def create_data_subject(
         return taxonomy_service.create_or_update_element(
             "data_subject", data_subject.model_dump()
         )
-    except KeyOrNameAlreadyExists:
+    except KeyOrNameAlreadyExists as e:
         raise HTTPException(
             status_code=HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Data subject with key {data_subject.fides_key} or name {data_subject.name} already exists.",
+            detail=str(e),
         )
     except (ValidationError, PydanticValidationError) as e:
         raise HTTPException(

fides/api/api/v1/endpoints/pre_approval_webhook_endpoints.py

@@ -90,7 +90,7 @@ def get_pre_approval_webhook_detail(
     ],
     response_model=List[schemas.PreApprovalWebhookResponse],
 )
-def create_or_update_pre_execution_webhooks(
+def create_or_update_pre_approval_webhooks(
     *,
     db: Session = Depends(deps.get_db),
     webhooks: Annotated[List[schemas.PreApprovalWebhookCreate], Field(max_length=50)],  # type: ignore
@@ -148,7 +148,7 @@ def create_or_update_pre_execution_webhooks(
         webhooks_to_remove.delete()
 
     logger.info(
-        "Creating/updating Policy Pre-Execution Webhooks: {}", staged_webhook_keys
+        "Creating/updating Policy Pre-Approval Webhooks: {}", staged_webhook_keys
     )
     # Committing to database now, as a last step, once we've verified that all the webhooks
     # in the request are free of issues.
@@ -164,7 +164,7 @@ def create_or_update_pre_execution_webhooks(
     ],
     response_model=schemas.PreApprovalWebhookResponse,
 )
-def update_pre_execution_webhook(
+def update_pre_approval_webhook(
     *,
     db: Session = Depends(deps.get_db),
     webhook_key: FidesKey,
@@ -193,7 +193,7 @@ def update_pre_execution_webhook(
             detail=exc.args[0],
         )
 
-    # Pre Execution Webhooks are not committed by default, so we commit at the end.
+    # Pre Approval Webhooks are not committed by default, so we commit at the end.
     db.commit()
     return schemas.PreApprovalWebhookResponse(
         connection_config=loaded_webhook.connection_config,
@@ -207,7 +207,7 @@ def update_pre_execution_webhook(
     status_code=HTTP_200_OK,
     dependencies=[Security(verify_oauth_client, scopes=[scopes.WEBHOOK_DELETE])],
 )
-def delete_pre_execution_webhook(
+def delete_pre_approval_webhook(
     *,
     db: Session = Depends(deps.get_db),
     webhook_key: FidesKey,

fides/api/api/v1/endpoints/privacy_request_endpoints.py

@@ -29,7 +29,7 @@ from loguru import logger
 from pydantic import Field
 from pydantic import ValidationError as PydanticValidationError
 from sqlalchemy import cast, column, null, or_, select
-from sqlalchemy.orm import Query, Session
+from sqlalchemy.orm import Query, Session, selectinload
 from sqlalchemy.sql.expression import nullslast
 from starlette.responses import StreamingResponse
 from starlette.status import (
@@ -88,9 +88,11 @@ from fides.api.schemas.dataset import CollectionAddressResponse, DryRunDatasetRe
 from fides.api.schemas.external_https import PrivacyRequestResumeFormat
 from fides.api.schemas.policy import ActionType, CurrentStep
 from fides.api.schemas.privacy_request import (
+    BULK_PRIVACY_REQUEST_BATCH_SIZE,
     BulkPostPrivacyRequests,
     BulkReviewResponse,
     BulkSoftDeletePrivacyRequests,
+    CancelPrivacyRequests,
     CheckpointActionRequired,
     DenyPrivacyRequests,
     ExecutionLogDetailResponse,
@@ -147,6 +149,7 @@ from fides.common.api.v1.urn_registry import (
     PRIVACY_REQUEST_BULK_FINALIZE,
     PRIVACY_REQUEST_BULK_RETRY,
     PRIVACY_REQUEST_BULK_SOFT_DELETE,
+    PRIVACY_REQUEST_CANCEL,
     PRIVACY_REQUEST_DENY,
     PRIVACY_REQUEST_FILTERED_RESULTS,
     PRIVACY_REQUEST_FINALIZE,
@@ -223,7 +226,9 @@ def create_privacy_request(
     privacy_request_service: PrivacyRequestService = Depends(
         get_privacy_request_service
     ),
-    data: Annotated[List[PrivacyRequestCreate], Field(max_length=50)],  # type: ignore
+    data: Annotated[
+        List[PrivacyRequestCreate], Field(max_length=BULK_PRIVACY_REQUEST_BATCH_SIZE)
+    ],  # type: ignore
 ) -> BulkPostPrivacyRequests:
     """
     Given a list of privacy request data elements, create corresponding PrivacyRequest objects
@@ -249,7 +254,9 @@ def create_privacy_request_authenticated(
         verify_oauth_client,
         scopes=[PRIVACY_REQUEST_CREATE],
     ),
-    data: Annotated[List[PrivacyRequestCreate], Field(max_length=50)],  # type: ignore
+    data: Annotated[
+        List[PrivacyRequestCreate], Field(max_length=BULK_PRIVACY_REQUEST_BATCH_SIZE)
+    ],  # type: ignore
 ) -> BulkPostPrivacyRequests:
     """
     Given a list of privacy request data elements, create corresponding PrivacyRequest objects
@@ -270,7 +277,10 @@ def privacy_request_csv_download(
     f = io.StringIO()
     csv_file = csv.writer(f)
 
-    privacy_request_ids: List[str] = [r.id for r in privacy_request_query]
+    # Execute query once and convert to list to avoid multiple iterations
+    privacy_requests: List[PrivacyRequest] = privacy_request_query.all()
+    privacy_request_ids: List[str] = [r.id for r in privacy_requests]
+
     denial_audit_log_query: Query = db.query(AuditLog).filter(
         AuditLog.action == AuditLogAction.denied,
         AuditLog.privacy_request_id.in_(privacy_request_ids),
@@ -279,7 +289,7 @@ def privacy_request_csv_download(
         r.privacy_request_id: r.message for r in denial_audit_log_query
     }
 
-    identity_columns, custom_field_columns = get_variable_columns(privacy_request_query)
+    identity_columns, custom_field_columns = get_variable_columns(privacy_requests)
 
     csv_file.writerow(
         [
@@ -299,7 +309,7 @@ def privacy_request_csv_download(
     )
 
     pr: PrivacyRequest
-    for pr in privacy_request_query:
+    for pr in privacy_requests:
         denial_reason = (
             denial_audit_logs[pr.id]
             if pr.status == PrivacyRequestStatus.denied and pr.id in denial_audit_logs
@@ -344,12 +354,12 @@ def privacy_request_csv_download(
 
 
 def get_variable_columns(
-    privacy_request_query: Query,
+    privacy_requests: List[PrivacyRequest],
 ) -> tuple[List[str], Dict[str, str]]:
     identity_columns: Set[str] = set()
     custom_field_columns: Dict[str, str] = {}
 
-    for pr in privacy_request_query:
+    for pr in privacy_requests:
         identity_columns.update(
             extract_identity_column_names(pr.get_persisted_identity().model_dump())
         )
@@ -486,7 +496,7 @@ def _filter_privacy_request_queryset(
     errored_gt: Optional[datetime] = None,
     external_id: Optional[str] = None,
     location: Optional[str] = None,
-    action_type: Optional[ActionType] = None,
+    action_type: Optional[Union[ActionType, List[ActionType]]] = None,
     include_consent_webhook_requests: Optional[bool] = False,
     include_deleted_requests: Optional[bool] = False,
 ) -> Query:
@@ -676,9 +686,11 @@ def _filter_privacy_request_queryset(
             PrivacyRequest.finished_processing_at > errored_gt,
         )
     if action_type:
+        if isinstance(action_type, ActionType):
+            action_type = [action_type]
         policy_ids_for_action_type = (
             db.query(Rule)
-            .filter(Rule.action_type == action_type)
+            .filter(Rule.action_type.in_(action_type))
             .with_entities(Rule.policy_id)
             .distinct()
         )
@@ -792,7 +804,7 @@ def _shared_privacy_request_search(
     errored_gt: Optional[datetime] = None,
     external_id: Optional[str] = None,
     location: Optional[str] = None,
-    action_type: Optional[ActionType] = None,
+    action_type: Optional[Union[ActionType, List[ActionType]]] = None,
     verbose: Optional[bool] = False,
     include_identities: Optional[bool] = False,
     include_custom_privacy_request_fields: Optional[bool] = False,
@@ -811,7 +823,8 @@ def _shared_privacy_request_search(
 
     logger.debug("Finding all request statuses with pagination params {}", params)
 
-    query = db.query(PrivacyRequest)
+    # Use query_without_large_columns to prevent OOM errors when loading many privacy requests
+    query = PrivacyRequest.query_without_large_columns(db)
     query = _filter_privacy_request_queryset(
         db,
         query,
@@ -843,10 +856,29 @@ def _shared_privacy_request_search(
 
     if download_csv:
         _validate_result_size(query)
+        # Eager load relationships needed for CSV export to avoid N+1 queries
+        query = query.options(
+            selectinload(PrivacyRequest.provided_identities),  # type: ignore[attr-defined]
+            selectinload(PrivacyRequest.custom_fields),  # type: ignore[attr-defined]
+            selectinload(PrivacyRequest.policy).selectinload(Policy.rules),  # type: ignore[attr-defined]
+        )
         # Returning here if download_csv param was specified
         logger.info("Downloading privacy requests as csv")
         return privacy_request_csv_download(db, query)
 
+    # Eager load relationships for regular list view to avoid N+1 queries
+    if include_identities or include_custom_privacy_request_fields:
+        eager_load_options = []
+        if include_identities:
+            eager_load_options.append(
+                selectinload(PrivacyRequest.provided_identities)  # type: ignore[attr-defined]
+            )
+        if include_custom_privacy_request_fields:
+            eager_load_options.append(
+                selectinload(PrivacyRequest.custom_fields)  # type: ignore[attr-defined]
+            )
+        query = query.options(*eager_load_options)
+
     # Conditionally embed execution log details in the response.
     if verbose:
         logger.info("Finding execution and audit log details")
@@ -1283,15 +1315,26 @@ def validate_manual_input(
     ],
 )
 def bulk_restart_privacy_request_from_failure(
-    privacy_request_ids: List[str],
+    privacy_request_ids: Annotated[
+        List[str], Field(max_length=BULK_PRIVACY_REQUEST_BATCH_SIZE)
+    ],
     *,
     db: Session = Depends(deps.get_db),
 ) -> BulkPostPrivacyRequests:
-    """Bulk restart a of privacy request from failure."""
+    """Bulk restart privacy requests from failure."""
     succeeded: List[PrivacyRequestResponse] = []
     failed: List[Dict[str, Any]] = []
+
+    # Fetch all privacy requests in one query to avoid N+1
+    privacy_requests_dict = {
+        pr.id: pr
+        for pr in PrivacyRequest.query_without_large_columns(db)
+        .filter(PrivacyRequest.id.in_(privacy_request_ids))
+        .all()
+    }
+
     for privacy_request_id in privacy_request_ids:
-        privacy_request = PrivacyRequest.get(db, object_id=privacy_request_id)
+        privacy_request = privacy_requests_dict.get(privacy_request_id)
 
         if not privacy_request:
             failed.append(
@@ -1357,10 +1400,10 @@ def restart_privacy_request_from_failure(
     )
 
     # Automatically resubmit the request if the cache has expired
+
     if (
-        not privacy_request.get_cached_identity_data()
-        and privacy_request.status
-        not in [PrivacyRequestStatus.complete, PrivacyRequestStatus.pending]
+        not privacy_request.verify_cache_for_identity_data()
+        and privacy_request.status != PrivacyRequestStatus.complete
     ):
         logger.info(
             f"Cached data for privacy request {privacy_request.id} has expired, automatically resubmitting request"
@@ -1477,10 +1520,37 @@ def deny_privacy_request(
     )
 
 
+@router.patch(
+    PRIVACY_REQUEST_CANCEL,
+    status_code=HTTP_200_OK,
+    response_model=BulkReviewResponse,
+)
+def cancel_privacy_request(
+    *,
+    client: ClientDetail = Security(
+        verify_oauth_client,
+        scopes=[PRIVACY_REQUEST_REVIEW],
+    ),
+    privacy_request_service: PrivacyRequestService = Depends(
+        get_privacy_request_service
+    ),
+    privacy_requests: CancelPrivacyRequests,
+) -> BulkReviewResponse:
+    """Cancel a list of privacy requests and/or report failure"""
+
+    return privacy_request_service.cancel_privacy_requests(
+        privacy_requests.request_ids, privacy_requests.reason, user_id=client.user_id
+    )
+
+
 def _validate_privacy_request_pending_or_error(
     db: Session, privacy_request_id: str
 ) -> None:
-    privacy_request = PrivacyRequest.get(db, object_id=privacy_request_id)
+    privacy_request = (
+        PrivacyRequest.query_without_large_columns(db)
+        .filter(PrivacyRequest.id == privacy_request_id)
+        .first()
+    )
     if not privacy_request:
         raise HTTPException(
             status_code=HTTP_404_NOT_FOUND,
@@ -2184,8 +2254,18 @@ def bulk_soft_delete_privacy_requests(
     if client.id == CONFIG.security.oauth_root_client_id:
         user_id = "root"
 
-    for privacy_request_id in privacy_requests.request_ids:
-        privacy_request = PrivacyRequest.get(db, object_id=privacy_request_id)
+    request_ids = privacy_requests.request_ids
+
+    # Fetch all privacy requests in one query to avoid N+1
+    privacy_requests_dict = {
+        pr.id: pr
+        for pr in PrivacyRequest.query_without_large_columns(db)
+        .filter(PrivacyRequest.id.in_(request_ids))
+        .all()
+    }
+
+    for privacy_request_id in request_ids:
+        privacy_request = privacy_requests_dict.get(privacy_request_id)
 
         if not privacy_request:
             failed.append(

fides/api/api/v1/endpoints/saas_config_endpoints.py

@@ -1,11 +1,8 @@
-from io import BytesIO
 from typing import Optional
-from zipfile import BadZipFile, ZipFile
 
-from fastapi import Body, Depends, HTTPException, Request
+from fastapi import Depends, HTTPException, Request
 from fastapi.encoders import jsonable_encoder
 from fastapi.params import Security
-from fastapi.responses import JSONResponse
 from fideslang.validation import FidesKey
 from loguru import logger
 from pydantic import ValidationError
@@ -48,15 +45,11 @@ from fides.api.service.authentication.authentication_strategy import (
 from fides.api.service.authentication.authentication_strategy_oauth2_authorization_code import (
     OAuth2AuthorizationCodeAuthenticationStrategy,
 )
-from fides.api.service.connectors.saas.connector_registry_service import (
-    CustomConnectorTemplateLoader,
-)
 from fides.api.util.api_router import APIRouter
 from fides.api.util.connection_util import validate_secrets_error_message
 from fides.api.util.event_audit_util import generate_connection_audit_event_details
 from fides.common.api.scope_registry import (
     CONNECTION_AUTHORIZE,
-    CONNECTOR_TEMPLATE_REGISTER,
     SAAS_CONFIG_CREATE_OR_UPDATE,
     SAAS_CONFIG_DELETE,
     SAAS_CONFIG_READ,
@@ -64,7 +57,6 @@ from fides.common.api.scope_registry import (
 )
 from fides.common.api.v1.urn_registry import (
     AUTHORIZE,
-    REGISTER_CONNECTOR_TEMPLATE,
     SAAS_CONFIG,
     SAAS_CONFIG_VALIDATE,
     SAAS_CONNECTOR_FROM_TEMPLATE,
@@ -312,11 +304,11 @@ def authorize_connection(
     response_model=SaasConnectionTemplateResponse,
 )
 def instantiate_connection_from_template(
-    saas_connector_type: str,
+    connector_template_type: str,
     template_values: SaasConnectionTemplateValues,
     db: Session = Depends(deps.get_db),
 ) -> SaasConnectionTemplateResponse:
-    return instantiate_connection(db, saas_connector_type, template_values)
+    return instantiate_connection(db, connector_template_type, template_values)
 
 
 def instantiate_connection(
@@ -373,36 +365,3 @@ def instantiate_connection(
     return SaasConnectionTemplateResponse(
         connection=connection_config, dataset=dataset_config.ctl_dataset
     )
-
-
-@router.post(
-    REGISTER_CONNECTOR_TEMPLATE,
-    dependencies=[Security(verify_oauth_client, scopes=[CONNECTOR_TEMPLATE_REGISTER])],
-)
-def register_custom_connector_template(
-    file: bytes = Body(..., media_type="application/zip"),
-    db: Session = Depends(deps.get_db),
-) -> JSONResponse:
-    """
-    Registers a custom connector template from a zip file uploaded by the user.
-    The endpoint performs the following steps:
-
-    1. Validates the uploaded file is a proper zip file.
-    2. Uses the CustomConnectorTemplateLoader to validate, register, and save the template to the database.
-
-    If the uploaded file is not a valid zip file or there are any validation errors
-    when creating the ConnectorTemplates an HTTP 400 status code with error details is returned.
-    """
-
-    try:
-        with ZipFile(BytesIO(file), "r") as zip_file:
-            CustomConnectorTemplateLoader.save_template(db=db, zip_file=zip_file)
-    except BadZipFile:
-        raise HTTPException(status_code=400, detail="Invalid zip file")
-    except Exception as exc:
-        logger.exception("Error loading connector template from zip file.")
-        raise HTTPException(status_code=400, detail=str(exc))
-
-    return JSONResponse(
-        content={"message": "Connector template successfully registered."}
-    )

fides/api/api/v1/endpoints/storage_endpoints.py

@@ -95,7 +95,11 @@ def upload_data(
     """
     logger.info("Finding privacy request with id '{}'", request_id)
 
-    privacy_request = PrivacyRequest.get(db, object_id=request_id)
+    privacy_request = (
+        PrivacyRequest.query_without_large_columns(db)
+        .filter(PrivacyRequest.id == request_id)
+        .first()
+    )
     if not privacy_request:
         raise HTTPException(
             status_code=HTTP_404_NOT_FOUND,

fides/api/api/v1/endpoints/system.py

@@ -557,7 +557,7 @@ async def get(
 )
 def instantiate_connection_from_template(
     fides_key: str,
-    saas_connector_type: str,
+    connector_template_type: str,
     template_values: SaasConnectionTemplateValues,
     db: Session = Depends(deps.get_db),
 ) -> SaasConnectionTemplateResponse:
@@ -567,4 +567,4 @@ def instantiate_connection_from_template(
     """
 
     system = get_system(db, fides_key)
-    return instantiate_connection(db, saas_connector_type, template_values, system)
+    return instantiate_connection(db, connector_template_type, template_values, system)