stoobly-agent 0.33.7__py3-none-any.whl → 0.34.0__py3-none-any.whl

stoobly_agent/__init__.py

@@ -1,2 +1,2 @@
 COMMAND = 'stoobly-agent'
-VERSION = '0.33.7'
+VERSION = '0.34.0'

stoobly_agent/app/cli/endpoint_cli.py

@@ -1,4 +1,4 @@
-import click
+import click, sys
 
 from stoobly_agent.app.models.types import OPENAPI_FORMAT
 from stoobly_agent.app.settings import Settings
@@ -7,6 +7,7 @@ from stoobly_agent.lib.utils.conditional_decorator import ConditionalDecorator
 
 from .helpers.endpoint_facade import EndpointFacade
 from .helpers.endpoints_apply_context import EndpointsApplyContext
+from .helpers.endpoints_import_context import EndpointsImportContext
 from .helpers.feature_flags import local, remote
 from .helpers.validations import validate_project_key, validate_scenario_key
 
@@ -54,3 +55,25 @@ def apply(**kwargs):
 
   facade = EndpointFacade(settings)
   facade.apply(context)
+
+@endpoint.command(
+  "import",
+  help="Import endpoints"
+)
+@click.option('--source-format', required=True, type=click.Choice([OPENAPI_FORMAT]), help="Spec file format.")
+@click.option('--source-path', help='Path to spec file.')
+def import_endpoint(**kwargs):
+  context = EndpointsImportContext()
+
+  project_key = settings.proxy.intercept.project_key
+  if project_key:
+    project_key = validate_project_key(project_key)
+    context.with_project(project_key.id)
+  
+  context.with_source(kwargs.get('source_path'), kwargs.get('source_format'))
+
+  endpoint_handler = lambda endpoint: print(f"{bcolors.OKBLUE}Importing Endpoint: {endpoint['method']} {endpoint['path']}{bcolors.ENDC}")
+  context.with_endpoint_handler(endpoint_handler)
+  
+  facade = EndpointFacade(settings)
+  facade.import_endpoints(context)

stoobly_agent/app/cli/helpers/endpoint_facade.py

@@ -2,9 +2,17 @@ import pdb
 
 from stoobly_agent.app.models.factories.resource.request import RequestResourceFactory
 from stoobly_agent.app.settings import Settings
+from stoobly_agent.lib.api.endpoints_resource import EndpointsResource
+from stoobly_agent.lib.api.header_names_resource import HeaderNamesResource
+from stoobly_agent.lib.api.body_param_names_resource import BodyParamNamesResource
+from stoobly_agent.lib.api.query_param_names_resource import QueryParamNamesResource
+from stoobly_agent.lib.api.response_param_names_resource import ResponseParamNamesResource
+from stoobly_agent.lib.api.response_header_names_resource import ResponseHeaderNamesResource
 
 from .endpoints_apply_context import EndpointsApplyContext
+from .endpoints_import_context import EndpointsImportContext
 from .endpoints_apply_service import apply_endpoints
+from .endpoints_import_service import import_endpoints
 from .synchronize_request_service import SynchronizeRequestService
 
 class EndpointFacade():
@@ -22,4 +30,17 @@ class EndpointFacade():
     )
     context.with_request_handler(request_handler)
 
-    apply_endpoints(context)
+    apply_endpoints(context)
+  
+  def import_endpoints(self, context: EndpointsImportContext):
+    api_url = self.__settings.remote.api_url
+    api_key = self.__settings.remote.api_key
+
+    context.with_endpoint_resource(EndpointsResource(api_url, api_key))
+    context.with_header_name_resource(HeaderNamesResource(api_url, api_key))
+    context.with_body_param_name_resource(BodyParamNamesResource(api_url, api_key))
+    context.with_query_param_name_resource(QueryParamNamesResource(api_url, api_key))
+    context.with_response_param_name_resource(ResponseParamNamesResource(api_url, api_key))
+    context.with_response_header_name_resource(ResponseHeaderNamesResource(api_url, api_key))
+
+    import_endpoints(context)

stoobly_agent/app/cli/helpers/endpoints_import_context.py

@@ -0,0 +1,57 @@
+from typing import Callable, TypedDict
+
+from .openapi_endpoint_adapter import OpenApiEndpointAdapter
+from stoobly_agent.app.models.types import OPENAPI_FORMAT
+from stoobly_agent.lib.api.body_param_names_resource import BodyParamNamesResource
+from stoobly_agent.lib.api.endpoints_resource import EndpointsResource
+from stoobly_agent.lib.api.header_names_resource import HeaderNamesResource
+from stoobly_agent.lib.api.interfaces.endpoints import EndpointShowResponse
+from stoobly_agent.lib.api.query_param_names_resource import QueryParamNamesResource
+from stoobly_agent.lib.api.response_param_names_resource import ResponseParamNamesResource
+from stoobly_agent.lib.api.response_header_names_resource import ResponseHeaderNamesResource
+
+class EndpointsImportContext:
+  def __init__(self):
+    self.endpoints = []
+    self.endpoint_handlers = []
+    self.resources = {}
+    self.project_id = None
+
+  def with_endpoint_handler(self, handler: Callable[[EndpointShowResponse], None]):
+    self.endpoint_handlers.append(handler)
+    return self
+  
+  def with_project(self, project_id: int):
+    self.project_id = project_id
+    return self
+  
+  def with_endpoint_resource(self, resource: EndpointsResource):
+    self.resources['endpoint'] = resource
+    return self
+  
+  def with_header_name_resource(self, resource: HeaderNamesResource):
+    self.resources['header_name'] = resource
+    return self
+
+  def with_body_param_name_resource(self, resource: BodyParamNamesResource):
+    self.resources['body_param_name'] = resource
+    return self
+
+  def with_query_param_name_resource(self, resource: QueryParamNamesResource):
+    self.resources['query_param_name'] = resource
+    return self
+
+  def with_response_param_name_resource(self, resource: ResponseParamNamesResource):
+    self.resources['response_param_name'] = resource
+    return self
+  
+  def with_response_header_name_resource(self, resource: ResponseHeaderNamesResource):
+    self.resources['response_header_name'] = resource
+    return self
+
+  def with_source(self, path: str, format: str):
+    if format == OPENAPI_FORMAT:
+      endpoint_adapter = OpenApiEndpointAdapter()
+      self.endpoints += endpoint_adapter.adapt_from_file(path)
+
+    return self

stoobly_agent/app/cli/helpers/endpoints_import_service.py

@@ -0,0 +1,147 @@
+import json
+import requests
+import sys
+from typing import Dict
+
+from .endpoints_import_context import EndpointsImportContext
+from stoobly_agent.app.models.types import ENDPOINT_COMPONENT_NAMES
+from stoobly_agent.lib.api.body_param_names_resource import BodyParamNamesResource
+from stoobly_agent.lib.api.endpoints_resource import EndpointsResource
+from stoobly_agent.lib.api.header_names_resource import HeaderNamesResource
+from stoobly_agent.lib.api.interfaces.endpoints import BodyParamName
+from stoobly_agent.lib.api.interfaces.endpoints import EndpointShowResponse
+from stoobly_agent.lib.api.interfaces.endpoints import RequestComponentName
+from stoobly_agent.lib.api.query_param_names_resource import QueryParamNamesResource
+from stoobly_agent.lib.api.response_header_names_resource import ResponseHeaderNamesResource
+from stoobly_agent.lib.api.response_param_names_resource import ResponseParamNamesResource
+from stoobly_agent.lib.logger import bcolors
+
+def import_endpoints(context: EndpointsImportContext):
+    for endpoint in context.endpoints:
+        for endpoint_handler in context.endpoint_handlers:
+            endpoint_handler(endpoint)
+
+        try:
+            res = import_endpoint(context.project_id, context.resources['endpoint'], endpoint)
+        except requests.HTTPError as e:
+            error_handler(endpoint, e)
+            return
+        
+        if res.status_code == 409: # Endpoint already created
+            continue
+
+        endpoint_id = res.json()['id']
+        try:
+            res = import_component_names(context.project_id, endpoint_id, endpoint, context.resources)
+        except requests.HTTPError as e:
+            error_handler(endpoint, e)
+            try:
+                cleanup_endpoint(context.project_id, endpoint_id, context.resources['endpoint'])
+            except requests.HTTPError as e:
+                print(f"{bcolors.FAIL}Encountered {e.response.status_code} {e.response.reason}: {e.response.text} - Failed to delete endpoint: {endpoint['method']} {endpoint['path']}{bcolors.ENDC}", file=sys.stderr)
+            return
+
+def import_endpoint(project_id: int, endpoint_resource: EndpointsResource, endpoint: EndpointShowResponse):
+    res: requests.Response = endpoint_resource.create(**{
+        'host': endpoint.get('host'),
+        'method': endpoint.get('method'),
+        'path_segments': json.dumps(endpoint.get('path_segment_names', [])),
+        'path': endpoint.get('path'),
+        'port': endpoint.get('port'),
+        'project_id': project_id,
+    })
+
+    if res.ok or res.status_code == 409: # Endpoint already created
+        return res
+    
+    res.raise_for_status()
+
+def import_header_name(project_id: int, endpoint_id: int, header_name_resource: HeaderNamesResource, header_name: RequestComponentName): 
+    res: requests.Response = header_name_resource.create(endpoint_id, {
+        'name': header_name.get('name'),
+        'is_deterministic': header_name.get('is_deterministic', True),
+        'is_required': header_name.get('is_required', False),
+        'endpoint_id': endpoint_id,
+        'project_id': project_id,  
+    })
+
+    res.raise_for_status()
+
+def import_body_param_name(project_id: int, endpoint_id: int, body_param_name_resource: BodyParamNamesResource, body_param_name: BodyParamName):
+    res: requests.Response = body_param_name_resource.create(endpoint_id, {
+        'name': body_param_name.get('name'),
+        'is_deterministic': body_param_name.get('is_deterministic', True),
+        'is_required': body_param_name.get('is_required', False),
+        'inferred_type': body_param_name.get('inferred_type'),
+        'query': body_param_name.get('query'),
+        'endpoint_id': endpoint_id,
+        'project_id': project_id,
+    })
+
+    res.raise_for_status()
+
+def import_query_param_name(project_id: int, endpoint_id: int, query_param_name_resource: QueryParamNamesResource, query_param_name: RequestComponentName):
+    res: requests.Response = query_param_name_resource.create(endpoint_id, {
+        'name': query_param_name.get('name'),
+        'is_deterministic': query_param_name.get('is_deterministic', True),
+        'is_required': query_param_name.get('is_required', False),
+        'endpoint_id': endpoint_id,
+        'project_id': project_id,
+    })
+
+    res.raise_for_status()
+
+def import_response_param_name(project_id: int, endpoint_id: int, response_param_name_resource: ResponseParamNamesResource, response_param_name: RequestComponentName):
+    res: requests.Response = response_param_name_resource.create(endpoint_id, {
+        'name': response_param_name.get('name'),
+        'is_deterministic': response_param_name.get('is_deterministic', True),
+        'is_required': response_param_name.get('is_required', False),
+        'inferred_type': response_param_name.get('inferred_type'),
+        'query': response_param_name.get('query'),
+        'endpoint_id': endpoint_id,
+        'project_id': project_id,
+    })
+
+    res.raise_for_status()
+
+def import_response_header_name(project_id: int, endpoint_id: int, response_header_name_resource: ResponseHeaderNamesResource, response_header_name: RequestComponentName):
+    res: requests.Response = response_header_name_resource.create(endpoint_id, {
+        'name': response_header_name.get('name'),
+        'is_deterministic': response_header_name.get('is_deterministic', True),
+        'is_required': response_header_name.get('is_required', False),
+        'endpoint_id': endpoint_id,
+        'project_id': project_id,  
+    })
+
+    res.raise_for_status()
+
+component_name_import_dispatch = {
+    ENDPOINT_COMPONENT_NAMES[0]: import_header_name,
+    ENDPOINT_COMPONENT_NAMES[1]: import_body_param_name,
+    ENDPOINT_COMPONENT_NAMES[2]: import_query_param_name,
+    ENDPOINT_COMPONENT_NAMES[3]: import_response_header_name,
+    ENDPOINT_COMPONENT_NAMES[4]: import_response_param_name
+}
+
+def process_import(component_name: str, *args):
+    return component_name_import_dispatch[component_name](*args)
+
+def import_component_names(project_id: int, endpoint_id: int, endpoint: EndpointShowResponse, resources: Dict[str, EndpointsResource]):
+    for component_name in ENDPOINT_COMPONENT_NAMES:
+        for component in endpoint.get(f'{component_name}s', {}):
+            resource = resources[component_name]
+            process_import(component_name, project_id, endpoint_id, resource, component)
+
+def cleanup_endpoint(project_id: int, endpoint_id: int, resource: EndpointsResource):
+    print(f"{bcolors.FAIL}Cleaning up partial import...{bcolors.ENDC}")
+    res: requests.Response = resource.destroy(endpoint_id, **{
+        'project_id': project_id
+    })
+
+    res.raise_for_status()
+
+def error_handler(endpoint: EndpointShowResponse, error: requests.HTTPError):
+    print(
+        f"{bcolors.FAIL}Encountered {error.response.status_code} {error.response.reason}: {error.response.text} - Failed to import endpoint: {endpoint['method']} {endpoint['path']} - Aborting operation{bcolors.ENDC}", 
+        file=sys.stderr
+    )

stoobly_agent/app/cli/helpers/openapi_endpoint_adapter.py

@@ -73,19 +73,32 @@ class OpenApiEndpointAdapter():
           endpoint: EndpointShowResponse = {}
           endpoint['id'] = endpoint_counter
           endpoint['method'] = http_method.upper()
-          endpoint['host'] = parsed_url.netloc
+          endpoint['host'] = '-' if parsed_url.netloc == '' else parsed_url.netloc
 
           joined_path = self.__urljoin(parsed_url.path, path_name)
           split_parts = joined_path.split('/')
           pattern_path = []
+          segment_names = []
           for part in split_parts:
             sanitized_part = part
+            segment_name = part
             if part.startswith('{') and part.endswith('}'):
               sanitized_part = '%' 
+              segment_name = f":{part[1:-1]}"
             pattern_path.append(sanitized_part)
+            segment_names.append(segment_name)
           pattern_path_str = '/'.join(pattern_path)
           endpoint['match_pattern'] = pattern_path_str
           endpoint['path'] = joined_path
+
+          endpoint['path_segment_names'] = []
+          for segment_name in segment_names:
+            if segment_name == "":
+              continue
+            path_component_name: RequestComponentName = {}
+            path_component_name['name'] = segment_name
+            path_component_name['type'] = "alias" if segment_name.startswith(':') else "static"
+            endpoint['path_segment_names'].append(path_component_name)
           
           endpoint['port'] = str(parsed_url.port)
           if endpoint['port'] is None or endpoint['port'] == 'None':
@@ -94,7 +107,7 @@ class OpenApiEndpointAdapter():
             elif parsed_url.scheme == 'http':
               endpoint['port'] = '80'
             else:
-              endpoint['port'] = ''
+              endpoint['port'] = '0'
 
           alias_counter = 0
           header_param_counter = 0
@@ -142,7 +155,10 @@ class OpenApiEndpointAdapter():
                   param_value = self.__open_api_to_default_python_type(open_api_type)
 
               literal_query_param = {
-                parameter['name']: {'value': param_value}
+                parameter['name']: {
+                  'value': param_value,
+                  'required': parameter.get('required', False),
+                }
               }
 
               if not endpoint.get('literal_query_params'):
@@ -238,6 +254,11 @@ class OpenApiEndpointAdapter():
             else:
               self.__convert_literal_component_param(endpoint, required_body_params, [literal_body_params], 'body_param_name', 'literal_body_params')
 
+          # Responses -> construct lists of response header and response param name resources
+          responses = operation.get('responses', {})
+          if responses:
+            self.__parse_responses(endpoint, responses, components)
+
           endpoints.append(endpoint)
     
     return endpoints
@@ -391,11 +412,30 @@ class OpenApiEndpointAdapter():
       component_name = component_data[1]
       component = components.get(component_type, {})
 
+      # If component_type is 'headers'
+      # Example: '#components/headers/X-RateLimit-Limit'
+      if component_type == "headers":
+        # In this case, literal_body_params represents a header rather than request or response body params
+        literal_body_params['name'] = component_name
+        header_example = component.get('example')
+        if header_example:
+          literal_body_params['values'].append(header_example)
+        literal_body_params['is_required'] = component.get('is_required', False)
+        literal_body_params['is_deterministic'] = True
+        return literal_body_params
+
       # Example: {'type': 'object', 'required': ['name'], 'properties': {'name': {'type': 'string'}, 'tag': {'type': 'string'}}}
       body_spec = component.content()[component_name]
       required_body_params += body_spec.get('required', [])
 
-      param_properties = body_spec.get('properties')
+      param_properties = {}
+      schema_type = body_spec.get('type')
+      if schema_type:
+        if schema_type == 'object':
+          param_properties = body_spec.get('properties', {})
+        elif schema_type == 'array':
+          param_properties = {'tmp': body_spec['items']}
+
       all_of = body_spec.get('allOf')
       any_of = body_spec.get('anyOf')
       one_of = body_spec.get('oneOf')
@@ -421,7 +461,7 @@ class OpenApiEndpointAdapter():
       # elif any_of or one_of:
 
       return param_properties 
-
+  
   def __convert_literal_component_param(self, endpoint: EndpointShowResponse,
       required_component_params: List[str], literal_component_params: Union[dict, list],
       component_name: str, literal_component_name: str) -> None:
@@ -444,7 +484,11 @@ class OpenApiEndpointAdapter():
       else:
         param['is_required'] = False
 
-    endpoint[component_name + 's'] = built_params_list
+    if not endpoint.get(component_name + 's'):
+      endpoint[component_name + 's'] = built_params_list
+    else:
+      endpoint[component_name + 's'].extend(built_params_list)
+
     del endpoint[literal_component_name]
 
   # urllib.parse.urljoin() doesn't work for some of our edge cases
@@ -557,3 +601,64 @@ class OpenApiEndpointAdapter():
     
     return result
 
+  def __parse_responses(self, endpoint: EndpointShowResponse, responses: Spec, components: Spec):
+    for response_code, response_definition in responses.items():
+      # Construct response param name components
+      literal_response_params = {}
+      response_body_array = False
+      required_response_params = []
+      response_content = response_definition.get('content', {})
+      for mimetype, media_type in response_content.items():
+        param_properties = {}
+        schema = media_type['schema']
+        
+        if '$ref' in schema:
+          reference = schema['$ref']
+          self.__dereference(components, reference, required_response_params, literal_response_params)
+        else:
+          schema_type = schema.get('type')
+          if schema_type:
+            if schema_type == 'object':
+              param_properties = schema.get('properties', {})
+            elif schema_type == 'array':
+              response_body_array = True
+              param_properties = {'tmp': schema['items']}
+        
+        for property_key, property_value in param_properties.items():
+          if property_key in required_response_params:
+            param_properties[property_key]['required'] = True
+          
+        self.__extract_param_properties(components, None, required_response_params, param_properties, literal_response_params)
+
+        if literal_response_params:
+          endpoint['literal_response_params'] = literal_response_params
+
+        # Only support first media type
+        break
+      
+      literal_response_params = endpoint.get('literal_response_params')
+      if literal_response_params:
+        if not response_body_array:
+          self.__convert_literal_component_param(endpoint, required_response_params, literal_response_params, 'response_param_name', 'literal_response_params')
+        else:
+          self.__convert_literal_component_param(endpoint, required_response_params, [literal_response_params], 'response_param_name', 'literal_response_params')
+
+      # Construct response header name components
+      response_headers = response_definition.get('headers', {})
+      for header_name, header_definition in response_headers.items():
+        response_header_name: RequestComponentName = {}
+        response_header_name['name'] = header_name
+        
+        if '$ref' in header_definition:
+          reference = header_definition['$ref']
+          self.__dereference(components, reference, [], response_header_name)
+        else:
+          header_example = header_definition.get('example')
+          if header_example:
+            response_header_name['values'].append(header_example)
+          response_header_name['is_required'] = header_definition.get('is_required', False)
+          response_header_name['is_deterministic'] = True
+          
+        if not endpoint.get('response_header_names'):
+          endpoint['response_header_names'] = []
+        endpoint['response_header_names'].append(response_header_name)	  

stoobly_agent/app/models/types/endpoint.py

@@ -1,7 +1,33 @@
-from typing import Literal, TypedDict
+from typing import TypedDict
 
 OPENAPI_FORMAT = 'openapi'
 
+ENDPOINT_COMPONENT_NAMES = [
+  "header_name",
+  "body_param_name",
+  "query_param_name",
+  "response_header_name",
+  "response_param_name"
+]
+
 class EndpointCreateParams(TypedDict):
-  format: Literal[f"{OPENAPI_FORMAT}"]
+  host: str
+  method: str
+  path_segments: str
   path: str
+  port: str
+  project_id: str
+
+class HeaderNameCreateParams(TypedDict):
+  name: str
+  is_required: bool
+  is_deterministic: bool
+  project_id: str
+  endpoint_id: int
+	
+class ParamNameCreateParams(TypedDict):
+  name: str
+  project_id: str
+  endpoint_id: int
+  inferred_type: str
+  query: str

stoobly_agent/app/settings/intercept_settings.py

@@ -42,7 +42,7 @@ class InterceptSettings:
 
   @mode.setter
   def mode(self, v):
-    if v in [mode.MOCK, mode.NONE, mode.RECORD, mode.TEST]:
+    if v in [mode.MOCK, mode.NONE, mode.RECORD, mode.REPLAY, mode.TEST]:
       self.__mode = v
       self.__intercept_settings['mode'] = v
 

stoobly_agent/lib/api/api.py

@@ -69,3 +69,7 @@ class Api():
     def put(self, url, **kwargs):
       handler = lambda: requests.put(url, **kwargs)
       return self.without_proxy(handler)
+    
+    def delete(self, url, **kwargs):
+      handler = lambda: requests.delete(url, **kwargs)
+      return self.without_proxy(handler)

stoobly_agent/lib/api/body_param_names_resource.py

@@ -0,0 +1,36 @@
+import requests
+import urllib
+import pdb
+
+from stoobly_agent.app.models.types import ParamNameCreateParams
+
+from ..logger import Logger
+from .endpoints_resource import EndpointsResource
+
+class BodyParamNamesResource(EndpointsResource):
+  BODY_PARAM_NAMES_ENDPOINT = 'body_param_names'
+
+  def create(self, endpoint_id: int, params: ParamNameCreateParams = {}):
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.BODY_PARAM_NAMES_ENDPOINT}"
+    return self.post(url, headers=self.default_headers, json=params)
+
+  def index(self, endpoint_id: int, query_params = {}) -> requests.Response:
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.BODY_PARAM_NAMES_ENDPOINT}"
+
+    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+
+    return self.get(url, headers=self.default_headers, params=query_params)
+
+  def show(self, endpoint_id: int, body_param_name_id: int, query_params = {}) -> requests.Response:
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.BODY_PARAM_NAMES_ENDPOINT}/{body_param_name_id}"
+
+    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+
+    return self.get(url, headers=self.default_headers, params=query_params)
+  
+  def destroy(self, endpoint_id, body_param_name_id: int, query_params = {}) -> requests.Response:
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.BODY_PARAM_NAMES_ENDPOINT}/{body_param_name_id}"
+
+    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+
+    return self.delete(url, headers=self.default_headers, params=query_params)

stoobly_agent/lib/api/endpoints_resource.py

@@ -11,7 +11,7 @@ class EndpointsResource(StooblyApi):
 
   def create(self, **params):
     url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}"
-    return self.post(url, headers=self.default_headers, data=params)
+    return self.post(url, headers=self.default_headers, json=params)
 
   def index(self, **query_params: EndpointsIndexQueryParams) -> requests.Response:
     url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}"
@@ -25,4 +25,11 @@ class EndpointsResource(StooblyApi):
 
     Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
 
-    return self.get(url, headers=self.default_headers, params=query_params)
+    return self.get(url, headers=self.default_headers, params=query_params)
+
+  def destroy(self, endpoint_id: int, **query_params) -> requests.Response:
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}"
+
+    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+
+    return self.delete(url, headers=self.default_headers, params=query_params)

stoobly_agent/lib/api/header_names_resource.py

@@ -0,0 +1,36 @@
+import requests
+import urllib
+import pdb
+
+from stoobly_agent.app.models.types import HeaderNameCreateParams
+
+from ..logger import Logger
+from .endpoints_resource import EndpointsResource
+
+class HeaderNamesResource(EndpointsResource):
+  HEADER_NAMES_ENDPOINT = 'header_names'
+
+  def create(self, endpoint_id: int, params: HeaderNameCreateParams = {}):
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.HEADER_NAMES_ENDPOINT}"
+    return self.post(url, headers=self.default_headers, json=params)
+
+  def index(self, endpoint_id: int, query_params = {}) -> requests.Response:
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.HEADER_NAMES_ENDPOINT}"
+
+    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+
+    return self.get(url, headers=self.default_headers, params=query_params)
+
+  def show(self, endpoint_id: int, header_name_id: int, query_params = {}) -> requests.Response:
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.HEADER_NAMES_ENDPOINT}/{header_name_id}"
+
+    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+
+    return self.get(url, headers=self.default_headers, params=query_params)
+  
+  def destroy(self, endpoint_id: int, header_name_id: int, query_params = {}) -> requests.Response:
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.HEADER_NAMES_ENDPOINT}/{header_name_id}"
+
+    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+
+    return self.delete(url, headers=self.default_headers, params=query_params)

stoobly_agent/lib/api/interfaces/endpoints.py

@@ -43,8 +43,10 @@ class EndpointShowResponse(TypedDict):
   path_segment_names: List[RequestComponentName]
   query_param_names: List[RequestComponentName]
   response_param_names: List[ResponseParamName]
+  response_header_names: List[RequestComponentName]
   literal_query_params: Optional[dict]
   literal_body_params: Optional[dict]
+  literal_response_params: Optional[dict]
 
 ARRAY_TYPE = 'Array'
 

stoobly_agent/lib/api/query_param_names_resource.py

@@ -0,0 +1,36 @@
+import requests
+import urllib
+import pdb
+
+from stoobly_agent.app.models.types import ParamNameCreateParams
+
+from ..logger import Logger
+from .endpoints_resource import EndpointsResource
+
+class QueryParamNamesResource(EndpointsResource):
+  QUERY_PARAM_NAMES_ENDPOINT = 'query_param_names'
+
+  def create(self, endpoint_id: int, params: ParamNameCreateParams = {}):
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.QUERY_PARAM_NAMES_ENDPOINT}"
+    return self.post(url, headers=self.default_headers, json=params)
+
+  def index(self, endpoint_id: int, query_params = {}) -> requests.Response:
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.QUERY_PARAM_NAMES_ENDPOINT}"
+
+    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+
+    return self.get(url, headers=self.default_headers, params=query_params)
+
+  def show(self, endpoint_id: int, query_param_name_id: int, query_params = {}) -> requests.Response:
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.QUERY_PARAM_NAMES_ENDPOINT}/{query_param_name_id}"
+
+    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+
+    return self.get(url, headers=self.default_headers, params=query_params)
+  
+  def destroy(self, endpoint_id: int, query_param_name_id: int, query_params = {}) -> requests.Response:
+    url = f"{self.service_url}/{self.ENDPOINTS_ENDPOINT}/{endpoint_id}/{self.QUERY_PARAM_NAMES_ENDPOINT}/{query_param_name_id}"
+
+    Logger.instance().debug(f"{self.LOG_ID}.request_response:{url}?{urllib.parse.urlencode(query_params)}")
+
+    return self.delete(url, headers=self.default_headers, params=query_params)