stoobly-agent 0.34.7__py3-none-any.whl → 0.34.9__py3-none-any.whl

stoobly_agent/__init__.py

@@ -1,2 +1,2 @@
 COMMAND = 'stoobly-agent'
-VERSION = '0.34.7'
+VERSION = '0.34.9'

stoobly_agent/app/api/requests_controller.py

@@ -41,7 +41,7 @@ class RequestsController:
             return
 
         raw_requests = body_params.get('requests')
-        payloads_delimitter = body_params.get('payloads_delimitter') or REQUEST_DELIMITTER.decode()
+        payloads_delimitter = body_params.get('payloads_delimitter') or REQUEST_DELIMITTER
         toks = raw_requests.split(payloads_delimitter)
 
         if len(toks) % 2 != 0:

stoobly_agent/app/cli/helpers/endpoints_import_service.py

@@ -1,7 +1,7 @@
 import json
 import requests
 import sys
-from typing import Dict
+from typing import Dict, TypedDict, Optional
 
 from .endpoints_import_context import EndpointsImportContext
 from stoobly_agent.app.models.types import ENDPOINT_COMPONENT_NAMES
@@ -16,12 +16,19 @@ from stoobly_agent.lib.api.response_header_names_resource import ResponseHeaderN
 from stoobly_agent.lib.api.response_param_names_resource import ResponseParamNamesResource
 from stoobly_agent.lib.logger import bcolors
 
+class ComponentImportArgs(TypedDict):
+    project_id: int
+    endpoint_id: int
+    resource: EndpointsResource
+    component: RequestComponentName
+    parents: Optional[Dict]
+
 def import_endpoints(context: EndpointsImportContext):
     for endpoint in context.endpoints:
         for endpoint_handler in context.endpoint_handlers:
             endpoint_handler(endpoint)
 
-        try:
+        try:    
             res = import_endpoint(context.project_id, context.resources['endpoint'], endpoint)
         except requests.HTTPError as e:
             error_handler(e, f"Failed to import endpoint: {endpoint['method']} {endpoint['path']}")
@@ -57,7 +64,12 @@ def import_endpoint(project_id: int, endpoint_resource: EndpointsResource, endpo
     
     res.raise_for_status()
 
-def import_header_name(project_id: int, endpoint_id: int, header_name_resource: HeaderNamesResource, header_name: RequestComponentName): 
+def import_header_name(args: ComponentImportArgs):
+    project_id = args['project_id']
+    endpoint_id = args['endpoint_id']
+    header_name_resource = args['resource']
+    header_name = args['component']
+
     res: requests.Response = header_name_resource.create(endpoint_id, {
         'name': header_name.get('name'),
         'is_deterministic': header_name.get('is_deterministic', True),
@@ -68,7 +80,18 @@ def import_header_name(project_id: int, endpoint_id: int, header_name_resource:
 
     res.raise_for_status()
 
-def import_body_param_name(project_id: int, endpoint_id: int, body_param_name_resource: BodyParamNamesResource, body_param_name: BodyParamName):
+def import_body_param_name(args: ComponentImportArgs):
+    project_id = args['project_id']
+    endpoint_id = args['endpoint_id']
+    body_param_name_resource = args['resource']
+    body_param_name = args['component']
+    parents = args['parents']
+
+    body_param_name_id = None
+    parent_id = body_param_name.get('body_param_name_id')
+    if parent_id:
+        body_param_name_id = parents[parent_id]
+    
     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),
@@ -77,11 +100,20 @@ def import_body_param_name(project_id: int, endpoint_id: int, body_param_name_re
         'query': body_param_name.get('query'),
         'endpoint_id': endpoint_id,
         'project_id': project_id,
+        'body_param_name_id': body_param_name_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_id = res.json()['id']
+    parents[body_param_name['id']] = res_id
+
+def import_query_param_name(args: ComponentImportArgs):
+    project_id = args['project_id']
+    endpoint_id = args['endpoint_id']
+    query_param_name_resource = args['resource']
+    query_param_name = args['component']
+
     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),
@@ -92,7 +124,18 @@ def import_query_param_name(project_id: int, endpoint_id: int, query_param_name_
 
     res.raise_for_status()
 
-def import_response_param_name(project_id: int, endpoint_id: int, response_param_name_resource: ResponseParamNamesResource, response_param_name: RequestComponentName):
+def import_response_param_name(args: ComponentImportArgs):
+    project_id = args['project_id']
+    endpoint_id = args['endpoint_id']
+    response_param_name_resource = args['resource']
+    response_param_name = args['component']
+    parents = args['parents']
+
+    response_param_name_id = None
+    parent_id = response_param_name.get('response_param_name_id')
+    if parent_id:
+        response_param_name_id = parents[parent_id]
+    
     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),
@@ -101,11 +144,21 @@ def import_response_param_name(project_id: int, endpoint_id: int, response_param
         'query': response_param_name.get('query'),
         'endpoint_id': endpoint_id,
         'project_id': project_id,
+        'response_param_name_id': response_param_name_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_id = res.json()['id']
+    parents[response_param_name['id']] = res_id
+
+
+def import_response_header_name(args: ComponentImportArgs):
+    project_id = args['project_id']
+    endpoint_id = args['endpoint_id']
+    response_header_name_resource = args['resource']
+    response_header_name = args['component']
+
     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),
@@ -124,14 +177,20 @@ component_name_import_dispatch = {
     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:
+        parents: Dict[int, int] = {}
         for component in endpoint.get(f'{component_name}s', {}):
             resource = resources[component_name]
-            process_import(component_name, project_id, endpoint_id, resource, component)
+            args = {
+                'project_id': project_id,
+                'endpoint_id': endpoint_id,
+                'resource': resource,
+                'component': component,
+                'parents': parents
+            }
+            component_name_import_dispatch[component_name](args)
+            
 
 def cleanup_endpoint(project_id: int, endpoint_id: int, resource: EndpointsResource):
     print(f"{bcolors.OKBLUE}Cleaning up partial import...{bcolors.ENDC}")

stoobly_agent/app/cli/helpers/openapi_endpoint_adapter.py

@@ -114,9 +114,13 @@ class OpenApiEndpointAdapter():
           operation = path[http_method]
           required_query_params = []
           required_body_params = []
+          literal_query_params = []
 
           parameters = operation.get("parameters", {})
           for parameter in parameters:
+            if '$ref' in parameter.keys():
+              parameter = self.__dereference(components, parameter['$ref'])
+
             if parameter['in'] == 'query':
               # query_param: RequestComponentName = {}
               # query_param['name'] = parameter['name']
@@ -131,39 +135,10 @@ class OpenApiEndpointAdapter():
               if not endpoint.get('query_param_names'):
                 endpoint['query_param_names'] = []
 
-              schema = parameter['schema']
-              open_api_type = schema['type']
-
-              param_value = None
-              if open_api_type == 'array':
-                item_type = schema['items']['type']
-                default_value = schema['items'].get('default')
-                item_default = None
-                if default_value:
-                  item_default = {'value': default_value}
-                else:
-                  item_default = {'value': self.__open_api_to_default_python_type(item_type)}
-
-                param_value = [item_default]
+              schema = parameter.get('schema', {})
+              self.__extract_param_properties(components, required_query_params, {parameter['name']: schema}, literal_query_params, curr_id=len(literal_query_params)+1)
 
-              # TODO: can query params be something besides raw or array?
-              else:
-                default_value = schema.get('default')
-                if default_value:
-                  param_value = default_value
-                else:
-                  param_value = self.__open_api_to_default_python_type(open_api_type)
-
-              literal_query_param = {
-                parameter['name']: {
-                  'value': param_value,
-                  'required': parameter.get('required', False),
-                }
-              }
-
-              if not endpoint.get('literal_query_params'):
-                endpoint['literal_query_params'] = {}
-              endpoint['literal_query_params'].update(literal_query_param)
+              endpoint['literal_query_params'] = literal_query_params
 
             elif parameter['in'] == 'header':
               header: RequestComponentName = {}
@@ -206,39 +181,16 @@ class OpenApiEndpointAdapter():
           request_body = operation.get("requestBody", {})
           required_request_body = request_body.get("required")
           required_body_params = []
-          literal_body_params = {}
-          request_body_array = False
+          literal_body_params = []
 
           content = request_body.get("content", {})
           for mimetype, media_type in content.items():
-            param_properties = {}
-            schema = media_type['schema']
-
-            # If Spec Component reference, look it up in components
-            if '$ref' in schema:
-              reference = schema['$ref']
-              self.__dereference(components, reference, required_body_params, literal_body_params)
-            else:
-              required_body_params = schema.get('required', [])
+            schema = media_type.get('schema')
+            if schema:
+              self.__extract_param_properties(components, required_body_params, {'tmp': schema}, literal_body_params)
 
-              schema_type = schema.get('type')
-              if schema_type:
-                if schema_type == 'object':
-                  param_properties = schema.get('properties', {})
-                elif schema_type == 'array':
-                  request_body_array = True
-                  param_properties = {'tmp': schema['items']}
-
-            for property_key, property_value in param_properties.items():
-              if property_key in required_body_params:
-                param_properties[property_key]['required'] = True
-
-            if not endpoint.get('literal_body_params'):
-              endpoint['literal_body_params'] = {}
-
-            self.__extract_param_properties(components, None, required_body_params, param_properties, literal_body_params)
-
-            endpoint['literal_body_params'] = literal_body_params
+            if literal_body_params:
+              endpoint['literal_body_params'] = literal_body_params
 
             # Only support first media type
             break
@@ -249,10 +201,7 @@ class OpenApiEndpointAdapter():
             
           literal_body_params = endpoint.get('literal_body_params')
           if literal_body_params:
-            if not request_body_array:
-              self.__convert_literal_component_param(endpoint, required_body_params, literal_body_params, 'body_param_name', 'literal_body_params')
-            else:
-              self.__convert_literal_component_param(endpoint, required_body_params, [literal_body_params], 'body_param_name', 'literal_body_params')
+            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', {})
@@ -332,74 +281,90 @@ class OpenApiEndpointAdapter():
 
     return list(literal_params)[-2]
 
-  def __extract_param_properties(self, components, reference, required_body_params, param_properties, literal_body_params, nested_parameters: bool = False):
-    if not param_properties:
-      return
-
-    flatten: bool = False
+  def __extract_param_properties(self, components, required_component_params, schema_object, literal_component_params, curr_id=0, parent_id=None, parent=None, query_string=''):
+    # Name of the schema object (i.e. the name of the body_param_name or response_param_name component)
+    property_name = list(schema_object.keys())[0]
 
-    for property_name, property_type_dict in param_properties.items():
-      if '$ref' in property_type_dict.keys():
-        if property_name not in literal_body_params:
-          literal_body_params[property_name] = {'value': {}} 
+    # The actual OpenAPI schema object
+    property_schema = list(schema_object.values())[0] 
 
-        reference = property_type_dict['$ref']
-        self.__dereference(components, reference, required_body_params, literal_body_params, nested_parameters=True)
+    if '$ref' in property_schema.keys():
+      property_schema = self.__dereference(components, property_schema.get('$ref'))
 
-      elif property_type_dict.get('properties'): 
-        reference = None
-        required_body_params += property_type_dict.get('required', [])
-        param_properties = {}
-        if not nested_parameters:
-          param_properties = property_type_dict.get('properties')
+    # Generates the entire query string for this particular property (ex: Pets[*].name for property 'name' of a 'Pet' element in the 'Pets' array
+    if property_name == 'tmp':
+      query = query_string 
+    else:
+      if property_name.endswith('Element'):
+        query = f"{query_string}[*]"
+      elif query_string == '':
+        query = property_name
+      else:
+        query = f"{query_string}.{property_name}"
 
-        for property_key, property_value in param_properties.items():
-          if property_key in required_body_params:
+    # A schema is traversable if it has one more non-empty nested schema objects
+    traversable = property_schema.get('properties') or property_schema.get('items') or property_schema.get('allOf')
+    
+    if not traversable:
+      # Ex: {'name': {'type': 'string', 'description': 'Name of pet', 'Example': 'Buddy'}}
+      if property_name != 'tmp':
+        literal_val_type = self.__open_api_to_default_python_type(property_schema.get('type', 'object'))
+        literal_val = {'name': property_name, 'value': literal_val_type, 'required': property_schema.get('required', False), 'query': query, 'id': curr_id, 'parent_id': parent_id}
+        literal_component_params.append(literal_val)
+      return curr_id
+
+    if 'properties' in property_schema.keys():
+      # Ex: {'tmp': {'type': 'object', 'required': ['name'], 'properties': {'name': {'type': 'string'}, 'tag': {'type': 'string'}}}}
+      required_component_params += property_schema.get('required', [])
+
+      # curr_id_tmp is the parent_id of all elements in param_properties
+      # Should be set to parent_id when property_name is 'tmp' to handle case where a schema uses the 'allOf' keyword since curr_id will change between every recursive call on each 'part' element in the allOf list
+      curr_id_tmp = parent_id if property_name == 'tmp' else curr_id 
+
+      literal_val = parent if property_name == 'tmp' else {'name': property_name, 'value': {}, 'required': property_schema.get('schema_required', False), 'query': query, 'id': curr_id, 'parent_id': parent_id}
+
+      if property_name != 'tmp':
+        literal_component_params.append(literal_val)
+
+      param_properties = property_schema.get('properties')
+      for property_key, property_value in param_properties.items():
+        if property_key in required_component_params:
+          if property_value.get('type') == 'object':
+            # Necessary to avoid overwriting the 'required' list of an object-type schema
+            property_value['schema_required'] = True
+          else:
             property_value['required'] = True
-            required_body_params.remove(property_key)
-
-        self.__extract_param_properties(components, reference, required_body_params, param_properties, literal_body_params, nested_parameters=False)
-
-      elif property_type_dict.get('type') == 'array':
-        reference = None
-        param_properties = {'tmp': property_type_dict['items']}
-
-        if property_name not in literal_body_params:
-          literal_body_params[property_name] = {'value': []} 
-          if property_type_dict.get('required') == True:
-            literal_body_params[property_name]['required'] = True
-
-        self.__extract_param_properties(components, reference, required_body_params, param_properties, literal_body_params, nested_parameters=True)
-
+          required_component_params.remove(property_key)
+        curr_id = self.__extract_param_properties(components, required_component_params, {property_key: property_value}, literal_component_params, curr_id=curr_id+1, parent_id=curr_id_tmp, parent=literal_val, query_string=query)    
+
+    elif property_schema.get('type') == 'array':
+      # Ex: {'tmp': {'type': 'array', 'items': {'$ref': '#/components/schemas/NewPet'}}}
+      if property_name == 'tmp':
+        schema_object = {"Element": property_schema['items']}
+        curr_id = self.__extract_param_properties(components, required_component_params, schema_object, literal_component_params, curr_id=curr_id+1, parent_id=parent_id, parent=parent, query_string=query)
       else:
-        literal_val_type = self.__open_api_to_default_python_type(property_type_dict['type'])
-        literal_val = {'value': literal_val_type, 'required': property_type_dict.get('required', False)}
-
-        if nested_parameters:
-          most_recent_param = self.__get_most_recent_param(literal_body_params)
-          second_most_recent_param = self.__get_second_most_recent_param(literal_body_params)
-          if most_recent_param == 'tmp':
-            flatten = True
-
-          if flatten:
-            if second_most_recent_param and type(literal_body_params[second_most_recent_param]['value']) is list:
-              literal_body_params[second_most_recent_param]['value'].append({ property_name: literal_val })
-            else:
-              literal_body_params[property_name] = literal_val
-          else:
-            if type(literal_body_params[most_recent_param]['value']) is dict:
-              if not literal_body_params[most_recent_param].get('value'):
-                literal_body_params[most_recent_param]['value'] = {}
-              literal_body_params[most_recent_param]['value'][property_name] = literal_val
-
-            elif type(literal_body_params[most_recent_param]['value']) is list:
-              literal_body_params[most_recent_param]['value'].append(literal_val)
-        else:
-          literal_body_params[property_name] = literal_val
-
-    literal_body_params.pop('tmp', None)
+        schema_object = {f"{property_name}Element": property_schema['items']}
+        literal_val = {'name': property_name, 'value': [], 'required': property_schema.get('required', False), 'query': query, 'id': curr_id, 'parent_id': parent_id}
+        literal_component_params.append(literal_val)
+        curr_id = self.__extract_param_properties(components, required_component_params, schema_object, literal_component_params, curr_id=curr_id+1, parent_id=curr_id, parent=parent, query_string=query)
+
+    elif 'allOf' in property_schema.keys():
+      # Ex: {'Element': {'type': 'object', 'allOf': [{'$ref': '#/components/schemas/NewPet'}, {'type': 'object', 'required': ['id'], 'properties': {'id': {'type': 'integer', 'format': 'int64'}}}]}}
+      all_of = property_schema.get('allOf')
+      literal_val = parent if property_name == 'tmp' else {'name': property_name, 'value': {}, 'required': property_schema.get('self_required', False), 'query': query, 'id': curr_id, 'parent_id': parent_id}
+      if property_name != 'tmp':
+        literal_component_params.append(literal_val)
+
+      curr_id_tmp = parent_id if property_name == 'tmp' else curr_id 
+      for part in all_of:
+        required_component_params = part.get('required', [])
+        curr_id = self.__extract_param_properties(components, required_component_params, {'tmp': part}, literal_component_params, curr_id=curr_id, parent_id=curr_id_tmp, parent=literal_val, query_string=query)
+
+    return curr_id
+  
 
-  def __dereference(self, components: Spec, reference: str, required_body_params: List, literal_body_params, nested_parameters: bool = False):
+  # Returns the schema object located at the given reference path
+  def __dereference(self, components: Spec, reference: str):
     # '#/components/schemas/NewPet'
     if not reference.startswith('#'):
       print('external references are not supported yet')
@@ -412,55 +377,13 @@ 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 = {}
-      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')
-
-      if param_properties:
-        for param_prop_key, param_prop_val in param_properties.items():
-          if param_prop_key in required_body_params:
-            param_prop_val['required'] = True
-            required_body_params.remove(param_prop_key)
-
-        self.__extract_param_properties(components, None, required_body_params, param_properties, literal_body_params, nested_parameters=nested_parameters)
-
-      elif all_of:
-        for part in all_of:
-          required_body_params = part.get('required', [])
-          nested_reference = part.get('$ref')
-          if nested_reference:
-            self.__extract_param_properties(components, nested_reference, required_body_params, {'tmp': part}, literal_body_params)
-          else:
-            self.__extract_param_properties(components, None, required_body_params, {'tmp': part}, literal_body_params)
-
-      # TODO
-      # elif any_of or one_of:
-
-      return param_properties 
+        
+      if '$ref' in body_spec.keys():
+        body_spec = self.__dereference(components, body_spec.get('$ref'))
+      
+      return body_spec 
   
   def __convert_literal_component_param(self, endpoint: EndpointShowResponse,
       required_component_params: List[str], literal_component_params: Union[dict, list],
@@ -608,32 +531,14 @@ class OpenApiEndpointAdapter():
         continue
 
       # Construct response param name components
-      literal_response_params = {}
-      response_body_array = False
+      literal_response_params = []
       required_response_params = []
       response_content = response_definition.get('content', {})
       for mimetype, media_type in response_content.items():
-        param_properties = {}
-        schema = media_type['schema']
+        schema = media_type.get('schema')
+        if schema:
+          self.__extract_param_properties(components, required_response_params, {'tmp': schema}, literal_response_params)
         
-        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
 
@@ -642,10 +547,7 @@ class OpenApiEndpointAdapter():
       
       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')
+        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', {})
@@ -654,14 +556,13 @@ class OpenApiEndpointAdapter():
         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
+          header_definition = self.__dereference(components, header_definition.get('$ref'))
+
+        header_example = header_definition.get('example')
+        if header_example:
+          response_header_name['value']= 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'] = []