@atlashub/smartstack-cli 3.36.0 → 3.38.0

package/templates/skills/efcore/references/both-contexts.md

@@ -0,0 +1,32 @@
+# Both Contexts Deployment
+
+When `RUN_BOTH=true` (auto-detected for client projects with SmartStack NuGet):
+
+```bash
+# 1. Deploy CoreDbContext first (system tables: Users, Roles, Tenants...)
+echo "=== Deploying CoreDbContext (core schema) ==="
+DBCONTEXT="CoreDbContext"
+SCHEMA="core"
+# Run steps 2-6 with CoreDbContext...
+
+dotnet ef database update \
+  --context "CoreDbContext" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT" \
+  --verbose
+
+# 2. Then ExtensionsDbContext (client tables)
+echo ""
+echo "=== Deploying ExtensionsDbContext (extensions schema) ==="
+DBCONTEXT="ExtensionsDbContext"
+SCHEMA="extensions"
+# Run steps 2-6 with ExtensionsDbContext...
+
+dotnet ef database update \
+  --context "ExtensionsDbContext" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT" \
+  --verbose
+```
+
+**Order matters:** Core MUST be deployed first (Extensions may have foreign keys to Core tables).

package/templates/skills/efcore/references/database-operations.md

@@ -0,0 +1,67 @@
+# Database Operations
+
+## Common Validation Checks
+
+### Check Required Variables
+
+```bash
+# Validate required variables from step-00-init
+for VAR_NAME in DBCONTEXT DBCONTEXT_TYPE INFRA_PROJECT STARTUP_PROJECT SELECTED_ENV; do
+  eval VAR_VALUE=\$$VAR_NAME
+  if [ -z "$VAR_VALUE" ]; then
+    echo "ERROR: Required variable $VAR_NAME is not set"
+    echo "Run step-00-init first"
+    exit 1
+  fi
+done
+```
+
+## Backup Command
+
+```bash
+BACKUP_DIR=".claude/gitflow/backup/database"
+mkdir -p "$BACKUP_DIR"
+
+BACKUP_FILE="$BACKUP_DIR/${DATABASE_NAME}_$(date +%Y%m%d_%H%M%S).bak"
+
+echo "Creating backup: $BACKUP_FILE"
+
+sqlcmd -S "$SERVER_NAME" -E -Q "BACKUP DATABASE [$DATABASE_NAME] TO DISK='$BACKUP_FILE'"
+
+if [ $? -eq 0 ]; then
+  echo "Backup created: $BACKUP_FILE"
+else
+  echo "WARNING: Backup failed. Continue anyway?"
+fi
+```
+
+## Connection Test
+
+```bash
+CONNECTION_TEST=$(dotnet ef database list \
+  --context "$DBCONTEXT" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT" 2>&1)
+
+if [ $? -eq 0 ]; then
+  echo "Connection:  OK"
+else
+  echo "Connection:  FAILED"
+  echo ""
+  echo "$CONNECTION_TEST"
+fi
+```
+
+## Migration Count Utilities
+
+```bash
+# Count applied and pending
+MIGRATION_OUTPUT=$(dotnet ef migrations list \
+  --context "$DBCONTEXT" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT" 2>/dev/null)
+
+APPLIED=$(echo "$MIGRATION_OUTPUT" | grep -v "(Pending)" | grep -c "^[0-9]" || echo "0")
+PENDING=$(echo "$MIGRATION_OUTPUT" | grep -c "(Pending)" || echo "0")
+TOTAL=$((APPLIED + PENDING))
+```

package/templates/skills/efcore/references/destructive-operations.md

@@ -0,0 +1,38 @@
+# Destructive Operations & Zero-Downtime Patterns
+
+When a migration contains destructive operations (DropColumn, RenameColumn, AlterColumn, DropTable), consider zero-downtime patterns for production deployments.
+
+## Detection
+
+Migration Analysis counts:
+- DropColumn
+- RenameColumn
+- AlterColumn
+- DropTable
+
+If any count > 0, display warning and reference this document.
+
+## Zero-Downtime Patterns
+
+For production deployments with destructive operations:
+
+1. **Add → Populate → Migrate → Remove** (for column renames)
+   - Add new column
+   - Populate from old column
+   - Deploy migration
+   - Remove old column in next deployment window
+
+2. **Feature Flags** (for table changes)
+   - Add feature flag
+   - Deploy new code path
+   - Migrate data
+   - Remove old code path after stabilization
+
+3. **Gradual Rollout**
+   - Deploy to staging first
+   - Monitor for issues
+   - Gradually roll to production clusters
+
+## Reference
+
+See OWASP and database migration best practices for your platform.

package/templates/skills/efcore/references/reset-operations.md

@@ -0,0 +1,81 @@
+# Database Reset Operations
+
+## Drop Database
+
+```bash
+echo ""
+echo "Dropping database..."
+
+dotnet ef database drop \
+  --context "$DBCONTEXT" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT" \
+  --force
+EXIT_CODE=$?
+
+if [ $EXIT_CODE -ne 0 ]; then
+  echo "ERROR: Drop failed (exit code: $EXIT_CODE)"
+  echo "Database may be in use. Close connections and retry."
+  exit 1
+fi
+
+echo "Database dropped."
+```
+
+## Recreate + Apply Migrations
+
+```bash
+echo ""
+echo "Recreating database with migrations..."
+
+dotnet ef database update \
+  --context "$DBCONTEXT" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT" \
+  --verbose
+EXIT_CODE=$?
+
+if [ $EXIT_CODE -ne 0 ]; then
+  echo ""
+  echo "ERROR: Recreation failed (exit code: $EXIT_CODE)"
+  exit 1
+fi
+
+echo "Database recreated."
+```
+
+## Summary After Reset
+
+```bash
+MIGRATION_COUNT=$(dotnet ef migrations list \
+  --context "$DBCONTEXT" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT" 2>/dev/null | \
+  grep -c "^[0-9]" || echo "0")
+
+echo ""
+echo "==========================================="
+echo "RESET COMPLETE"
+echo "==========================================="
+echo ""
+echo "Database:    $DATABASE_NAME"
+echo "Environment: $SELECTED_ENV"
+echo "DbContext:   $DBCONTEXT"
+echo ""
+echo "Operations:"
+echo "  - Drop: OK"
+echo "  - Create: OK"
+echo "  - Migrations: $MIGRATION_COUNT applied"
+if [ -n "$BACKUP_FILE" ]; then
+echo "  - Backup: $BACKUP_FILE"
+fi
+echo ""
+echo "Compliance:  EF Core CLI only"
+echo ""
+echo "==========================================="
+echo ""
+echo "Next steps:"
+echo "  /efcore db-status    # Verify status"
+echo "  /efcore db-seed      # Add test data"
+echo ""
+```

package/templates/skills/efcore/references/seed-methods.md

@@ -0,0 +1,86 @@
+# Seed Methods Detection & Execution
+
+## Detect Available Seed Methods
+
+```bash
+echo ""
+echo "Detecting seed methods..."
+
+SEED_METHODS=""
+
+# HasData() in configurations (RECOMMENDED)
+if grep -rq "\.HasData(" . --include="*.cs" 2>/dev/null; then
+  SEED_METHODS+=" hasdata"
+  echo "  - HasData(): Found"
+fi
+
+# IDataSeeder classes
+if grep -rq "IDataSeeder\|class.*Seeder" . --include="*.cs" 2>/dev/null; then
+  SEED_METHODS+=" seeder-class"
+  echo "  - Seeder classes: Found"
+fi
+
+# --seed CLI argument
+if grep -q "\-\-seed" ./src/*/Program.cs 2>/dev/null; then
+  SEED_METHODS+=" cli-argument"
+  echo "  - CLI --seed: Found"
+fi
+
+# WARNING: SQL scripts detected
+if [ -f "./scripts/seed.sql" ] || find . -name "seed*.sql" 2>/dev/null | grep -q .; then
+  echo ""
+  echo "WARNING: SQL seed scripts detected - FORBIDDEN by conventions"
+  echo "Migrate to HasData() or IDataSeeder"
+fi
+
+if [ -z "$SEED_METHODS" ]; then
+  echo "  No seed methods found"
+fi
+```
+
+## Execute Seed - HasData
+
+```bash
+echo ""
+echo "HasData is applied via migrations."
+echo "Running database update to ensure all HasData is applied..."
+
+dotnet ef database update \
+  --context "$DBCONTEXT" \
+  --project "$INFRA_PROJECT" \
+  --startup-project "$STARTUP_PROJECT"
+```
+
+## Execute Seed - Seeder Class
+
+```bash
+echo ""
+echo "Running seeder class..."
+
+dotnet run --project "$STARTUP_PROJECT" -- --seed
+EXIT_CODE=$?
+
+if [ $EXIT_CODE -ne 0 ]; then
+  echo "Seed command failed or not supported (exit code: $EXIT_CODE)"
+  echo "Check if --seed argument is implemented in Program.cs"
+fi
+```
+
+## Execute Seed - CLI Argument
+
+```bash
+echo ""
+echo "Running application with --seed..."
+
+dotnet run --project "$STARTUP_PROJECT" -- --seed
+```
+
+## Verify Seed Data
+
+```bash
+echo ""
+echo "Verifying seed data..."
+
+# Quick check - count records in key tables
+# This is application-specific
+```

package/templates/skills/efcore/references/shared-init-functions.md

@@ -0,0 +1,250 @@
+# Shared Initialization Functions
+
+## Ensure dotnet ef Available (Platform-Aware)
+
+**CRITICAL:** On Windows (Git Bash, MSYS2), `dotnet ef` may not be on the shell PATH
+even though it's installed. This function fixes PATH before any EF Core command.
+
+```bash
+ensure_dotnet_ef() {
+  # Quick check: already available?
+  if dotnet ef --version &>/dev/null; then
+    DOTNET_EF_VERSION=$(dotnet ef --version 2>/dev/null)
+    echo "dotnet-ef: $DOTNET_EF_VERSION"
+    return 0
+  fi
+
+  echo "dotnet-ef not on PATH, attempting platform-aware fix..."
+
+  # Try all known .NET global tools locations
+  # - $USERPROFILE/.dotnet/tools  → Windows via Git Bash (USERPROFILE=C:\Users\xxx)
+  # - $HOME/.dotnet/tools         → Linux/macOS or Git Bash fallback
+  # - $LOCALAPPDATA/Microsoft/dotnet/tools → Windows alternate location
+  for TOOLS_DIR in \
+    "$USERPROFILE/.dotnet/tools" \
+    "$HOME/.dotnet/tools" \
+    "$LOCALAPPDATA/Microsoft/dotnet/tools"; do
+    if [ -n "$TOOLS_DIR" ] && [ -d "$TOOLS_DIR" ]; then
+      export PATH="$TOOLS_DIR:$PATH"
+      echo "  PATH += $TOOLS_DIR"
+    fi
+  done
+
+  # Verify after PATH fix
+  if dotnet ef --version &>/dev/null; then
+    DOTNET_EF_VERSION=$(dotnet ef --version 2>/dev/null)
+    echo "dotnet-ef: $DOTNET_EF_VERSION (found after PATH fix)"
+    return 0
+  fi
+
+  echo "ERROR: dotnet-ef not available"
+  echo "Install with: dotnet tool install --global dotnet-ef"
+  echo ""
+  echo "If installed but not found, check:"
+  echo "  Windows: %USERPROFILE%\\.dotnet\\tools must be in PATH"
+  echo "  Linux:   ~/.dotnet/tools must be in PATH"
+  exit 1
+}
+
+ensure_dotnet_ef
+```
+
+**IMPORTANT — WSL pitfall:**
+If the shell resolves `$HOME` to `/home/{user}` (WSL path) instead of `/c/Users/{user}` (Git Bash),
+the .NET SDK may not be found even if `dotnet-ef` is. Use `$USERPROFILE` first on Windows.
+
+## Detect EF Core Project
+
+```bash
+detect_efcore_project() {
+  # Find project with EF Core reference
+  CSPROJ=$(find . -name "*.csproj" -exec grep -l "Microsoft.EntityFrameworkCore" {} \; | head -1)
+
+  if [ -z "$CSPROJ" ]; then
+    echo "ERROR: No EF Core project found"
+    exit 1
+  fi
+
+  PROJECT_DIR=$(dirname "$CSPROJ")
+  PROJECT_NAME=$(basename "$CSPROJ" .csproj)
+  MIGRATIONS_DIR="$PROJECT_DIR/Persistence/Migrations"
+
+  # Find startup and infrastructure projects
+  STARTUP_PROJECT=$(find . -name "*.Api.csproj" -o -name "*Web.csproj" | head -1)
+  INFRA_PROJECT=$(find . -name "*Infrastructure.csproj" | head -1)
+  [ -z "$INFRA_PROJECT" ] && INFRA_PROJECT="$CSPROJ"
+
+  echo "Project: $PROJECT_NAME"
+  echo "Migrations: $MIGRATIONS_DIR"
+}
+```
+
+## Detect DbContext (Core vs Extensions)
+
+```bash
+detect_dbcontext() {
+  # Priority 1: SmartStack.Domain exists → SmartStack source project (Core only)
+  if find . -type d -name "SmartStack.Domain" | grep -q .; then
+    DBCONTEXT="CoreDbContext"
+    DBCONTEXT_TYPE="core"
+    SCHEMA="core"
+    RUN_BOTH=false
+    echo "DbContext: CoreDbContext (SmartStack.Domain found)"
+    return
+  fi
+
+  # Priority 2: Client project with SmartStack NuGet → BOTH contexts
+  if find . -name "*.csproj" -exec grep -ql "PackageReference.*SmartStack" {} \; 2>/dev/null; then
+    DBCONTEXT="CoreDbContext"
+    DBCONTEXT_TYPE="both"
+    SCHEMA="core"
+    RUN_BOTH=true
+    echo "DbContext: Both (Core from SmartStack NuGet + Extensions local)"
+    echo "  Deploy order: CoreDbContext → ExtensionsDbContext"
+    return
+  fi
+
+  # Priority 3: Scan for DbContext in code
+  CORE_CTX=$(find . -name "*.cs" -exec grep -l "CoreDbContext" {} \; 2>/dev/null | head -1)
+  EXT_CTX=$(find . -name "*.cs" -exec grep -l "ExtensionsDbContext" {} \; 2>/dev/null | head -1)
+
+  if [ -n "$CORE_CTX" ] && [ -n "$EXT_CTX" ]; then
+    DBCONTEXT="CoreDbContext"
+    DBCONTEXT_TYPE="both"
+    SCHEMA="core"
+    RUN_BOTH=true
+    echo "DbContext: Both (CoreDbContext + ExtensionsDbContext found)"
+  elif [ -n "$CORE_CTX" ] && [ -z "$EXT_CTX" ]; then
+    DBCONTEXT="CoreDbContext"
+    DBCONTEXT_TYPE="core"
+    SCHEMA="core"
+    RUN_BOTH=false
+  elif [ -z "$CORE_CTX" ] && [ -n "$EXT_CTX" ]; then
+    DBCONTEXT="ExtensionsDbContext"
+    DBCONTEXT_TYPE="extensions"
+    SCHEMA="extensions"
+    RUN_BOTH=false
+  else
+    DBCONTEXT=""
+    DBCONTEXT_TYPE=""
+    SCHEMA=""
+    RUN_BOTH=false
+  fi
+}
+```
+
+## Detect Environment
+
+```bash
+detect_environment() {
+  API_DIR=$(find . -type d -name "*.Api" | head -1)
+  [ -z "$API_DIR" ] && API_DIR="src/SmartStack.Api"
+
+  # Priority: --env flag > appsettings.Local.json > error
+  if [ -n "$ENV_FLAG" ]; then
+    CONFIG_FILE="$API_DIR/appsettings.${ENV_FLAG}.json"
+  elif [ -f "$API_DIR/appsettings.Local.json" ]; then
+    CONFIG_FILE="$API_DIR/appsettings.Local.json"
+    SELECTED_ENV="Local"
+  else
+    echo "ERROR: No appsettings.Local.json found"
+    echo "Create one or use --env flag"
+    exit 1
+  fi
+
+  echo "Environment: $SELECTED_ENV"
+  echo "Config: $CONFIG_FILE"
+}
+```
+
+## Determine Base Branch
+
+```bash
+determine_base_branch() {
+  CURRENT_BRANCH=$(git branch --show-current)
+
+  case "$CURRENT_BRANCH" in
+    feature/*)
+      BASE_BRANCH="develop"
+      BRANCH_TYPE="feature"
+      ;;
+    release/*)
+      BASE_BRANCH="main"
+      BRANCH_TYPE="release"
+      ;;
+    hotfix/*)
+      BASE_BRANCH="main"
+      BRANCH_TYPE="hotfix"
+      ;;
+    develop)
+      BASE_BRANCH="main"
+      BRANCH_TYPE="develop"
+      ;;
+    main|master)
+      echo "ERROR: Cannot run on main/master branch"
+      exit 1
+      ;;
+    *)
+      BASE_BRANCH="develop"
+      BRANCH_TYPE="unknown"
+      ;;
+  esac
+
+  echo "Branch: $CURRENT_BRANCH ($BRANCH_TYPE)"
+  echo "Base: $BASE_BRANCH"
+}
+```
+
+## Block Production
+
+```bash
+block_production() {
+  # Check for production indicators (case-insensitive)
+  if grep -qi '"Production"' "$CONFIG_FILE" 2>/dev/null; then
+    echo "BLOCKED: Production environment detected in $CONFIG_FILE"
+    exit 1
+  fi
+
+  # Case-insensitive database name check
+  DB_LOWER=$(echo "$DATABASE_NAME" | tr '[:upper:]' '[:lower:]')
+  if [[ "$DB_LOWER" == *"prod"* ]] || [[ "$DB_LOWER" == *"production"* ]]; then
+    echo "BLOCKED: Production database detected ($DATABASE_NAME)"
+    exit 1
+  fi
+
+  # Environment name check (case-insensitive)
+  ENV_LOWER=$(echo "$SELECTED_ENV" | tr '[:upper:]' '[:lower:]')
+  if [[ "$ENV_LOWER" == "production" ]] || [[ "$ENV_LOWER" == "prod" ]]; then
+    echo "BLOCKED: Production environment selected ($SELECTED_ENV)"
+    exit 1
+  fi
+}
+```
+
+## Dual Context Helper
+
+```bash
+# Helper for steps that need to run for both contexts when RUN_BOTH=true
+# Usage: run_for_contexts "command_or_function"
+# Executes with CoreDbContext first, then ExtensionsDbContext
+# Maintains deploy order constraint: Core MUST run first
+
+run_for_contexts() {
+  if [ "$RUN_BOTH" = "true" ]; then
+    echo "=== Running for CoreDbContext (core schema) ==="
+    DBCONTEXT="CoreDbContext"
+    DBCONTEXT_TYPE="core"
+    SCHEMA="core"
+    eval "$1"
+
+    echo ""
+    echo "=== Running for ExtensionsDbContext (extensions schema) ==="
+    DBCONTEXT="ExtensionsDbContext"
+    DBCONTEXT_TYPE="extensions"
+    SCHEMA="extensions"
+    eval "$1"
+  else
+    eval "$1"
+  fi
+}
+```

package/templates/skills/efcore/references/sql-objects-injection.md

@@ -0,0 +1,61 @@
+# SQL Objects Injection
+
+EF Core does NOT generate DDL for TVF, views, and stored procedures.
+SQL source scripts are in `Persistence/SqlObjects/` (Embedded Resources).
+After a migration/squash/rebase, they must be re-injected into the consolidated migration.
+
+## Injection Process
+
+```bash
+# Check if SqlObjects folder exists with .sql files
+SQL_OBJECTS_DIR="$INFRA_PROJECT_DIR/Persistence/SqlObjects"
+SQL_FILES=$(find "$SQL_OBJECTS_DIR" -name "*.sql" 2>/dev/null | wc -l)
+
+if [ "$SQL_FILES" -gt 0 ]; then
+  echo ""
+  echo "Found $SQL_FILES SQL object(s) in SqlObjects/"
+  echo "Injecting SqlObjectHelper.ApplyAll(migrationBuilder) into migration..."
+
+  # Validate migration file path before sed operations
+  if [ ! -f "$MIGRATION_FILE" ]; then
+    echo "ERROR: Migration file not found: $MIGRATION_FILE"
+    exit 1
+  fi
+  if ! echo "$MIGRATION_FILE" | grep -qE '\.cs$'; then
+    echo "ERROR: Invalid migration file path (not .cs): $MIGRATION_FILE"
+    exit 1
+  fi
+
+  # Add using directive if not present
+  if ! grep -q "using SmartStack.Infrastructure.Persistence.SqlObjects;" "$MIGRATION_FILE"; then
+    sed -i '1s/^/using SmartStack.Infrastructure.Persistence.SqlObjects;\n/' "$MIGRATION_FILE"
+  fi
+
+  # Add SqlObjectHelper.ApplyAll at the end of Up() method
+  sed -i '/protected override void Up/,/^        }/ {
+    /^        }/ i\
+\            // Apply SQL objects (TVF, Views, SP) from embedded resources\
+\            SqlObjectHelper.ApplyAll(migrationBuilder);
+  }' "$MIGRATION_FILE"
+
+  # Verify injection succeeded (fallback to manual step if sed pattern didn't match)
+  if ! grep -q "SqlObjectHelper.ApplyAll" "$MIGRATION_FILE"; then
+    echo "WARNING: Automatic injection failed (indentation pattern may differ)"
+    echo ""
+    echo "MANUAL STEP REQUIRED: Add these lines inside the Up() method before the closing brace:"
+    echo '    using SmartStack.Infrastructure.Persistence.SqlObjects;'
+    echo '    ...'
+    echo '    SqlObjectHelper.ApplyAll(migrationBuilder);'
+    echo ""
+    echo "File: $MIGRATION_FILE"
+  else
+    echo "  SqlObjectHelper.ApplyAll(migrationBuilder) injected"
+  fi
+  find "$SQL_OBJECTS_DIR" -name "*.sql" -exec basename {} \; | while read f; do
+    echo "  - $f"
+  done
+else
+  echo ""
+  echo "No SQL objects found in SqlObjects/ - skipping injection"
+fi
+```

package/templates/skills/efcore/references/troubleshooting.md

@@ -0,0 +1,81 @@
+# EF Core Troubleshooting
+
+## Database Status
+
+### Troubleshooting (if connection fails)
+
+```
+TROUBLESHOOTING
+├── SQL Server running?
+├── appsettings.Local.json configured?
+├── Database exists?
+└── Commands: /efcore db-reset, /efcore db-deploy
+```
+
+## Deploy Errors
+
+| Error | Resolution |
+|-------|------------|
+| Connection failed | Check SQL Server, credentials |
+| Migration error | Review migration, consider reset |
+| Constraint violation | Check data, may need seed |
+
+## Reset Protections
+
+| Protection | Description |
+|------------|-------------|
+| Env Display | Shows database BEFORE confirmation |
+| Confirmation | Explicit request with database NAME |
+| Production Block | Blocks if Production detected |
+| EF Core Only | No raw SQL |
+
+## Seed Setup Guide
+
+If no seed methods detected, display guide:
+
+```
+SEED SETUP GUIDE
+================
+
+Option 1: HasData() in Configuration (RECOMMENDED)
+--------------------------------------------------
+// In UserConfiguration.cs
+builder.HasData(new User {
+    Id = Guid.Parse("7f3c9a2e-8d1b-4e5f-a6c8-9b4d2f7e1a3c"),
+    Name = "Admin",
+    Email = "admin@example.com"
+});
+
+// Then run:
+dotnet ef migrations add SeedData
+
+Option 2: IDataSeeder Class
+---------------------------
+public class UserSeeder : IDataSeeder
+{
+    public async Task SeedAsync(DbContext context)
+    {
+        if (!await context.Users.AnyAsync())
+        {
+            context.Users.Add(new User { ... });
+            await context.SaveChangesAsync();
+        }
+    }
+}
+
+// Register in Program.cs and call via --seed argument
+```
+
+## Migration from SQL
+
+```csharp
+// BEFORE (FORBIDDEN): scripts/seed.sql
+INSERT INTO Users (Id, Name) VALUES (1, 'Admin');
+
+// AFTER (CORRECT): UserConfiguration.cs
+builder.HasData(new User {
+    Id = Guid.Parse("7f3c9a2e-8d1b-4e5f-a6c8-9b4d2f7e1a3c"),
+    Name = "Admin"
+});
+// Then: dotnet ef migrations add SeedData
+```