Add support for Cosmetology public search

backend/cosmetology-app/bin/run_python_tests.py

@@ -30,6 +30,7 @@
     'lambdas/python/disaster-recovery',
     'lambdas/python/migration',
     'lambdas/python/provider-data-v1',
+    'lambdas/python/search',
     'lambdas/python/staff-user-pre-token',
     'lambdas/python/staff-users',
     '.',  # CDK tests

backend/cosmetology-app/lambdas/python/common/cc_common/data_model/schema/provider/api.py

@@ -1,5 +1,5 @@
 # ruff: noqa: N801, N815, ARG002  invalid-name unused-argument
-from marshmallow import ValidationError, validates_schema
+from marshmallow import ValidationError, post_load, validates_schema
 from marshmallow.fields import Integer, List, Nested, Raw, String
 from marshmallow.validate import Length, Range, Regexp
 
@@ -208,6 +208,19 @@ class ProviderPublicResponseSchema(ForgivingSchema):
     # Note the lack of `licenses` here: we do not return license data for public endpoints
 
 
+class PublicLicenseSearchResponseSchema(ForgivingSchema):
+    """
+    License object fields returned by the public query providers endpoint (OpenSearch-backed).
+    Jurisdiction is renamed to licenseJurisdiction for parity with JCC implementation.
+    """
+
+    providerId = Raw(required=True, allow_none=False)
+    givenName = String(required=True, allow_none=False, validate=Length(1, 100))
+    familyName = String(required=True, allow_none=False, validate=Length(1, 100))
+    licenseJurisdiction = String(required=True, allow_none=False)
+    compact = Compact(required=True, allow_none=False)
+    licenseNumber = String(required=True, allow_none=False, validate=Length(1, 100))
+
 class QueryProvidersRequestSchema(CCRequestSchema):
     """
     Schema for query providers requests.
@@ -228,14 +241,15 @@ class QuerySchema(CCRequestSchema):
         jurisdiction = Jurisdiction(required=False, allow_none=False)
         givenName = String(required=False, allow_none=False, validate=Length(min=1, max=100))
         familyName = String(required=False, allow_none=False, validate=Length(min=1, max=100))
+        licenseNumber = String(required=False, allow_none=False, validate=Length(min=1, max=100))
 
     class PaginationSchema(ForgivingSchema):
         """
         Nested schema for the pagination object within the request.
         """
 
         lastKey = String(required=False, allow_none=False, validate=Length(min=1, max=1024))
-        pageSize = Integer(required=False, allow_none=False)
+        pageSize = Integer(required=False, allow_none=False, validate=Range(min=5, max=100))
 
     class SortingSchema(ForgivingSchema):
         """

backend/cosmetology-app/lambdas/python/common/tests/unit/test_data_model/test_schema/test_provider.py

@@ -108,6 +108,26 @@ def test_general_response_schema_does_not_include_date_of_birth_in_licenses(self
         self.assertNotIn('dateOfBirth', result['licenses'][0])
 
 
+class TestQueryProvidersRequestSchema(TstLambdas):
+    """QueryProvidersRequestSchema.QuerySchema licenseNumber length matches API Gateway model (max 100)."""
+
+    def test_query_license_number_accepts_100_chars(self):
+        from cc_common.data_model.schema.provider.api import QueryProvidersRequestSchema
+
+        ln = 'x' * 100
+        body = {'query': {'licenseNumber': ln, 'jurisdiction': 'oh'}}
+        loaded = QueryProvidersRequestSchema().load(body)
+        self.assertEqual(ln, loaded['query']['licenseNumber'])
+
+    def test_query_license_number_rejects_over_100_chars(self):
+        from cc_common.data_model.schema.provider.api import QueryProvidersRequestSchema
+
+        body = {'query': {'licenseNumber': 'x' * 101, 'jurisdiction': 'oh'}}
+        with self.assertRaises(ValidationError) as ctx:
+            QueryProvidersRequestSchema().load(body)
+        self.assertIn('licenseNumber', ctx.exception.messages['query'])
+
+
 class TestProviderRecordSchema(TstLambdas):
     def test_serde(self):
         """Test round-trip deserialization/serialization"""

backend/cosmetology-app/lambdas/python/provider-data-v1/handlers/public_lookup.py

@@ -8,108 +8,6 @@
 from . import get_provider_information
 
 
-@api_handler
-def public_query_providers(event: dict, context: LambdaContext):  # noqa: ARG001 unused-argument
-    """Query providers data
-    :param event: Standard API Gateway event, API schema documented in the CDK ApiStack
-    :param LambdaContext context:
-    """
-    compact = event['pathParameters']['compact']
-
-    # Parse and validate the request body using the schema to strip whitespace
-    try:
-        schema = QueryProvidersRequestSchema()
-        body = schema.loads(event['body'])
-    except ValidationError as e:
-        logger.warning('Invalid request body', errors=e.messages)
-        raise CCInvalidRequestException(f'Invalid request: {e.messages}') from e
-
-    query = body.get('query', {})
-    if 'providerId' in query.keys():
-        provider_id = query['providerId']
-        query = {'providerId': provider_id}
-        resp = config.data_client.get_provider(
-            compact=compact,
-            provider_id=provider_id,
-            pagination=body.get('pagination'),
-            detail=False,
-        )
-        resp['query'] = query
-
-    else:
-        if 'givenName' in query.keys() and 'familyName' not in query.keys():
-            raise CCInvalidRequestException('familyName is required if givenName is provided')
-        provider_name = None
-        if 'familyName' in query.keys():
-            provider_name = (query.get('familyName'), query.get('givenName'))
-
-        jurisdiction = query.get('jurisdiction')
-
-        if jurisdiction:
-            # If the request is for a jurisdiction that is not live yet in the compact,
-            # we return empty results to reduce the number of queries made
-            # otherwise the request will search through the entire data set
-            if not config.compact_configuration_client.is_jurisdiction_live_in_compact(compact, jurisdiction):
-                logger.info(
-                    'Jurisdiction is not live in compact, returning empty results',
-                    compact=compact,
-                    jurisdiction=jurisdiction,
-                )
-                return {
-                    'query': query,
-                    'sorting': body.get('sorting', {}),
-                    'providers': [],
-                    'pagination': body.get('pagination', {}),
-                }
-
-        sorting = body.get('sorting', {})
-        sorting_key = sorting.get('key')
-
-        sort_direction = sorting.get('direction', 'ascending')
-        scan_forward = sort_direction == 'ascending'
-
-        match sorting_key:
-            case None | 'familyName':
-                resp = {
-                    'query': query,
-                    'sorting': {'key': 'familyName', 'direction': sort_direction},
-                    **config.data_client.get_providers_sorted_by_family_name(
-                        compact=compact,
-                        jurisdiction=jurisdiction,
-                        provider_name=provider_name,
-                        scan_forward=scan_forward,
-                        pagination=body.get('pagination'),
-                    ),
-                }
-            case 'dateOfUpdate':
-                if provider_name is not None:
-                    raise CCInvalidRequestException(
-                        'givenName and familyName are not supported for sorting by dateOfUpdate',
-                    )
-                resp = {
-                    'query': query,
-                    'sorting': {'key': 'dateOfUpdate', 'direction': sort_direction},
-                    **config.data_client.get_providers_sorted_by_updated(
-                        compact=compact,
-                        jurisdiction=jurisdiction,
-                        scan_forward=scan_forward,
-                        pagination=body.get('pagination'),
-                    ),
-                }
-            case _:
-                # This shouldn't happen unless our api validation gets misconfigured
-                raise CCInvalidRequestException(f"Invalid sort key: '{sorting_key}'")
-    # Convert generic field to more specific one for this API and sanitize data
-    unsanitized_providers = resp.pop('items', [])
-    # for the public query endpoint, we only return publicly available data
-    public_schema = ProviderPublicResponseSchema()
-    sanitized_providers = [public_schema.load(provider) for provider in unsanitized_providers]
-
-    resp['providers'] = sanitized_providers
-
-    return resp
-
-
 @api_handler
 def public_get_provider(event: dict, context: LambdaContext):  # noqa: ARG001 unused-argument
     """Return one provider's data