stackforge-cli 0.1.4__tar.gz → 0.1.5__tar.gz

{stackforge_cli-0.1.4 → stackforge_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackforge-cli
-Version: 0.1.4
+Version: 0.1.5
 Summary: A CLI scaffolder for .NET Clean Architecture projects
 License: MIT
 Keywords: scaffolder,dotnet,clean-architecture,cli
@@ -11,6 +11,8 @@ Classifier: Environment :: Console
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: colorama>=0.4.6
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
 
 # StackForge
 

{stackforge_cli-0.1.4 → stackforge_cli-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stackforge-cli"
-version = "0.1.4"
+version = "0.1.5"
 description = "A CLI scaffolder for .NET Clean Architecture projects"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -20,8 +20,19 @@ dependencies = [
     "colorama>=0.4.6",
 ]
 
+[project.optional-dependencies]
+test = ["pytest>=8"]
+
 [project.scripts]
 stackforge = "stackforge.scaffold:main"
 
 [tool.setuptools.packages.find]
-where = ["src"]
+where = ["src"]
+
+[tool.setuptools.package-data]
+stackforge = ["templates/**/*.tmpl"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src", "tests"]
+markers = ["dotnet: builds the generated solution with the .NET SDK (slow)"]

stackforge_cli-0.1.5/src/stackforge/engines/dotnet/api_generator.py

@@ -0,0 +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):
+    for folder in API_FOLDERS:
+        (base / folder).mkdir(parents=True, exist_ok=True)
+
+    for template in API_TEMPLATES:
+        render_file(ENGINE, base, template, project)
+
+    ui.file_created("API/ structure and files")

stackforge_cli-0.1.5/src/stackforge/engines/dotnet/config_generator.py

@@ -0,0 +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):
+    render_file(ENGINE, base, ".env", project)
+    ui.file_created(".env")
+
+
+def generate_appsettings(base: Path, project: str):
+    render_file(ENGINE, base, "API/appsettings.json", project)
+    ui.file_created("API/appsettings.json")
+
+
+def generate_appsettings_development(base: Path, project: str):
+    render_file(ENGINE, base, "API/appsettings.Development.json", project)
+    ui.file_created("API/appsettings.Development.json")

stackforge_cli-0.1.5/src/stackforge/engines/dotnet/docker_generator.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+from stackforge import ui
+from stackforge.templating import render_file
+
+ENGINE = "dotnet"
+
+
+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):
+    render_file(ENGINE, base, "docker-compose.yml", project)
+    ui.file_created("docker-compose.yml")

{stackforge_cli-0.1.4 → stackforge_cli-0.1.5}/src/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")
 
 

stackforge_cli-0.1.5/src/stackforge/engines/dotnet/layers_generator.py

@@ -0,0 +1,103 @@
+from pathlib import Path
+from stackforge import ui
+from stackforge.templating import render_file
+
+ENGINE = "dotnet"
+
+
+def _generate_layer(base: Path, project: str, layer: str, folders: list[str], templates: list[str]):
+    for folder in folders:
+        (base / folder).mkdir(parents=True, exist_ok=True)
+
+    for template in templates:
+        render_file(ENGINE, base, template, project)
+
+    ui.file_created(f"{layer}/ structure and files")
+
+
+def generate_application_layer(base: Path, project: str):
+    _generate_layer(
+        base,
+        project,
+        "Application",
+        folders=[
+            "Application/Common/Behaviors",
+            "Application/Common/Constants",
+            "Application/Common/Exceptions",
+            "Application/Common/Models/Serialization",
+            "Application/Helpers",
+            "Application/Interfaces",
+            "Application/Mappings",
+            "Application/Services",
+        ],
+        templates=[
+            "Application/Common/Behaviors/ValidationBehavior.cs",
+            "Application/Common/Constants/ErrorMessages.cs",
+            "Application/Common/Exceptions/AppExceptions.cs",
+            "Application/Common/Exceptions/NotFoundException.cs",
+            "Application/Common/Models/ApiResponse.cs",
+            "Application/Common/Models/Result.cs",
+            "Application/Common/Models/PagingParams.cs",
+            "Application/Common/Models/PaginatedResult.cs",
+            "Application/Common/Models/PagedList.cs",
+            "Application/Common/Models/PagedResponse.cs",
+            "Application/Common/Models/Serialization/IsoDateTime.cs",
+        ],
+    )
+
+
+def generate_domain_layer(base: Path, project: str):
+    _generate_layer(
+        base,
+        project,
+        "Domain",
+        folders=[
+            "Domain/Common",
+            "Domain/Entities/Identity",
+            "Domain/Enums",
+            "Domain/Utils",
+        ],
+        templates=[
+            "Domain/Common/BaseEntity.cs",
+            "Domain/Common/EnumMemberExtensions.cs",
+            "Domain/Entities/Identity/Role.cs",
+            "Domain/Entities/Identity/User.cs",
+            "Domain/Entities/Identity/UserRole.cs",
+            "Domain/GlobalUsings.cs",
+        ],
+    )
+
+
+def generate_infrastructure_layer(base: Path, project: str):
+    _generate_layer(
+        base,
+        project,
+        "Infrastructure",
+        folders=[
+            "Infrastructure/BackgroundServices",
+            "Infrastructure/Configurations",
+            "Infrastructure/Options",
+            "Infrastructure/Services",
+        ],
+        templates=[],
+    )
+
+
+def generate_persistence_layer(base: Path, project: str):
+    _generate_layer(
+        base,
+        project,
+        "Persistence",
+        folders=[
+            "Persistence/Configurations",
+            "Persistence/Extensions",
+            "Persistence/Migrations",
+            "Persistence/Seeders",
+        ],
+        templates=[
+            "Persistence/DataContext.cs",
+            "Persistence/Seeders/RoleSeeder.cs",
+            "Persistence/Seeders/UserSeeder.cs",
+            "Persistence/Configurations/UserRoleConfiguration.cs",
+        ],
+    )

stackforge_cli-0.1.5/src/stackforge/engines/dotnet/program_generator.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+from stackforge import ui
+from stackforge.templating import render_file
+
+ENGINE = "dotnet"
+
+# Layers that get a ConfigureServices.Add<Layer>Services() extension.
+CONFIGURE_SERVICES_LAYERS = {"Application", "Infrastructure", "Persistence", "API"}
+
+
+def generate_configure_services(layer: str, base: Path, project: str):
+    if layer not in CONFIGURE_SERVICES_LAYERS:
+        return
+
+    render_file(ENGINE, base, f"{layer}/ConfigureServices.cs", project)
+    ui.file_created(f"{layer}/ConfigureServices.cs")
+
+
+def generate_program_cs(base: Path, project: str):
+    render_file(ENGINE, base, "API/Program.cs", project)
+    ui.file_created("API/Program.cs")

stackforge_cli-0.1.5/src/stackforge/templates/dotnet/API/Configurations/Swagger/ApiRoles.cs.tmpl

@@ -0,0 +1,9 @@
+namespace __PROJECT__.API.Configurations.Swagger
+{
+    public static class ApiRoles
+    {
+        public const string SuperAdmin = "SuperAdmin";
+        public const string Admin = "Admin";
+        public const string User = "User";
+    }
+}

stackforge_cli-0.1.5/src/stackforge/templates/dotnet/API/ConfigureServices.cs.tmpl

@@ -0,0 +1,120 @@
+using __PROJECT__.API.Interface;
+using __PROJECT__.API.Options;
+using __PROJECT__.API.Services;
+using __PROJECT__.Domain.Entities.Identity;
+using __PROJECT__.Persistence;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.IdentityModel.Tokens;
+using Microsoft.OpenApi.Models;
+using System.Text;
+using System.Text.Json.Serialization;
+
+namespace __PROJECT__.API
+{
+    public static class ConfigureServices
+    {
+        public const string CorsPolicy = "Cors";
+
+        public static IServiceCollection AddApiServices(this IServiceCollection services, IConfiguration configuration)
+        {
+            services.Configure<JwtOptions>(configuration.GetSection("Jwt"));
+            var jwtOptions = new JwtOptions();
+            configuration.GetSection("Jwt").Bind(jwtOptions);
+
+            services.AddControllers()
+                .AddJsonOptions(options => options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter()));
+
+            services.AddEndpointsApiExplorer();
+
+            services.AddSwaggerGen(config =>
+            {
+                config.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
+                {
+                    Name = "Authorization",
+                    Type = SecuritySchemeType.Http,
+                    Scheme = "bearer",
+                    BearerFormat = "JWT",
+                    In = ParameterLocation.Header,
+                    Description = "Enter your JWT token only (no 'Bearer' prefix needed)"
+                });
+
+                config.AddSecurityRequirement(new OpenApiSecurityRequirement
+                {
+                    {
+                        new OpenApiSecurityScheme
+                        {
+                            Reference = new OpenApiReference
+                            {
+                                Type = ReferenceType.SecurityScheme,
+                                Id = "Bearer"
+                            }
+                        },
+                        Array.Empty<string>()
+                    }
+                });
+            });
+
+            // Browser origins allowed to call the API. Format: scheme + host (+ port if non-default), no trailing slash.
+            // Only add frontends you own: an allowed origin's scripts can call this API from a visitor's browser.
+            // Bearer tokens travel in the Authorization header, so credentials (cookies) are not allowed.
+            services.AddCors(options =>
+            {
+                options.AddPolicy(CorsPolicy, policy =>
+                {
+                    policy.AllowAnyMethod()
+                        .AllowAnyHeader()
+                        .WithExposedHeaders("WWW-Authenticate", "Retry-After")
+                        .WithOrigins(
+                            "http://localhost:3000"
+                            );
+                });
+            });
+
+            services.AddIdentity<User, Role>(options =>
+            {
+                options.Password.RequireDigit = true;
+                options.Password.RequireLowercase = true;
+                options.Password.RequireUppercase = true;
+                options.Password.RequireNonAlphanumeric = true;
+                options.Password.RequiredLength = 8;
+            })
+            .AddEntityFrameworkStores<DataContext>()
+            .AddDefaultTokenProviders();
+
+            services.AddAuthentication(options =>
+            {
+                options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+                options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+            })
+            .AddJwtBearer(options =>
+            {
+                options.TokenValidationParameters = new TokenValidationParameters
+                {
+                    ValidateIssuer = true,
+                    ValidateAudience = true,
+                    ValidateLifetime = true,
+                    ValidateIssuerSigningKey = true,
+                    ValidIssuer = jwtOptions.Issuer,
+                    ValidAudience = jwtOptions.Audience,
+                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtOptions.SecretKey))
+                };
+            });
+
+            // Deny by default: endpoints without an explicit policy require an authenticated user.
+            // Public endpoints must opt out with [AllowAnonymous].
+            services.AddAuthorization(options =>
+            {
+                options.FallbackPolicy = new AuthorizationPolicyBuilder()
+                    .RequireAuthenticatedUser()
+                    .Build();
+            });
+
+            //Scopes
+            services.AddScoped<IJwtService, JwtService>();
+
+            return services;
+        }
+    }
+}

stackforge_cli-0.1.5/src/stackforge/templates/dotnet/API/Controllers/BaseApiController.cs.tmpl

@@ -0,0 +1,24 @@
+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;
+        }
+    }
+}

stackforge_cli-0.1.5/src/stackforge/templates/dotnet/API/Controllers/Main/AccountController.cs.tmpl

@@ -0,0 +1,68 @@
+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
+            });
+        }
+    }
+}

stackforge_cli-0.1.5/src/stackforge/templates/dotnet/API/DTOs/AccountDTOs.cs.tmpl

@@ -0,0 +1,23 @@
+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>();
+    }
+}

stackforge_cli-0.1.5/src/stackforge/templates/dotnet/API/Interface/IJwtService.cs.tmpl

@@ -0,0 +1,7 @@
+namespace __PROJECT__.API.Interface
+{
+    public interface IJwtService
+    {
+        string GenerateToken(Guid userId, string email);
+    }
+}

stackforge_cli-0.1.5/src/stackforge/templates/dotnet/API/Options/JwtOptions.cs.tmpl

@@ -0,0 +1,10 @@
+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; }
+    }
+}

stackforge_cli-0.1.5/src/stackforge/templates/dotnet/API/Program.cs.tmpl

@@ -0,0 +1,45 @@
+using __PROJECT__.API;
+using __PROJECT__.Application;
+using __PROJECT__.Domain.Entities.Identity;
+using __PROJECT__.Infrastructure;
+using __PROJECT__.Persistence;
+using Microsoft.AspNetCore.Identity;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Layer services
+builder.Services.AddApplicationServices();
+builder.Services.AddInfrastructureServices();
+builder.Services.AddPersistenceServices(builder.Configuration);
+builder.Services.AddApiServices(builder.Configuration);
+
+var app = builder.Build();
+
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+if (!app.Environment.IsDevelopment())
+{
+    app.UseHttpsRedirection();
+}
+app.UseRouting();
+app.UseCors(__PROJECT__.API.ConfigureServices.CorsPolicy);
+app.UseAuthentication();
+app.UseAuthorization();
+app.MapControllers();
+
+using (var scope = app.Services.CreateScope())
+{
+    var db = scope.ServiceProvider.GetRequiredService<DataContext>();
+    db.Database.EnsureCreated();
+
+    var roleManager = scope.ServiceProvider.GetRequiredService<RoleManager<Role>>();
+    var userManager = scope.ServiceProvider.GetRequiredService<UserManager<User>>();
+    await __PROJECT__.Persistence.Seeders.RoleSeeder.SeedAsync(roleManager);
+    await __PROJECT__.Persistence.Seeders.UserSeeder.SeedAsync(userManager);
+}
+
+app.Run();

stackforge_cli-0.1.5/src/stackforge/templates/dotnet/API/Properties/launchSettings.json.tmpl

@@ -0,0 +1,31 @@
+{
+  "$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
+    }
+  }
+}