@atlashub/smartstack-cli 1.36.0 → 2.0.0

package/templates/mcp-scaffolding/tests/validator.test.cs.hbs

@@ -0,0 +1,428 @@
+{{!-- SmartStack Validator Test Template --}}
+{{!-- Generates unit tests for FluentValidation validators following SmartStack conventions --}}
+
+using FluentAssertions;
+using FluentValidation.TestHelper;
+using Xunit;
+using {{namespace}}.Application.DTOs;
+using {{namespace}}.Application.Validators;
+
+namespace {{namespace}}.Tests.Unit.Validators;
+
+/// <summary>
+/// Unit tests for <see cref="{{name}}Validator"/>.
+/// Follows SmartStack testing conventions: {Method}_When{Condition}_Should{Result}
+/// </summary>
+public class {{name}}ValidatorTests
+{
+    private readonly Create{{name}}RequestValidator _createValidator;
+    private readonly Update{{name}}RequestValidator _updateValidator;
+
+    public {{name}}ValidatorTests()
+    {
+        _createValidator = new Create{{name}}RequestValidator();
+        _updateValidator = new Update{{name}}RequestValidator();
+    }
+
+    #region Create Request - Code Validation
+
+    [Fact]
+    public void CreateValidator_WhenCodeIsValid_ShouldNotHaveErrors()
+    {
+        // Arrange
+        var request = new Create{{name}}Request { Code = "VALID-001" };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldNotHaveValidationErrorFor(x => x.Code);
+    }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("   ")]
+    public void CreateValidator_WhenCodeIsNullOrEmpty_ShouldHaveError(string? invalidCode)
+    {
+        // Arrange
+        var request = new Create{{name}}Request { Code = invalidCode! };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.Code)
+            .WithErrorMessage("*required*");
+    }
+
+    [Fact]
+    public void CreateValidator_WhenCodeExceedsMaxLength_ShouldHaveError()
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = new string('A', 101) // Exceeds 100 char limit
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.Code)
+            .WithErrorMessage("*100 characters*");
+    }
+
+    [Theory]
+    [InlineData("valid-code")]
+    [InlineData("VALID_CODE_123")]
+    [InlineData("Code.With.Dots")]
+    public void CreateValidator_WhenCodeHasValidFormat_ShouldNotHaveErrors(string validCode)
+    {
+        // Arrange
+        var request = new Create{{name}}Request { Code = validCode };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldNotHaveValidationErrorFor(x => x.Code);
+    }
+
+    [Theory]
+    [InlineData("code with spaces")]
+    [InlineData("code<script>")]
+    [InlineData("code;drop")]
+    public void CreateValidator_WhenCodeHasInvalidCharacters_ShouldHaveError(string invalidCode)
+    {
+        // Arrange
+        var request = new Create{{name}}Request { Code = invalidCode };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.Code)
+            .WithErrorMessage("*invalid characters*");
+    }
+
+    #endregion
+
+    #region Create Request - Name Validation
+
+    [Fact]
+    public void CreateValidator_WhenNameIsValid_ShouldNotHaveErrors()
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            Name = "Valid Name"
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldNotHaveValidationErrorFor(x => x.Name);
+    }
+
+    [Fact]
+    public void CreateValidator_WhenNameExceedsMaxLength_ShouldHaveError()
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            Name = new string('A', 256) // Exceeds 255 char limit
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.Name)
+            .WithErrorMessage("*255 characters*");
+    }
+
+    #endregion
+
+    #region Update Request Validation
+
+    [Fact]
+    public void UpdateValidator_WhenValidData_ShouldNotHaveErrors()
+    {
+        // Arrange
+        var request = new Update{{name}}Request
+        {
+            Name = "Updated Name",
+            // Add other updatable properties
+        };
+
+        // Act
+        var result = _updateValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldNotHaveAnyValidationErrors();
+    }
+
+    [Fact]
+    public void UpdateValidator_WhenOptionalFieldsAreNull_ShouldNotHaveErrors()
+    {
+        // Arrange
+        var request = new Update{{name}}Request
+        {
+            Name = null, // Optional field can be null
+        };
+
+        // Act
+        var result = _updateValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldNotHaveAnyValidationErrors();
+    }
+
+    #endregion
+
+    #region Date Validation (if applicable)
+
+    [Fact]
+    public void CreateValidator_WhenStartDateIsInPast_ShouldHaveError()
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            StartDate = DateTime.UtcNow.AddDays(-1)
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.StartDate)
+            .WithErrorMessage("*future*");
+    }
+
+    [Fact]
+    public void CreateValidator_WhenEndDateBeforeStartDate_ShouldHaveError()
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            StartDate = DateTime.UtcNow.AddDays(10),
+            EndDate = DateTime.UtcNow.AddDays(5)
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.EndDate)
+            .WithErrorMessage("*after start date*");
+    }
+
+    #endregion
+
+    #region Numeric Validation (if applicable)
+
+    [Theory]
+    [InlineData(-1)]
+    [InlineData(-100)]
+    public void CreateValidator_WhenQuantityIsNegative_ShouldHaveError(int invalidQuantity)
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            Quantity = invalidQuantity
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.Quantity)
+            .WithErrorMessage("*greater than*0*");
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(1000)]
+    public void CreateValidator_WhenQuantityIsValid_ShouldNotHaveErrors(int validQuantity)
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            Quantity = validQuantity
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldNotHaveValidationErrorFor(x => x.Quantity);
+    }
+
+    #endregion
+
+    #region Email Validation (if applicable)
+
+    [Theory]
+    [InlineData("valid@example.com")]
+    [InlineData("user.name@domain.org")]
+    [InlineData("user+tag@example.co.uk")]
+    public void CreateValidator_WhenEmailIsValid_ShouldNotHaveErrors(string validEmail)
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            Email = validEmail
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldNotHaveValidationErrorFor(x => x.Email);
+    }
+
+    [Theory]
+    [InlineData("invalid")]
+    [InlineData("invalid@")]
+    [InlineData("@invalid.com")]
+    [InlineData("invalid@.com")]
+    public void CreateValidator_WhenEmailIsInvalid_ShouldHaveError(string invalidEmail)
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            Email = invalidEmail
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.Email)
+            .WithErrorMessage("*valid email*");
+    }
+
+    #endregion
+
+    #region Collection Validation (if applicable)
+
+    [Fact]
+    public void CreateValidator_WhenItemsCollectionIsEmpty_ShouldHaveError()
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            Items = new List<string>()
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.Items)
+            .WithErrorMessage("*at least one item*");
+    }
+
+    [Fact]
+    public void CreateValidator_WhenItemsExceedMaxCount_ShouldHaveError()
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            Items = Enumerable.Range(1, 101).Select(i => $"Item-{i}").ToList()
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.Items)
+            .WithErrorMessage("*maximum*100*");
+    }
+
+    #endregion
+
+    #region Cross-Field Validation
+
+    [Fact]
+    public void CreateValidator_WhenDependentFieldsMissing_ShouldHaveError()
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            RequiresApproval = true,
+            ApproverEmail = null // Required when RequiresApproval is true
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.ApproverEmail)
+            .WithErrorMessage("*required when*");
+    }
+
+    #endregion
+
+    #region Security Validation
+
+    [Theory]
+    [InlineData("<script>alert('xss')</script>")]
+    [InlineData("'; DROP TABLE Users; --")]
+    [InlineData("{{'{{'}}constructor{{'}}'}}")]
+    public void CreateValidator_WhenInputContainsMaliciousContent_ShouldHaveError(string maliciousInput)
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "TEST",
+            Description = maliciousInput
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.ShouldHaveValidationErrorFor(x => x.Description)
+            .WithErrorMessage("*invalid characters*");
+    }
+
+    #endregion
+
+    #region Error Message Format
+
+    [Fact]
+    public void CreateValidator_WhenMultipleErrors_ShouldReturnAllErrors()
+    {
+        // Arrange
+        var request = new Create{{name}}Request
+        {
+            Code = "",     // Invalid
+            Name = new string('A', 500), // Too long
+        };
+
+        // Act
+        var result = _createValidator.TestValidate(request);
+
+        // Assert
+        result.Errors.Should().HaveCountGreaterThan(1);
+        result.ShouldHaveValidationErrorFor(x => x.Code);
+        result.ShouldHaveValidationErrorFor(x => x.Name);
+    }
+
+    #endregion
+}

package/templates/ralph/README.md

@@ -27,15 +27,15 @@ Edit `ralph.config.yaml` to customize:
 
 Ralph **requires** these MCP servers to function:
 
-### 1. Download MCP packages
+### 1. Install packages
 ```bash
-npm install -g @atlashub/smartstack-mcp
+npm install -g @atlashub/smartstack-cli
 npm install -g @upstash/context7-mcp
 ```
 
 ### 2. Register in Claude Code
 ```bash
-claude mcp add smartstack -- npx @atlashub/smartstack-mcp
+claude mcp add smartstack -- npx -p @atlashub/smartstack-cli smartstack-mcp
 claude mcp add context7 -- npx @upstash/context7-mcp
 ```
 

package/templates/ralph/ralph.config.yaml

@@ -13,8 +13,8 @@ mcp:
       health_check: true
 
     - name: smartstack
-      description: "SmartStack validation and scaffolding"
-      install_command: "npm install -g @atlashub/smartstack-mcp && claude mcp add smartstack -- npx @atlashub/smartstack-mcp"
+      description: "SmartStack validation and scaffolding (bundled in CLI)"
+      install_command: "claude mcp add smartstack -- npx -p @atlashub/smartstack-cli smartstack-mcp"
       health_check: true
 
   # Behavior when MCP is unavailable

package/templates/skills/admin/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: admin
+description: Admin account management - reset passwords, manage local admin accounts
+argument-hint: "<subcommand> [options]"
+disable-model-invocation: true
+---
+
+<objective>
+Manage SmartStack admin accounts. Wraps the `smartstack admin` CLI command with guided workflows.
+
+**WARNING:** This skill modifies database records directly. Always confirm before executing.
+</objective>
+
+<quick_start>
+```bash
+/admin reset              # Reset local admin password (guided)
+/admin reset --force      # Reset without confirmation
+```
+</quick_start>
+
+<workflow>
+
+## Subcommands
+
+| Command | Description |
+|---------|-------------|
+| `/admin reset` | Reset the localAdmin account password |
+
+## /admin reset
+
+1. **Detect SmartStack.app** - Look for `.smartstack/config.json` or `SmartStack.Api/` directory
+2. **Run CLI command:**
+   ```bash
+   smartstack admin reset
+   ```
+3. **If `--force` flag passed:**
+   ```bash
+   smartstack admin reset --force
+   ```
+4. **Report result** - Show new credentials or error message
+
+</workflow>