kubiya-control-plane-api 0.9.15__py3-none-any.whl

control_plane_api/app/lib/templating/parsers/env.py

@@ -0,0 +1,85 @@
+"""
+Parser for environment variable template variables: {{.env.VAR}}
+
+Supports referencing environment variables.
+"""
+
+import re
+from typing import Optional
+from control_plane_api.app.lib.templating.parsers.base import BaseParser
+from control_plane_api.app.lib.templating.types import TemplateVariable, TemplateVariableType
+
+
+class EnvVariableParser(BaseParser):
+    """
+    Parser for environment variable template variables.
+
+    Syntax: {{.env.VARIABLE_NAME}}
+    Valid names: alphanumeric characters and underscores (following Unix conventions)
+    Examples: {{.env.API_KEY}}, {{.env.DATABASE_URL}}, {{.env.PORT}}
+    """
+
+    _pattern = re.compile(r"\{\{\.env\.([a-zA-Z_][a-zA-Z0-9_]*)\}\}")
+
+    @property
+    def pattern(self) -> re.Pattern:
+        """Pattern to match environment variables: {{.env.VAR}}"""
+        return self._pattern
+
+    @property
+    def variable_type(self) -> TemplateVariableType:
+        """Returns ENV variable type."""
+        return TemplateVariableType.ENV
+
+    def parse_match(self, match: re.Match, template: str) -> Optional[TemplateVariable]:
+        """
+        Parse a regex match into a TemplateVariable.
+
+        Args:
+            match: Regex match object for {{.env.VAR}}
+            template: Full template string
+
+        Returns:
+            TemplateVariable with the parsed information
+        """
+        env_var_name = match.group(1)
+        raw = match.group(0)
+        start = match.start()
+        end = match.end()
+
+        # Additional validation
+        if not self.validate_name(env_var_name):
+            return None
+
+        # Store with "env." prefix for consistency
+        name = f"env.{env_var_name}"
+
+        return TemplateVariable(
+            name=name,
+            type=self.variable_type,
+            raw=raw,
+            start=start,
+            end=end
+        )
+
+    def validate_name(self, name: str) -> bool:
+        """
+        Validate environment variable name.
+
+        Rules (following Unix conventions):
+        - Must start with a letter or underscore
+        - Can contain letters, digits, and underscores
+        - Cannot be empty
+        - By convention, usually uppercase but not required
+
+        Args:
+            name: Environment variable name to validate
+
+        Returns:
+            True if valid, False otherwise
+        """
+        if not name:
+            return False
+
+        # Must start with letter or underscore, contain only alphanumeric and underscores
+        return bool(re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", name))

control_plane_api/app/lib/templating/parsers/graph.py

@@ -0,0 +1,112 @@
+"""
+Parser for context graph node template variables: {{.graph.node-id}}
+
+Supports referencing nodes from the context graph by their ID.
+"""
+
+import re
+from typing import Optional
+from control_plane_api.app.lib.templating.parsers.base import BaseParser
+from control_plane_api.app.lib.templating.types import TemplateVariable, TemplateVariableType
+
+
+class GraphNodeParser(BaseParser):
+    """
+    Parser for context graph node template variables.
+
+    Syntax: {{.graph.node-id}}
+    Valid node IDs: alphanumeric characters, underscores, hyphens, and dots
+    Examples: {{.graph.user-123}}, {{.graph.repo_456}}, {{.graph.service.prod}}
+
+    When compiled, these variables will be replaced with formatted node data including:
+    - Node properties (metadata)
+    - Relationships (incoming/outgoing)
+    - Labels and types
+    """
+
+    _pattern = re.compile(r"\{\{\.graph\.([a-zA-Z0-9._-]+)\}\}")
+
+    @property
+    def pattern(self) -> re.Pattern:
+        """Pattern to match graph node variables: {{.graph.node-id}}"""
+        return self._pattern
+
+    @property
+    def variable_type(self) -> TemplateVariableType:
+        """Returns GRAPH variable type."""
+        return TemplateVariableType.GRAPH
+
+    def parse_match(self, match: re.Match, template: str) -> Optional[TemplateVariable]:
+        """
+        Parse a regex match into a TemplateVariable.
+
+        Args:
+            match: Regex match object for {{.graph.node-id}}
+            template: Full template string
+
+        Returns:
+            TemplateVariable with the parsed information
+        """
+        node_id = match.group(1)
+        raw = match.group(0)
+        start = match.start()
+        end = match.end()
+
+        # Additional validation
+        if not self.validate_node_id(node_id):
+            return None
+
+        # Store with "graph." prefix for consistency
+        name = f"graph.{node_id}"
+
+        return TemplateVariable(
+            name=name,
+            type=self.variable_type,
+            raw=raw,
+            start=start,
+            end=end
+        )
+
+    def validate_name(self, name: str) -> bool:
+        """
+        Validate variable name (implements BaseParser abstract method).
+
+        For graph variables, the name format is "graph.node-id".
+
+        Args:
+            name: Variable name to validate
+
+        Returns:
+            True if valid, False otherwise
+        """
+        if not name or not name.startswith("graph."):
+            return False
+
+        # Extract node ID after "graph." prefix
+        node_id = name[6:]  # len("graph.") == 6
+        return self.validate_node_id(node_id)
+
+    def validate_node_id(self, node_id: str) -> bool:
+        """
+        Validate node ID.
+
+        Rules:
+        - Must contain only alphanumeric characters, underscores, hyphens, and dots
+        - Cannot be empty
+        - Cannot start or end with special characters (best practice)
+
+        Args:
+            node_id: Node ID to validate
+
+        Returns:
+            True if valid, False otherwise
+        """
+        if not node_id:
+            return False
+
+        # Basic pattern check - allow alphanumeric, underscore, hyphen, and dot
+        # Allow single character IDs or multi-character with proper start/end
+        if not re.match(r"^[a-zA-Z0-9][a-zA-Z0-9._-]*[a-zA-Z0-9]$|^[a-zA-Z0-9]$", node_id):
+            return False
+
+        return True

control_plane_api/app/lib/templating/parsers/secret.py

@@ -0,0 +1,87 @@
+"""
+Parser for secret template variables: {{.secret.name}}
+
+Supports referencing secrets from the vault.
+"""
+
+import re
+from typing import Optional
+from control_plane_api.app.lib.templating.parsers.base import BaseParser
+from control_plane_api.app.lib.templating.types import TemplateVariable, TemplateVariableType
+
+
+class SecretVariableParser(BaseParser):
+    """
+    Parser for secret template variables.
+
+    Syntax: {{.secret.secret_name}}
+    Valid names: alphanumeric characters, underscores, and hyphens
+    Examples: {{.secret.api_key}}, {{.secret.github-token}}, {{.secret.db_password}}
+    """
+
+    _pattern = re.compile(r"\{\{\.secret\.([a-zA-Z0-9_-]+)\}\}")
+
+    @property
+    def pattern(self) -> re.Pattern:
+        """Pattern to match secret variables: {{.secret.name}}"""
+        return self._pattern
+
+    @property
+    def variable_type(self) -> TemplateVariableType:
+        """Returns SECRET variable type."""
+        return TemplateVariableType.SECRET
+
+    def parse_match(self, match: re.Match, template: str) -> Optional[TemplateVariable]:
+        """
+        Parse a regex match into a TemplateVariable.
+
+        Args:
+            match: Regex match object for {{.secret.name}}
+            template: Full template string
+
+        Returns:
+            TemplateVariable with the parsed information
+        """
+        secret_name = match.group(1)
+        raw = match.group(0)
+        start = match.start()
+        end = match.end()
+
+        # Additional validation
+        if not self.validate_name(secret_name):
+            return None
+
+        # Store with "secret." prefix for consistency
+        name = f"secret.{secret_name}"
+
+        return TemplateVariable(
+            name=name,
+            type=self.variable_type,
+            raw=raw,
+            start=start,
+            end=end
+        )
+
+    def validate_name(self, name: str) -> bool:
+        """
+        Validate secret name.
+
+        Rules:
+        - Must contain only alphanumeric characters, underscores, and hyphens
+        - Cannot be empty
+        - Cannot start or end with hyphen or underscore (best practice)
+
+        Args:
+            name: Secret name to validate
+
+        Returns:
+            True if valid, False otherwise
+        """
+        if not name:
+            return False
+
+        # Basic pattern check
+        if not re.match(r"^[a-zA-Z0-9][a-zA-Z0-9_-]*[a-zA-Z0-9]$|^[a-zA-Z0-9]$", name):
+            return False
+
+        return True

control_plane_api/app/lib/templating/parsers/simple.py

@@ -0,0 +1,81 @@
+"""
+Parser for simple template variables: {{variable}}
+
+Supports basic variable substitution with alphanumeric names and underscores.
+"""
+
+import re
+from typing import Optional
+from control_plane_api.app.lib.templating.parsers.base import BaseParser
+from control_plane_api.app.lib.templating.types import TemplateVariable, TemplateVariableType
+
+
+class SimpleVariableParser(BaseParser):
+    """
+    Parser for simple template variables.
+
+    Syntax: {{variable_name}}
+    Valid names: alphanumeric characters and underscores only
+    Examples: {{user}}, {{api_key}}, {{database_name}}
+    """
+
+    _pattern = re.compile(r"\{\{([a-zA-Z0-9_]+)\}\}")
+
+    @property
+    def pattern(self) -> re.Pattern:
+        """Pattern to match simple variables: {{variable}}"""
+        return self._pattern
+
+    @property
+    def variable_type(self) -> TemplateVariableType:
+        """Returns SIMPLE variable type."""
+        return TemplateVariableType.SIMPLE
+
+    def parse_match(self, match: re.Match, template: str) -> Optional[TemplateVariable]:
+        """
+        Parse a regex match into a TemplateVariable.
+
+        Args:
+            match: Regex match object for {{variable}}
+            template: Full template string
+
+        Returns:
+            TemplateVariable with the parsed information
+        """
+        name = match.group(1)
+        raw = match.group(0)
+        start = match.start()
+        end = match.end()
+
+        # Additional validation
+        if not self.validate_name(name):
+            return None
+
+        return TemplateVariable(
+            name=name,
+            type=self.variable_type,
+            raw=raw,
+            start=start,
+            end=end
+        )
+
+    def validate_name(self, name: str) -> bool:
+        """
+        Validate simple variable name.
+
+        Rules:
+        - Must contain only alphanumeric characters and underscores
+        - Cannot be empty
+        - Cannot start with a number (enforced by pattern)
+
+        Args:
+            name: Variable name to validate
+
+        Returns:
+            True if valid, False otherwise
+        """
+        if not name:
+            return False
+
+        # Check pattern (redundant but explicit)
+        return bool(re.match(r"^[a-zA-Z_][a-zA-Z0-9_]*$", name))