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

stackforge/engines/dotnet/program_generator.py

@@ -1,195 +1,245 @@
-from pathlib import Path
-from stackforge import ui
-
-
-def generate_configure_services(layer: str, base: Path, project: str):
-    templates = {
-        "Application": f"""using FluentValidation;
-using MediatR;
-using Microsoft.Extensions.DependencyInjection;
-using System.Reflection;
-
-namespace {project}.Application
-{{
-    public static class ConfigureServices
-    {{
-        public static IServiceCollection AddApplicationServices(this IServiceCollection services)
-        {{
-            services.AddMediatR(cfg =>
-                cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));
-
-            services.AddAutoMapper(cfg => cfg.AddMaps(Assembly.GetExecutingAssembly()));
-
-            services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
-
-            return services;
-        }}
-    }}
-}}
-""",
-        "Infrastructure": f"""using Microsoft.Extensions.DependencyInjection;
-
-namespace {project}.Infrastructure
-{{
-    public static class ConfigureServices
-    {{
-        public static IServiceCollection AddInfrastructureServices(this IServiceCollection services)
-        {{
-            // Register infrastructure services here
-
-            return services;
-        }}
-    }}
-}}
-""",
-        "Persistence": f"""using {project}.Persistence;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace {project}.Persistence
-{{
-    public static class ConfigureServices
-    {{
-        public static IServiceCollection AddPersistenceServices(this IServiceCollection services, IConfiguration configuration)
-        {{
-            services.AddDbContext<DataContext>(options =>
-                options.UseNpgsql(configuration.GetConnectionString("DefaultConnection")));
-
-            return services;
-        }}
-    }}
-}}
-""",
-    }
-
-    if layer not in templates:
-        return
-
-    file_path = base / layer / "ConfigureServices.cs"
-    file_path.write_text(templates[layer])
-    ui.file_created(f"{layer}/ConfigureServices.cs")
-
-
-def generate_program_cs(base: Path, project: str):
-    content = f"""using {project}.Application;
-using {project}.Infrastructure;
-using {project}.Persistence;
-using {project}.API.Interface;
-using {project}.API.Options;
-using {project}.API.Services;
-using Microsoft.AspNetCore.Authentication.JwtBearer;
-using Microsoft.AspNetCore.Identity;
-using Microsoft.IdentityModel.Tokens;
-using {project}.Domain.Entities.Identity;
-using System.Text;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Layer services
-builder.Services.AddApplicationServices();
-builder.Services.AddInfrastructureServices();
-builder.Services.AddPersistenceServices(builder.Configuration);
-
-// Identity
-builder.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();
-
-// JWT
-builder.Services.Configure<JwtOptions>(builder.Configuration.GetSection("Jwt"));
-var jwtOptions = new {project}.API.Options.JwtOptions();
-builder.Configuration.GetSection("Jwt").Bind(jwtOptions);
-builder.Services.AddScoped<IJwtService, JwtService>();
-
-builder.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))
-    }};
-}});
-
-// Controllers
-builder.Services.AddControllers();
-
-// Swagger
-builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen(c =>
-{{
-    c.AddSecurityDefinition("Bearer", new Microsoft.OpenApi.Models.OpenApiSecurityScheme
-    {{
-        Name = "Authorization",
-        Type = Microsoft.OpenApi.Models.SecuritySchemeType.Http,
-        Scheme = "bearer",
-        BearerFormat = "JWT",
-        In = Microsoft.OpenApi.Models.ParameterLocation.Header,
-        Description = "Enter your JWT token only (no 'Bearer' prefix needed)"
-    }});
-    c.AddSecurityRequirement(new Microsoft.OpenApi.Models.OpenApiSecurityRequirement
-    {{
-        {{
-            new Microsoft.OpenApi.Models.OpenApiSecurityScheme
-            {{
-                Reference = new Microsoft.OpenApi.Models.OpenApiReference
-                {{
-                    Type = Microsoft.OpenApi.Models.ReferenceType.SecurityScheme,
-                    Id = "Bearer"
-                }}
-            }},
-            Array.Empty<string>()
-        }}
-    }});
-}});
-
-var app = builder.Build();
-
-if (app.Environment.IsDevelopment())
-{{
-    app.UseSwagger();
-    app.UseSwaggerUI();
-}}
-
-if (!app.Environment.IsDevelopment())
-{{
-    app.UseHttpsRedirection();
-}}
-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();
-"""
-
-    file_path = base / "API" / "Program.cs"
-    file_path.write_text(content)
-    ui.file_created("API/Program.cs")
+from pathlib import Path
+from stackforge import ui
+
+
+def generate_configure_services(layer: str, base: Path, project: str):
+    templates = {
+        "Application": f"""using FluentValidation;
+using MediatR;
+using Microsoft.Extensions.DependencyInjection;
+using System.Reflection;
+
+namespace {project}.Application
+{{
+    public static class ConfigureServices
+    {{
+        public static IServiceCollection AddApplicationServices(this IServiceCollection services)
+        {{
+            services.AddMediatR(cfg =>
+                cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));
+
+            services.AddAutoMapper(cfg => cfg.AddMaps(Assembly.GetExecutingAssembly()));
+
+            services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
+
+            return services;
+        }}
+    }}
+}}
+""",
+        "Infrastructure": f"""using Microsoft.Extensions.DependencyInjection;
+
+namespace {project}.Infrastructure
+{{
+    public static class ConfigureServices
+    {{
+        public static IServiceCollection AddInfrastructureServices(this IServiceCollection services)
+        {{
+            // Register infrastructure services here
+
+            return services;
+        }}
+    }}
+}}
+""",
+        "Persistence": f"""using {project}.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace {project}.Persistence
+{{
+    public static class ConfigureServices
+    {{
+        public static IServiceCollection AddPersistenceServices(this IServiceCollection services, IConfiguration configuration)
+        {{
+            services.AddDbContext<DataContext>(options =>
+                options.UseNpgsql(configuration.GetConnectionString("DefaultConnection")));
+
+            return services;
+        }}
+    }}
+}}
+""",
+        "API": f"""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;
+        }}
+    }}
+}}
+""",
+    }
+
+    if layer not in templates:
+        return
+
+    file_path = base / layer / "ConfigureServices.cs"
+    file_path.write_text(templates[layer])
+    ui.file_created(f"{layer}/ConfigureServices.cs")
+
+
+def generate_program_cs(base: Path, project: str):
+    content = f"""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();
+"""
+
+    file_path = base / "API" / "Program.cs"
+    file_path.write_text(content)
+    ui.file_created("API/Program.cs")

stackforge/engines/dotnet/scaffolder.py

@@ -1,74 +1,74 @@
-from pathlib import Path
-from stackforge import ui
-from .csproj_generator import generate_csproj
-from .program_generator import generate_configure_services, generate_program_cs
-from .docker_generator import generate_dockerfile, generate_docker_compose
-from .config_generator import generate_env, generate_appsettings, generate_appsettings_development
-from .git_generator import generate_gitignore, generate_github_workflow, generate_sln, git_init
-from .api_generator import generate_api_structure
-from .layers_generator import (
-    generate_application_layer,
-    generate_domain_layer,
-    generate_infrastructure_layer,
-    generate_persistence_layer,
-)
-
-def scaffold_folders(base: Path, project: str):
-    layers = [
-        "API",
-        "Application",
-        "Domain",
-        "Infrastructure",
-        "Persistence"
-    ]
-
-    ui.section(f"Scaffolding '{project}'")
-
-    ui.step("Creating folders")
-    for layer in layers:
-        folder = base / layer
-        folder.mkdir(parents=True, exist_ok=True)
-        ui.file_created(layer)
-
-    ui.section("Generating .csproj files")
-    for layer in layers:
-        generate_csproj(layer, base)
-
-    ui.section("Generating service registrations")
-    for layer in ["Application", "Infrastructure", "Persistence"]:
-        generate_configure_services(layer, base, project)
-
-    ui.section("Generating Program.cs")
-    generate_program_cs(base, project)
-
-    ui.section("Generating Docker files")
-    generate_dockerfile(base)
-    generate_docker_compose(base, project)
-
-    ui.section("Generating config files")
-    generate_env(base, project)
-    generate_appsettings(base, project)
-    generate_appsettings_development(base, project)
-
-    ui.section("Generating API layer")
-    generate_api_structure(base, project)
-
-    ui.section("Generating layer files")
-    generate_application_layer(base, project)
-    generate_domain_layer(base, project)
-    generate_infrastructure_layer(base, project)
-    generate_persistence_layer(base, project)
-
-    ui.section("Generating solution file")
-    generate_sln(base, project)
-
-    ui.section("Generating .gitignore")
-    generate_gitignore(base)
-
-    ui.section("Generating GitHub workflow")
-    generate_github_workflow(base)
-
-    ui.section("Initializing Git repository")
-    git_init(base, project)
-
-    ui.done()
+from pathlib import Path
+from stackforge import ui
+from .csproj_generator import generate_csproj
+from .program_generator import generate_configure_services, generate_program_cs
+from .docker_generator import generate_dockerfile, generate_docker_compose
+from .config_generator import generate_env, generate_appsettings, generate_appsettings_development
+from .git_generator import generate_gitignore, generate_github_workflow, generate_sln, git_init
+from .api_generator import generate_api_structure
+from .layers_generator import (
+    generate_application_layer,
+    generate_domain_layer,
+    generate_infrastructure_layer,
+    generate_persistence_layer,
+)
+
+def scaffold_folders(base: Path, project: str):
+    layers = [
+        "API",
+        "Application",
+        "Domain",
+        "Infrastructure",
+        "Persistence"
+    ]
+
+    ui.section(f"Scaffolding '{project}'")
+
+    ui.step("Creating folders")
+    for layer in layers:
+        folder = base / layer
+        folder.mkdir(parents=True, exist_ok=True)
+        ui.file_created(layer)
+
+    ui.section("Generating .csproj files")
+    for layer in layers:
+        generate_csproj(layer, base)
+
+    ui.section("Generating service registrations")
+    for layer in ["Application", "Infrastructure", "Persistence", "API"]:
+        generate_configure_services(layer, base, project)
+
+    ui.section("Generating Program.cs")
+    generate_program_cs(base, project)
+
+    ui.section("Generating Docker files")
+    generate_dockerfile(base)
+    generate_docker_compose(base, project)
+
+    ui.section("Generating config files")
+    generate_env(base, project)
+    generate_appsettings(base, project)
+    generate_appsettings_development(base, project)
+
+    ui.section("Generating API layer")
+    generate_api_structure(base, project)
+
+    ui.section("Generating layer files")
+    generate_application_layer(base, project)
+    generate_domain_layer(base, project)
+    generate_infrastructure_layer(base, project)
+    generate_persistence_layer(base, project)
+
+    ui.section("Generating solution file")
+    generate_sln(base, project)
+
+    ui.section("Generating .gitignore")
+    generate_gitignore(base)
+
+    ui.section("Generating GitHub workflow")
+    generate_github_workflow(base)
+
+    ui.section("Initializing Git repository")
+    git_init(base, project)
+
+    ui.done()

stackforge/project_name.py

@@ -1,34 +1,34 @@
-import re
-
-_CAMEL_PARTS = re.compile(r"[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\b)|\d+")
-
-
-def is_valid_project_name(name: str) -> bool:
-    if not name or not name[0].isalpha():
-        return False
-    if not re.fullmatch(r"[A-Za-z0-9_-]+", name):
-        return False
-    if name.startswith(("-", "_")) or name.endswith(("-", "_")):
-        return False
-    if "__" in name or "--" in name:
-        return False
-    return True
-
-
-def _title_part(part: str) -> str:
-    if not part:
-        return ""
-    if part.isdigit():
-        return part
-    return part[0].upper() + part[1:]
-
-
-def to_pascal_case(name: str) -> str:
-    if "_" in name:
-        parts = name.split("_")
-    elif "-" in name:
-        parts = name.split("-")
-    else:
-        parts = _CAMEL_PARTS.findall(name) or [name]
-
-    return "".join(_title_part(part) for part in parts if part)
+import re
+
+_CAMEL_PARTS = re.compile(r"[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\b)|\d+")
+
+
+def is_valid_project_name(name: str) -> bool:
+    if not name or not name[0].isalpha():
+        return False
+    if not re.fullmatch(r"[A-Za-z0-9_-]+", name):
+        return False
+    if name.startswith(("-", "_")) or name.endswith(("-", "_")):
+        return False
+    if "__" in name or "--" in name:
+        return False
+    return True
+
+
+def _title_part(part: str) -> str:
+    if not part:
+        return ""
+    if part.isdigit():
+        return part
+    return part[0].upper() + part[1:]
+
+
+def to_pascal_case(name: str) -> str:
+    if "_" in name:
+        parts = name.split("_")
+    elif "-" in name:
+        parts = name.split("-")
+    else:
+        parts = _CAMEL_PARTS.findall(name) or [name]
+
+    return "".join(_title_part(part) for part in parts if part)