It can be beneficial to support new businesses through a dedicated pre-regulated service and operating account, through to a fully licensed bank. This approach can provide cost-effective “access ...

Tagged: clearbank

Dropblock for mobile launches today, a free, Web3 storage application offering individuals, developers, and business users a unique and completely secure mobile storage and data-sharing solution. Simply download Dropblock today from the App Store or from ...

New Dropblock Mobile App Offers Free, Completely Secure Data Storage and Sharing

We are delighted to announce that BMLL has won the ‘Best Data Science Solution’ at the Hedgeweek US Emerging Manager Awards 2023. The award recognises excellence among hedge fund emerging fund managers and service providers. The nominated firms were ...

BMLL wins ‘Best Data Science Solution’ at the Hedgeweek US Emerging Manager Awards 2023

Global information and insights company TransUnion is working with personal credit platform Monevo and incuto – a fintech for social good – to offer UK consumers improved access to credit and ...

TransUnion, Monevo and Incuto collaborate on credit access for community banks

Global information and insights company TransUnion is working with personal credit platform Monevo and incuto – a fintech for social good – to offer UK consumers improved access to credit and a broader range of affordable credit products. This joint ...

TransUnion, Monevo and Incuto Come Together To Expand Consumer Access to Credit

It’s like Harold Wilson’s ‘white heat of technology’ visio...

Future of Cities Debate: building world class urban innovation centres for the future

So it development with incuto supply all of our people borrowing choices away from not-for-cash neighborhood lenders brings a much-called for solution.” incuto, which is the leading technology merchant in order to borrowing unions, did alongside Experian ...

Experian releases money of non-funds society loan providers

Il telefono squilla: numero sconosciuto. Ma so chi è, dall’altra parte. Erin Doom è una voce dolce e calma, un silenzio per scegliere bene le parole e qualche volta una risata all’improvviso ...

Erin Doom: «L’ombra è meglio della luce»

Incuto

incuto

Once, I had a requirement to implement server-side logging for GRPC requests. GRPC has an interceptor mechanism that can be used for logging, GRPC request verification, authentication, etc. To intercept requests on the server side, it is necessary to implement ServerInterceptor. And inherit two abstract classes, ServerCall and ServerCall.Listener. First, let’s make our implementation of ServerCall.Listener. There is ForwardingServerCallListener that gives calls to the next listener in the chain. We will extend this class and override the method onMessage. We will use the ConcurrentLinkedQueue for storing received requests. This method might be invoked more than one time if using client-side streaming. Also, there are the onComplete and onCancel methods that will be invoked after completing the GRPC request or after the client’s cancelation. Our implementation uses the queue for storing sent requests. class LoggingServerCallListener<ReqT>(
    private val delegate: ServerCall.Listener<ReqT>,
    private val input: ConcurrentLinkedQueue<ReqT>
) : ForwardingServerCallListener<ReqT>() {

    override fun delegate(): ServerCall.Listener<ReqT> {
        return delegate
    }

    override fun onMessage(message: ReqT) {
        super.onMessage(message)
        input.offer(message)
    }
} Next, we need to implement the ServerCall class. There is the implementation SimpleForwardingServerCall that works as ForwardingServerCallListener for ServerCall.Listener. We will use the same instance of ConcurrentLinkedQueue for getting received requests. Also, we will use another instance of the queue for storing sent responses. We will implement the sendMessage method that invokes before a response is sent to a client. This method can be invoked more than once if the result is server-side streaming. We will also override the close method, which will be called after all data has been sent to the client or an error occurs. The method ensures that there will be no further calls to onMessage or sendMessage. import com.google.protobuf.GeneratedMessageV3
import com.google.protobuf.util.JsonFormat
import io.grpc.ForwardingServerCall.SimpleForwardingServerCall
import io.grpc.Metadata
import io.grpc.ServerCall
import io.grpc.Status
import org.slf4j.LoggerFactory
import java.util.concurrent.ConcurrentLinkedQueue

class LoggingServerCall<RequestType, ResponseType>(
    delegate: ServerCall<RequestType, ResponseType>,
    private val metadata: Metadata,
    private val input: ConcurrentLinkedQueue<RequestType>,
    private val output: ConcurrentLinkedQueue<ResponseType>
) : SimpleForwardingServerCall<RequestType, ResponseType>(delegate) {

    override fun sendMessage(message: ResponseType) {
        output.offer(message)
        super.sendMessage(message)
    }

    override fun close(status: Status, trailers: Metadata) {
        if (status.isOk) {
            val requestId = metadata.get(REQUEST_ID_METADATA_KEY)

            val printer = JsonFormat.printer()

            val request = input
                .filterIsInstance<GeneratedMessageV3>()
                .joinToString(separator = ", ", prefix = "[", postfix = "]", transform = printer::print)

            val response = output
                .filterIsInstance<GeneratedMessageV3>()
                .joinToString(separator = ", ", prefix = "[", postfix = "]", transform = printer::print)

            logger.info("The request with id: $requestId and request data $request returns $response")

        } else if (listOf(Status.INTERNAL.code, Status.NOT_FOUND.code, Status.INVALID_ARGUMENT.code).contains(status.code)) {
            val requestId = metadata.get(REQUEST_ID_METADATA_KEY)
            logger.error("An error occurred while processing the request with request-id $requestId", status.asRuntimeException())
        }

        super.close(status, trailers)
    }

    companion object {
        private val logger = LoggerFactory.getLogger(LoggingServerCall::class.java)
        private val REQUEST_ID_METADATA_KEY = Metadata.Key.of("x-request-id", Metadata.ASCII_STRING_MARSHALLER)
    }
} Our implementation is very simple. We use JsonFormater for converting protobuf to JSON and joining to the string. Also, we take a request ID from the metadata for emulating real logging situations. Then we log the message into the system out. If an error occurs, we will log it. After that, the onComplete/onCancel methods of the listener will be called. Next, we must implement our ServerInterceptor which uses both our ServerCall and ServerCall.Listener. class LoggingInterceptor : ServerInterceptor {
    override fun <ReqT : Any, RespT : Any?> interceptCall(
        call: ServerCall<ReqT, RespT>,
        headers: Metadata,
        next: ServerCallHandler<ReqT, RespT>
    ): ServerCall.Listener<ReqT> {
        val input = ConcurrentLinkedQueue<ReqT>()
        val output = ConcurrentLinkedQueue<RespT>()
        val loggingServerCall = LoggingServerCall(call, headers, input, output)
        return LoggingServerCallListener(next.startCall(loggingServerCall, headers), input)
    }
} To start the processing request, we must call the startCall method of the ServerCallHandler class. After that, we must register our server interceptor. fun main(args: Array<String>) {
	val server = ServerBuilder
        .forPort(8080)
		.addService(OurGrpcService())
		.intercept(LoggingInterceptor())
		.build()
	
	server.start()
} In the second part, we consider how to work with client interceptors. I hope the article can help you with how to work with the server-side interceptors in GRPC.

How to Implement Server-Side Interceptors for Logging GRPC Requests

Real Time Data Processing: Easily Processing 10 Million Messages With Golang, Kafka and MongoDB

How to Use Next.js to Implement the Backends-for-Frontends Pattern

The world of NFTs is vast and although this type of asset has been in circulation for several years now, the news and developments related to them have not stopped, bringing novelty and innovation in the creation and in providing additional previously unthinkable features. Apparently, this trend that has launched the various blockchains to be more used, thanks to the simplicity of creating NFTs, has led to some blockchains achieving greater success than others, with some remaining behind, such as that of Bitcoin, which, due to its structure and characteristics focused more on security than on speed or cost, is not configured as an optimal blockchain for NFT minting. Despite this, it doesn't mean that we cannot create NFTs on this blockchain, however by paying high fees and obviously also clogging up the related blockchain, creating heavy blocks containing information other than those for which the blockchain was designed. We will go into detail about how to create NFTs on Bitcoin and what the process is for creating both a compatible wallet and the NFTs themselves. NFT with the Ordinals protocol Some of you may know that 1 bitcoin is made up of 100 million units, called satoshis or sat for short, and these satoshis are numbered in order starting from 0. In fact, these numbers are “ordinal numbers”, and because of this, it is possible to exploit them to create NFTs. For those who want to learn more about this protocol, we recommend , instead below there is the algorithm that was created: checking here # subsidy of block at given height
def subsidy(height):
return 50 * 100_000_000 >> height // 210_000
# first ordinal of subsidy of block at given height
def first_ordinal(height):
start = 0
for height in range(height):
start += subsidy(height)
return start
# assign ordinals in given block
def assign_ordinals(block):
first = first_ordinal(block.height)
last = first + subsidy(block.height)
coinbase_ordinals = list(range(first, last))
for transaction in block.transactions[1:]:
ordinals = []
for input in transaction.inputs:
ordinals.extend(input.ordinals)
for output in transaction.outputs:
output.ordinals = ordinals[:output.value]
of ordinals[:output.value]
coinbase_ordinals.extend(ordinals)
for output in block.transaction[0].outputs:
output.ordinals = coinbase_ordinals[:output.value]
from coinbase_ordinals[:output.value] How to create a Bitcoin address for NFTs These NFTs exploit the satoshis and since the satoshis themselves are fungible, if we don't take precautions, we could end up transferring in a transaction even those satoshis to which the NFTs we have created are connected. We need to create a new address and wallet that allows us to have greater control over the movements of the satoshis in our address, and a useful tool for this purpose is certainly . Sparrow Wallet The first step is to download Sparrow wallet and create a new bitcoin address. After installing the wallet, we will have to create a new wallet and to do this we go to File and New Wallet: In the next screen, we will have to set a new address and to do it in the "Address" section we must choose "Taproot (P2TR)": Then we will need to click on the "New or Imported Bitcoin Address" button below to create a new Bitcoin address with those characteristics: At this point we should create the words relating to our address and we opt to use the number of words we prefer, in our case 12 words and press the "Generate New" button: Let's remember to type these words into the next step we will have to insert them and then press the "Create Keystore" button: Now we can import the keystore we created earlier, by clicking on the Import button: Finally, after we have created everything, we will have to press the "Apply" button: How to receive Bitcoin NFTs Using this wallet, we can also receive NFTs and we must remember to always create a new account to receive the different NFTs, and to do so, in the "Receive" menu, we find the button below to create a new address "Get Next Address" and use the address shown to us: To receive Bitcoin NFTs, we should freeze the UTXOs related to the NFTs and do so, we should right-click on the related transaction, then click the "Freeze UTXO" item. This will ensure that we will not send these NFTs by mistake. When we should transfer them, just do the reverse process and click on "Unfreze UTXO". How to mint an NFT on Bitcoin Now that we have all the tools to receive and avoid losing NFTs by mistake, it's time to see how to create our NFTs and do this we have two solutions, either by taking advantage of the related algorithm created and therefore all at the command line, or take advantage of some convenient and practical services. For those more geeks, they can check out the code directly on GitHub , instead for those who want the simplest approach we can take advantage of or , also because the procedure is simple and the steps are similar. here this service this other The first thing you need to do is load the image we want to transform into an NFT: After that, we have to enter our address where our NFT will be sent: At this point, we just have to pay the lee fee and wait for the transaction to arrive at our address, and in this case, we see that we are going to spend just under $13 and wait over 24 hours, while if we want the transaction to be processed in 30 minutes, then we should pay more around $70: How to see Bitcoin NFTs Once we have created the NFT, we can see it through some platforms , and just enter the hash of the transaction relating to the NFT to see all the information relating to it: like this Conclusions Bitcoin-based tokens are possible even if they are a little complicated and require a higher investment than on other platforms. Additionally, the cost of creating them is not as cheap as on other platforms. Finally I conclude with a video of the process: https://youtu.be/4losgVDBxIE?embedable=true

Creating NFTs on the Bitcoin Network

Doubtful Points and Criticism

Difficulties and Preliminary Approach

When I decided to build an open-source earlier this year and to build it in C# I needed a template for building the transport layer of the server. I was particularly happy when I checked out the TechEmpower benchmarks in which ASP.NET Kestrel currently ranks 3rd in plaintext benchmark scores with 7,023,107 responses per second. In this post, I will demonstrate how a high-performance TCP server can be built and I will do so by borrowing some ideas from Kestrel. Telegram Server The code presented leverages low allocation asynchronous programming patterns and pooling to be blazing fast. Socket operations in .NET are described by which is a reusable object that provides a callback-based asynchronous pattern. First this pattern needs to be wrapped with an async one by implementing the interface so that allocations for the asynchronous path can be avoided. SocketAsyncEventArgs IValueTaskSource AwaitableEventArgs.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketAwaitableEventArgs.cs#L10-L77
public class AwaitableEventArgs : SocketAsyncEventArgs, IValueTaskSource<int>
{
    private ManualResetValueTaskSourceCore<int> _source;

    public AwaitableEventArgs() :
        base(unsafeSuppressExecutionContextFlow: true)
    {
    }

    protected override void OnCompleted(SocketAsyncEventArgs args)
    {
        if (SocketError != SocketError.Success)
        {
            _source.SetException(new SocketException((int)SocketError));
        }

        _source.SetResult(BytesTransferred);
    }

    public int GetResult(short token)
    {
        int result = _source.GetResult(token);
        _source.Reset();
        return result;
    }

    public ValueTaskSourceStatus GetStatus(short token)
    {
        return _source.GetStatus(token);
    }

    public void OnCompleted(Action<object?> continuation, object? state, short token,
        ValueTaskSourceOnCompletedFlags flags)
    {
        _source.OnCompleted(continuation, state, token, flags);
    }
} This is rewritten from the original implementation and the main difference is this version uses for the sake of simplicity while the original one uses a thinner custom implementation of the interface. here ManualResetValueTaskSourceCore IValueTaskSource Needed and implementations are derived from the above. They first set the buffer for the and then call the respective or method of the which returns true if the I/O operation is pending in which case can be the for the returned as the base class implements the interface. When is fired, awaited will either return the bytes received/sent or throw an . However if the above call returns false it means the I/O operation completed synchronously and synchronous path needs to be handled. Receiver Sender AwaitableEventArgs SocketAsyncEventArgs SendAsync ReceiveAsync Socket Receiver/Sender source ValueTask OnCompleted(SocketAsyncEventArgs args) ValueTask Exception Receiver.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketReceiver.cs
public class Receiver : AwaitableEventArgs
{
   private short _token;
   public ValueTask<int> ReceiveAsync(Socket socket, Memory<byte> memory)
   {
      SetBuffer(memory);
      if (socket.ReceiveAsync(this))
      {
         return new ValueTask<int>(this, _token++);
      }

      var transferred = BytesTransferred;
      var err = SocketError;
      return err == SocketError.Success
         ? new ValueTask<int>(transferred)
         : ValueTask.FromException<int>(new SocketException((int)err));
   }
} also needs to handle the buffer being a as it will be the case. Sender ReadOnlySequence<byte> Sender.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketSender.cs
public class Sender: AwaitableEventArgs
{
    private short _token;
    private List<ArraySegment<byte>>? _buffers;
    public ValueTask<int> SendAsync(Socket socket, in ReadOnlyMemory<byte> data)
    {
        SetBuffer(MemoryMarshal.AsMemory(data));
        if (socket.SendAsync(this))
        {
            return new ValueTask<int>(this, _token++);
        }

        var transferred = BytesTransferred;
        var err = SocketError;
        return err == SocketError.Success
            ? new ValueTask<int>(transferred)
            : ValueTask.FromException<int>(new SocketException((int)err));
    }
    public ValueTask<int> SendAsync(Socket socket, in ReadOnlySequence<byte> data)
    {
        if (data.IsSingleSegment)
        {
            return SendAsync(socket, data.First);
        }
        _buffers ??= new List<ArraySegment<byte>>();
        foreach (var buff in data)
        {
            if (!MemoryMarshal.TryGetArray(buff, out var array))
            {
                throw new InvalidOperationException("Buffer is not backed by an array.");
            }

            _buffers.Add(array);
        }

        BufferList = _buffers;

        if (socket.SendAsync(this))
        {
            return new ValueTask<int>(this, _token++);
        }

        var transferred = BytesTransferred;
        var err = SocketError;
        return err == SocketError.Success
            ? new ValueTask<int>(transferred)
            : ValueTask.FromException<int>(new SocketException((int)err));
    }
    public void Reset()
    {
        if (BufferList != null)
        {
            BufferList = null;

            _buffers?.Clear();
        }
        else
        {
            SetBuffer(null, 0, 0);
        }
    }
} A lightweight implementation is also needed. This is backed by a and leverages for keeping a cheaper atomic count. SenderPool ConcurrentQueue Interlocked SenderPool.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketSenderPool.cs
public class SenderPool : IDisposable
{
    private readonly int MaxNumberOfSenders;
    private int _count;
    private readonly ConcurrentQueue<Sender> _senders = new();
    private bool _disposed = false;

    public SenderPool(int maxNumberOfSenders = 128)
    {
        MaxNumberOfSenders = maxNumberOfSenders;
    }

    public Sender Rent()
    {
        if (_senders.TryDequeue(out var sender))
        {
            Interlocked.Decrement(ref _count);
            sender.Reset();
            return sender;
        }

        return new Sender();
    }

    public void Return(Sender sender)
    {
        if (_disposed || _count >= MaxNumberOfSenders)
        {
            sender.Dispose();
        }
        else
        {
            Interlocked.Increment(ref _count);
            _senders.Enqueue(sender);
        }
    }

    public void Dispose()
    {
        if (_disposed) return;
        _disposed = true;
        while (_senders.TryDequeue(out var sender))
        {
            sender.Dispose();
        }
    }
} Now this is the part things start to get more fun. Writing a TCP server requires buffering and parsing streaming data which is a complex task and can be tedious and hard to get right the first time around. Luckily is designed exactly for this problem. It reduces code complexity and allows high performance parsing of streaming data. I highly recommend anyone reading this to read the original as well to get a better grasp. Next piece of code will leverage this library. System.IO.Pipelines article Connection.cs //From: https://github.com/dotnet/aspnetcore/blob/main/src/Servers/Kestrel/Transport.Sockets/src/Internal/SocketConnection.cs
public class Connection : IAsyncDisposable
{
    private const int MinBuffSize = 1024;
    private readonly Socket _socket;
    private readonly Receiver _receiver;
    private Sender? _sender;
    private readonly SenderPool _senderPool;
    private Task? _receiveTask;
    private Task? _sendTask;
    private readonly Pipe _transportPipe;
    private readonly Pipe _applicationPipe;
    private readonly object _shutdownLock = new object();
    private volatile bool _socketDisposed;
    public PipeWriter Output { get;}
    public PipeReader Input { get;}

    public Connection(Socket socket, SenderPool senderPool)
    {
        _socket = socket;
        _receiver = new Receiver();
        _senderPool = senderPool;
        _transportPipe = new Pipe();
        Output = _transportPipe.Writer;
        _applicationPipe = new Pipe();
        Input = _applicationPipe.Reader;
    }

    public void Start()
    {
        try
        {
            _sendTask = SendLoop();
            _receiveTask = ReceiveLoop();
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
    }
    private async Task SendLoop()
    {
        try
        {
            while (true)
            {
                var result = await _transportPipe.Reader.ReadAsync();
                if (result.IsCanceled)
                {
                    break;
                }
                var buff = result.Buffer;
                if (!buff.IsEmpty)
                {
                    _sender = _senderPool.Rent();
                    await _sender.SendAsync(_socket, result.Buffer);
                    _senderPool.Return(_sender);
                    _sender = null;
                }
                _transportPipe.Reader.AdvanceTo(buff.End);
                if (result.IsCompleted)
                {
                    break;
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
        finally
        {
            _applicationPipe.Writer.Complete();
            Shutdown();
        }
    }
    private async Task ReceiveLoop()
    {
        try
        {
            while (true)
            {
                var buff = _applicationPipe.Writer.GetMemory(MinBuffSize);
                var bytes = await _receiver.ReceiveAsync(_socket, buff);
                if (bytes == 0)
                {
                    break;
                }
                _applicationPipe.Writer.Advance(bytes);
                var result = await _applicationPipe.Writer.FlushAsync();
                if (result.IsCanceled || result.IsCompleted)
                {
                    break;
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }
        finally
        {
            _applicationPipe.Writer.Complete();
            Shutdown();
        }
    }

    public async ValueTask DisposeAsync()
    {
        _transportPipe.Reader.Complete();
        _applicationPipe.Writer.Complete();
        try
        {
            if (_receiveTask != null)
            {
                await _receiveTask;
            }

            if (_sendTask != null)
            {
                await _sendTask;
            }
        }
        finally
        {
            _receiver.Dispose();
            _sender?.Dispose();
        }
    }
    public void Shutdown()
    {
        lock (_shutdownLock)
        {
            if (_socketDisposed)
            {
                return;
            }
            _socketDisposed = true;
            try
            {
                _socket.Shutdown(SocketShutdown.Both);
            }
            finally
            {
                _socket.Dispose();
            }
        }
    }
} The class has: Connection a for the connection Receiver references to the and the Socket SenderPool a for transport and another one for the application Pipe and finally two loops for sending and receiving. So how do we send/receive data? The for the transport pipe is exposed as the public property and the polls for data written to this pipe renting a before every send operation returning it to the pool after completion. The for the application pipe is exposed as the public property and the basically gets a buffer from this pipe and receives into it. Then there is some cleanup code. This again is a simplified version of the original Kestrel implementation. PipeWriter Output SendLoop Sender PipeReader Input ReceiveLoop TCP Echo At this point a TCP Echo server needs just a few more lines of code. Following simply copies back the received bytes: Program.cs var senderPool = new SenderPool(1024);
var listenSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, 8989));
listenSocket.Listen(128);
while (true)
{
    var socket = await listenSocket.AcceptAsync();
    var connection = new Connection(socket, senderPool);
    _ = ProcessConnection(connection);
}

static async Task ProcessConnection(Connection connection)
{
    connection.Start();
    while (true)
    {
        var result = await connection.Input.ReadAsync();
        if (result.IsCanceled)
        {
            break;
        }
        var buff = result.Buffer;
        if (!buff.IsEmpty)
        {
            if (buff.IsSingleSegment)
            {
                await connection.Output.WriteAsync(buff.First);
            }
            else
            {
                foreach (var mem in buff)
                {
                    await connection.Output.WriteAsync(mem);
                }
            }
        }
        connection.Input.AdvanceTo(buff.End, buff.End);
        if (result.IsCompleted)
        {
            break;
        }
    }
    connection.Shutdown();
    await connection.DisposeAsync();
} This will serve as a base for a High Performance TCP Server but of course more measurements and optimizations might be necessary. Code above omits some more advanced implementation details for the sake of simplicity. Some of them are outlined below. schedule-me-not When creating a , it’s possible to specify a and ‘s for the reader and the writer via the and Kestrel uses a custom here along with a lock-free . implementation as well supports a as to have fine-grained control where the I/O happens. Following pseudo-code tries to simplify and outline how Kestrel utilizes schedulers. Pipe MemoryPool<byte> PipeScheduler PipeOptions PinnedBlockMemoryPool IOQueue SocketAwaitableEventArgs PipeScheduler var memoryPool = new PinnedBlockMemoryPool();
var applicationScheduler = PipeScheduler.ThreadPool;
var transportScheduler = new IOQueue();
var socketScheduler = transportScheduler;

var receiver = new SocketReceiver(socketScheduler);

var InputOptions = new PipeOptions(memoryPool, 
        applicationScheduler, transportScheduler, 
        maxReadBufferSize, maxReadBufferSize / 2, 
        useSynchronizationContext: false),

var OutputOptions = new PipeOptions(memoryPool, 
        transportScheduler, applicationScheduler, 
        maxWriteBufferSize, maxWriteBufferSize / 2, 
        useSynchronizationContext: false),

var SocketSenderPool = new SocketSenderPool(PipeScheduler.Inline), It can also be seen above and is used for flow control. This is when processing data is more complicated than simply sending it back in which case the reader would allocate more and more memory. When is set however and if the amount of data in the pipe is more than set value will not be completed until it is less than again. PauseWriterThreshold ResumeWriterThreshold PauseWriterThreshold PipeWriter.FlushAsync ResumeWriterThreshold Where to go from here? As I was writing the code for this post some preliminary benchmarks showed that the code presented is actually somewhat slower than a basic Echo Server. Netty would reach 115000 requests per second while code above would reach 110000. It however is a well-established framework, so it shouldn’t be too surprising. This just shows that some proper benchmarks are needed along with profiling and optimization. Netty The full source can be viewed at . the GitHub repo

Building a High Performance TCP Server in C#

REST has long been a popular architectural paradigm for creating , but in recent years has put REST's reign in jeopardy. APIs GraphQL's rise in popularity When it comes to establishing or leveraging API architecture design, the debate between GraphQL and REST is raging, and most firms are split between the two. While REST is generally recognized as the industry standard for creating APIs, GraphQL has been heralded as a new technology capable of overcoming REST's limitations. REST and GraphQL are two data retrieval technologies. The main distinction between GraphQL and RestAPIs is that GraphQL is a query language standard, whereas REST is an architectural idea for network-based computing. We'll walk you through the working process with both options, and you’ll be able to compare which one is more fit for you: GraphQL vs REST. But first, let’s define the terms. GraphQL Explanation GraphQL is a runtime for satisfying queries with existing data, as well as an open-source data query and manipulation language for APIs. GraphQL, which is largely maintained and developed by the GraphQL Foundation, has seen tremendous acceptance across a wide range of verticals and use cases, including companies such as Twitter, Expedia, Shopify, and GraphCMS, to mention a few. By allowing the user to receive just the data they expressly requested, this API architecture design eliminates any performance difficulties caused by extra fetching. Furthermore, many entities can be merged into a single query. GraphQL offers the advantage of tolerating client-side changes without affecting the server, allowing for quick front-end product updates. Developers that utilize GraphQL on the backend obtain a lot of information about any data request and how the available data is being used. You may also be interested in the Graph Database Examples outlook. RestAPI Definition RestAPI today is a much easier technique to enable stateless and type-free machine-to-machine communication using only the ubiquitous HTTP protocol and no other layers. This made it possible for systems to be loosely connected and more tolerant of contract changes between systems, such as between businesses. For firms delivering API architecture design and developing developer platforms, RestAPI has become the de facto norm. The benefit of REST is that it eliminates the need for any specific setup or libraries when interacting with someone else's API. Common tools such as cURL and web browsers can be used to send requests. REST's key advantage is that it is scalable and decouples client and server, enabling developers to work independently on products and applications. It is adaptable to a wide number of forms and can suit a wide range of requirements. Getting Started Now, we can compare both API architecture designs in practice. But, before we start with installation descriptions, you need to install a typical Django project, connect it to PostgreSQL and make migrations. For the following work you also need to provide simple Django models: GraphQL vs REST Store in models.py from django.db import models


class Store(models.Model):
   name = models.CharField(max_length=256, verbose_name='Store name')
   address = models.CharField(max_length=256)
   email = models.EmailField()
   opening_hours = models.TimeField(verbose_name='Opening hours')
   closing_hours = models.TimeField(verbose_name='Closing hours') And Product in another file: models.py from django.db import models
from django.core.validators import MaxValueValidator, MinValueValidator


class Product(models.Model):
   title = models.CharField(max_length=256, verbose_name='Product title')
   description = models.TextField(max_length=5000)
   price = models.FloatField(
       validators=[MinValueValidator(0.0), MaxValueValidator(10000.0)],
   )
   amount = models.SmallIntegerField()
   store = models.ForeignKey('stores.Store', on_delete=models.CASCADE) GraphQL In Django Installation process: pip install graphene-django In file: settings.py INSTALLED_APPS = [
    ...
    "django.contrib.staticfiles", # Required for GraphiQL
    "graphene_django"
]

GRAPHENE = {
    "SCHEMA": "app.schema.schema"
} We need to add a graphql URL to the of your Django project: urls.py from graphene_django.views import GraphQLView

from django.contrib import admin
from django.urls import path
from django.views.decorators.csrf import csrf_exempt

from app.schema import schema

urlpatterns = [
   path('admin/', admin.site.urls),
   path("graphql", csrf_exempt(GraphQLView.as_view(graphiql=True, schema=schema))),
] For querying process (like use GET) you need to provide object types and resolvers: import graphene
from graphene_django import DjangoObjectType
from app.stores.models import Store
from app.products.models import Product

class StoreType(DjangoObjectType):
   class Meta:
       model = Store
       fields = (
           'id', 'name', 'address', 'email', 'opening_hours', 'closing_hours',
       )


class ProductType(DjangoObjectType):
   class Meta:
       model = Product
       fields = (
           'id', 'title', 'description', 'price', 'amount', 'store',
       )


class Query(graphene.ObjectType):
   stores = graphene.List(StoreType)
   products = graphene.List(ProductType)

   def resolve_stores(root, info, **kwargs):
       # Querying a list
       return Store.objects.all()

   def resolve_products(root, info, **kwargs):
       # Querying a list
       return Product.objects.all()

schema = graphene.Schema(query=Query) GraphQL Testing For testing you can just type in your browser: http://127.0.0.1:8000/graphql If you want something to change (create or update) you need to provide inputs and create/update class with arguments and mutation methods: class StoreInput(graphene.InputObjectType):
   name = graphene.String()
   address = graphene.String()
   email = graphene.String()
   opening_hours = graphene.Time()
   closing_hours = graphene.Time()


class CreateStore(graphene.Mutation):
   class Arguments:
       input = StoreInput(required=True)

   store = graphene.Field(StoreType)

   @classmethod
   def mutate(cls, root, info, input):
       store = Store()
       store.name = input.name
       store.address = input.address
       store.email = input.email
       store.opening_hours = input.opening_hours
       store.closing_hours = input.closing_hours
       store.save()
       return CreateStore(store=store)

class UpdateStore(graphene.Mutation):
   class Arguments:
       input = StoreInput(required=True)
       id = graphene.ID()

   store = graphene.Field(StoreType)

   @classmethod
   def mutate(cls, root, info, input, id):
       store = Store.objects.get(pk=id)
       store.name = input.name
       store.address = input.address
       store.email = input.email
       store.opening_hours = input.opening_hours
       store.closing_hours = input.closing_hours
       store.save()
       return UpdateStore(store=store)


class ProductInput(graphene.InputObjectType):
   title = graphene.String()
   description = graphene.String()
   price = graphene.Float()
   amount = graphene.Int()
   store = graphene.ID()


class CreateProduct(graphene.Mutation):
   class Arguments:
       input = ProductInput(required=True)

   product = graphene.Field(ProductType)

   @classmethod
   def mutate(cls, root, info, input):
       product = Product()
       product.title = input.title
       product.description = input.description
       product.price = input.price
       product.amount = input.amount
       product.store = input.store
       product.save()
       return CreateProduct(product=product)

class UpdateProduct(graphene.Mutation):
   class Arguments:
       input = ProductInput(required=True)
       id = graphene.ID()

   product = graphene.Field(ProductType)

   @classmethod
   def mutate(cls, root, info, input, id):
       product = Product.objects.get(pk=id)
       product.title = input.title
       product.description = input.description
       product.price = input.price
       product.amount = input.amount
       product.store = input.store
       product.save()
       return UpdateProduct(product=product)

class Mutation(graphene.ObjectType):
   create_store = CreateStore.Field()
   update_store = UpdateStore.Field()
   update_product = CreateProduct.Field()
   create_product = UpdateProduct.Field()

schema = graphene.Schema(query=Query, mutation=Mutation) Also, you can test creation in the browser: RestAPI In Django Installation process: pip install djangorestframework In file: settings.py INSTALLED_APPS = [
   ...
   'rest_framework',
]

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 10
} You should make serializers in : products/serializers.py from rest_framework import serializers

from .models import Product


class ProductSerializer(serializers.ModelSerializer):
   class Meta:
       model = Product
       fields = '__all__' And also, in : stores/serializers.py from rest_framework import serializers

from .models import Store


class StoreSerializer(serializers.ModelSerializer):
   class Meta:
       model = Store
       fields = '__all__' After this you need to make your views: from rest_framework import generics
from rest_framework.permissions import AllowAny

from .serializers import ProductSerializer
from .models import Product


class RetriveUpdateDestroyProductView(generics.RetrieveUpdateDestroyAPIView):
   queryset = Product.objects.all()
   serializer_class = ProductSerializer
   permission_classes = [AllowAny]


class ListCreateProductView(generics.ListCreateAPIView):
   queryset = Product.objects.all()
   serializer_class = ProductSerializer
   permission_classes = [AllowAny] from rest_framework import generics
from rest_framework.permissions import AllowAny

from .serializers import StoreSerializer
from .models import Store


class RetriveUpdateDestroyStoreView(generics.RetrieveUpdateDestroyAPIView):
   queryset = Store.objects.all()
   serializer_class = StoreSerializer
   permission_classes = [AllowAny]


class ListCreateStoreView(generics.ListCreateAPIView):
   queryset = Store.objects.all()
   serializer_class = StoreSerializer
   permission_classes = [AllowAny] And connect it in file: urls.py In app/stores/urls.py from django.urls import path
from .views import ListCreateStoreView, RetriveUpdateDestroyStoreView


urlpatterns = [
   path('<int:pk>/', RetriveUpdateDestroyStoreView.as_view(), name='store-get-update-delete'),
   path('', ListCreateStoreView.as_view(), name='store-post-list'),
] In app/products/urls.py from django.urls import path
from .views import ListCreateProductView, RetriveUpdateDestroyProductView


urlpatterns = [
   path('<int:pk>/', RetriveUpdateDestroyProductView.as_view(), name='product-get-update-delete'),
   path('', ListCreateProductView.as_view(), name='product-post-list'),
] And in app/urls.py from django.contrib import admin
from django.urls import path, include

urlpatterns = [
   path('admin/', admin.site.urls),
   path('store/', include('app.stores.urls')),
   path('product/', include('app.products.urls')),
] RestAPI Testing After this, you can test it in Postman. For getting products: And creating a new store: GraphQL Vs REST If we compare the examples of the two API integration designs, we can see that the implementation of GraphQL requires more description of the logic of creating new objects, and in the RestAPI there are many ready-made solutions out of the box. That is, GraphQL requires a more complex implementation. Instead, GraphQL adds usability. For example, to make a query and get additional fields you need to register them when querying. At the same time for RestAPI, if you need new fields, then the backend needs to implement new serializers. Also, using GraphQL requires fewer queries to get the information you need. This is important when the Internet may not be good enough (for example, on mobile devices that use a mobile network). GraphQL is more focused on the client-side than well-created documentation, which is created independently. However, among the negatives can be called incompatibility with HTTP. You cannot use statuses (only 200 and 500 are used) and methods (POST only). That takes away flexibility in the processing of errors on a client's part. It is also quite problematic to implement caching in GraphQL due to the use of a single endpoint in different queries. As for security, GraphQL needs to be worked on further, because with the help of queries to different graphs, you can make a query to another user through the rock store to which they belong. In REST there is no such problem as the client receives only what is registered in the endpoint. Summary: How To Choose? GraphQL is fairly new compared to RestAPI, and it's easy to use. Its flexibility and high query speed make it a great alternative to RestAPI. GraphQL will be brilliant when you need a quick interface development, and you expect the program to respond quickly and in a short amount of time. REST, on the other hand, is a more suitable solution for more complex programs with more caching and bug reports. It all comes down to your needs. Some APIs, such as analytics APIs, may not be suitable for GraphQL since they have a small number of entities and connections between them. GraphQL may be more useful in applications with a large number of domain objects, such as e-commerce, where you have goods, users, orders, payments, and so on. However, obviously, to make a decision that won’t affect your app’s performance lately in a bad way, it’s better to confide in software development experts. First published . here

GraphQL vs REST - Syntax Comparison

I love . Laravel As a PHP developer with a history of working in everything from WordPress to CodeIgniter, when Laravel came on the scene it was a revelation. From the design to the usability, it is an absolutely top-notch framework that contains untold depths of power. That said, sometimes Laravel's own opinionated structure can get in the way of what can feel like pretty simple intentions, such as adding custom global arguments to all Artisan commands. What do I mean by "custom global arguments?" As an example, Artisan commands have the all same set of arguments and options that can be used during runtime: --raw             To output raw command list
    --format=FORMAT   The output format (txt, xml, json, or md) [default: "txt"]
    --short           To skip describing commands' arguments
-h, --help            Display help for the given command. When no command is given display help for the list command
-q, --quiet           Do not output any message
-V, --version         Display this application version
    --ansi|--no-ansi  Force (or disable --no-ansi) ANSI output
-n, --no-interaction  Do not ask any interactive question
    --env[=ENV]       The environment the command should run under
-v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug But, what if we wanted to add options and arguments? our own A Wild Problem Has Appeared! I've always been a pretty big fan of for both its power and ease-of-use—okay, maybe not so much lately thanks to how poorly they've communicated their most recent , but I've been a fan. Heroku security incident historically One of Heroku's most frustrating drawbacks, though, is how limited the Scheduler is. A kind of half-assed cron, allows you to run any command on 10-minute, 1-hour, or 1-day intervals, which is useful, but also woefully insufficient for many different types of jobs. Heroku's Scheduler kind of What if I only need something run weekly, monthly, or even yearly? Scheduler says "no." So, in order to work around this (within a typical Laravel application), I have traditionally added an additional argument to my Artisan commands that limits running on specific days. For example: php artisan run:command --day=friday Pretty simple design, right? It gets the job done, but it's hardly scalable. Copying the same several lines of " " logic can get pretty tedious (not to mention nothing close to DRY), so I dug into Artisan to better understand how I could add additional global parameters that can be applied to commands, rather than just the ones I specify. if current day == --day parameter, then run, otherwise return 0 all Extending Artisan Thankfully Laravel, being the object-oriented framework that it is, is pretty easy to extend. The challenge isn't so much in the extension as it is in properly writing said extension up into the rest of the application. That said, before we can actually wire up, we first need to extend the class and add our own custom argument. To do this, create a new file called and paste the following code in: anything Console\Application --day ./app/Console/Application.php <?php
namespace App\Console;

use Illuminate\Console\Application as Artisan;
use Illuminate\Support\Str;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;

class Application extends Artisan
{
    /**
     * Runs the current application.
     *
     * @return int 0 if everything went fine, or an error code
     */
    public function doRun(InputInterface $input, OutputInterface $output)
    {
      if ( !$this->checkDay($input) ) {
        $output->writeln(sprintf('<comment>This command can only be run on %s.</comment>', Str::plural(ucfirst($input->getParameterOption('--day')))), OutputInterface::VERBOSITY_QUIET);

        return 0;
      }

      return parent::doRun($input, $output);
    }

    protected function getDefaultInputDefinition()
    {
        $definition = parent::getDefaultInputDefinition();

        $definition->addOption(new InputOption('--day', null, InputOption::VALUE_OPTIONAL, "Only run the command on the specified day of the week"));

        return $definition;
    }

    public function checkDay(InputInterface $input)
    {
      $day = $input->getParameterOption('--day');

      if ( !$day ) {
        return true;
      }

      return strtolower(now()->englishDayOfWeek) === strtolower($day);
    }
} What the above code is doing can be broken down into a few parts: It creates a new method that gets our custom global parameter ( ) and checks the value against the current day of the week. If the two values are matched (or is not provided), then will return , otherwise it will return . checkDay() --day --day checkDay() true false It extends the method and checks the value of before running the rest of the command. If returns false, the command will immediately and print a comment indicating that the command can only be run on the specified day. doRun() checkDay() checkDay() return 0 Finally, because we want anyone that types to this new argument, we extend and add a new definition indicating that both , and how it works. php artisan --help know about getDefaultInputFunction() --day exists Wiring It Up So, we've extended our console application, but if we were to run our new argument won't show up yet. That's because we need to about our new class, otherwise it will load the original class by default. php artisan --help --day tell Laravel Console\Application To do this, open up and add the following function to the class: ./app/Console/Kernel.php Kernel /**
 * Retrieve the artisan application instance.
 *
 * @return \Illuminate\Console\Application
 */
protected function getArtisan()
{
  if (is_null($this->artisan)) {
    return $this->artisan = (new \App\Console\Application($this->app, $this->events, $this->app->version()))->resolveCommands($this->commands);
  }

  return $this->artisan;
} What the above function does is tell Laravel to load our newly defined class when setting Artisan up, rather than the default class. Because we extended the original class, the existing functionality will still be maintained, but with the new functionality we just added. \App\Console\Application \Illuminate\Console\Application Console\Application Now, if we were to type , we would see a new argument listed in the response: php artisan --help --raw             To output raw command list
    --format=FORMAT   The output format (txt, xml, json, or md) [default: "txt"]
    --short           To skip describing commands' arguments
-h, --help            Display help for the given command. When no command is given display help for the list command
-q, --quiet           Do not output any message
-V, --version         Display this application version
    --ansi|--no-ansi  Force (or disable --no-ansi) ANSI output
-n, --no-interaction  Do not ask any interactive question
    --env[=ENV]       The environment the command should run under
    --day[=DAY]       Only run the command on the specified day of the week
-v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug Fin. That's it! All-in-all, it's a pretty straightforward change with some potentially powerful implications. Also published at flower.codes

Extending Laravel Artisan Commands

Auth requirements are quite varied. Therefore any auth solution must provide the ability to customise their APIs. Each solution uses its own terminology for this feature: Keycloak uses “Implementing a SPI” Auth0 calls these “Auth0 actions” Firebase calls these “Extend using cloud functions” AWS Cognito uses the term “Lambda triggers & Custom challenge” SuperTokens calls this feature “Overrides” These features allow you to change the default behaviour of the auth APIs by: Creating an HTTP webhook in your API layer which is then called by the auth provider Uploading code to the auth provider (for example JS code for Auth0, or Java interface implementation for Keycloak) which run at specific points in the API’s logic. Uploading code to the auth provider which can replace the existing API’s logic entirely (as opposed to just running at specific points in the API) How powerful these solutions are, depends on: The auth provider providing the right “hook points” in their API, where your custom code can run. Your familiarity with the programming language you need to use to write the custom code. How easily your custom code can integrate with your existing infrastructure code (for example database connection setup), and how easily it can be maintained (for example, you may need to maintain the custom code snippets in your git repo as well as on the auth provider’s dashboard). In this article, we will be talking about how to customise the auth APIs provided by SuperTokens using its “Override” feature. In order to understand that, we must first understand how SuperTokens fits within an app. SuperTokens’ architecture Here we can see the architecture diagram for the self-hosted version of SuperTokens. On the left, we have the client (browser, mobile app) which talks to your APIs. Your API layer has your application APIs (shown as /api1/, /api2/, ..) and also APIs automatically exposed by the SuperTokens backend SDKs via our middleware function (shown as /auth/signin, /auth/signout, ...). The SuperTokens APIs talk to the SuperTokens Core (HTTP microservice) to persist data in the database. Your application APIs can also talk to the core if needed. Keeping this in mind, the concept of override is that you can change the behaviour of the SuperTokens APIs (exposed to the frontend) as per your requirements (all within your API layer, in the language you already use). Think of this being similar to overrides in object-oriented programming where you have an original implementation, and you can modify its behaviour by overriding the existing functions. You can even call the “super” class implementation of that function in your override function. Overriding feature in SuperTokens Whilst this article is focused on a NodeJS backend, the concepts here are very similar to all the other backend SDKs provided by SuperTokens. To override the default implementation, we must use the override config value when calling . Each recipe inside the , accepts an override config that can be used to change the behaviour of that recipe: supertokens.init recipeList supertokens.init({
   appInfo: {...},
   recipeList: [
       EmailPassword.init({
           override: {
               functions: (originalImplementation) => {
                   return originalImplementation
               },
               apis: (originalImplementation) => {
                   return originalImplementation
               }
           }
       }),
       Session.init({...})
   ]
}) In the above, we have defined the skeleton code for how to override the behaviour of the EmailPassword recipe. A very similar skeleton is applicable for overriding the Session (or any other) recipe. There are two types of override: APIs: These govern how the APIs exposed by that recipe behave. For EmailPassword, these are the sign in / sign up, reset password and email verification APIs. By overriding these, you can change how these APIs behave when they are called from the frontend. Functions: These are the functions that govern how the recipe itself behaves. They can be called by you manually in your APIs and they are also used in the APIs we expose to the frontend. By default, they query the SuperTokens core and return its response. The difference between the two are: API functions have access to the request and response objects depending on the web framework being used API functions can call several recipe functions or even call functions from multiple recipes. For example, the API function in the EmailPassword recipe, calls the recipe function from EmailPassword recipe and the function from the Session recipe. signInPOST signIn createNewSession You always want to try and use the config since that will make the minimum change to the default behaviour. If the inputs to those functions don’t suffice for your use case, then you should override the APIs. override.functions In both these types of overrides, they accept the variable as an input and the return is an object that has the same type as the . originalImplementation originalImplementaion For EmailPassword recipe, the object contains: originalImplementation For function override (see full type def ): here signIn signUp updateEmailOrPassword createResetPasswordToken resetPasswordUsingToken getUserByEmail getUserById For API override (see full type def ) here signInPOST signUpPOST emailExistsGET generatePasswordResetTokenPOST passwordResetPOST For Session recipe, the object contains: originalImplementation For function override (See full type def ) here createNewSession getAccessTokenLifeTimeMS getAllSessionHandlesForUser getRefreshTokenLifeTimeMS getSession getSessionInformation refreshSession revokeAllSessionsForUser revokeMultipleSessions revokeSession updateAccessTokenPayload updateSessionData For API override (see full type def ) here refreshPOST signOutPOST In the code snippet above, we are not modifying the default behaviour of any of these functions since we are simply returning the object. If you want to modify the function, then we can do so like this: originalImplementation signIn EmailPassword.init({
   override: {
       functions: (originalImplementation) => {
           return {
               ...originalImplementation,
               signIn: async function (input) {
                   let email = input.email;
                   let password = input.password;
 
                   // TODO: some custom logic before
 
                   let originalResponse = await originalImplementation.signIn(input);
 
                   // TODO: some custom logic after
 
                   return originalResponse;
               }
           }
       },
       apis: (originalImplementation) => {
           return {
               ...originalImplementation
           }
       }
   }
}) In the above code snippet, we have provided a custom function that uses the original implementation’s function. As marked above (in comments), we can write custom logic before or after calling the original implementation. signIn signIn TODO If we wish, we can even avoid calling the original implementation entirely and define our own logic. For example, if we wanted to use a different password hashing algorithm that is not supported by SuperTokens. Special cases for modifying APIs Sometimes, you may want to modify the default API to: Access the request object, for example, to read the origin header Send a custom reply to your frontend UI that deviates from our predefined output types Disable an API we have provided entirely. For example, you may want to do this if you do not want users to self sign up in your application. The function signature of all the API interface functions has an parameter that contains the original request and response objects. You can read from the request object and write to the response object as you normally would in your own APIs. options For example, if you want to read the request’s origin header during the sign up API, you can do it as follows: EmailPassword.init({
   override: {
       apis: (originalImplementation) => {
           return {
               ...originalImplementation,
               signUpPOST: async function (input) {
                   if (originalImplementation.signUpPOST === undefined) {
                       throw new Error("should never come here.");
                   }
 
                   let origin = input.options.req.getHeaderValue("origin");
 
                   // TODO: do something with the origin
 
                   return originalImplementation.signUpPOST(input);
               }
 
           }
       }
   }
}) As you can see above, we can access the request object using input.options.req. Likewise, if we want to send a custom response to the frontend, we can access the response object via . input.options.res Finally, to disable an API that we provide, you can set it to as follows: undefined EmailPassword.init({
   override: {
       apis: (originalImplementation) => {
           return {
               ...originalImplementation,
               signUpPOST: undefined
 
           }
       }
   }
}) This will disable the sign up API, and requests to /auth/signup will be passed along to your APIs or yield a 404. Advantages of the override method: Make modifications in the language and web framework you are already familiar with, within your own backend layer. This allows you to reuse your code for connecting to your database, sending a custom reply, logging requests and responses, sending analytics events, handling errors etc. Furthermore, since you already know the language and the web framework, the learning curve is minimal. Easier maintainability: Some auth providers require you to upload code onto their dashboard. This means you need to make sure that changes to that version of the code in your git repo are reflected on the auth provider’s dashboard (and vice versa). This can be a headache, especially with larger team sizes. With SuperTokens, all the mods you will ever need will live in the same codebase as all of your other backend code - SuperTokens is just another library you use. Flexibility in customisations: If you noticed, we don’t provide any special “hook” points (like pre-sign up or post sign up callbacks). You simply create your own implementation based on the original implementation. In fact, you can even copy the original implementation’s code and paste that in your own implementation if required. Hence, your modifications can be at any point in the API logic. In turn, this provides maximum flexibility. Flexibility in integrations: Auth APIs have to interact with several other services like those used for sending emails or SMSs, spam/anomaly detection or rate-limiting. Since the APIs are all within your own backend layer, you can use any such service(s) in the APIs we provide - you are not limited to the ones we (eventually will) support. Conclusion In the post, we saw how we can use the Overrides feature to modify the behaviour of any of the auth APIs exposed by SuperTokens. Whilst this blog focuses on NodeJS, the concept is the same in all the other SDKs we provide. Written by the Folks at — hope you enjoyed! We are always available on our . Join us if you have any questions or need any help. SuperTokens Discord server First Published here

Stories, News & Mentions about INCUTO

Incuto’s Stories on HackerNoon

Incuto's News & Mentions