open source Notesnook API

2026-02-12 19:22:45 +00:00 · 2022-12-28 16:20:25 +05:00
parent cf406454cd
commit d2217adce7
85 changed files with 4137 additions and 0 deletions
--- a/Notesnook.API/Accessors/SyncItemsRepositoryAccessor.cs
+++ b/Notesnook.API/Accessors/SyncItemsRepositoryAccessor.cs
@@ -0,0 +1,45 @@
+using Notesnook.API.Interfaces;
+using Notesnook.API.Models;
+using Notesnook.API.Repositories;
+using Streetwriters.Common.Models;
+using Streetwriters.Data.Repositories;
+
+namespace Notesnook.API.Accessors
+{
+    public class SyncItemsRepositoryAccessor : ISyncItemsRepositoryAccessor
+    {
+        public SyncItemsRepository<Note> Notes { get; }
+        public SyncItemsRepository<Notebook> Notebooks { get; }
+        public SyncItemsRepository<Shortcut> Shortcuts { get; }
+        public SyncItemsRepository<Relation> Relations { get; }
+        public SyncItemsRepository<Reminder> Reminders { get; }
+        public SyncItemsRepository<Content> Contents { get; }
+        public SyncItemsRepository<Setting> Settings { get; }
+        public SyncItemsRepository<Attachment> Attachments { get; }
+        public Repository<UserSettings> UsersSettings { get; }
+        public Repository<Monograph> Monographs { get; }
+
+        public SyncItemsRepositoryAccessor(SyncItemsRepository<Note> _notes,
+        SyncItemsRepository<Notebook> _notebooks,
+        SyncItemsRepository<Content> _content,
+        SyncItemsRepository<Setting> _settings,
+        SyncItemsRepository<Attachment> _attachments,
+        SyncItemsRepository<Shortcut> _shortcuts,
+        SyncItemsRepository<Relation> _relations,
+        SyncItemsRepository<Reminder> _reminders,
+        Repository<UserSettings> _usersSettings,
+        Repository<Monograph> _monographs)
+        {
+            Notebooks = _notebooks;
+            Notes = _notes;
+            Contents = _content;
+            Settings = _settings;
+            Attachments = _attachments;
+            UsersSettings = _usersSettings;
+            Monographs = _monographs;
+            Shortcuts = _shortcuts;
+            Reminders = _reminders;
+            Relations = _relations;
+        }
+    }
+}
--- a/Notesnook.API/Authorization/EmailVerifiedRequirement.cs
+++ b/Notesnook.API/Authorization/EmailVerifiedRequirement.cs
@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+
+namespace Notesnook.API.Authorization
+{
+    public class EmailVerifiedRequirement : AuthorizationHandler<EmailVerifiedRequirement>, IAuthorizationRequirement
+    {
+        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, EmailVerifiedRequirement requirement)
+        {
+            var isEmailVerified = context.User.HasClaim("verified", "true");
+            var isUserBasic = context.User.HasClaim("notesnook:status", "basic") || context.User.HasClaim("notesnook:status", "premium_expired");
+            if (!isUserBasic || isEmailVerified)
+                context.Succeed(requirement);
+            return Task.CompletedTask;
+        }
+    }
+}
--- a/Notesnook.API/Authorization/NotesnookUserRequirement.cs
+++ b/Notesnook.API/Authorization/NotesnookUserRequirement.cs
@@ -0,0 +1,18 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+
+namespace Notesnook.API.Authorization
+{
+    public class NotesnookUserRequirement : AuthorizationHandler<NotesnookUserRequirement>, IAuthorizationRequirement
+    {
+        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, NotesnookUserRequirement requirement)
+        {
+            var isInAudience = context.User.HasClaim("aud", "notesnook");
+            var hasRole = context.User.HasClaim("role", "notesnook");
+            if (isInAudience && hasRole)
+                context.Succeed(requirement);
+            return Task.CompletedTask;
+        }
+    }
+}
--- a/Notesnook.API/Authorization/ProUserRequirement.cs
+++ b/Notesnook.API/Authorization/ProUserRequirement.cs
@@ -0,0 +1,18 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+
+namespace Notesnook.API.Authorization
+{
+    public class ProUserRequirement : AuthorizationHandler<ProUserRequirement>, IAuthorizationRequirement
+    {
+        private string[] allowedClaims = { "trial", "premium", "premium_canceled" };
+        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, ProUserRequirement requirement)
+        {
+            var isProOrTrial = context.User.HasClaim((c) => c.Type == "notesnook:status" && allowedClaims.Contains(c.Value));
+            if (isProOrTrial)
+                context.Succeed(requirement);
+            return Task.CompletedTask;
+        }
+    }
+}
--- a/Notesnook.API/Authorization/SyncRequirement.cs
+++ b/Notesnook.API/Authorization/SyncRequirement.cs
@@ -0,0 +1,89 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Authorization.Policy;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.SignalR;
+
+namespace Notesnook.API.Authorization
+{
+    public class SyncRequirement : AuthorizationHandler<SyncRequirement>, IAuthorizationRequirement
+    {
+        private Dictionary<string, string> pathErrorPhraseMap = new Dictionary<string, string>
+        {
+            ["/sync/attachments"] = "use attachments",
+            ["/sync"] = "sync your notes",
+            ["/hubs/sync"] = "sync your notes",
+            ["/monographs"] = "publish monographs"
+        };
+
+        private string[] allowedClaims = { "trial", "premium", "premium_canceled" };
+        protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, SyncRequirement requirement)
+        {
+            PathString path = context.Resource is DefaultHttpContext httpContext ? httpContext.Request.Path : null;
+            var result = this.IsAuthorized(context.User, path);
+            if (result.Succeeded) context.Succeed(requirement);
+            else
+            {
+                var hasReason = result.AuthorizationFailure.FailureReasons.Count() > 0;
+                if (hasReason)
+                    context.Fail(result.AuthorizationFailure.FailureReasons.First());
+                else context.Fail();
+            }
+
+            return Task.CompletedTask;
+        }
+
+        public PolicyAuthorizationResult IsAuthorized(ClaimsPrincipal User, PathString requestPath)
+        {
+            var id = User.FindFirstValue("sub");
+
+            if (string.IsNullOrEmpty(id))
+            {
+                var reason = new AuthorizationFailureReason[]
+                {
+                    new AuthorizationFailureReason(this, "Invalid token.")
+                };
+                return PolicyAuthorizationResult.Forbid(AuthorizationFailure.Failed(reason));
+            }
+
+            var hasSyncScope = User.HasClaim("scope", "notesnook.sync");
+            var isInAudience = User.HasClaim("aud", "notesnook");
+            var hasRole = User.HasClaim("role", "notesnook");
+
+            var isEmailVerified = User.HasClaim("verified", "true");
+
+            if (!isEmailVerified)
+            {
+                var phrase = "continue";
+
+                foreach (var item in pathErrorPhraseMap)
+                {
+                    if (requestPath != null && requestPath.StartsWithSegments(item.Key))
+                        phrase = item.Value;
+                }
+
+                var error = $"Please confirm your email to {phrase}.";
+                var reason = new AuthorizationFailureReason[]
+                {
+                    new AuthorizationFailureReason(this, error)
+                };
+                return PolicyAuthorizationResult.Forbid(AuthorizationFailure.Failed(reason));
+                //  context.Fail(new AuthorizationFailureReason(this, error));
+            }
+
+            var isProOrTrial = User.HasClaim((c) => c.Type == "notesnook:status" && allowedClaims.Contains(c.Value));
+            if (hasSyncScope && isInAudience && hasRole && isEmailVerified)
+                return PolicyAuthorizationResult.Success(); //(requirement);
+            return PolicyAuthorizationResult.Forbid();
+        }
+
+        public override Task HandleAsync(AuthorizationHandlerContext context)
+        {
+            return this.HandleRequirementAsync(context, this);
+        }
+
+    }
+}
--- a/Notesnook.API/Controllers/AnnouncementController.cs
+++ b/Notesnook.API/Controllers/AnnouncementController.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Notesnook.API.Models;
+using Streetwriters.Data.Repositories;
+
+namespace Notesnook.API.Controllers
+{
+
+    [ApiController]
+    [Route("announcements")]
+    public class AnnouncementController : ControllerBase
+    {
+        private Repository<Announcement> Announcements { get; set; }
+        public AnnouncementController(Repository<Announcement> announcements)
+        {
+            Announcements = announcements;
+        }
+
+        [HttpGet("active")]
+        [AllowAnonymous]
+        public async Task<IActionResult> GetActiveAnnouncements([FromQuery] string userId)
+        {
+            var announcements = await Announcements.FindAsync((a) => a.IsActive);
+            return Ok(announcements.Where((a) => a.UserIds != null && a.UserIds.Length > 0
+                                                    ? a.UserIds.Contains(userId)
+                                                    : true));
+        }
+    }
+}
--- a/Notesnook.API/Controllers/MonographsController.cs
+++ b/Notesnook.API/Controllers/MonographsController.cs
@@ -0,0 +1,116 @@
+using System;
+using System.Linq;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Notesnook.API.Models;
+using Streetwriters.Common.Models;
+using Streetwriters.Data.Interfaces;
+using Streetwriters.Data.Repositories;
+
+namespace Notesnook.API.Controllers
+{
+    [ApiController]
+    [Route("monographs")]
+    [Authorize("Sync")]
+    public class MonographsController : ControllerBase
+    {
+        private Repository<Monograph> Monographs { get; set; }
+        private readonly IUnitOfWork unit;
+        private const int MAX_DOC_SIZE = 15 * 1024 * 1024;
+        public MonographsController(Repository<Monograph> monographs, IUnitOfWork unitOfWork)
+        {
+            Monographs = monographs;
+            unit = unitOfWork;
+        }
+
+        [HttpPost]
+        public async Task<IActionResult> PublishAsync([FromBody] Monograph monograph)
+        {
+            var userId = this.User.FindFirstValue("sub");
+            if (userId == null) return Unauthorized();
+
+            if (await Monographs.GetAsync(monograph.Id) != null) return base.Conflict("This monograph is already published.");
+
+            if (monograph.EncryptedContent == null)
+                monograph.CompressedContent = monograph.Content.CompressBrotli();
+            monograph.UserId = userId;
+            monograph.DatePublished = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+
+            if (monograph.EncryptedContent?.Cipher.Length > MAX_DOC_SIZE || monograph.CompressedContent?.Length > MAX_DOC_SIZE)
+                return base.BadRequest("Monograph is too big. Max allowed size is 15mb.");
+
+            Monographs.Insert(monograph);
+
+            if (!await unit.Commit()) return BadRequest();
+            return Ok(new
+            {
+                id = monograph.Id
+            });
+        }
+
+        [HttpPatch]
+        public async Task<IActionResult> UpdateAsync([FromBody] Monograph monograph)
+        {
+            if (await Monographs.GetAsync(monograph.Id) == null) return NotFound();
+
+            if (monograph.EncryptedContent == null)
+                monograph.CompressedContent = monograph.Content.CompressBrotli();
+            else
+                monograph.Content = null;
+
+            monograph.DatePublished = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+            Monographs.Update(monograph.Id, monograph);
+
+            if (!await unit.Commit()) return BadRequest();
+            return Ok(new
+            {
+                id = monograph.Id
+            });
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> GetUserMonographsAsync()
+        {
+            var userId = this.User.FindFirstValue("sub");
+            if (userId == null) return Unauthorized();
+
+            var userMonographs = await Monographs.FindAsync((m) => m.UserId == userId);
+            return Ok(userMonographs.Select((m) => m.Id));
+        }
+
+
+        [HttpGet("{id}")]
+        [AllowAnonymous]
+        public async Task<IActionResult> GetMonographAsync([FromRoute] string id)
+        {
+            var monograph = await Monographs.FindOneAsync((m) => m.Id == id);
+            if (monograph == null)
+            {
+                return NotFound(new
+                {
+                    error = "invalid_id",
+                    error_description = $"No such monograph found."
+                });
+            }
+
+            if (monograph.SelfDestruct)
+                await Monographs.DeleteByIdAsync(monograph.Id);
+
+            if (monograph.EncryptedContent == null)
+                monograph.Content = monograph.CompressedContent.DecompressBrotli();
+            return Ok(monograph);
+        }
+
+
+        [HttpDelete("{id}")]
+        public async Task<IActionResult> DeleteAsync([FromRoute] string id)
+        {
+            Monographs.DeleteById(id);
+            if (!await unit.Commit()) return BadRequest();
+            return Ok();
+        }
+    }
+}
--- a/Notesnook.API/Controllers/S3Controller.cs
+++ b/Notesnook.API/Controllers/S3Controller.cs
@@ -0,0 +1,111 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Amazon.S3;
+using Amazon.Runtime;
+using Amazon.S3.Model;
+using System.Threading.Tasks;
+using System.Text.RegularExpressions;
+using System.Security.Claims;
+using System.Net.Http;
+using System.Linq;
+using Notesnook.API.Interfaces;
+using System;
+
+namespace Notesnook.API.Controllers
+{
+    [ApiController]
+    [Route("s3")]
+    [Authorize("Sync")]
+    [ResponseCache(NoStore = true, Location = ResponseCacheLocation.None)]
+    public class S3Controller : ControllerBase
+    {
+        private IS3Service S3Service { get; set; }
+        public S3Controller(IS3Service s3Service)
+        {
+            S3Service = s3Service;
+        }
+
+        [HttpPut]
+        public IActionResult Upload([FromQuery] string name)
+        {
+            var userId = this.User.FindFirstValue("sub");
+            var url = S3Service.GetUploadObjectUrl(userId, name);
+            if (url == null) return BadRequest("Could not create signed url.");
+            return Ok(url);
+        }
+
+
+        [HttpGet("multipart")]
+        public async Task<IActionResult> MultipartUpload([FromQuery] string name, [FromQuery] int parts, [FromQuery] string uploadId)
+        {
+            var userId = this.User.FindFirstValue("sub");
+            try
+            {
+                var meta = await S3Service.StartMultipartUploadAsync(userId, name, parts, uploadId);
+                return Ok(meta);
+            }
+            catch (Exception ex) { return BadRequest(ex.Message); }
+        }
+
+        [HttpDelete("multipart")]
+        public async Task<IActionResult> AbortMultipartUpload([FromQuery] string name, [FromQuery] string uploadId)
+        {
+            var userId = this.User.FindFirstValue("sub");
+            try
+            {
+                await S3Service.AbortMultipartUploadAsync(userId, name, uploadId);
+                return Ok();
+            }
+            catch (Exception ex) { return BadRequest(ex.Message); }
+        }
+
+        [HttpPost("multipart")]
+        public async Task<IActionResult> CompleteMultipartUpload([FromBody] CompleteMultipartUploadRequest uploadRequest)
+        {
+            var userId = this.User.FindFirstValue("sub");
+            try
+            {
+                await S3Service.CompleteMultipartUploadAsync(userId, uploadRequest);
+                return Ok();
+            }
+            catch (Exception ex) { return BadRequest(ex.Message); }
+        }
+
+        [HttpGet]
+        [Authorize]
+        public IActionResult Download([FromQuery] string name)
+        {
+            var userId = this.User.FindFirstValue("sub");
+            var url = S3Service.GetDownloadObjectUrl(userId, name);
+            if (url == null) return BadRequest("Could not create signed url.");
+            return Ok(url);
+        }
+
+        [HttpHead]
+        [Authorize]
+        public async Task<IActionResult> Info([FromQuery] string name)
+        {
+            var userId = this.User.FindFirstValue("sub");
+            var size = await S3Service.GetObjectSizeAsync(userId, name);
+            if (size == null) return BadRequest();
+
+            HttpContext.Response.Headers.ContentLength = size;
+            return Ok();
+        }
+
+        [HttpDelete]
+        public async Task<IActionResult> DeleteAsync([FromQuery] string name)
+        {
+            try
+            {
+                var userId = this.User.FindFirstValue("sub");
+                await S3Service.DeleteObjectAsync(userId, name);
+                return Ok();
+            }
+            catch (Exception ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+    }
+}
--- a/Notesnook.API/Controllers/UsersController.cs
+++ b/Notesnook.API/Controllers/UsersController.cs
@@ -0,0 +1,98 @@
+using System;
+using System.Net.Http;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Notesnook.API.Interfaces;
+using Notesnook.API.Models.Responses;
+using Streetwriters.Common;
+using Streetwriters.Common.Extensions;
+using Streetwriters.Common.Models;
+
+namespace Notesnook.API.Controllers
+{
+    [ApiController]
+    [Authorize]
+    [Route("users")]
+    public class UsersController : ControllerBase
+    {
+        private readonly HttpClient httpClient;
+        private readonly IHttpContextAccessor HttpContextAccessor;
+        private IUserService UserService { get; set; }
+        public UsersController(IUserService userService, IHttpContextAccessor accessor)
+        {
+            httpClient = new HttpClient();
+            HttpContextAccessor = accessor;
+            UserService = userService;
+        }
+
+        [HttpPost]
+        [AllowAnonymous]
+        public async Task<IActionResult> Signup()
+        {
+            try
+            {
+                await UserService.CreateUserAsync();
+                return Ok();
+            }
+            catch (Exception ex)
+            {
+                await Slogger<UsersController>.Error(nameof(Signup), "Couldn't sign up.", ex.ToString());
+                return BadRequest(new { error = ex.Message });
+            }
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> GetUser()
+        {
+            UserResponse response = await UserService.GetUserAsync();
+            if (!response.Success) return BadRequest(response);
+            return Ok(response);
+        }
+
+        [HttpPatch]
+        public async Task<IActionResult> UpdateUser([FromBody] UserResponse user)
+        {
+            UserResponse response = await UserService.GetUserAsync(false);
+
+            if (user.AttachmentsKey != null)
+                await UserService.SetUserAttachmentsKeyAsync(response.UserId, user.AttachmentsKey);
+            else return BadRequest();
+
+            return Ok();
+        }
+
+        [HttpPost("reset")]
+        public async Task<IActionResult> Reset([FromForm] bool removeAttachments)
+        {
+            var userId = this.User.FindFirstValue("sub");
+
+            if (await UserService.ResetUserAsync(userId, removeAttachments))
+                return Ok();
+            return BadRequest();
+        }
+
+        [HttpPost("delete")]
+        public async Task<IActionResult> Delete()
+        {
+            try
+            {
+                var userId = this.User.FindFirstValue("sub");
+
+                Response response = await this.httpClient.ForwardAsync<Response>(this.HttpContextAccessor, $"{Servers.IdentityServer.ToString()}/account/unregister", HttpMethod.Post);
+                if (!response.Success) return BadRequest();
+
+                if (await UserService.DeleteUserAsync(userId, User.FindFirstValue("jti")))
+                    return Ok();
+
+                return BadRequest();
+            }
+            catch
+            {
+                return BadRequest();
+            }
+        }
+    }
+}
--- a/Notesnook.API/Extensions/AuthorizationResultTransformer.cs
+++ b/Notesnook.API/Extensions/AuthorizationResultTransformer.cs
@@ -0,0 +1,54 @@
+using System.Linq;
+using System.Net;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Authorization.Policy;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Notesnook.API.Authorization;
+
+namespace Notesnook.API.Extensions
+{
+    public class AuthorizationResultTransformer : IAuthorizationMiddlewareResultHandler
+    {
+        private readonly IAuthorizationMiddlewareResultHandler _handler;
+
+        public AuthorizationResultTransformer()
+        {
+            _handler = new AuthorizationMiddlewareResultHandler();
+        }
+
+        public async Task HandleAsync(
+            RequestDelegate requestDelegate,
+            HttpContext httpContext,
+            AuthorizationPolicy authorizationPolicy,
+            PolicyAuthorizationResult policyAuthorizationResult)
+        {
+            var isWebsocket = httpContext.Request.Headers.Upgrade == "websocket";
+
+            if (!isWebsocket && policyAuthorizationResult.Forbidden && policyAuthorizationResult.AuthorizationFailure != null)
+            {
+                var error = string.Join("\n", policyAuthorizationResult.AuthorizationFailure.FailureReasons.Select((r) => r.Message));
+
+                if (!string.IsNullOrEmpty(error) && !isWebsocket)
+                {
+                    httpContext.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
+                    httpContext.Response.ContentType = "application/json";
+                    await httpContext.Response.WriteAsync(JsonSerializer.Serialize(new { error }));
+                    return;
+                }
+
+                await _handler.HandleAsync(requestDelegate, httpContext, authorizationPolicy, policyAuthorizationResult);
+            }
+            else if (isWebsocket)
+            {
+                await _handler.HandleAsync(requestDelegate, httpContext, authorizationPolicy, PolicyAuthorizationResult.Success());
+            }
+            else
+            {
+                await _handler.HandleAsync(requestDelegate, httpContext, authorizationPolicy, policyAuthorizationResult);
+            }
+        }
+    }
+}
--- a/Notesnook.API/Extensions/TransactionHelper.cs
+++ b/Notesnook.API/Extensions/TransactionHelper.cs
@@ -0,0 +1,25 @@
+using System.Threading;
+using System;
+using System.Threading.Tasks;
+
+namespace MongoDB.Driver
+{
+    public static class TransactionHelper
+    {
+        public static async Task StartTransaction(this IMongoClient client, Action<CancellationToken> operate, CancellationToken ct)
+        {
+            using (var session = await client.StartSessionAsync())
+            {
+                var transactionOptions = new TransactionOptions(readPreference: ReadPreference.Nearest, readConcern: ReadConcern.Local, writeConcern: WriteConcern.WMajority);
+                await session.WithTransactionAsync((handle, token) =>
+                {
+                    return Task.Run(() =>
+                    {
+                        operate(token);
+                        return true;
+                    });
+                }, transactionOptions, ct);
+            }
+        }
+    }
+}
--- a/Notesnook.API/Hubs/SyncHub.cs
+++ b/Notesnook.API/Hubs/SyncHub.cs
@@ -0,0 +1,272 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Security.Claims;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.SignalR;
+using Notesnook.API.Authorization;
+using Notesnook.API.Interfaces;
+using Notesnook.API.Models;
+using Streetwriters.Common.Models;
+using Streetwriters.Data.Interfaces;
+
+namespace Notesnook.API.Hubs
+{
+    public interface ISyncHubClient
+    {
+        Task SyncItem(SyncTransferItem transferItem);
+        Task RemoteSyncCompleted(long lastSynced);
+        Task SyncCompleted();
+    }
+
+    [Authorize("Sync")]
+    public class SyncHub : Hub<ISyncHubClient>
+    {
+        private ISyncItemsRepositoryAccessor Repositories { get; }
+        private readonly IUnitOfWork unit;
+
+        public SyncHub(ISyncItemsRepositoryAccessor syncItemsRepositoryAccessor, IUnitOfWork unitOfWork)
+        {
+            Repositories = syncItemsRepositoryAccessor;
+            unit = unitOfWork;
+        }
+
+        public override Task OnConnectedAsync()
+        {
+            var result = new SyncRequirement().IsAuthorized(Context.User, new PathString("/hubs/sync"));
+            if (!result.Succeeded)
+            {
+                var reason = result.AuthorizationFailure.FailureReasons.FirstOrDefault();
+                throw new HubException(reason?.Message ?? "Unauthorized");
+            }
+            var id = Context.User.FindFirstValue("sub");
+            Groups.AddToGroupAsync(Context.ConnectionId, id);
+            return base.OnConnectedAsync();
+        }
+
+        public override Task OnDisconnectedAsync(Exception exception)
+        {
+            var id = Context.User.FindFirstValue("sub");
+            Groups.RemoveFromGroupAsync(Context.ConnectionId, id);
+            return base.OnDisconnectedAsync(exception);
+        }
+
+        public async Task<int> SyncItem(BatchedSyncTransferItem transferItem)
+        {
+
+            var userId = Context.User.FindFirstValue("sub");
+            if (string.IsNullOrEmpty(userId)) return 0;
+
+            var others = Clients.OthersInGroup(userId);
+
+            UserSettings userSettings = await this.Repositories.UsersSettings.FindOneAsync((u) => u.UserId == userId);
+
+            long dateSynced = transferItem.LastSynced > userSettings.LastSynced ? transferItem.LastSynced : userSettings.LastSynced;
+
+            for (int i = 0; i < transferItem.Items.Length; ++i)
+            {
+                var data = transferItem.Items[i];
+                var type = transferItem.Types[i];
+
+                others.SyncItem(
+                        new SyncTransferItem
+                        {
+                            Item = data,
+                            ItemType = type,
+                            LastSynced = dateSynced,
+                            Total = transferItem.Total,
+                            Current = transferItem.Current + i
+                        });
+
+                switch (type)
+                {
+                    case "content":
+                        Repositories.Contents.Upsert(JsonSerializer.Deserialize<Content>(data), userId, dateSynced);
+                        break;
+                    case "attachment":
+                        Repositories.Attachments.Upsert(JsonSerializer.Deserialize<Attachment>(data), userId, dateSynced);
+                        break;
+                    case "note":
+                        Repositories.Notes.Upsert(JsonSerializer.Deserialize<Note>(data), userId, dateSynced);
+                        break;
+                    case "notebook":
+                        Repositories.Notebooks.Upsert(JsonSerializer.Deserialize<Notebook>(data), userId, dateSynced);
+                        break;
+                    case "shortcut":
+                        Repositories.Shortcuts.Upsert(JsonSerializer.Deserialize<Shortcut>(data), userId, dateSynced);
+                        break;
+                    case "reminder":
+                        Repositories.Reminders.Upsert(JsonSerializer.Deserialize<Reminder>(data), userId, dateSynced);
+                        break;
+                    case "relation":
+                        Repositories.Relations.Upsert(JsonSerializer.Deserialize<Relation>(data), userId, dateSynced);
+                        break;
+                    case "settings":
+                        var settings = JsonSerializer.Deserialize<Setting>(data);
+                        settings.Id = MongoDB.Bson.ObjectId.Parse(userId);
+                        settings.ItemId = userId;
+                        Repositories.Settings.Upsert(settings, userId, dateSynced);
+                        break;
+                    case "vaultKey":
+                        userSettings.VaultKey = JsonSerializer.Deserialize<EncryptedData>(data);
+                        Repositories.UsersSettings.Upsert(userSettings, (u) => u.UserId == userId);
+                        break;
+                    default:
+                        throw new HubException("Invalid item type.");
+                }
+
+            }
+
+            return await unit.Commit() ? 1 : 0;
+
+        }
+
+        public async Task<bool> SyncCompleted(long dateSynced)
+        {
+            var userId = Context.User.FindFirstValue("sub");
+
+            UserSettings userSettings = await this.Repositories.UsersSettings.FindOneAsync((u) => u.UserId == userId);
+
+            long lastSynced = dateSynced > userSettings.LastSynced ? dateSynced : userSettings.LastSynced;
+
+            userSettings.LastSynced = lastSynced;
+
+            await this.Repositories.UsersSettings.UpsertAsync(userSettings, (u) => u.UserId == userId);
+
+            await Clients.OthersInGroup(userId).RemoteSyncCompleted(lastSynced);
+            return true;
+        }
+
+        public async IAsyncEnumerable<SyncTransferItem> FetchItems(long lastSyncedTimestamp, [EnumeratorCancellation]
+        CancellationToken cancellationToken)
+        {
+            var userId = Context.User.FindFirstValue("sub");
+
+            var userSettings = await Repositories.UsersSettings.FindOneAsync((u) => u.UserId == userId);
+            if (userSettings.LastSynced > 0 && lastSyncedTimestamp > userSettings.LastSynced)
+                throw new HubException($"Provided timestamp value is too large. Server timestamp: {userSettings.LastSynced} Sent timestamp: {lastSyncedTimestamp}");
+
+            // var client = Clients.Caller;
+
+            if (lastSyncedTimestamp > 0 && userSettings.LastSynced == lastSyncedTimestamp)
+            {
+                yield return new SyncTransferItem
+                {
+                    LastSynced = userSettings.LastSynced,
+                    Synced = true
+                };
+                yield break;
+            }
+
+
+            var attachments = await Repositories.Attachments.GetItemsSyncedAfterAsync(userId, lastSyncedTimestamp);
+
+            var notes = await Repositories.Notes.GetItemsSyncedAfterAsync(userId, lastSyncedTimestamp);
+
+            var notebooks = await Repositories.Notebooks.GetItemsSyncedAfterAsync(userId, lastSyncedTimestamp);
+
+            var contents = await Repositories.Contents.GetItemsSyncedAfterAsync(userId, lastSyncedTimestamp);
+
+            var settings = await Repositories.Settings.GetItemsSyncedAfterAsync(userId, lastSyncedTimestamp);
+
+            var shortcuts = await Repositories.Shortcuts.GetItemsSyncedAfterAsync(userId, lastSyncedTimestamp);
+
+            var reminders = await Repositories.Reminders.GetItemsSyncedAfterAsync(userId, lastSyncedTimestamp);
+
+            var relations = await Repositories.Relations.GetItemsSyncedAfterAsync(userId, lastSyncedTimestamp);
+
+            var collections = new Dictionary<string, IEnumerable<object>>
+            {
+                ["attachment"] = attachments,
+                ["note"] = notes,
+                ["notebook"] = notebooks,
+                ["content"] = contents,
+                ["shortcut"] = shortcuts,
+                ["reminder"] = reminders,
+                ["relation"] = relations,
+                ["settings"] = settings,
+            };
+
+            if (userSettings.VaultKey != null)
+            {
+                collections.Add("vaultKey", new object[] { userSettings.VaultKey });
+            }
+
+            var total = collections.Values.Sum((a) => a.Count());
+            if (total == 0)
+            {
+                yield return new SyncTransferItem
+                {
+                    Synced = true,
+                    LastSynced = userSettings.LastSynced
+                };
+                yield break;
+            }
+
+            foreach (var collection in collections)
+            {
+                foreach (var item in collection.Value)
+                {
+                    if (item == null) continue;
+                    // Check the cancellation token regularly so that the server will stop producing items if the client disconnects.
+                    cancellationToken.ThrowIfCancellationRequested();
+                    yield return new SyncTransferItem
+                    {
+                        LastSynced = userSettings.LastSynced,
+                        Synced = false,
+                        Item = JsonSerializer.Serialize(item),
+                        ItemType = collection.Key,
+                        Total = total,
+                    };
+                }
+            }
+        }
+
+    }
+
+    [MessagePack.MessagePackObject]
+    public struct BatchedSyncTransferItem
+    {
+        [MessagePack.Key("lastSynced")]
+        public long LastSynced { get; set; }
+
+        [MessagePack.Key("items")]
+        public string[] Items { get; set; }
+
+        [MessagePack.Key("types")]
+        public string[] Types { get; set; }
+
+        [MessagePack.Key("total")]
+        public int Total { get; set; }
+
+        [MessagePack.Key("current")]
+        public int Current { get; set; }
+    }
+
+    [MessagePack.MessagePackObject]
+    public struct SyncTransferItem
+    {
+        [MessagePack.Key("synced")]
+        public bool Synced { get; set; }
+
+        [MessagePack.Key("lastSynced")]
+        public long LastSynced { get; set; }
+
+        [MessagePack.Key("item")]
+        public string Item { get; set; }
+
+        [MessagePack.Key("itemType")]
+        public string ItemType { get; set; }
+
+        [MessagePack.Key("total")]
+        public int Total { get; set; }
+
+        [MessagePack.Key("current")]
+        public int Current { get; set; }
+    }
+}
--- a/Notesnook.API/Interfaces/IEncrypted.cs
+++ b/Notesnook.API/Interfaces/IEncrypted.cs
@@ -0,0 +1,10 @@
+namespace Notesnook.API.Interfaces
+{
+    public interface IEncrypted
+    {
+        string Cipher { get; set; }
+        string IV { get; set; }
+        long Length { get; set; }
+        string Salt { get; set; }
+    }
+}
--- a/Notesnook.API/Interfaces/IMonograph.cs
+++ b/Notesnook.API/Interfaces/IMonograph.cs
@@ -0,0 +1,14 @@
+using Notesnook.API.Models;
+using Streetwriters.Common.Interfaces;
+
+namespace Notesnook.API.Interfaces
+{
+    public interface IMonograph : IDocument
+    {
+        string Title { get; set; }
+        string UserId { get; set; }
+        byte[] CompressedContent { get; set; }
+        EncryptedData EncryptedContent { get; set; }
+        long DatePublished { get; set; }
+    }
+}
--- a/Notesnook.API/Interfaces/IS3Service.cs
+++ b/Notesnook.API/Interfaces/IS3Service.cs
@@ -0,0 +1,21 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Amazon.S3.Model;
+using Notesnook.API.Models;
+using Notesnook.API.Models.Responses;
+using Streetwriters.Common.Interfaces;
+
+namespace Notesnook.API.Interfaces
+{
+    public interface IS3Service
+    {
+        Task DeleteObjectAsync(string userId, string name);
+        Task DeleteDirectoryAsync(string userId);
+        Task<long?> GetObjectSizeAsync(string userId, string name);
+        string GetUploadObjectUrl(string userId, string name);
+        string GetDownloadObjectUrl(string userId, string name);
+        Task<MultipartUploadMeta> StartMultipartUploadAsync(string userId, string name, int parts, string uploadId = null);
+        Task AbortMultipartUploadAsync(string userId, string name, string uploadId);
+        Task CompleteMultipartUploadAsync(string userId, CompleteMultipartUploadRequest uploadRequest);
+    }
+}
--- a/Notesnook.API/Interfaces/ISyncItem.cs
+++ b/Notesnook.API/Interfaces/ISyncItem.cs
@@ -0,0 +1,24 @@
+using System.Text.Json.Serialization;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Bson.Serialization.Serializers;
+using Notesnook.API.Models;
+using Streetwriters.Common.Attributes;
+using Streetwriters.Common.Converters;
+using Streetwriters.Common.Interfaces;
+
+namespace Notesnook.API.Interfaces
+{
+    [BsonSerializer(typeof(ImpliedImplementationInterfaceSerializer<ISyncItem, SyncItem>))]
+    [JsonInterfaceConverter(typeof(InterfaceConverter<ISyncItem, SyncItem>))]
+    public interface ISyncItem
+    {
+        long DateSynced
+        {
+            get; set;
+        }
+
+        string UserId { get; set; }
+        string Algorithm { get; set; }
+        string IV { get; set; }
+    }
+}
--- a/Notesnook.API/Interfaces/ISyncItemsRepositoryAccessor.cs
+++ b/Notesnook.API/Interfaces/ISyncItemsRepositoryAccessor.cs
@@ -0,0 +1,21 @@
+using Notesnook.API.Models;
+using Notesnook.API.Repositories;
+using Streetwriters.Common.Models;
+using Streetwriters.Data.Repositories;
+
+namespace Notesnook.API.Interfaces
+{
+    public interface ISyncItemsRepositoryAccessor
+    {
+        SyncItemsRepository<Note> Notes { get; }
+        SyncItemsRepository<Notebook> Notebooks { get; }
+        SyncItemsRepository<Shortcut> Shortcuts { get; }
+        SyncItemsRepository<Reminder> Reminders { get; }
+        SyncItemsRepository<Relation> Relations { get; }
+        SyncItemsRepository<Content> Contents { get; }
+        SyncItemsRepository<Setting> Settings { get; }
+        SyncItemsRepository<Attachment> Attachments { get; }
+        Repository<UserSettings> UsersSettings { get; }
+        Repository<Monograph> Monographs { get; }
+    }
+}
--- a/Notesnook.API/Interfaces/IUserService.cs
+++ b/Notesnook.API/Interfaces/IUserService.cs
@@ -0,0 +1,16 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Notesnook.API.Models.Responses;
+using Streetwriters.Common.Interfaces;
+
+namespace Notesnook.API.Interfaces
+{
+    public interface IUserService
+    {
+        Task CreateUserAsync();
+        Task<bool> DeleteUserAsync(string userId, string jti);
+        Task<bool> ResetUserAsync(string userId, bool removeAttachments);
+        Task<UserResponse> GetUserAsync(bool repair = true);
+        Task SetUserAttachmentsKeyAsync(string userId, IEncrypted key);
+    }
+}
--- a/Notesnook.API/Interfaces/IUserSettings.cs
+++ b/Notesnook.API/Interfaces/IUserSettings.cs
@@ -0,0 +1,23 @@
+using Notesnook.API.Models;
+using Streetwriters.Common.Interfaces;
+using Streetwriters.Common.Models;
+
+namespace Notesnook.API.Interfaces
+{
+    public interface IUserSettings : IDocument
+    {
+        string UserId { get; set; }
+
+        long LastSynced
+        {
+            get; set;
+        }
+
+        EncryptedData VaultKey
+        {
+            get; set;
+        }
+
+        string Salt { get; set; }
+    }
+}
--- a/Notesnook.API/Models/Algorithms.cs
+++ b/Notesnook.API/Models/Algorithms.cs
@@ -0,0 +1,7 @@
+namespace Notesnook.API.Models
+{
+    public class Algorithms
+    {
+        public static string Default => "xcha-argon2i13-7";
+    }
+}
--- a/Notesnook.API/Models/Announcement.cs
+++ b/Notesnook.API/Models/Announcement.cs
@@ -0,0 +1,142 @@
+using System;
+using System.Runtime.Serialization;
+using System.Text.Json.Serialization;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+using Streetwriters.Data.Attributes;
+
+namespace Notesnook.API.Models
+{
+    [BsonCollection("notesnook", "announcements")]
+    public class Announcement
+    {
+        public Announcement()
+        {
+            this.Id = ObjectId.GenerateNewId().ToString();
+        }
+
+        [BsonId]
+        [BsonRepresentation(BsonType.ObjectId)]
+        [BsonElement("id")]
+        [JsonPropertyName("id")]
+        public string Id { get; set; }
+
+        [JsonPropertyName("type")]
+        [BsonElement("type")]
+        public string Type { get; set; }
+
+        [JsonPropertyName("timestamp")]
+        [BsonElement("timestamp")]
+        public long Timestamp { get; set; }
+
+        [JsonPropertyName("platforms")]
+        [BsonElement("platforms")]
+        public string[] Platforms { get; set; }
+
+        [JsonPropertyName("isActive")]
+        [BsonElement("isActive")]
+        public bool IsActive { get; set; }
+
+        [JsonPropertyName("userTypes")]
+        [BsonElement("userTypes")]
+        public string[] UserTypes { get; set; }
+
+        [JsonPropertyName("appVersion")]
+        [BsonElement("appVersion")]
+        public int AppVersion { get; set; }
+
+        [JsonPropertyName("body")]
+        [BsonElement("body")]
+        public BodyComponent[] Body { get; set; }
+
+        [JsonIgnore]
+        [BsonElement("userIds")]
+        public string[] UserIds { get; set; }
+
+
+        [Obsolete]
+        [JsonPropertyName("title")]
+        [DataMember(Name = "title")]
+        [BsonElement("title")]
+        public string Title { get; set; }
+
+        [Obsolete]
+        [JsonPropertyName("description")]
+        [BsonElement("description")]
+        public string Description { get; set; }
+
+        [Obsolete]
+        [JsonPropertyName("callToActions")]
+        [BsonElement("callToActions")]
+        public CallToAction[] CallToActions { get; set; }
+    }
+
+    public class BodyComponent
+    {
+        [JsonPropertyName("type")]
+        [BsonElement("type")]
+        public string Type { get; set; }
+
+        [JsonPropertyName("platforms")]
+        [BsonElement("platforms")]
+        public string[] Platforms { get; set; }
+
+        [JsonPropertyName("style")]
+        [BsonElement("style")]
+        public Style Style { get; set; }
+
+        [JsonPropertyName("src")]
+        [BsonElement("src")]
+        public string Src { get; set; }
+
+        [JsonPropertyName("text")]
+        [BsonElement("text")]
+        public string Text { get; set; }
+
+        [JsonPropertyName("value")]
+        [BsonElement("value")]
+        public string Value { get; set; }
+
+        [JsonPropertyName("items")]
+        [BsonElement("items")]
+        public BodyComponent[] Items { get; set; }
+
+        [JsonPropertyName("actions")]
+        [BsonElement("actions")]
+        public CallToAction[] Actions { get; set; }
+    }
+
+    public class Style
+    {
+        [JsonPropertyName("marginTop")]
+        [BsonElement("marginTop")]
+        public int MarginTop { get; set; }
+
+        [JsonPropertyName("marginBottom")]
+        [BsonElement("marginBottom")]
+        public int MarginBottom { get; set; }
+
+        [JsonPropertyName("textAlign")]
+        [BsonElement("textAlign")]
+        public string TextAlign { get; set; }
+    }
+
+    public class CallToAction
+    {
+        [JsonPropertyName("type")]
+        [BsonElement("type")]
+        public string Type { get; set; }
+
+        [JsonPropertyName("platforms")]
+        [BsonElement("platforms")]
+        public string[] Platforms { get; set; }
+
+        [JsonPropertyName("data")]
+        [BsonElement("data")]
+        public string Data { get; set; }
+
+        [JsonPropertyName("title")]
+        [BsonElement("title")]
+        public string Title { get; set; }
+    }
+}
--- a/Notesnook.API/Models/EncryptedData.cs
+++ b/Notesnook.API/Models/EncryptedData.cs
@@ -0,0 +1,37 @@
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+using Notesnook.API.Interfaces;
+using System.Runtime.Serialization;
+using System.Text.Json.Serialization;
+
+namespace Notesnook.API.Models
+{
+    public class EncryptedData : IEncrypted
+    {
+        [JsonPropertyName("iv")]
+        [BsonElement("iv")]
+        [DataMember(Name = "iv")]
+        public string IV
+        {
+            get; set;
+        }
+
+        [JsonPropertyName("cipher")]
+        [BsonElement("cipher")]
+        [DataMember(Name = "cipher")]
+        public string Cipher
+        {
+            get; set;
+        }
+
+        [JsonPropertyName("length")]
+        [BsonElement("length")]
+        [DataMember(Name = "length")]
+        public long Length { get; set; }
+
+        [JsonPropertyName("salt")]
+        [BsonElement("salt")]
+        [DataMember(Name = "salt")]
+        public string Salt { get; set; }
+    }
+}
--- a/Notesnook.API/Models/Monograph.cs
+++ b/Notesnook.API/Models/Monograph.cs
@@ -0,0 +1,43 @@
+using System.Text.Json.Serialization;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+using Notesnook.API.Interfaces;
+using Streetwriters.Data.Attributes;
+
+namespace Notesnook.API.Models
+{
+    [BsonCollection("notesnook", "monographs")]
+    public class Monograph : IMonograph
+    {
+        public Monograph()
+        {
+            Id = ObjectId.GenerateNewId().ToString();
+        }
+
+        [BsonId]
+        [BsonRepresentation(BsonType.ObjectId)]
+        public string Id { get; set; }
+
+        [JsonPropertyName("title")]
+        public string Title { get; set; }
+
+        [JsonPropertyName("userId")]
+        public string UserId { get; set; }
+
+        [JsonPropertyName("selfDestruct")]
+        public bool SelfDestruct { get; set; }
+
+        [JsonPropertyName("encryptedContent")]
+        public EncryptedData EncryptedContent { get; set; }
+
+        [JsonPropertyName("datePublished")]
+        public long DatePublished { get; set; }
+
+        [JsonPropertyName("content")]
+        [BsonIgnore]
+        public string Content { get; set; }
+
+        [JsonIgnore]
+        public byte[] CompressedContent { get; set; }
+    }
+}
--- a/Notesnook.API/Models/MultipartUploadMeta.cs
+++ b/Notesnook.API/Models/MultipartUploadMeta.cs
@@ -0,0 +1,8 @@
+namespace Notesnook.API.Models
+{
+    public class MultipartUploadMeta
+    {
+        public string UploadId { get; set; }
+        public string[] Parts { get; set; }
+    }
+}
--- a/Notesnook.API/Models/Responses/SignupResponse.cs
+++ b/Notesnook.API/Models/Responses/SignupResponse.cs
@@ -0,0 +1,16 @@
+using System.Runtime.Serialization;
+using System.Text.Json.Serialization;
+using Streetwriters.Common.Interfaces;
+using Streetwriters.Common.Models;
+
+namespace Notesnook.API.Models.Responses
+{
+    public class SignupResponse : Response
+    {
+        [JsonPropertyName("userId")]
+        public string UserId { get; set; }
+
+        [JsonPropertyName("errors")]
+        public string[] Errors { get; set; }
+    }
+}
--- a/Notesnook.API/Models/Responses/UserResponse.cs
+++ b/Notesnook.API/Models/Responses/UserResponse.cs
@@ -0,0 +1,24 @@
+using System.Runtime.Serialization;
+using System.Text.Json.Serialization;
+using Notesnook.API.Interfaces;
+using Streetwriters.Common.Interfaces;
+using Streetwriters.Common.Models;
+
+namespace Notesnook.API.Models.Responses
+{
+    public class UserResponse : UserModel, IResponse
+    {
+        [JsonPropertyName("salt")]
+        public string Salt { get; set; }
+
+        [JsonPropertyName("attachmentsKey")]
+        public EncryptedData AttachmentsKey { get; set; }
+
+        [JsonPropertyName("subscription")]
+        public ISubscription Subscription { get; set; }
+
+        [JsonIgnore]
+        public bool Success { get; set; }
+        public int StatusCode { get; set; }
+    }
+}
--- a/Notesnook.API/Models/S3Options.cs
+++ b/Notesnook.API/Models/S3Options.cs
@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+using System.Runtime.Serialization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Notesnook.API.Models
+{
+    public class S3Options
+    {
+        public string ServiceUrl { get; set; }
+        public string Region { get; set; }
+        public string AccessKeyId { get; set; }
+        public string SecretAccessKey { get; set; }
+    }
+}
--- a/Notesnook.API/Models/SyncItem.cs
+++ b/Notesnook.API/Models/SyncItem.cs
@@ -0,0 +1,108 @@
+using System.ComponentModel.DataAnnotations;
+using System.Runtime.Serialization;
+using System.Text.Json.Serialization;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+using Notesnook.API.Interfaces;
+using Streetwriters.Data.Attributes;
+
+namespace Notesnook.API.Models
+{
+    public class SyncItem : ISyncItem
+    {
+        [IgnoreDataMember]
+        [JsonPropertyName("dateSynced")]
+        public long DateSynced
+        {
+            get; set;
+        }
+
+        [DataMember(Name = "userId")]
+        [JsonPropertyName("userId")]
+        public string UserId
+        {
+            get; set;
+        }
+
+        [JsonPropertyName("iv")]
+        [DataMember(Name = "iv")]
+        [Required]
+        public string IV
+        {
+            get; set;
+        }
+
+
+        [JsonPropertyName("cipher")]
+        [DataMember(Name = "cipher")]
+        [Required]
+        public string Cipher
+        {
+            get; set;
+        }
+
+        [DataMember(Name = "id")]
+        [JsonPropertyName("id")]
+        public string ItemId
+        {
+            get; set;
+        }
+
+        [BsonId]
+        [BsonIgnoreIfDefault]
+        [BsonRepresentation(BsonType.ObjectId)]
+        [JsonIgnore]
+        public ObjectId Id
+        {
+            get; set;
+        }
+
+        [JsonPropertyName("length")]
+        [DataMember(Name = "length")]
+        [Required]
+        public long Length
+        {
+            get; set;
+        }
+
+        [JsonPropertyName("v")]
+        [DataMember(Name = "v")]
+        [Required]
+        public double Version
+        {
+            get; set;
+        }
+
+        [JsonPropertyName("alg")]
+        [DataMember(Name = "alg")]
+        [Required]
+        public string Algorithm
+        {
+            get; set;
+        } = Algorithms.Default;
+    }
+
+    [BsonCollection("notesnook", "attachments")]
+    public class Attachment : SyncItem { }
+
+    [BsonCollection("notesnook", "content")]
+    public class Content : SyncItem { }
+
+    [BsonCollection("notesnook", "notes")]
+    public class Note : SyncItem { }
+
+    [BsonCollection("notesnook", "notebooks")]
+    public class Notebook : SyncItem { }
+
+    [BsonCollection("notesnook", "relations")]
+    public class Relation : SyncItem { }
+
+    [BsonCollection("notesnook", "reminders")]
+    public class Reminder : SyncItem { }
+
+    [BsonCollection("notesnook", "settings")]
+    public class Setting : SyncItem { }
+
+    [BsonCollection("notesnook", "shortcuts")]
+    public class Shortcut : SyncItem { }
+}
--- a/Notesnook.API/Models/UserSettings.cs
+++ b/Notesnook.API/Models/UserSettings.cs
@@ -0,0 +1,25 @@
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+using Notesnook.API.Interfaces;
+using Streetwriters.Data.Attributes;
+
+namespace Notesnook.API.Models
+{
+    [BsonCollection("notesnook", "user_settings")]
+    public class UserSettings : IUserSettings
+    {
+        public UserSettings()
+        {
+            this.Id = ObjectId.GenerateNewId().ToString();
+        }
+        public string UserId { get; set; }
+        public long LastSynced { get; set; }
+        public string Salt { get; set; }
+        public EncryptedData VaultKey { get; set; }
+        public EncryptedData AttachmentsKey { get; set; }
+
+        [BsonId]
+        [BsonRepresentation(BsonType.ObjectId)]
+        public string Id { get; set; }
+    }
+}
--- a/Notesnook.API/Notesnook.API.csproj
+++ b/Notesnook.API/Notesnook.API.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <StartupObject>Notesnook.API.Program</StartupObject>
+    <LangVersion>10.0</LangVersion>
+    <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
+    <TargetLatestRuntimePatch>true</TargetLatestRuntimePatch>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AWSSDK.Core" Version="3.7.12.5" />
+    <PackageReference Include="IdentityServer4.AccessTokenValidation" Version="3.0.1" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.OpenIdConnect" Version="6.0.0" />
+    <PackageReference Include="AspNetCore.HealthChecks.MongoDb" Version="6.0.1-rc2.2" />
+    <PackageReference Include="AWSSDK.S3" Version="3.7.9.21" />
+    <PackageReference Include="Microsoft.AspNetCore.SignalR.Protocols.MessagePack" Version="6.0.3" />
+    <PackageReference Include="Microsoft.AspNetCore.Server.Kestrel.Https" Version="2.2.0" />
+ </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Streetwriters.Common\Streetwriters.Common.csproj" />
+    <ProjectReference Include="..\Streetwriters.Data\Streetwriters.Data.csproj" />
+  </ItemGroup>
+
+
+</Project>
--- a/Notesnook.API/Program.cs
+++ b/Notesnook.API/Program.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using Amazon.S3;
+using Amazon.S3.Model;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Server.Kestrel.Https;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Streetwriters.Common;
+
+namespace Notesnook.API
+{
+    public class Program
+    {
+        public static async Task Main(string[] args)
+        {
+            IHost host = CreateHostBuilder(args).Build();
+            await host.RunAsync();
+        }
+
+        public static IHostBuilder CreateHostBuilder(string[] args) =>
+            Host.CreateDefaultBuilder(args)
+                .ConfigureWebHostDefaults(webBuilder =>
+                {
+                    webBuilder
+                    .UseStartup<Startup>()
+                    .UseKestrel((options) =>
+                    {
+                        options.Limits.MaxRequestBodySize = long.MaxValue;
+#if DEBUG
+                        options.ListenAnyIP(int.Parse(Servers.NotesnookAPI.Port));
+#else
+                        options.ListenAnyIP(443, listenerOptions =>
+                        {
+                            listenerOptions.UseHttps(Servers.OriginSSLCertificate);
+                        });
+                        options.ListenAnyIP(80);
+                        options.Listen(IPAddress.Parse(Servers.NotesnookAPI.Hostname), int.Parse(Servers.NotesnookAPI.Port));
+#endif
+                    });
+                });
+    }
+}
--- a/Notesnook.API/Properties/launchSettings.json
+++ b/Notesnook.API/Properties/launchSettings.json
@@ -0,0 +1,30 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:1740",
+      "sslPort": 44313
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "weatherforecast",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "Notesnook.API": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "weatherforecast",
+      "applicationUrl": "http://localhost:6000",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}
--- a/Notesnook.API/Repositories/SyncItemsRepository.cs
+++ b/Notesnook.API/Repositories/SyncItemsRepository.cs
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualBasic;
+using MongoDB.Bson;
+using MongoDB.Driver;
+using Notesnook.API.Interfaces;
+using Notesnook.API.Models;
+using Streetwriters.Common;
+using Streetwriters.Data.Interfaces;
+using Streetwriters.Data.Repositories;
+
+namespace Notesnook.API.Repositories
+{
+    public class SyncItemsRepository<T> : Repository<T> where T : SyncItem
+    {
+        public SyncItemsRepository(IDbContext dbContext) : base(dbContext)
+        {
+            Collection.Indexes.CreateOne(new CreateIndexModel<T>(Builders<T>.IndexKeys.Descending(i => i.DateSynced).Ascending(i => i.UserId)));
+            Collection.Indexes.CreateOne(new CreateIndexModel<T>(Builders<T>.IndexKeys.Ascending((i) => i.ItemId).Ascending(i => i.UserId)));
+        }
+
+        private readonly List<string> ALGORITHMS = new List<string> { Algorithms.Default };
+        private bool IsValidAlgorithm(string algorithm)
+        {
+            return ALGORITHMS.Contains(algorithm);
+        }
+
+        public async Task<IEnumerable<T>> GetItemsSyncedAfterAsync(string userId, long timestamp)
+        {
+            var cursor = await Collection.FindAsync(n => (n.DateSynced > timestamp) && n.UserId.Equals(userId));
+            return cursor.ToList();
+        }
+
+        // public async Task DeleteIdsAsync(string[] ids, string userId, CancellationToken token = default(CancellationToken))
+        // {
+        //     await Collection.DeleteManyAsync<T>((i) => ids.Contains(i.Id) && i.UserId == userId, token);
+        // }
+
+        public void DeleteByUserId(string userId)
+        {
+            dbContext.AddCommand((handle, ct) => Collection.DeleteManyAsync<T>(handle, (i) => i.UserId == userId, cancellationToken: ct));
+        }
+
+        public async Task UpsertAsync(T item, string userId, long dateSynced)
+        {
+
+            if (item.Length > 15 * 1024 * 1024)
+            {
+                throw new Exception($"Size of item \"{item.ItemId}\" is too large. Maximum allowed size is 15 MB.");
+            }
+
+            if (!IsValidAlgorithm(item.Algorithm))
+            {
+                throw new Exception($"Invalid alg identifier {item.Algorithm}");
+            }
+
+            item.DateSynced = dateSynced;
+            item.UserId = userId;
+
+            await base.UpsertAsync(item, (x) => (x.ItemId == item.ItemId) && x.UserId == userId);
+        }
+
+        public void Upsert(T item, string userId, long dateSynced)
+        {
+
+            if (item.Length > 15 * 1024 * 1024)
+            {
+                throw new Exception($"Size of item \"{item.ItemId}\" is too large. Maximum allowed size is 15 MB.");
+            }
+
+            if (!IsValidAlgorithm(item.Algorithm))
+            {
+                throw new Exception($"Invalid alg identifier {item.Algorithm}");
+            }
+
+            item.DateSynced = dateSynced;
+            item.UserId = userId;
+
+            // await base.UpsertAsync(item, (x) => (x.ItemId == item.ItemId) && x.UserId == userId);
+            base.Upsert(item, (x) => (x.ItemId == item.ItemId) && x.UserId == userId);
+        }
+    }
+}
--- a/Notesnook.API/Services/S3Service.cs
+++ b/Notesnook.API/Services/S3Service.cs
@@ -0,0 +1,211 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Amazon;
+using Amazon.Runtime;
+using Amazon.S3;
+using Amazon.S3.Model;
+using Microsoft.Extensions.Options;
+using Notesnook.API.Interfaces;
+using Notesnook.API.Models;
+using Streetwriters.Common;
+
+namespace Notesnook.API.Services
+{
+    public class S3Service : IS3Service
+    {
+        private readonly string BUCKET_NAME = "nn-attachments";
+        private AmazonS3Client S3Client { get; }
+        private HttpClient httpClient = new HttpClient();
+
+        public S3Service(IOptions<S3Options> s3Options)
+        {
+            var config = new AmazonS3Config
+            {
+#if DEBUG
+                ServiceURL = Servers.S3Server.ToString(),
+#else
+                ServiceURL = s3Options.Value.ServiceUrl,
+                AuthenticationRegion = s3Options.Value.Region,
+#endif
+                ForcePathStyle = true,
+                SignatureMethod = SigningAlgorithm.HmacSHA256,
+                SignatureVersion = "4"
+            };
+#if DEBUG
+            S3Client = new AmazonS3Client("S3RVER", "S3RVER", config);
+#else
+            S3Client = new AmazonS3Client(s3Options.Value.AccessKeyId, s3Options.Value.SecretAccessKey, config);
+#endif
+            AWSConfigsS3.UseSignatureVersion4 = true;
+        }
+
+        public async Task DeleteObjectAsync(string userId, string name)
+        {
+            var objectName = GetFullObjectName(userId, name);
+            if (objectName == null) throw new Exception("Invalid object name."); ;
+
+            var response = await S3Client.DeleteObjectAsync(BUCKET_NAME, objectName);
+
+            if (!IsSuccessStatusCode(((int)response.HttpStatusCode)))
+                throw new Exception("Could not delete object.");
+        }
+
+        public async Task DeleteDirectoryAsync(string userId)
+        {
+            var request = new ListObjectsV2Request
+            {
+                BucketName = BUCKET_NAME,
+                Prefix = userId,
+            };
+
+            var response = new ListObjectsV2Response();
+            var keys = new List<KeyVersion>();
+            do
+            {
+                response = await S3Client.ListObjectsV2Async(request);
+                response.S3Objects.ForEach(obj => keys.Add(new KeyVersion
+                {
+                    Key = obj.Key,
+                }));
+
+                request.ContinuationToken = response.NextContinuationToken;
+            }
+            while (response.IsTruncated);
+
+            if (keys.Count <= 0) return;
+
+            var deleteObjectsResponse = await S3Client
+            .DeleteObjectsAsync(new DeleteObjectsRequest
+            {
+                BucketName = BUCKET_NAME,
+                Objects = keys,
+            });
+
+            if (!IsSuccessStatusCode((int)deleteObjectsResponse.HttpStatusCode))
+                throw new Exception("Could not delete directory.");
+        }
+
+        public async Task<long?> GetObjectSizeAsync(string userId, string name)
+        {
+            var url = this.GetPresignedURL(userId, name, HttpVerb.HEAD);
+            if (url == null) return null;
+
+            var request = new HttpRequestMessage(HttpMethod.Head, url);
+            var response = await httpClient.SendAsync(request);
+            return response.Content.Headers.ContentLength;
+        }
+
+
+        public string GetUploadObjectUrl(string userId, string name)
+        {
+            var url = this.GetPresignedURL(userId, name, HttpVerb.PUT);
+            if (url == null) return null;
+            return url;
+        }
+
+        public string GetDownloadObjectUrl(string userId, string name)
+        {
+            var url = this.GetPresignedURL(userId, name, HttpVerb.GET);
+            if (url == null) return null;
+            return url;
+        }
+
+        public async Task<MultipartUploadMeta> StartMultipartUploadAsync(string userId, string name, int parts, string uploadId = null)
+        {
+            var objectName = GetFullObjectName(userId, name);
+            if (userId == null || objectName == null) throw new Exception("Could not initiate multipart upload.");
+
+            if (string.IsNullOrEmpty(uploadId))
+            {
+                var response = await S3Client.InitiateMultipartUploadAsync(BUCKET_NAME, objectName);
+                if (!IsSuccessStatusCode(((int)response.HttpStatusCode))) throw new Exception("Failed to initiate multipart upload.");
+
+                uploadId = response.UploadId;
+            }
+
+            var signedUrls = new string[parts];
+            for (var i = 0; i < parts; ++i)
+            {
+                signedUrls[i] = GetPresignedURLForUploadPart(objectName, uploadId, i + 1);
+            }
+
+            return new MultipartUploadMeta
+            {
+                UploadId = uploadId,
+                Parts = signedUrls
+            };
+        }
+
+        public async Task AbortMultipartUploadAsync(string userId, string name, string uploadId)
+        {
+            var objectName = GetFullObjectName(userId, name);
+            if (userId == null || objectName == null) throw new Exception("Could not abort multipart upload.");
+
+            var response = await S3Client.AbortMultipartUploadAsync(BUCKET_NAME, objectName, uploadId);
+            if (!IsSuccessStatusCode(((int)response.HttpStatusCode))) throw new Exception("Failed to abort multipart upload.");
+        }
+
+        public async Task CompleteMultipartUploadAsync(string userId, CompleteMultipartUploadRequest uploadRequest)
+        {
+            var objectName = GetFullObjectName(userId, uploadRequest.Key);
+            if (userId == null || objectName == null) throw new Exception("Could not abort multipart upload.");
+
+            uploadRequest.Key = objectName;
+            uploadRequest.BucketName = BUCKET_NAME;
+            var response = await S3Client.CompleteMultipartUploadAsync(uploadRequest);
+            if (!IsSuccessStatusCode(((int)response.HttpStatusCode))) throw new Exception("Failed to complete multipart upload.");
+        }
+
+        private string GetPresignedURL(string userId, string name, HttpVerb httpVerb)
+        {
+            var objectName = GetFullObjectName(userId, name);
+            if (userId == null || objectName == null) return null;
+
+            var request = new GetPreSignedUrlRequest
+            {
+                BucketName = BUCKET_NAME,
+                Expires = System.DateTime.Now.AddHours(1),
+                Verb = httpVerb,
+                Key = objectName,
+#if DEBUG
+                Protocol = Protocol.HTTP,
+#else
+                Protocol = Protocol.HTTPS,
+#endif
+            };
+            return S3Client.GetPreSignedURL(request);
+        }
+
+        private string GetPresignedURLForUploadPart(string objectName, string uploadId, int partNumber)
+        {
+            return S3Client.GetPreSignedURL(new GetPreSignedUrlRequest
+            {
+                BucketName = BUCKET_NAME,
+                Expires = System.DateTime.Now.AddHours(1),
+                Verb = HttpVerb.PUT,
+                Key = objectName,
+                PartNumber = partNumber,
+                UploadId = uploadId,
+#if DEBUG
+                Protocol = Protocol.HTTP,
+#else
+                Protocol = Protocol.HTTPS,
+#endif
+            });
+        }
+
+        private string GetFullObjectName(string userId, string name)
+        {
+            if (userId == null || !Regex.IsMatch(name, "[0-9a-zA-Z!" + Regex.Escape("-") + "_.*'()]")) return null;
+            return $"{userId}/{name}";
+        }
+
+        bool IsSuccessStatusCode(int statusCode)
+        {
+            return ((int)statusCode >= 200) && ((int)statusCode <= 299);
+        }
+    }
+}
--- a/Notesnook.API/Services/UserService.cs
+++ b/Notesnook.API/Services/UserService.cs
@@ -0,0 +1,194 @@
+using System;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Notesnook.API.Interfaces;
+using Notesnook.API.Models;
+using Notesnook.API.Models.Responses;
+using Streetwriters.Common;
+using Streetwriters.Common.Enums;
+using Streetwriters.Common.Extensions;
+using Streetwriters.Common.Messages;
+using Streetwriters.Common.Models;
+using Streetwriters.Data.Interfaces;
+
+namespace Notesnook.API.Services
+{
+    public class UserService : IUserService
+    {
+        private static readonly System.Security.Cryptography.RandomNumberGenerator Rng = System.Security.Cryptography.RandomNumberGenerator.Create();
+        private readonly HttpClient httpClient;
+        private IHttpContextAccessor HttpContextAccessor { get; }
+        private ISyncItemsRepositoryAccessor Repositories { get; }
+        private IS3Service S3Service { get; set; }
+        private readonly IUnitOfWork unit;
+
+        public UserService(IHttpContextAccessor accessor,
+        ISyncItemsRepositoryAccessor syncItemsRepositoryAccessor,
+        IUnitOfWork unitOfWork, IS3Service s3Service)
+        {
+            httpClient = new HttpClient();
+
+            Repositories = syncItemsRepositoryAccessor;
+            HttpContextAccessor = accessor;
+            unit = unitOfWork;
+            S3Service = s3Service;
+        }
+
+        public async Task CreateUserAsync()
+        {
+            SignupResponse response = await httpClient.ForwardAsync<SignupResponse>(this.HttpContextAccessor, $"{Servers.IdentityServer}/signup", HttpMethod.Post);
+            if (!response.Success || (response.Errors != null && response.Errors.Length > 0))
+            {
+                await Slogger<UserService>.Error(nameof(CreateUserAsync), "Couldn't sign up.", JsonSerializer.Serialize(response));
+                if (response.Errors != null && response.Errors.Length > 0) throw new Exception(string.Join(" ", response.Errors));
+                else throw new Exception("Could not create a new account. Error code: " + response.StatusCode);
+            }
+
+            await Repositories.UsersSettings.InsertAsync(new UserSettings
+            {
+                UserId = response.UserId,
+                LastSynced = 0,
+                Salt = GetSalt()
+            });
+
+            await WampServers.SubscriptionServer.PublishMessageAsync(WampServers.SubscriptionServer.Topics.CreateSubscriptionTopic, new CreateSubscriptionMessage
+            {
+                AppId = ApplicationType.NOTESNOOK,
+                Provider = SubscriptionProvider.STREETWRITERS,
+                Type = SubscriptionType.BASIC,
+                UserId = response.UserId,
+                StartTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+            });
+
+            await Slogger<UserService>.Info(nameof(CreateUserAsync), "New user created.", JsonSerializer.Serialize(response));
+        }
+
+        public async Task<UserResponse> GetUserAsync(bool repair = true)
+        {
+            UserResponse response = await httpClient.ForwardAsync<UserResponse>(this.HttpContextAccessor, $"{Servers.IdentityServer.ToString()}/account", HttpMethod.Get);
+            if (!response.Success) return response;
+
+            SubscriptionResponse subscriptionResponse = await httpClient.ForwardAsync<SubscriptionResponse>(this.HttpContextAccessor, $"{Servers.SubscriptionServer}/subscriptions", HttpMethod.Get);
+            if (repair && subscriptionResponse.StatusCode == 404)
+            {
+                await Slogger<UserService>.Error(nameof(GetUserAsync), "Repairing user subscription.", JsonSerializer.Serialize(response));
+                // user was partially created. We should continue the process here.
+                await WampServers.SubscriptionServer.PublishMessageAsync(WampServers.SubscriptionServer.Topics.CreateSubscriptionTopic, new CreateSubscriptionMessage
+                {
+                    AppId = ApplicationType.NOTESNOOK,
+                    Provider = SubscriptionProvider.STREETWRITERS,
+                    Type = SubscriptionType.TRIAL,
+                    UserId = response.UserId,
+                    StartTime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                    ExpiryTime = DateTimeOffset.UtcNow.AddDays(7).ToUnixTimeMilliseconds()
+                });
+                // just a dummy object
+                subscriptionResponse.Subscription = new Subscription
+                {
+                    AppId = ApplicationType.NOTESNOOK,
+                    Provider = SubscriptionProvider.STREETWRITERS,
+                    Type = SubscriptionType.TRIAL,
+                    UserId = response.UserId,
+                    StartDate = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+                    ExpiryDate = DateTimeOffset.UtcNow.AddDays(7).ToUnixTimeMilliseconds()
+                };
+            }
+
+            var userSettings = await Repositories.UsersSettings.FindOneAsync((u) => u.UserId == response.UserId);
+            if (repair && userSettings == null)
+            {
+                await Slogger<UserService>.Error(nameof(GetUserAsync), "Repairing user settings.", JsonSerializer.Serialize(response));
+                userSettings = new UserSettings
+                {
+                    UserId = response.UserId,
+                    LastSynced = 0,
+                    Salt = GetSalt()
+                };
+                await Repositories.UsersSettings.InsertAsync(userSettings);
+            }
+            response.AttachmentsKey = userSettings.AttachmentsKey;
+            response.Salt = userSettings.Salt;
+            response.Subscription = subscriptionResponse.Subscription;
+            return response;
+        }
+
+        public async Task SetUserAttachmentsKeyAsync(string userId, IEncrypted key)
+        {
+            var userSettings = await Repositories.UsersSettings.FindOneAsync((u) => u.UserId == userId);
+            userSettings.AttachmentsKey = (EncryptedData)key;
+            await Repositories.UsersSettings.UpdateAsync(userSettings.Id, userSettings);
+        }
+
+        public async Task<bool> DeleteUserAsync(string userId, string jti)
+        {
+            var cc = new CancellationTokenSource();
+
+            Repositories.Notes.DeleteByUserId(userId);
+            Repositories.Notebooks.DeleteByUserId(userId);
+            Repositories.Shortcuts.DeleteByUserId(userId);
+            Repositories.Contents.DeleteByUserId(userId);
+            Repositories.Settings.DeleteByUserId(userId);
+            Repositories.Attachments.DeleteByUserId(userId);
+            Repositories.UsersSettings.Delete((u) => u.UserId == userId);
+
+            await WampServers.SubscriptionServer.PublishMessageAsync(WampServers.SubscriptionServer.Topics.DeleteSubscriptionTopic, new DeleteSubscriptionMessage
+            {
+                AppId = ApplicationType.NOTESNOOK,
+                UserId = userId
+            });
+
+            await WampServers.MessengerServer.PublishMessageAsync(WampServers.MessengerServer.Topics.SendSSETopic, new SendSSEMessage
+            {
+                SendToAll = false,
+                OriginTokenId = jti,
+                UserId = userId,
+                Message = new Message
+                {
+                    Type = "userDeleted",
+                    Data = JsonSerializer.Serialize(new { reason = "accountDeleted" })
+                }
+            });
+
+            await S3Service.DeleteDirectoryAsync(userId);
+
+            return await unit.Commit();
+        }
+
+        public async Task<bool> ResetUserAsync(string userId, bool removeAttachments)
+        {
+            var cc = new CancellationTokenSource();
+
+            Repositories.Notes.DeleteByUserId(userId);
+            Repositories.Notebooks.DeleteByUserId(userId);
+            Repositories.Shortcuts.DeleteByUserId(userId);
+            Repositories.Contents.DeleteByUserId(userId);
+            Repositories.Settings.DeleteByUserId(userId);
+            Repositories.Attachments.DeleteByUserId(userId);
+            Repositories.Monographs.DeleteMany((m) => m.UserId == userId);
+            if (!await unit.Commit()) return false;
+
+            var userSettings = await Repositories.UsersSettings.FindOneAsync((s) => s.UserId == userId);
+
+            userSettings.AttachmentsKey = null;
+            userSettings.VaultKey = null;
+            userSettings.LastSynced = 0;
+
+            await Repositories.UsersSettings.UpsertAsync(userSettings, (s) => s.UserId == userId);
+
+            if (removeAttachments)
+                await S3Service.DeleteDirectoryAsync(userId);
+
+            return true;
+        }
+
+        private string GetSalt()
+        {
+            byte[] salt = new byte[16];
+            Rng.GetNonZeroBytes(salt);
+            return Convert.ToBase64String(salt).TrimEnd('=').Replace('+', '-').Replace('/', '_');
+        }
+    }
+}
--- a/Notesnook.API/Startup.cs
+++ b/Notesnook.API/Startup.cs
@@ -0,0 +1,233 @@
+using System;
+using System.IdentityModel.Tokens.Jwt;
+using System.IO.Compression;
+using System.Security.Claims;
+using System.Text;
+using System.Text.Encodings.Web;
+using System.Threading.Tasks;
+using IdentityModel.AspNetCore.OAuth2Introspection;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Connections;
+using Microsoft.AspNetCore.HttpOverrides;
+using Microsoft.AspNetCore.ResponseCompression;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using MongoDB.Bson.Serialization;
+using Notesnook.API.Accessors;
+using Notesnook.API.Authorization;
+using Notesnook.API.Extensions;
+using Notesnook.API.Hubs;
+using Notesnook.API.Interfaces;
+using Notesnook.API.Models;
+using Notesnook.API.Repositories;
+using Notesnook.API.Services;
+using Streetwriters.Common;
+using Streetwriters.Common.Extensions;
+using Streetwriters.Common.Messages;
+using Streetwriters.Common.Models;
+using Streetwriters.Data;
+using Streetwriters.Data.DbContexts;
+using Streetwriters.Data.Interfaces;
+using Streetwriters.Data.Repositories;
+
+namespace Notesnook.API
+{
+    public class Startup
+    {
+        public Startup(IConfiguration configuration)
+        {
+            Configuration = configuration;
+        }
+
+        public IConfiguration Configuration { get; }
+
+        // This method gets called by the runtime. Use this method to add services to the container.
+        public void ConfigureServices(IServiceCollection services)
+        {
+            var dbSettings = Configuration.GetSection("MongoDbSettings").Get<DbSettings>();
+            services.AddSingleton<IDbSettings>(dbSettings);
+
+            services.TryAddSingleton<IHttpContextAccessor, HttpContextAccessor>();
+
+            JwtSecurityTokenHandler.DefaultMapInboundClaims = false;
+            JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
+
+            services.AddCors();
+
+            services.AddDistributedMemoryCache(delegate (MemoryDistributedCacheOptions cacheOptions)
+            {
+                cacheOptions.SizeLimit = 262144000L;
+            });
+
+            services.AddAuthorization(options =>
+            {
+                options.AddPolicy("Notesnook", policy =>
+                {
+                    policy.AuthenticationSchemes.Add("introspection");
+                    policy.RequireAuthenticatedUser();
+                    policy.Requirements.Add(new NotesnookUserRequirement());
+                });
+                options.AddPolicy("Sync", policy =>
+                {
+                    policy.AuthenticationSchemes.Add("introspection");
+                    policy.RequireAuthenticatedUser();
+                    policy.Requirements.Add(new SyncRequirement());
+                });
+                options.AddPolicy("Verified", policy =>
+                {
+                    policy.AuthenticationSchemes.Add("introspection");
+                    policy.RequireAuthenticatedUser();
+                    policy.Requirements.Add(new EmailVerifiedRequirement());
+                });
+                options.AddPolicy("Pro", policy =>
+                {
+                    policy.AuthenticationSchemes.Add("introspection");
+                    policy.RequireAuthenticatedUser();
+                    policy.Requirements.Add(new ProUserRequirement());
+                });
+                options.AddPolicy("BasicAdmin", policy =>
+                {
+                    policy.AuthenticationSchemes.Add("BasicAuthentication");
+                    policy.RequireClaim(ClaimTypes.Role, "Admin");
+                });
+
+                options.DefaultPolicy = options.GetPolicy("Notesnook");
+            }).AddSingleton<IAuthorizationMiddlewareResultHandler, AuthorizationResultTransformer>(); ;
+
+            services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+            .AddOAuth2Introspection("introspection", options =>
+            {
+                options.Authority = Servers.IdentityServer.ToString();
+                options.ClientSecret = Environment.GetEnvironmentVariable("NOTESNOOK_API_SECRET");
+                options.ClientId = "notesnook";
+                options.DiscoveryPolicy.RequireHttps = false;
+                options.TokenRetriever = new Func<HttpRequest, string>(req =>
+                {
+                    var fromHeader = TokenRetrieval.FromAuthorizationHeader();
+                    var fromQuery = TokenRetrieval.FromQueryString();   //needed for signalr and ws/wss conections to be authed via jwt
+                    return fromHeader(req) ?? fromQuery(req);
+                });
+
+                options.Events.OnTokenValidated = (context) =>
+                {
+                    if (long.TryParse(context.Principal.FindFirst("exp")?.Value, out long expiryTime))
+                    {
+                        context.Properties.ExpiresUtc = DateTimeOffset.FromUnixTimeSeconds(expiryTime);
+                    }
+                    context.Properties.AllowRefresh = true;
+                    context.Properties.IsPersistent = true;
+                    context.HttpContext.User = context.Principal;
+                    return Task.CompletedTask;
+                };
+                options.SaveToken = true;
+                options.EnableCaching = true;
+                options.CacheDuration = TimeSpan.FromMinutes(30);
+            });
+
+            if (!BsonClassMap.IsClassMapRegistered(typeof(UserSettings)))
+            {
+                BsonClassMap.RegisterClassMap<UserSettings>();
+            }
+
+            if (!BsonClassMap.IsClassMapRegistered(typeof(EncryptedData)))
+            {
+                BsonClassMap.RegisterClassMap<EncryptedData>();
+            }
+
+            if (!BsonClassMap.IsClassMapRegistered(typeof(CallToAction)))
+            {
+                BsonClassMap.RegisterClassMap<CallToAction>();
+            }
+
+            if (!BsonClassMap.IsClassMapRegistered(typeof(Announcement)))
+            {
+                BsonClassMap.RegisterClassMap<Announcement>();
+            }
+
+            services.AddScoped<IDbContext, MongoDbContext>();
+            services.AddScoped<IUnitOfWork, UnitOfWork>();
+            services.AddScoped(typeof(Repository<>));
+            services.AddScoped(typeof(SyncItemsRepository<>));
+
+            services.TryAddTransient<ISyncItemsRepositoryAccessor, SyncItemsRepositoryAccessor>();
+            services.TryAddTransient<IUserService, UserService>();
+            services.TryAddTransient<IS3Service, S3Service>();
+
+            services.AddControllers();
+
+            services.AddHealthChecks().AddMongoDb(dbSettings.ConnectionString, dbSettings.DatabaseName, "database-check");
+            services.AddSignalR((hub) =>
+            {
+                hub.MaximumReceiveMessageSize = 100 * 1024 * 1024;
+                hub.EnableDetailedErrors = true;
+            }).AddMessagePackProtocol();
+
+            services.AddResponseCompression(options =>
+            {
+                options.EnableForHttps = true;
+                options.Providers.Add<BrotliCompressionProvider>();
+                options.Providers.Add<GzipCompressionProvider>();
+            });
+
+            services.Configure<BrotliCompressionProviderOptions>(options =>
+            {
+                options.Level = CompressionLevel.Fastest;
+            });
+            services.Configure<GzipCompressionProviderOptions>(options =>
+            {
+                options.Level = CompressionLevel.Fastest;
+            });
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+        {
+            if (!env.IsDevelopment())
+            {
+                app.UseForwardedHeaders(new ForwardedHeadersOptions
+                {
+                    ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
+                });
+            }
+
+            app.UseResponseCompression();
+
+            app.UseCors("notesnook");
+
+            app.UseWamp(WampServers.NotesnookServer, (realm, server) =>
+            {
+                IUserService service = app.GetScopedService<IUserService>();
+                realm.Subscribe<DeleteUserMessage>(server.Topics.DeleteUserTopic, async (ev) =>
+                {
+                    await service.DeleteUserAsync(ev.UserId, null);
+                });
+            });
+
+            app.UseRouting();
+
+            app.UseAuthentication();
+            app.UseAuthorization();
+
+            app.UseEndpoints(endpoints =>
+            {
+                endpoints.MapControllers();
+                endpoints.MapHealthChecks("/health");
+                endpoints.MapHub<SyncHub>("/hubs/sync", options =>
+                {
+                    options.CloseOnAuthenticationExpiration = false;
+                    options.Transports = HttpTransportType.WebSockets;
+                });
+            });
+        }
+    }
+}
--- a/Notesnook.API/appsettings.Development.json
+++ b/Notesnook.API/appsettings.Development.json
@@ -0,0 +1,13 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "MongoDbSettings": {
+    "ConnectionString": "mongodb://localhost:27017/notesnook",
+    "DatabaseName": "notesnook"
+  }
+}