stackforge-cli 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

stackforge/engines/dotnet/api_generator.py

@@ -1,314 +1,39 @@
 from pathlib import Path
 from stackforge import ui
+from stackforge.templating import render_file
+
+ENGINE = "dotnet"
+
+API_FOLDERS = [
+    "API/Configurations/Swagger",
+    "API/Controllers/Main",
+    "API/Helpers",
+    "API/Interface",
+    "API/Options",
+    "API/Properties",
+    "API/Services",
+    "API/Swagger",
+    "API/DTOs",
+]
+
+API_TEMPLATES = [
+    "API/Controllers/BaseApiController.cs",
+    "API/Options/JwtOptions.cs",
+    "API/Interface/IJwtService.cs",
+    "API/Services/JwtService.cs",
+    "API/Swagger/EnumMemberSchemaFilter.cs",
+    "API/Configurations/Swagger/ApiRoles.cs",
+    "API/Properties/launchSettings.json",
+    "API/DTOs/AccountDTOs.cs",
+    "API/Controllers/Main/AccountController.cs",
+]
 
 
 def generate_api_structure(base: Path, project: str):
-    # Folders
-    folders = [
-        "API/Configurations/Swagger",
-        "API/Controllers/Main",
-        "API/Helpers",
-        "API/Interface",
-        "API/Options",
-        "API/Properties",
-        "API/Services",
-        "API/Swagger",
-        "API/DTOs",
-    ]
-
-    for folder in folders:
+    for folder in API_FOLDERS:
         (base / folder).mkdir(parents=True, exist_ok=True)
 
-    _generate_base_controller(base, project)
-    _generate_jwt_options(base, project)
-    _generate_ijwt_service(base, project)
-    _generate_jwt_service(base, project)
-    _generate_enum_schema_filter(base, project)
-    _generate_api_roles(base, project)
-    _generate_launch_settings(base)
-    _generate_login_dto(base, project)
-    _generate_account_controller(base, project)
+    for template in API_TEMPLATES:
+        render_file(ENGINE, base, template, project)
 
     ui.file_created("API/ structure and files")
-
-
-def _generate_base_controller(base: Path, project: str):
-    content = f"""using Microsoft.AspNetCore.Mvc;
-using System.Security.Claims;
-
-namespace {project}.API.Controllers
-{{
-    [Route("api/[controller]")]
-    [ApiController]
-    public class BaseApiController : ControllerBase
-    {{
-        protected Guid GetUserId() => Guid.Parse(User?.FindFirst(ClaimTypes.NameIdentifier)?.Value!);
-
-        protected string GetCurrentEmail() => User?.FindFirstValue(ClaimTypes.Email)!;
-
-        protected Guid? GetOrganizationId()
-        {{
-            var claim = User?.FindFirst("OrganizationId");
-
-            if (claim == null || !Guid.TryParse(claim.Value, out var orgId))
-                return null;
-
-            return orgId;
-        }}
-    }}
-}}
-"""
-    (base / "API/Controllers/BaseApiController.cs").write_text(content)
-
-
-def _generate_jwt_options(base: Path, project: str):
-    content = f"""namespace {project}.API.Options
-{{
-    public class JwtOptions
-    {{
-        public string Issuer {{ get; set; }} = string.Empty;
-        public string Audience {{ get; set; }} = string.Empty;
-        public string SecretKey {{ get; set; }} = string.Empty;
-        public int ExpiryMinutes {{ get; set; }}
-    }}
-}}
-"""
-    (base / "API/Options/JwtOptions.cs").write_text(content)
-
-
-def _generate_ijwt_service(base: Path, project: str):
-    content = f"""namespace {project}.API.Interface
-{{
-    public interface IJwtService
-    {{
-        string GenerateToken(Guid userId, string email);
-    }}
-}}
-"""
-    (base / "API/Interface/IJwtService.cs").write_text(content)
-
-
-def _generate_jwt_service(base: Path, project: str):
-    content = f"""using {project}.API.Interface;
-using {project}.API.Options;
-using Microsoft.Extensions.Options;
-using Microsoft.IdentityModel.Tokens;
-using System.IdentityModel.Tokens.Jwt;
-using System.Security.Claims;
-using System.Text;
-
-namespace {project}.API.Services
-{{
-    public class JwtService : IJwtService
-    {{
-        private readonly JwtOptions _options;
-
-        public JwtService(IOptions<JwtOptions> options)
-        {{
-            _options = options.Value;
-        }}
-
-        public string GenerateToken(Guid userId, string email)
-        {{
-            var claims = new[]
-            {{
-                new Claim(ClaimTypes.NameIdentifier, userId.ToString()),
-                new Claim(ClaimTypes.Email, email),
-            }};
-
-            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_options.SecretKey));
-            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
-
-            var token = new JwtSecurityToken(
-                issuer: _options.Issuer,
-                audience: _options.Audience,
-                claims: claims,
-                expires: DateTime.UtcNow.AddMinutes(_options.ExpiryMinutes),
-                signingCredentials: creds);
-
-            return new JwtSecurityTokenHandler().WriteToken(token);
-        }}
-    }}
-}}
-"""
-    (base / "API/Services/JwtService.cs").write_text(content)
-
-
-def _generate_enum_schema_filter(base: Path, project: str):
-    content = f"""using Microsoft.OpenApi.Any;
-using Microsoft.OpenApi.Models;
-using Swashbuckle.AspNetCore.SwaggerGen;
-using System.Runtime.Serialization;
-
-namespace {project}.API.Swagger
-{{
-    public class EnumMemberSchemaFilter : ISchemaFilter
-    {{
-        public void Apply(OpenApiSchema schema, SchemaFilterContext context)
-        {{
-            if (!context.Type.IsEnum) return;
-
-            schema.Enum.Clear();
-            foreach (var member in Enum.GetNames(context.Type))
-            {{
-                var field = context.Type.GetField(member);
-                var attr = field?.GetCustomAttributes(typeof(EnumMemberAttribute), false)
-                                 .OfType<EnumMemberAttribute>()
-                                 .FirstOrDefault();
-                schema.Enum.Add(new OpenApiString(attr?.Value ?? member));
-            }}
-        }}
-    }}
-}}
-"""
-    (base / "API/Swagger/EnumMemberSchemaFilter.cs").write_text(content)
-
-
-def _generate_api_roles(base: Path, project: str):
-    content = f"""namespace {project}.API.Configurations.Swagger
-{{
-    public static class ApiRoles
-    {{
-        public const string SuperAdmin = "SuperAdmin";
-        public const string Admin = "Admin";
-        public const string User = "User";
-    }}
-}}
-"""
-    (base / "API/Configurations/Swagger/ApiRoles.cs").write_text(content)
-
-
-def _generate_launch_settings(base: Path):
-    content = """{
-  "$schema": "https://json.schemastore.org/launchsettings.json",
-  "profiles": {
-    "http": {
-      "commandName": "Project",
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      },
-      "dotnetRunMessages": true,
-      "applicationUrl": "http://localhost:5000"
-    },
-    "https": {
-      "commandName": "Project",
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      },
-      "dotnetRunMessages": true,
-      "applicationUrl": "https://localhost:7013;http://localhost:5282"
-    },
-    "Container (Dockerfile)": {
-      "commandName": "Docker",
-      "launchUrl": "{Scheme}://{ServiceHost}:{ServicePort}",
-      "environmentVariables": {
-        "ASPNETCORE_HTTPS_PORTS": "8081",
-        "ASPNETCORE_HTTP_PORTS": "8080"
-      },
-      "publishAllPorts": true,
-      "useSSL": true
-    }
-  }
-}
-"""
-    (base / "API/Properties/launchSettings.json").write_text(content)
-
-def _generate_login_dto(base: Path, project: str):
-    content = f"""namespace {project}.API.DTOs
-{{
-    public class LoginRequest
-    {{
-        public string Email {{ get; set; }} = string.Empty;
-        public string Password {{ get; set; }} = string.Empty;
-    }}
-
-    public class LoginResponse
-    {{
-        public string Token {{ get; set; }} = string.Empty;
-        public string Email {{ get; set; }} = string.Empty;
-        public string FullName {{ get; set; }} = string.Empty;
-    }}
-
-    public class CurrentUserResponse
-    {{
-        public Guid Id {{ get; set; }}
-        public string Email {{ get; set; }} = string.Empty;
-        public string FullName {{ get; set; }} = string.Empty;
-        public IList<string> Roles {{ get; set; }} = new List<string>();
-    }}
-}}
-"""
-    (base / "API/DTOs/AccountDTOs.cs").write_text(content)
-
-
-def _generate_account_controller(base: Path, project: str):
-    content = f"""using {project}.API.Controllers;
-using {project}.API.DTOs;
-using {project}.API.Interface;
-using {project}.Domain.Entities.Identity;
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Identity;
-using Microsoft.AspNetCore.Mvc;
-
-namespace {project}.API.Controllers.Main
-{{
-    public class AccountController : BaseApiController
-    {{
-        private readonly UserManager<User> _userManager;
-        private readonly SignInManager<User> _signInManager;
-        private readonly IJwtService _jwtService;
-
-        public AccountController(
-            UserManager<User> userManager,
-            SignInManager<User> signInManager,
-            IJwtService jwtService)
-        {{
-            _userManager = userManager;
-            _signInManager = signInManager;
-            _jwtService = jwtService;
-        }}
-
-        [AllowAnonymous]
-        [HttpPost("login")]
-        public async Task<IActionResult> Login([FromBody] LoginRequest request)
-        {{
-            var user = await _userManager.FindByEmailAsync(request.Email);
-            if (user == null)
-                return Unauthorized("Invalid credentials.");
-
-            var result = await _signInManager.CheckPasswordSignInAsync(user, request.Password, false);
-            if (!result.Succeeded)
-                return Unauthorized("Invalid credentials.");
-
-            var token = _jwtService.GenerateToken(user.Id, user.Email!);
-
-            return Ok(new LoginResponse
-            {{
-                Token = token,
-                Email = user.Email!,
-                FullName = $"{{user.FirstName}} {{user.LastName}}"
-            }});
-        }}
-
-        [Authorize]
-        [HttpGet("me")]
-        public async Task<IActionResult> Me()
-        {{
-            var user = await _userManager.FindByIdAsync(GetUserId().ToString());
-            if (user == null)
-                return NotFound("User not found.");
-
-            var roles = await _userManager.GetRolesAsync(user);
-
-            return Ok(new CurrentUserResponse
-            {{
-                Id = user.Id,
-                Email = user.Email!,
-                FullName = $"{{user.FirstName}} {{user.LastName}}",
-                Roles = roles
-            }});
-        }}
-    }}
-}}
-"""
-    (base / "API/Controllers/Main/AccountController.cs").write_text(content)

stackforge/engines/dotnet/config_generator.py

@@ -1,77 +1,20 @@
 from pathlib import Path
 from stackforge import ui
+from stackforge.templating import render_file
 
+ENGINE = "dotnet"
 
-def generate_env(base: Path, project: str):
-    project_lower = project.lower()
-
-    content = f"""ASPNETCORE_ENVIRONMENT=Development
-DB_HOST=db
-DB_PORT=5432
-DB_NAME={project_lower}_db
-DB_USER=postgres
-DB_PASSWORD=postgres
-JWT_ISSUER=https://localhost:5000
-JWT_AUDIENCE=https://localhost:5000
-JWT_SECRET_KEY=your-super-secret-key-change-this-in-production
-JWT_EXPIRY_MINUTES=60
-"""
 
-    file_path = base / ".env"
-    file_path.write_text(content)
+def generate_env(base: Path, project: str):
+    render_file(ENGINE, base, ".env", project)
     ui.file_created(".env")
 
 
 def generate_appsettings(base: Path, project: str):
-    project_lower = project.lower()
-
-    content = f"""{{
-  "ConnectionStrings": {{
-    "DefaultConnection": "Host=db;Port=5432;Database={project_lower}_db;Username=postgres;Password=postgres"
-  }},
-  "Jwt": {{
-    "Issuer": "https://localhost:5000",
-    "Audience": "https://localhost:5000",
-    "SecretKey": "your-super-secret-key-change-this-in-production",
-    "ExpiryMinutes": 60
-  }},
-  "Logging": {{
-    "LogLevel": {{
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
-    }}
-  }},
-  "AllowedHosts": "*"
-}}
-"""
-
-    file_path = base / "API" / "appsettings.json"
-    file_path.write_text(content)
+    render_file(ENGINE, base, "API/appsettings.json", project)
     ui.file_created("API/appsettings.json")
 
 
 def generate_appsettings_development(base: Path, project: str):
-    project_lower = project.lower()
-
-    content = f"""{{
-  "ConnectionStrings": {{
-    "DefaultConnection": "Host=localhost;Port=5432;Database={project_lower}_db;Username=postgres;Password=postgres"
-  }},
-  "Jwt": {{
-    "Issuer": "https://localhost:5000",
-    "Audience": "https://localhost:5000",
-    "SecretKey": "your-super-secret-key-change-this-in-production",
-    "ExpiryMinutes": 60
-  }},
-  "Logging": {{
-    "LogLevel": {{
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
-    }}
-  }}
-}}
-"""
-
-    file_path = base / "API" / "appsettings.Development.json"
-    file_path.write_text(content)
-    ui.file_created("API/appsettings.Development.json")
+    render_file(ENGINE, base, "API/appsettings.Development.json", project)
+    ui.file_created("API/appsettings.Development.json")

stackforge/engines/dotnet/docker_generator.py

@@ -1,64 +1,15 @@
 from pathlib import Path
 from stackforge import ui
+from stackforge.templating import render_file
 
+ENGINE = "dotnet"
 
-def generate_dockerfile(base: Path):
-    content = """FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
-WORKDIR /app
 
-COPY . .
-
-RUN dotnet publish API/API.csproj -c Release -o out
-
-ENTRYPOINT ["dotnet", "out/API.dll"]
-"""
-
-    file_path = base / "Dockerfile"
-    file_path.write_text(content)
+def generate_dockerfile(base: Path, project: str = ""):
+    render_file(ENGINE, base, "Dockerfile", project)
     ui.file_created("Dockerfile")
 
 
 def generate_docker_compose(base: Path, project: str):
-    project_lower = project.lower()
-
-    content = f"""services:
-  api:
-    build: .
-    container_name: {project_lower}_api
-    ports:
-      - "5000:8080"
-    environment:
-      - ASPNETCORE_ENVIRONMENT=Development
-      - ConnectionStrings__DefaultConnection=Host=db;Port=5432;Database={project_lower}_db;Username=postgres;Password=postgres
-      - Jwt__Issuer=http://localhost:5000
-      - Jwt__Audience=http://localhost:5000
-      - Jwt__SecretKey=your-super-secret-key-change-this-in-production
-      - Jwt__ExpiryMinutes=60
-    depends_on:
-      db:
-        condition: service_healthy
-
-  db:
-    image: postgres:latest
-    container_name: {project_lower}_db
-    environment:
-      POSTGRES_DB: {project_lower}_db
-      POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: postgres
-    ports:
-      - "5432:5432"
-    volumes:
-      - {project_lower}_pgdata:/var/lib/postgresql
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U postgres"]
-      interval: 5s
-      timeout: 5s
-      retries: 5
-
-volumes:
-  {project_lower}_pgdata:
-"""
-
-    file_path = base / "docker-compose.yml"
-    file_path.write_text(content)
-    ui.file_created("docker-compose.yml")
+    render_file(ENGINE, base, "docker-compose.yml", project)
+    ui.file_created("docker-compose.yml")

stackforge/engines/dotnet/git_generator.py

@@ -2,6 +2,9 @@ import uuid
 import subprocess
 from pathlib import Path
 from stackforge import ui
+from stackforge.templating import render_file
+
+ENGINE = "dotnet"
 
 def generate_sln(base: Path, project: str):
     layers = ["API", "Application", "Domain", "Infrastructure", "Persistence"]
@@ -37,65 +40,13 @@ EndGlobal
     ui.file_created(f"{project}.sln")
 
     
-def generate_gitignore(base: Path):
-    content = """# Build results
-bin/
-obj/
-out/
-
-# Environment
-.env
-
-# VS / Rider
-.vs/
-.idea/
-*.user
-
-# Logs
-*.log
-"""
-
-    file_path = base / ".gitignore"
-    file_path.write_text(content)
+def generate_gitignore(base: Path, project: str = ""):
+    render_file(ENGINE, base, ".gitignore", project)
     ui.file_created(".gitignore")
 
 
-def generate_github_workflow(base: Path):
-    workflow_dir = base / ".github" / "workflows"
-    workflow_dir.mkdir(parents=True, exist_ok=True)
-
-    content = """name: Sync Environment Branches
-
-on:
-  push:
-    branches:
-      - main
-
-permissions:
-  contents: write
-
-jobs:
-  sync-branches:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Create staging branch if missing
-        run: |
-          if ! git ls-remote --exit-code origin refs/heads/staging; then
-            git push origin HEAD:refs/heads/staging
-          fi
-
-      - name: Create development branch if missing
-        run: |
-          if ! git ls-remote --exit-code origin refs/heads/development; then
-            git push origin HEAD:refs/heads/development
-          fi
-"""
-    file_path = workflow_dir / "sync-branches.yml"
-    file_path.write_text(content.lstrip())
+def generate_github_workflow(base: Path, project: str = ""):
+    render_file(ENGINE, base, ".github/workflows/sync-branches.yml", project)
     ui.file_created(".github/workflows/sync-branches.yml")