161 lines
5.0 KiB
Python
Executable File
161 lines
5.0 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Export GraphQL Query Utility
|
|
|
|
This script helps export discovered GraphQL queries into reusable formats
|
|
for easy integration into projects. It supports multiple output formats:
|
|
- JavaScript/TypeScript module
|
|
- Python module
|
|
- Plain GraphQL file
|
|
- JSON format with metadata
|
|
|
|
Usage:
|
|
python3 export_query.py <output_file> [--format js|py|graphql|json] [--name QueryName]
|
|
|
|
Then paste your GraphQL query when prompted, and press Ctrl+D (Unix) or Ctrl+Z (Windows) when done.
|
|
|
|
Examples:
|
|
# Export as JavaScript
|
|
python3 export_query.py queries/myQuery.js --format js --name GetLatestSwaps
|
|
|
|
# Export as Python
|
|
python3 export_query.py queries/myQuery.py --format py --name get_latest_swaps
|
|
|
|
# Export as plain GraphQL
|
|
python3 export_query.py queries/myQuery.graphql --format graphql
|
|
"""
|
|
|
|
import sys
|
|
import argparse
|
|
import json
|
|
from pathlib import Path
|
|
from datetime import datetime
|
|
|
|
|
|
def format_js(query: str, name: str, description: str = "") -> str:
|
|
"""Format query as JavaScript/TypeScript module."""
|
|
comment = f"/**\n * {description}\n */\n" if description else ""
|
|
return f"""{comment}export const {name} = `
|
|
{query}
|
|
`;
|
|
"""
|
|
|
|
|
|
def format_python(query: str, name: str, description: str = "") -> str:
|
|
"""Format query as Python module."""
|
|
docstring = f' """{description}"""\n' if description else ""
|
|
return f'''{name} = """
|
|
{query}
|
|
"""
|
|
{docstring}
|
|
'''
|
|
|
|
|
|
def format_graphql(query: str, description: str = "") -> str:
|
|
"""Format as plain GraphQL with optional comment."""
|
|
comment = f"# {description}\n\n" if description else ""
|
|
return f"{comment}{query}\n"
|
|
|
|
|
|
def format_json(query: str, name: str, description: str = "", variables: dict = None) -> str:
|
|
"""Format as JSON with metadata."""
|
|
data = {
|
|
"name": name,
|
|
"description": description,
|
|
"query": query,
|
|
"variables": variables or {},
|
|
"exported_at": datetime.now().isoformat()
|
|
}
|
|
return json.dumps(data, indent=2)
|
|
|
|
|
|
def read_multiline_input(prompt: str) -> str:
|
|
"""Read multiline input from stdin."""
|
|
print(prompt)
|
|
print("(Press Ctrl+D on Unix/Mac or Ctrl+Z on Windows when done)")
|
|
print("-" * 60)
|
|
lines = []
|
|
try:
|
|
while True:
|
|
line = input()
|
|
lines.append(line)
|
|
except EOFError:
|
|
pass
|
|
print("-" * 60)
|
|
return "\n".join(lines).strip()
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(
|
|
description="Export GraphQL queries into various formats for project use",
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
epilog=__doc__
|
|
)
|
|
parser.add_argument("output", help="Output file path")
|
|
parser.add_argument(
|
|
"--format",
|
|
choices=["js", "py", "graphql", "json"],
|
|
help="Output format (default: inferred from file extension)"
|
|
)
|
|
parser.add_argument("--name", help="Query name (required for js/py/json formats)")
|
|
parser.add_argument("--description", default="", help="Query description")
|
|
parser.add_argument("--variables", help="JSON string of query variables (for json format)")
|
|
|
|
args = parser.parse_args()
|
|
|
|
# Infer format from extension if not provided
|
|
output_path = Path(args.output)
|
|
format_type = args.format
|
|
if not format_type:
|
|
ext = output_path.suffix.lower()
|
|
format_map = {".js": "js", ".ts": "js", ".py": "py", ".graphql": "graphql", ".gql": "graphql", ".json": "json"}
|
|
format_type = format_map.get(ext)
|
|
if not format_type:
|
|
print(f"❌ Error: Cannot infer format from extension '{ext}'. Please specify --format", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# Validate name requirement
|
|
if format_type in ["js", "py", "json"] and not args.name:
|
|
print(f"❌ Error: --name is required for {format_type} format", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# Read the GraphQL query
|
|
query = read_multiline_input("\n📝 Paste your GraphQL query:")
|
|
if not query:
|
|
print("❌ Error: No query provided", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# Parse variables if provided
|
|
variables = None
|
|
if args.variables:
|
|
try:
|
|
variables = json.loads(args.variables)
|
|
except json.JSONDecodeError as e:
|
|
print(f"❌ Error: Invalid JSON in --variables: {e}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# Format the output
|
|
formatters = {
|
|
"js": lambda: format_js(query, args.name, args.description),
|
|
"py": lambda: format_python(query, args.name, args.description),
|
|
"graphql": lambda: format_graphql(query, args.description),
|
|
"json": lambda: format_json(query, args.name, args.description, variables)
|
|
}
|
|
|
|
output = formatters[format_type]()
|
|
|
|
# Create parent directory if it doesn't exist
|
|
output_path.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Write the output
|
|
output_path.write_text(output)
|
|
|
|
print(f"\n✅ Query exported successfully to: {output_path}")
|
|
print(f" Format: {format_type}")
|
|
if args.name:
|
|
print(f" Name: {args.name}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|