NcDanilo.UserLibrary 1.1.2

NcDanilo.UserLibrary

A .NET class library that provides ready-to-use services and repositories for user management, role management, and JWT-based authentication (access token + refresh token) backed by a SQL Server database.

Table of Contents

• Features
• Target Frameworks
• Installation
• Configuration
• Database Setup
• Getting Started
  • Registering Services (Dependency Injection)
  • User Registration
  • User Login
  • Role Management
  • Token Validation
• Project Structure
• Models & DTOs
• Interfaces
• Dependencies
• License

Features

• User management — create, read (by ID or email), update, soft-delete users.
• Role management — create, read, update, soft-delete roles.
• JWT access tokens — signed with HMAC-SHA256, expire after 15 minutes, carrying standard claims (id, email, given name, surname, role).
• Refresh tokens — persisted to SQL Server, expire after 7 days, support revocation.
• Password hashing — passwords are hashed with SHA-256 before storage.
• Fully async — all I/O operations are async/await with CancellationToken support.
• Interface-driven — every component is hidden behind an interface, making it easy to mock and test.

Target Frameworks

Installation

Install via the NuGet Package Manager or the .NET CLI:

dotnet add package NcDanilo.UserLibrary

Or search for NcDanilo.UserLibrary in the Visual Studio NuGet UI.

Configuration

The library reads its settings from an AppConfiguration object that is expected to be injected via IOptions<AppConfiguration>.

appsettings.json example

{
  "AppConfiguration": {
    "ConnectionString": "Server=localhost;Database=MyDb;Trusted_Connection=True;",
    "SecretKey": "your-very-secret-key-at-least-32-chars",
    "Issuer": "https://yourapp.com",
    "Audience": "https://yourapp.com"
  }
}

Database Setup

The library expects the following tables to exist in your SQL Server database.

Roles

CREATE TABLE Roles (
    Id       UNIQUEIDENTIFIER PRIMARY KEY,
    Name     NVARCHAR(100)    NOT NULL,
    Status   INT              NOT NULL DEFAULT 0  -- 0 = Enabled, 1 = Disabled
);

Users

CREATE TABLE Users (
    Id          UNIQUEIDENTIFIER PRIMARY KEY,
    FirstName   NVARCHAR(100)    NOT NULL,
    LastName    NVARCHAR(100)    NOT NULL,
    Email       NVARCHAR(256)    NOT NULL UNIQUE,
    Password    NVARCHAR(512)    NOT NULL,  -- SHA-256 base64 hash
    Status      INT              NOT NULL DEFAULT 0,
    BirthDate   DATETIME2        NOT NULL,
    RoleId      UNIQUEIDENTIFIER NOT NULL REFERENCES Roles(Id)
);

RefreshTokens

CREATE TABLE RefreshTokens (
    Id          UNIQUEIDENTIFIER PRIMARY KEY,
    UserId      UNIQUEIDENTIFIER NOT NULL,
    Token       NVARCHAR(512)    NOT NULL,
    Expiration  DATETIME2        NOT NULL,
    IsRevoked   BIT              NOT NULL DEFAULT 0
);

Note: "Delete" operations on both Users and Roles are implemented as soft deletes — the Status column is set to 1 (Disabled) rather than removing the row.

Getting Started

Registering Services (Dependency Injection)

using Microsoft.Extensions.DependencyInjection;
using UserLibrary.Configuration;
using UserLibrary.Interface;
using UserLibrary.Repository;
using UserLibrary.Service;

var services = new ServiceCollection();

// Bind configuration
services.Configure<AppConfiguration>(
    builder.Configuration.GetSection("AppConfiguration"));

// Register repositories
services.AddScoped<IUserRepository, UserRepository>();
services.AddScoped<IRoleRepository, RoleRepository>();
services.AddScoped<IRefreshTokenRepository, RefreshTokenRepository>();

// Register services
services.AddScoped<IManageTokenService, ManageTokenService>();
services.AddScoped<IUserService, UserService>();

User Registration

var newUser = new UserDto
{
    FirstName = "John",
    LastName  = "Doe",
    Email     = "john.doe@example.com",
    Password  = "P@ssw0rd!",
    BirthDate = new DateTime(1990, 1, 1),
    Status    = Status.Enabled,
    Role      = new RoleDto { Id = existingRoleId }
};

UserDto registered = await userService.RegisterUser(newUser, CancellationToken.None);
// registered.Password is null — never returned after hashing

User Login

UserDto loggedIn = await userService.LoginUser(
    "john.doe@example.com",
    "P@ssw0rd!",
    CancellationToken.None);

Console.WriteLine(loggedIn.AccessToken.Token);       // JWT string
Console.WriteLine(loggedIn.AccessToken.Expiration);  // UTC +15 minutes
Console.WriteLine(loggedIn.RefreshToken.Token);      // Refresh token string

Throws UnauthorizedAccessException on invalid credentials or a bad refresh token.

Role Management

// Create
var role = new Role { Id = Guid.NewGuid(), RoleName = "Admin", Status = Status.Enabled };
bool created = await roleRepository.CreateRole(role, CancellationToken.None);

// Read
Role fetched = await roleRepository.GetRoleById(role.Id, CancellationToken.None);

// Update
fetched.RoleName = "SuperAdmin";
bool updated = await roleRepository.UpdateRole(fetched, CancellationToken.None);

// Soft-delete (sets Status = Disabled)
bool deleted = await roleRepository.DeleteRole(role.Id, CancellationToken.None);

Token Validation

bool isValid = await manageTokenService.ValidateRefreshToken(
    userDto.RefreshToken,
    CancellationToken.None);

Returns true only when the token exists in the database, has not been revoked, and has not expired.

Project Structure

UserLibrary/
├── Configuration/
│   └── AppConfiguration.cs       # Settings POCO (connection string, JWT params)
├── Dto/
│   ├── UserDto.cs                 # User data transfer object
│   └── RoleDto.cs                 # Role data transfer object
├── Interface/
│   ├── IUserRepository.cs
│   ├── IRoleRepository.cs
│   ├── IRefreshTokenRepository.cs
│   ├── IUserService.cs
│   └── IManageTokenService.cs
├── Model/
│   ├── User.cs
│   ├── Role.cs
│   ├── AccessToken.cs
│   ├── RefreshToken.cs
│   └── Status.cs                  # Enum: Enabled = 0, Disabled = 1
├── Repository/
│   ├── UserRepository.cs
│   ├── RoleRepository.cs
│   └── RefreshTokenRepository.cs
├── Service/
│   ├── UserService.cs
│   └── ManageTokenService.cs
└── TokenHelper.cs                 # Static SHA-256 hashing utility

Models & DTOs

User / UserDto

AccessToken

RefreshToken

Interfaces

Dependencies

License

This project is licensed under the MIT License.