124 lines
4.0 KiB
Python
Executable File
124 lines
4.0 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Generate backend API endpoint from template with substitutions.
|
|
|
|
Creates route handlers with authentication, validation, and error handling.
|
|
"""
|
|
|
|
import sys
|
|
import argparse
|
|
import os
|
|
|
|
def read_template(template_path: str) -> str:
|
|
"""Read template file content."""
|
|
try:
|
|
with open(template_path, 'r') as f:
|
|
return f.read()
|
|
except FileNotFoundError:
|
|
raise FileNotFoundError(f"Template file not found: {template_path}")
|
|
|
|
def generate_endpoint(
|
|
path: str,
|
|
method: str,
|
|
resource: str,
|
|
framework: str,
|
|
template_content: str,
|
|
auth: bool = False,
|
|
validation: bool = False
|
|
) -> str:
|
|
"""
|
|
Generate endpoint code by substituting placeholders in template.
|
|
|
|
Args:
|
|
path: API endpoint path
|
|
method: HTTP method (GET, POST, etc.)
|
|
resource: Resource name (PascalCase)
|
|
framework: Backend framework (express, fastify, etc.)
|
|
template_content: Template file content
|
|
auth: Include authentication middleware
|
|
validation: Include validation middleware
|
|
|
|
Returns:
|
|
str: Generated endpoint code
|
|
"""
|
|
# Convert method to lowercase for handler name
|
|
method_lower = method.lower()
|
|
|
|
# Generate middleware chain
|
|
middlewares = []
|
|
if auth:
|
|
middlewares.append('authMiddleware')
|
|
if validation:
|
|
validator_name = f'validate{resource}'
|
|
middlewares.append(validator_name)
|
|
|
|
middleware_chain = ', '.join(middlewares) if middlewares else ''
|
|
|
|
# Convert resource to different cases
|
|
resource_lower = resource.lower()
|
|
resource_plural = resource.lower() + 's' # Simple pluralization
|
|
|
|
# Perform substitutions
|
|
substitutions = {
|
|
'${ROUTE_PATH}': path,
|
|
'${HTTP_METHOD}': method.upper(),
|
|
'${HTTP_METHOD_LOWER}': method_lower,
|
|
'${RESOURCE_NAME}': resource,
|
|
'${RESOURCE_NAME_LOWER}': resource_lower,
|
|
'${RESOURCE_NAME_PLURAL}': resource_plural,
|
|
'${VALIDATION_MIDDLEWARE}': f'validate{resource}' if validation else '',
|
|
'${AUTH_MIDDLEWARE}': 'authMiddleware' if auth else '',
|
|
'${MIDDLEWARE_CHAIN}': middleware_chain,
|
|
}
|
|
|
|
result = template_content
|
|
for placeholder, value in substitutions.items():
|
|
result = result.replace(placeholder, value)
|
|
|
|
return result
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description='Generate backend API endpoint from template')
|
|
parser.add_argument('--path', required=True, help='API endpoint path')
|
|
parser.add_argument('--method', required=True, choices=['GET', 'POST', 'PUT', 'PATCH', 'DELETE'], help='HTTP method')
|
|
parser.add_argument('--resource', required=True, help='Resource name (PascalCase)')
|
|
parser.add_argument('--framework', default='express', choices=['express', 'fastify', 'nestjs'], help='Backend framework')
|
|
parser.add_argument('--auth', action='store_true', help='Include authentication middleware')
|
|
parser.add_argument('--validation', action='store_true', help='Include validation middleware')
|
|
parser.add_argument('--template', required=True, help='Template file path')
|
|
parser.add_argument('--output', help='Output file path (optional, prints to stdout if not provided)')
|
|
|
|
args = parser.parse_args()
|
|
|
|
try:
|
|
# Read template
|
|
template_content = read_template(args.template)
|
|
|
|
# Generate endpoint
|
|
endpoint_code = generate_endpoint(
|
|
args.path,
|
|
args.method,
|
|
args.resource,
|
|
args.framework,
|
|
template_content,
|
|
args.auth,
|
|
args.validation
|
|
)
|
|
|
|
# Output
|
|
if args.output:
|
|
os.makedirs(os.path.dirname(args.output), exist_ok=True)
|
|
with open(args.output, 'w') as f:
|
|
f.write(endpoint_code)
|
|
print(f"✅ Endpoint generated: {args.output}")
|
|
else:
|
|
print(endpoint_code)
|
|
|
|
sys.exit(0)
|
|
except Exception as e:
|
|
print(f"❌ Error: {e}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
if __name__ == '__main__':
|
|
main()
|