NcDanilo.UserLibrary 1.2.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 securely hashed with BCrypt 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 .NET CLI:

dotnet add package NcDanilo.UserLibrary

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

Configuration

The library reads its settings from an AppConfiguration object 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,  -- BCrypt 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                 # JWT generation utility

Models & DTOs

User / UserDto

AccessToken

RefreshToken

Interfaces

Dependencies

License

This project is licensed under the MIT License — see LICENSE for details.