catocli 2.0.4__py3-none-any.whl → 2.1.0__py3-none-any.whl

schema/catolib.py

@@ -78,6 +78,11 @@ def openFile(fileName, readMode="rt"):
 ############ parsing schema ############
 
 def parseSchema(schema):
+	# Load settings to get childOperationParent and childOperationObjects configuration
+	settings = loadJSON("../settings.json")
+	childOperationParent = settings.get("childOperationParent", {})
+	childOperationObjects = settings.get("childOperationObjects", {})
+	
 	mutationOperationsTMP = {}
 	queryOperationsTMP = {}
 	for i, type in enumerate(schema["data"]["__schema"]["types"]):
@@ -94,7 +99,7 @@ def parseSchema(schema):
 		elif type["kind"] == "OBJECT":
 			if type["name"] == "Query":
 				for field in type["fields"]:
-					if field["name"] =="xdr":
+					if field["name"] in childOperationParent:
 						queryOperationsTMP[field["name"]] = copy.deepcopy(field)
 					else:
 						catoApiSchema["query"]["query."+field["name"]] = copy.deepcopy(field)
@@ -107,11 +112,11 @@ def parseSchema(schema):
 	
 	for queryType in queryOperationsTMP:
 		parentQueryOperationType = copy.deepcopy(queryOperationsTMP[queryType])
-		getChildOperations("query", parentQueryOperationType, parentQueryOperationType, "query." + queryType)
+		getChildOperations("query", parentQueryOperationType, parentQueryOperationType, "query." + queryType, childOperationObjects)
 	
 	for mutationType in mutationOperationsTMP:
 		parentMutationOperationType = copy.deepcopy(mutationOperationsTMP[mutationType])
-		getChildOperations("mutation", parentMutationOperationType, parentMutationOperationType, "mutation." + mutationType)
+		getChildOperations("mutation", parentMutationOperationType, parentMutationOperationType, "mutation." + mutationType, childOperationObjects)
 
 	for operationType in catoApiSchema:
 		for operationName in catoApiSchema[operationType]:
@@ -129,7 +134,7 @@ def parseSchema(schema):
 			payload = generateGraphqlPayload(parsedOperation["variablesPayload"],parsedOperation,operationName)
 			writeFile("../queryPayloads/"+operationName+".txt",payload["query"])
 
-def getChildOperations(operationType, curType, parentType, parentPath):
+def getChildOperations(operationType, curType, parentType, parentPath, childOperationObjects):
 	# Parse fields for nested args to map out all child operations
 	# This will separate fields like stories and story for query.xdr, 
 	# and all fields which are actually sub operations from mutation.internetFirewall, etc 
@@ -154,12 +159,14 @@ def getChildOperations(operationType, curType, parentType, parentPath):
 		parentFields = []
 		for field in curOfType["fields"]:
 			curFieldObject = copy.deepcopy(field)
-			if "args" in curFieldObject and len(curFieldObject["args"])>0:
+			if (("args" in curFieldObject and len(curFieldObject["args"])>0) or 
+				(curFieldObject["name"] in childOperationObjects) or 
+				(curOfType["name"] in childOperationObjects)):
 				hasChildren = True
 				curParentType = copy.deepcopy(parentType)
 				curFieldObject["args"] = getNestedArgDefinitions(curFieldObject["args"], curFieldObject["name"],None,None)
 				curParentType["childOperations"][curFieldObject["name"]] = curFieldObject
-				getChildOperations(operationType, curFieldObject, curParentType, parentPath + "." + curFieldObject["name"])
+				getChildOperations(operationType, curFieldObject, curParentType, parentPath + "." + curFieldObject["name"], childOperationObjects)
 	if not hasChildren:
 		catoApiSchema[operationType][parentPath] = parentType
 
@@ -193,7 +200,7 @@ def getNestedArgDefinitions(argsAry, parentParamPath, childOperations, parentFie
 	# print("getNestedArgDefinitions()",newArgsList.keys())
 	return newArgsList
 
-def getOfType(curType, ofType, parentParamPath, childOperations, parentFields):
+def getOfType(curType, ofType, parentParamPath, childOperations, parentFields, parentTypeName=None):
 	ofType["kind"].append(copy.deepcopy(curType["kind"]))
 	curParamPath = "" if (parentParamPath == None) else parentParamPath + "___"
 	if curType["ofType"] != None:
@@ -209,7 +216,7 @@ def getOfType(curType, ofType, parentParamPath, childOperations, parentFields):
 		ofType["indexType"] = "input_object"
 		ofType["definition"] = copy.deepcopy(catoApiIntrospection["input_objects"][ofType["name"]])
 		if ofType["definition"]["inputFields"] != None:
-			ofType["definition"]["inputFields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["inputFields"]), curParamPath, childOperations, parentFields)
+			ofType["definition"]["inputFields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["inputFields"]), curParamPath, childOperations, parentFields, ofType["name"])
 	elif "UNION" in ofType["kind"]:
 		ofType["indexType"] = "interface"
 		ofType["definition"] = copy.deepcopy(catoApiIntrospection["unions"][ofType["name"]])
@@ -236,14 +243,14 @@ def getOfType(curType, ofType, parentParamPath, childOperations, parentFields):
 		ofType["definition"] = copy.deepcopy(catoApiIntrospection["objects"][ofType["name"]])
 		if ofType["definition"]["fields"] != None and childOperations!=None:
 			ofType["definition"]["fields"] = checkForChildOperation(copy.deepcopy(ofType["definition"]["fields"]),childOperations)
-			ofType["definition"]["fields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["fields"]), curParamPath,childOperations, parentFields)
+			ofType["definition"]["fields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["fields"]), curParamPath,childOperations, parentFields, ofType["name"])
 		if ofType["definition"]["interfaces"] != None:
 			ofType["definition"]["interfaces"] = getNestedInterfaceDefinitions(copy.deepcopy(ofType["definition"]["interfaces"]), curParamPath,childOperations, parentFields)
 	elif "INTERFACE" in ofType["kind"]:
 		ofType["indexType"] = "interface"
 		ofType["definition"] = copy.deepcopy(catoApiIntrospection["interfaces"][ofType["name"]])
 		if ofType["definition"]["fields"] != None:
-			ofType["definition"]["fields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["fields"]), curParamPath, childOperations, parentFields)
+			ofType["definition"]["fields"] = getNestedFieldDefinitions(copy.deepcopy(ofType["definition"]["fields"]), curParamPath, childOperations, parentFields, ofType["name"])
 		if ofType["definition"]["possibleTypes"] != None:
 			ofType["definition"]["possibleTypes"] = getNestedInterfaceDefinitions(copy.deepcopy(ofType["definition"]["possibleTypes"]), curParamPath, childOperations, parentFields)
 			for interfaceName in ofType["definition"]["possibleTypes"]:
@@ -270,14 +277,14 @@ def getOfType(curType, ofType, parentParamPath, childOperations, parentFields):
 		ofType["definition"] = copy.deepcopy(catoApiIntrospection["enums"][ofType["name"]])
 	return ofType
 
-def getNestedFieldDefinitions(fieldsAry, parentParamPath,childOperations, parentFields):
+def getNestedFieldDefinitions(fieldsAry, parentParamPath,childOperations, parentFields, parentTypeName=None):
 	newFieldsList = {}
 	for field in fieldsAry:
 		if isinstance(field,str):
 			field = fieldsAry[field]
 		curParamPath = field["name"] if (parentParamPath == None) else (parentParamPath.replace("___",".") + field["name"])
 		# curParamPath = field["name"] if (parentParamPath == None) else (parentParamPath + "." + field["name"])
-		field["type"] = getOfType(field["type"], { "non_null": False, "kind": [], "name": None }, curParamPath,childOperations, parentFields)
+		field["type"] = getOfType(field["type"], { "non_null": False, "kind": [], "name": None }, curParamPath,childOperations, parentFields, parentTypeName)
 		field["path"] = curParamPath
 		field["id_str"] = curParamPath.replace(".","___")
 		if isinstance(field["type"]["kind"], list):
@@ -305,7 +312,11 @@ def getNestedFieldDefinitions(fieldsAry, parentParamPath,childOperations, parent
 				# print(json.dumps(field,indent=2,sort_keys=True))
 				# print(field["path"],parentFields)
 			# field["alias"] = renderCamelCase(field["type"]["name"]+"."+field["name"])+": "+field["name"]
-			field["alias"] = renderCamelCase(field["type"]["name"]+"."+field["name"])+": "+field["name"]
+			# Use parent type name instead of field type name for alias
+			if parentTypeName:
+				field["alias"] = renderCamelCase(field["name"]+"."+parentTypeName)+": "+field["name"]
+			else:
+				field["alias"] = renderCamelCase(field["type"]["name"]+"."+field["name"])+": "+field["name"]
 		if "records.fields" not in field["path"]:
 			newFieldsList[field["name"]] = field	
 	# for (fieldPath in newFieldList) {
@@ -326,9 +337,9 @@ def getNestedInterfaceDefinitions(possibleTypesAry, parentParamPath,childOperati
 		curInterface = curInterfaces[curInterfaceName]
 		curParamPath = "" if parentParamPath == None else parentParamPath + curInterface["name"] + "___"
 		if "fields" in curInterface and curInterface["fields"] != None:
-			curInterface["fields"] = getNestedFieldDefinitions(copy.deepcopy(curInterface["fields"]), curParamPath,childOperations, parentFields)
+			curInterface["fields"] = getNestedFieldDefinitions(copy.deepcopy(curInterface["fields"]), curParamPath,childOperations, parentFields, curInterface["name"])
 		if "inputFields" in curInterface and curInterface["inputFields"] != None:
-			curInterface["inputFields"] = getNestedFieldDefinitions(copy.deepcopy(curInterface["inputFields"]), curParamPath,childOperations, parentFields)
+			curInterface["inputFields"] = getNestedFieldDefinitions(copy.deepcopy(curInterface["inputFields"]), curParamPath,childOperations, parentFields, curInterface["name"])
 		if "interfaces" in curInterface and curInterface["interfaces"] != None:
 			curInterface["interfaces"] = getNestedInterfaceDefinitions(copy.deepcopy(curInterface["interfaces"]), curParamPath,childOperations, parentFields)
 		if "possibleTypes" in curInterface and curInterface["possibleTypes"] != None:
@@ -350,10 +361,10 @@ def parseOperation(curOperation,childOperations):
 			# for field in curOperation["type"]["definition"]["fields"]:
 			# 	parentFields.append(field["name"])
 			curOperation["type"]["definition"]["fields"] = checkForChildOperation(copy.deepcopy(curOperation["type"]["definition"]["fields"]),childOperations)
-			curOperation["type"]["definition"]["fields"] = copy.deepcopy(getNestedFieldDefinitions(curOperation["type"]["definition"]["fields"], None,childOperations,[]))
+			curOperation["type"]["definition"]["fields"] = copy.deepcopy(getNestedFieldDefinitions(curOperation["type"]["definition"]["fields"], None,childOperations,[], curOperation["type"]["name"]))
 		if "inputFields" in curOperation["type"]["definition"] and curOperation["type"]["definition"]["inputFields"] != None:
 			parentFields = curOperation["type"]["definition"]["inputFields"].keys()
-			curOperation["type"]["definition"]["inputFields"] = copy.deepcopy(getNestedFieldDefinitions(curOperation["type"]["definition"]["inputFields"], None,childOperations,parentFields))
+			curOperation["type"]["definition"]["inputFields"] = copy.deepcopy(getNestedFieldDefinitions(curOperation["type"]["definition"]["inputFields"], None,childOperations,parentFields, curOperation["type"]["name"]))
 	return curOperation
 
 def checkForChildOperation(fieldsAry,childOperations):
@@ -1069,7 +1080,12 @@ def renderArgsAndFields(responseArgStr, variablesObj, curOperation, definition,
 			responseArgStr += " {\n"
 			for subfieldIndex in field['type']['definition']['fields']:
 				subfield = field['type']['definition']['fields'][subfieldIndex]
-				subfield_name = subfield['alias'] if 'alias' in subfield else subfield['name']				
+				# updated logic: use fieldTypes to determine if aliasing is needed
+				if (subfield['type']['name'] in curOperation.get('fieldTypes', {}) and 
+					'SCALAR' not in subfield['type'].get('kind', [])):
+					subfield_name = subfield['name'] + field['type']['definition']['name'] + ": " + subfield['name']
+				else:
+					subfield_name = subfield['alias'] if 'alias' in subfield else subfield['name']
 				responseArgStr += indent + "	" + subfield_name
 				if subfield.get("args") and len(list(subfield["args"].keys()))>0:
 					argsPresent = False

schema/remove_policyid.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+
+import json
+import glob
+import os
+import sys
+
+def remove_policy_id_from_object(obj, path=""):
+    """
+    Recursively remove policyId fields from a JSON object.
+    """
+    if isinstance(obj, dict):
+        # Remove policyId field if it exists
+        if "policyId" in obj:
+            print(f"Removing policyId field at path: {path}")
+            del obj["policyId"]
+        
+        # Recursively process all other fields
+        for key, value in obj.items():
+            new_path = f"{path}.{key}" if path else key
+            remove_policy_id_from_object(value, new_path)
+    
+    elif isinstance(obj, list):
+        # Process each item in the list
+        for i, item in enumerate(obj):
+            new_path = f"{path}[{i}]" if path else f"[{i}]"
+            remove_policy_id_from_object(item, new_path)
+
+def process_file(file_path):
+    """
+    Process a single JSON file to remove policyId fields.
+    """
+    print(f"Processing file: {file_path}")
+    
+    try:
+        # Read the JSON file
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        
+        # Remove policyId fields
+        remove_policy_id_from_object(data, os.path.basename(file_path))
+        
+        # Write the modified JSON back to the file
+        with open(file_path, 'w') as f:
+            json.dump(data, f, indent=4, sort_keys=True)
+        
+        print(f"Successfully processed: {file_path}")
+        
+    except Exception as e:
+        print(f"Error processing {file_path}: {e}")
+        return False
+    
+    return True
+
+def main():
+    # Get the directory where this script is located
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    base_dir = os.path.dirname(script_dir)  # Go up one level to cato-cli directory
+    
+    # Find all query.policy*.json files in the models directory
+    models_dir = os.path.join(base_dir, "models")
+    pattern = os.path.join(models_dir, "query.policy*.json")
+    
+    files = glob.glob(pattern)
+    
+    if not files:
+        print("No query.policy*.json files found!")
+        return 1
+    
+    print(f"Found {len(files)} files to process:")
+    for file in files:
+        print(f"  - {os.path.basename(file)}")
+    
+    # Process each file
+    success_count = 0
+    for file_path in files:
+        if process_file(file_path):
+            success_count += 1
+    
+    print(f"\nProcessing complete!")
+    print(f"Successfully processed: {success_count}/{len(files)} files")
+    
+    if success_count != len(files):
+        return 1
+    
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

schema/remove_policyid_mutations.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+
+import json
+import os
+import glob
+
+def remove_policy_id_recursive(obj, path=""):
+    """
+    Recursively remove all 'policyId' keys from a JSON object.
+    Returns the number of removals made.
+    """
+    removals = 0
+    
+    if isinstance(obj, dict):
+        # Create a list of keys to remove to avoid modifying dict during iteration
+        keys_to_remove = []
+        for key in obj.keys():
+            if key == "policyId":
+                keys_to_remove.append(key)
+                current_path = f"{path}.{key}" if path else key
+                print(f"  Removing policyId at: {current_path}")
+                removals += 1
+        
+        # Remove the policyId keys
+        for key in keys_to_remove:
+            del obj[key]
+        
+        # Recursively process remaining values
+        for key, value in obj.items():
+            current_path = f"{path}.{key}" if path else key
+            removals += remove_policy_id_recursive(value, current_path)
+    
+    elif isinstance(obj, list):
+        for i, item in enumerate(obj):
+            current_path = f"{path}[{i}]" if path else f"[{i}]"
+            removals += remove_policy_id_recursive(item, current_path)
+    
+    return removals
+
+def process_mutation_policy_files():
+    """
+    Find and process all mutation.policy*.json files in the models directory.
+    """
+    models_dir = "/Users/briananderson/Documents/Dev/github.com/catonetworks/cato-cli/models"
+    pattern = os.path.join(models_dir, "mutation.policy*.json")
+    
+    files = glob.glob(pattern)
+    
+    if not files:
+        print("No mutation.policy*.json files found!")
+        return
+    
+    print(f"Found {len(files)} mutation.policy*.json files to process:")
+    
+    total_removals = 0
+    processed_files = 0
+    
+    for file_path in sorted(files):
+        filename = os.path.basename(file_path)
+        print(f"\nProcessing: {filename}")
+        
+        try:
+            # Read the JSON file
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            # Remove policyId fields
+            removals = remove_policy_id_recursive(data, filename)
+            
+            if removals > 0:
+                # Write back the modified JSON
+                with open(file_path, 'w', encoding='utf-8') as f:
+                    json.dump(data, f, indent=4, ensure_ascii=False)
+                
+                print(f"  Removed {removals} policyId field(s)")
+                total_removals += removals
+                processed_files += 1
+            else:
+                print("  No policyId fields found")
+                
+        except Exception as e:
+            print(f"  Error processing {filename}: {e}")
+    
+    print(f"\n=== Summary ===")
+    print(f"Files processed: {processed_files}")
+    print(f"Total policyId fields removed: {total_removals}")
+
+if __name__ == "__main__":
+    process_mutation_policy_files()