geek-cafe-saas-sdk 0.6.0__py3-none-any.whl

geek_cafe_saas_sdk/utilities/dynamodb_utils.py

@@ -0,0 +1,151 @@
+# DynamoDB Utilities
+
+from typing import Dict, Set
+
+# DynamoDB Reserved Keywords (subset of common ones)
+# Full list: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html
+DYNAMODB_RESERVED_KEYWORDS: Set[str] = {
+    'ABORT', 'ABSOLUTE', 'ACTION', 'ADD', 'AFTER', 'AGENT', 'AGGREGATE', 'ALL', 'ALSO', 'ALTER',
+    'ANALYZE', 'AND', 'ANY', 'ARCHIVE', 'ARE', 'ARRAY', 'AS', 'ASC', 'ASSERT', 'AST', 'AT',
+    'AUTHORIZATION', 'BACKUP', 'BATCH', 'BEFORE', 'BEGIN', 'BETWEEN', 'BIGINT', 'BINARY', 'BIT',
+    'BLOB', 'BLOCK', 'BOOLEAN', 'BOTH', 'BREAK', 'BUCKET', 'BULK', 'BY', 'BYTE', 'CALL', 'CALLED',
+    'CALLING', 'CAPACITY', 'CASCADE', 'CASCADED', 'CASE', 'CAST', 'CATALOG', 'CHAIN', 'CHANGE',
+    'CHANGED', 'CHARACTER', 'CHECK', 'CLASS', 'CLOB', 'CLOSE', 'CLUSTER', 'CLUSTERED', 'CLUSTERING',
+    'CLUSTERS', 'COALESCE', 'COLLATE', 'COLLATION', 'COLUMN', 'COLUMNS', 'COMBINE', 'COMMENT',
+    'COMMIT', 'COMMITTED', 'COMPACT', 'COMPILE', 'COMPILED', 'CONCURRENTLY', 'CONDITION',
+    'CONDITIONAL', 'CONFLICT', 'CONNECT', 'CONNECTION', 'CONSTRAINT', 'CONTAINS', 'CONVERT',
+    'COPY', 'COST', 'CREATE', 'CROSS', 'CSV', 'CUBE', 'CURRENT', 'CURSOR', 'CYCLE', 'DATA',
+    'DATABASE', 'DATABASES', 'DATE', 'DATETIME', 'DAY', 'DEALLOCATE', 'DEC', 'DECIMAL', 'DECLARE',
+    'DEFAULT', 'DEFAULTS', 'DEFERRABLE', 'DEFERRED', 'DEFINE', 'DEFINED', 'DEFINITION', 'DELETE',
+    'DELIMITER', 'DELIMITERS', 'DENSE_RANK', 'DEREF', 'DESC', 'DETACH', 'DETERMINISTIC', 'DICTIONARY',
+    'DISABLE', 'DISCARD', 'DISTINCT', 'DO', 'DOCUMENT', 'DOMAIN', 'DOUBLE', 'DROP', 'EACH', 'ELEMENT',
+    'ELSE', 'EMPTY', 'ENABLE', 'ENCODING', 'ENCRYPTED', 'END', 'ENUM', 'EQUAL', 'EQUALS', 'ERROR',
+    'ERRORS', 'ESCAPE', 'EVENT', 'EXCEPT', 'EXCEPTION', 'EXCEPTIONS', 'EXCLUDE', 'EXCLUDING',
+    'EXCLUSIVE', 'EXECUTE', 'EXISTS', 'EXPLAIN', 'EXPRESSION', 'EXTENDED', 'EXTENDS', 'EXTERNAL',
+    'EXTRACT', 'FALSE', 'FAMILY', 'FETCH', 'FILTER', 'FIRST', 'FLOAT', 'FOLLOWING', 'FOR', 'FORCE',
+    'FOREIGN', 'FORMAT', 'FORWARD', 'FOUNDATION', 'FRAME', 'FREE', 'FROM', 'FULL', 'FUNCTION',
+    'FUNCTIONS', 'GENERAL', 'GENERATED', 'GET', 'GLOBAL', 'GO', 'GOTO', 'GRANT', 'GRANTED', 'GREATEST',
+    'GROUP', 'GROUPING', 'GROUPS', 'HANDLER', 'HAVING', 'HEADER', 'HOLD', 'HOUR', 'IDENTITY', 'IF',
+    'ILIKE', 'IMMEDIATE', 'IMMUTABLE', 'IMPLICIT', 'IMPORT', 'IN', 'INCLUDING', 'INCREMENT',
+    'INCREMENTAL', 'INDEX', 'INDEXED', 'INDEXES', 'INDICATE', 'INHERITS', 'INITIALLY', 'INLINE',
+    'INNER', 'INOUT', 'INPUT', 'INSENSITIVE', 'INSERT', 'INSTEAD', 'INT', 'INTEGER', 'INTERSECT',
+    'INTERVAL', 'INTO', 'INVOKER', 'IS', 'ISNULL', 'ISOLATION', 'ITEM', 'ITEMS', 'ITERATE', 'JOIN',
+    'KEY', 'KEYS', 'LABEL', 'LANGUAGE', 'LARGE', 'LAST', 'LATERAL', 'LEAD', 'LEADING', 'LEAKPROOF',
+    'LEAST', 'LEFT', 'LENGTH', 'LEVEL', 'LIKE', 'LIMIT', 'LISTEN', 'LOAD', 'LOCAL', 'LOCALTIME',
+    'LOCALTIMESTAMP', 'LOCATION', 'LOCK', 'LOCKS', 'LOGGED', 'MAPPING', 'MATCH', 'MATERIALIZED',
+    'MAXVALUE', 'MINUS', 'MINUTE', 'MINVALUE', 'MODE', 'MODIFIES', 'MODIFY', 'MONTH', 'MOVE',
+    'NAME', 'NAMES', 'NATIONAL', 'NATURAL', 'NCHAR', 'NCLOB', 'NESTED', 'NEW', 'NEXT', 'NO',
+    'NONE', 'NOT', 'NOTHING', 'NOTIFY', 'NOTNULL', 'NOWAIT', 'NULL', 'NULLIF', 'NULLS', 'NUMBER',
+    'NUMERIC', 'OBJECT', 'OF', 'OFF', 'OFFSET', 'OIDS', 'OLD', 'ON', 'ONLY', 'OPERATOR', 'OPTION',
+    'OPTIONS', 'OR', 'ORDER', 'ORDINALITY', 'OTHERS', 'OUT', 'OUTER', 'OVER', 'OVERLAPS', 'OVERLAY',
+    'OVERRIDING', 'OWNED', 'OWNER', 'PARSER', 'PARTIAL', 'PARTITION', 'PARTITIONED', 'PARTITIONS',
+    'PASSING', 'PASSWORD', 'PLACING', 'PLANS', 'POLICY', 'POSITION', 'PRECEDING', 'PRECISION',
+    'PREPARE', 'PREPARED', 'PRESERVE', 'PRIMARY', 'PRIOR', 'PRIVILEGES', 'PROCEDURAL', 'PROCEDURE',
+    'PROGRAM', 'QUOTE', 'RANGE', 'RANK', 'READ', 'READS', 'REAL', 'REASSIGN', 'RECHECK', 'RECURSIVE',
+    'REF', 'REFERENCES', 'REFERENCING', 'REFRESH', 'REINDEX', 'RELATIVE', 'RELEASE', 'RENAME',
+    'REPEATABLE', 'REPLACE', 'REPLICA', 'RESET', 'RESTART', 'RESTRICT', 'RETURNING', 'RETURNS',
+    'REVOKE', 'RIGHT', 'ROLE', 'ROLES', 'ROLLBACK', 'ROLLUP', 'ROUTINE', 'ROUTINES', 'ROW',
+    'ROWS', 'RULE', 'SAVEPOINT', 'SCALE', 'SCHEMA', 'SCHEMAS', 'SCROLL', 'SEARCH', 'SECOND',
+    'SECURITY', 'SELECT', 'SEQUENCE', 'SEQUENCES', 'SERIALIZABLE', 'SERVER', 'SESSION', 'SET',
+    'SETS', 'SHARE', 'SHOW', 'SIMILAR', 'SIMPLE', 'SMALLINT', 'SNAPSHOT', 'SOME', 'SQL', 'STABLE',
+    'STANDALONE', 'START', 'STATEMENT', 'STATISTICS', 'STDIN', 'STDOUT', 'STORAGE', 'STORED',
+    'STRICT', 'STRIP', 'SUBSTRING', 'SYMMETRIC', 'SYSID', 'SYSTEM', 'TABLE', 'TABLES', 'TABLESPACE',
+    'TEMP', 'TEMPLATE', 'TEMPORARY', 'TEXT', 'THEN', 'TIME', 'TIMESTAMP', 'TO', 'TRAILING',
+    'TRANSACTION', 'TRANSFORM', 'TREAT', 'TRIGGER', 'TRIM', 'TRUE', 'TRUNCATE', 'TRUSTED', 'TYPE',
+    'TYPES', 'UESCAPE', 'UNBOUNDED', 'UNCOMMITTED', 'UNENCRYPTED', 'UNION', 'UNIQUE', 'UNKNOWN',
+    'UNLISTEN', 'UNLOGGED', 'UNTIL', 'UPDATE', 'USER', 'USERS', 'USING', 'VACUUM', 'VALID',
+    'VALIDATE', 'VALIDATOR', 'VALUE', 'VALUES', 'VARCHAR', 'VARIADIC', 'VARYING', 'VERBOSE',
+    'VERSION', 'VIEW', 'VIEWS', 'VOLATILE', 'WHEN', 'WHERE', 'WHITESPACE', 'WINDOW', 'WITH',
+    'WITHIN', 'WITHOUT', 'WORK', 'WRAPPER', 'WRITE', 'XML', 'XMLATTRIBUTES', 'XMLCONCAT', 'XMLELEMENT',
+    'XMLEXISTS', 'XMLFOREST', 'XMLPARSE', 'XMLPI', 'XMLROOT', 'XMLSERIALIZE', 'YEAR', 'YES', 'ZONE'
+}
+
+
+def build_expression_attribute_names(attributes: list[str]) -> Dict[str, str]:
+    """
+    Build ExpressionAttributeNames mapping for DynamoDB reserved keywords.
+
+    Args:
+        attributes: List of attribute names that may contain reserved keywords
+
+    Returns:
+        Dictionary mapping attribute placeholders to actual attribute names
+
+    Example:
+        >>> build_expression_attribute_names(['email', 'roles', 'name'])
+        {'#email': 'email', '#roles': 'roles', '#name': 'name'}
+    """
+    expression_attribute_names = {}
+
+    for attr in attributes:
+        if attr.upper() in DYNAMODB_RESERVED_KEYWORDS:
+            # Use placeholder for reserved keywords
+            placeholder = f"#{attr}"
+            expression_attribute_names[placeholder] = attr
+        else:
+            # For non-reserved keywords, we could still use placeholders for consistency
+            # but it's optional. For now, we'll only add placeholders for reserved keywords.
+            pass
+
+    return expression_attribute_names
+
+
+def replace_reserved_keywords_in_expression(expression: str, attribute_names: Dict[str, str]) -> str:
+    """
+    Replace reserved keyword attribute names with placeholders in expressions.
+
+    Args:
+        expression: The expression string (e.g., ProjectionExpression)
+        attribute_names: The ExpressionAttributeNames mapping
+
+    Returns:
+        Expression with reserved keywords replaced by placeholders
+
+    Example:
+        >>> replace_reserved_keywords_in_expression(
+        ...     "pk, sk, email, roles, name",
+        ...     {'#email': 'email', '#roles': 'roles'}
+        ... )
+        "pk, sk, #email, #roles, name"
+    """
+    result = expression
+
+    # Replace each reserved keyword with its placeholder
+    for placeholder, attr_name in attribute_names.items():
+        result = result.replace(attr_name, placeholder)
+
+    return result
+
+
+def build_projection_with_reserved_keywords(attributes: list[str]) -> tuple[str, Dict[str, str]]:
+    """
+    Convenience function to build projection expression and attribute names mapping.
+
+    Args:
+        attributes: List of attribute names for projection
+
+    Returns:
+        Tuple of (projection_expression, expression_attribute_names)
+
+    Example:
+        >>> projection, attr_names = build_projection_with_reserved_keywords(
+        ...     ['pk', 'sk', 'email', 'roles', 'name']
+        ... )
+        >>> projection
+        "pk, sk, #email, #roles, name"
+        >>> attr_names
+        {'#email': 'email', '#roles': 'roles'}
+    """
+    # Build the attribute names mapping
+    expression_attribute_names = build_expression_attribute_names(attributes)
+
+    # Create projection expression
+    projection_expression = ", ".join(attributes)
+
+    # Replace reserved keywords with placeholders
+    if expression_attribute_names:
+        projection_expression = replace_reserved_keywords_in_expression(
+            projection_expression, expression_attribute_names
+        )
+
+    return projection_expression, expression_attribute_names

geek_cafe_saas_sdk/utilities/environment_loader.py

@@ -0,0 +1,149 @@
+"""
+Geek Cafe SaaS Services Environment Services.
+
+This module provides utilities for loading and accessing environment variables
+used throughout the Geek Cafe SaaS Services application. It includes classes for
+loading environment files and accessing specific environment variables in a
+consistent manner.
+"""
+
+import os
+import json
+from typing import Dict, List, Any, Optional
+from pathlib import Path
+from dotenv import load_dotenv
+from aws_lambda_powertools import Logger
+
+
+logger = Logger(__name__)
+
+DEBUGGING = os.getenv("DEBUGGING", "false").lower() == "true"
+
+
+class EnvironmentLoader:
+    """Utility class for loading environment variables from files.
+    
+    This class provides methods to load environment variables from .env files,
+    load event files for testing, and search for files in the project directory structure.
+    """
+
+    def load_environment(
+        self,
+        *,
+        starting_path: Optional[str] = None,
+        file_name: str = ".env.dev",
+        override_vars: bool = True,
+        raise_error_if_not_found: bool = True,
+    ) -> None:
+        """Load environment variables from a .env file.
+        
+        Searches for the specified environment file starting from the given path
+        and loads the environment variables from it.
+        
+        Args:
+            starting_path: Path to start searching from. If None, uses the current file's location.
+            file_name: Name of the environment file to load (default: ".env.dev").
+            override_vars: Whether to override existing environment variables (default: True).
+            raise_error_if_not_found: Whether to raise an error if the file is not found (default: True).
+            
+        Raises:
+            RuntimeError: If the environment file is not found and raise_error_if_not_found is True.
+        """
+
+        if not starting_path:
+            starting_path = __file__
+
+        environment_file: str | None = self.find_file(
+            starting_path=starting_path,
+            file_name=file_name,
+            raise_error_if_not_found=raise_error_if_not_found,
+        )
+
+        if environment_file:
+            load_dotenv(dotenv_path=environment_file, override=override_vars)
+
+        if DEBUGGING:
+            env_vars = os.environ
+            logger.debug(f"Loaded environment file: {environment_file}")
+            # print(env_vars)
+
+    def load_event_file(self, full_path: str) -> Dict[str, Any]:
+        """Load and parse a JSON event file.
+        
+        Loads a JSON event file and handles common event structures by extracting
+        the actual event data from nested 'message' or 'event' fields if present.
+        
+        Args:
+            full_path: The full path to the JSON event file.
+            
+        Returns:
+            The parsed event data as a dictionary.
+            
+        Raises:
+            RuntimeError: If the event file does not exist.
+        """
+        if not os.path.exists(full_path):
+            raise RuntimeError(f"Failed to locate event file: {full_path}")
+
+        event: Dict = {}
+        with open(full_path, mode="r", encoding="utf-8") as json_file:
+            event = json.load(json_file)
+
+        if "message" in event:
+            tmp = event.get("message")
+            if isinstance(tmp, Dict):
+                event = tmp
+
+        if "event" in event:
+            tmp = event.get("event")
+            if isinstance(tmp, Dict):
+                event = tmp
+
+        return event
+
+    def find_file(
+        self, starting_path: str, file_name: str, raise_error_if_not_found: bool = True, max_parent_directories: int = 25
+    ) -> Optional[str]:
+        """Search for a file in the project directory structure.
+        
+        Searches for the specified file by traversing up the directory tree
+        starting from the given path, up to a maximum number of parent directories.
+        
+        Args:
+            starting_path: Path to start searching from.
+            file_name: Name of the file to search for.
+            raise_error_if_not_found: Whether to raise an error if the file is not found (default: True).
+            max_parent_directories: Maximum number of parent directories to search (default: 25).
+            
+        Returns:
+            The full path to the found file, or None if not found and raise_error_if_not_found is False.
+            
+        Raises:
+            RuntimeError: If the file is not found and raise_error_if_not_found is True.
+        """
+        parents = max_parent_directories
+        starting_path = starting_path or __file__
+
+        paths: List[str] = []
+        for parent in range(parents):
+            # Check if we have enough parent directories available
+            current_path = Path(starting_path)
+            if parent >= len(current_path.parents):
+                break
+            
+            path = current_path.parents[parent].absolute()
+            print(f"searching: {path}")
+            tmp = os.path.join(path, file_name)
+            paths.append(tmp)
+            if os.path.exists(tmp):
+                return tmp
+
+        if raise_error_if_not_found:
+            searched_paths = "\n".join(paths)
+            raise RuntimeError(
+                f"Failed to locate environment file: {file_name} in: \n {searched_paths}"
+            )
+
+        return None
+
+

geek_cafe_saas_sdk/utilities/environment_variables.py

@@ -0,0 +1,228 @@
+"""
+Geek Cafe SaaS Services Environment Services.
+
+This module provides utilities for loading and accessing environment variables
+used throughout the Geek Cafe SaaS Services application. It includes classes for
+loading environment files and accessing specific environment variables in a
+consistent manner.
+"""
+
+import os
+from typing import Optional
+from aws_lambda_powertools import Logger
+
+
+logger = Logger(__name__)
+
+DEBUGGING = os.getenv("DEBUGGING", "false").lower() == "true"
+
+
+
+
+
+class EnvironmentVariables:
+    """
+    Centralized access to environment variables used throughout the application.
+    
+    This class provides static methods to access environment variables in a consistent manner,
+    with proper typing and default values where appropriate. Using this class instead of direct
+    os.getenv calls helps track and manage all environment variables in one place, making
+    maintenance and documentation easier.
+    """
+
+    @staticmethod
+    def get_aws_region() -> Optional[str]:
+        """
+        Get the AWS region from environment variables.
+        
+        Returns:
+            The AWS region as a string, or None if not set.
+        """
+        value = os.getenv("AWS_REGION")
+        return value
+
+    @staticmethod
+    def get_aws_profile() -> Optional[str]:
+        """
+        Get the AWS profile used for CLI/boto3 commands.
+        
+        This should only be set with temporary credentials and only for development purposes.
+        
+        Returns:
+            The AWS profile name as a string, or None if not set.
+        """
+        value = os.getenv("AWS_PROFILE")
+        return value
+
+    @staticmethod
+    def get_aws_account_id() -> Optional[str]:
+        """
+        Get the AWS account ID from environment variables.
+        
+        Returns:
+            The AWS account ID as a string, or None if not set.
+        """
+        value = os.getenv("AWS_ACCOUNT_ID")
+        return value
+
+    @staticmethod
+    def get_auth_target_validation_level() -> Optional[str]:
+        """
+        Get the authentication target validation level from environment variables.
+        
+        Validation levels:
+            PASS_THROUGH: Allows the logged in user to be listed as the target
+                if the target user isn't explicitly listed. This provides backward compatibility
+                during conversion from short URLs to more detailed URL routes.
+                
+            STRICT: Requires a target user/tenant to be explicitly specified in the path.
+                This will be required for all new endpoints. The endpoints have been created
+                but some UI and tests have not been updated yet.
+        
+        Returns:
+            The validation level as a string ("PASS_THROUGH" or "STRICT"), or None if not set.
+        """
+        value = os.getenv("AUTH_TARGET_VALIDATION_LEVEL")
+        return value
+
+    
+
+    @staticmethod
+    def get_logging_level(default: str = "INFO") -> str:
+        """
+        Get the logging level from environment variables.
+        
+        Args:
+            default: Default logging level to use if not set in environment (default: "INFO").
+            
+        Returns:
+            The logging level as a string.
+        """
+        value = os.getenv("LOG_LEVEL", default)
+        return value
+
+    @staticmethod
+    def get_app_domain():
+        """
+        gets the app domain name from an environment var
+        """
+        value = os.getenv("APP_DOMAIN")
+        return value
+
+    @staticmethod
+    def get_ses_user_name():
+        """
+        gets the ses user-name from an environment var
+        """
+        value = os.getenv("SES_USER_NAME")
+        return value
+
+    @staticmethod
+    def get_ses_password():
+        """
+        gets the ses password from an environment var
+        """
+        value = os.getenv("SES_PASSWORD")
+        return value
+
+    @staticmethod
+    def get_ses_endpoint():
+        """
+        gets the ses endpoint from an environment var
+        """
+        value = os.getenv("SES_END_POINT")
+        return value
+
+    @staticmethod
+    def get_cognito_user_pool() -> str | None:
+        """
+        gets the cognito user pool from an environment var
+        """
+        value = os.getenv("COGNITO_USER_POOL")
+        return value
+
+    @staticmethod
+    def get_dynamodb_table_name():
+        """
+        gets the dynamodb table name from an environment var
+        """
+        value = os.getenv("APPLICATION_TABLE_NAME")
+        return value
+
+    @staticmethod
+    def get_dynamodb_raise_on_error_setting() -> bool:
+        """
+        gets the dynamodb table name from an environment var
+        """
+        value = str(os.getenv("RAISE_ON_DB_ERROR", "true")).lower() == "true"
+
+        return value
+
+    @staticmethod
+    def get_tenant_user_file_bucket_name():
+        """
+        gets the tenant user file bucket name from an environment var
+        """
+        value = os.getenv("TENANT_USER_FILE_BUCKET")
+        return value
+
+    @staticmethod
+    def get_tenant_user_upload_bucket_name():
+        """
+        gets the tenant user upload bucket name from an environment var
+        """
+        value = os.getenv("UPLOAD_BUCKET")
+        return value
+
+    @staticmethod
+    def get_lambda_function_to_invoke() -> str | None:
+        """
+        gets the lambda function to invoke from an environment var
+        this is used by sync to async lambda invocation, or by the queue
+        """
+        value = os.getenv("LAMBDA_FUNCTION_TO_INVOKE")
+        return value
+
+    @staticmethod
+    def get_amazon_trace_id():
+        """
+        gets the amazon trace id from an environment var
+        """
+        value = os.getenv("_X_AMZN_TRACE_ID", "NA")
+        return value
+
+    @staticmethod
+    def get_integration_tests_setting() -> bool:
+        """
+        determine if integration tests are run from an environment var
+        """
+        value = str(os.getenv("RUN_INTEGRATION_TESTS", "False")).lower() == "true"
+        env = EnvironmentVariables.get_environment_setting()
+
+        if env.lower().startswith("prod"):
+            value = False
+
+        return value
+
+    @staticmethod
+    def get_environment_setting() -> str:
+        """
+        gets the environment name from an environment var
+        """
+        value = os.getenv("ENVIRONMENT") or os.getenv("ENVIRONMENT_NAME")
+
+        if not value:
+            logger.warning(
+                "ENVIRONMENT var is not set. A future version will throw an error."
+            )
+            return ""
+
+        return value
+
+    @staticmethod
+    def is_development_environment() -> bool:
+        """
+        determine if the environment is development
+        """
+        env = EnvironmentVariables.get_environment_setting()
+        return env.lower().startswith("dev")

geek_cafe_saas_sdk/utilities/http_body_parameters.py

@@ -0,0 +1,44 @@
+from geek_cafe_saas_sdk.utilities.lambda_event_utility import LambdaEventUtility
+
+
+class HttpBodyParameters:
+    """Search Http QueryString Parameters"""
+
+    def start_date(self, event: dict) -> str | None:
+        """A start date path parameter (start-date)"""
+        return self.find(event, "start-date")
+
+    def end_date(self, event: dict) -> str | None:
+        """An end date path parameter (end-date)"""
+        return self.find(event, "end-date")
+
+    def user_id(self, event: dict) -> str | None:
+        """The userId path parameter (user-id)"""
+        return self.find(event, "user-id")
+
+    def status(self, event: dict) -> str | None:
+        """The status parameter"""
+        return self.find(event, "status")
+
+    def type(self, event: dict) -> str | None:
+        """The type parameter"""
+        return self.find(event, "type")
+
+    def file_id(self, event: dict) -> str | None:
+        """The file id parameter"""
+        return self.find(event, "file-id")
+
+    def tenant_id(self, event: dict) -> str | None:
+        """The tenant id parameter"""
+        return self.find(event, "tenant-id")
+
+    def subscription_id(self, event: dict) -> str | None:
+        """The subscription id parameter"""
+        return self.find(event, "subscription-id")
+
+    def find(self, event: dict, key: str) -> str | None:
+        """Generic Search/Find a key in the path parameters"""
+        value = LambdaEventUtility.get_value_from_event(event, key)
+        if isinstance(value, str):
+            return value
+        return None

geek_cafe_saas_sdk/utilities/http_path_parameters.py

@@ -0,0 +1,60 @@
+"""
+Geek Cafe SaaS Services Http Path Parameters
+"""
+
+import os
+from .lambda_event_utility import LambdaEventUtility
+
+DEFAULT_RESPONSE_LIMIT = os.getenv("DEFAULT_RESPONSE_LIMIT")
+
+
+class HttpPathParameters:
+    """Search Http Path Parameters"""
+
+    def start_date(self, event: dict) -> str | None:
+        """A start date path parameter (start-date)"""
+        return self.find(event, "start-date")
+
+    def end_date(self, event: dict) -> str | None:
+        """An end date path parameter (end-date)"""
+        return self.find(event, "end-date")
+
+    def user_id(self, event: dict) -> str | None:
+        """The userId path parameter (user-id)"""
+        return self.find(event, "user-id")
+
+    def status(self, event: dict) -> str | None:
+        """The status parameter"""
+        return self.find(event, "status")
+
+    def file_id(self, event: dict) -> str | None:
+        """The file id parameter"""
+        return self.find(event, "file-id")
+
+    def tenant_id(self, event: dict) -> str | None:
+        """The tenant id parameter"""
+        return self.find(event, "tenant-id")
+
+    def subscription_id(self, event: dict) -> str | None:
+        """The subscription id parameter"""
+        return self.find(event, "subscription-id")
+
+    def find(self, event: dict, key: str) -> str | None:
+        """Generic Search/Find a key in the path parameters"""
+        value = LambdaEventUtility.get_value_from_path_parameters(event, key)
+        if isinstance(value, str):
+            return value
+        return None
+
+    def limit(self, event: dict) -> int | None:
+        """
+        Returns the limit if any. Used for response limits on datasets
+        responses from DynamoDB
+        """
+        value = self.find(event, "limit")
+        if isinstance(value, str):
+            try:
+                return int(value)
+            except:  # noqa: E722, pylint: disable=w0702
+                pass
+        return None