DEV Community: Railson Ferreira de Souza

Docker Image Bun + Node + Yarn

Railson Ferreira de Souza — Thu, 14 Sep 2023 17:00:02 +0000

Hello there! 👋

Recently, Bun 1.0 was released, and since it seems to follow the "node shape" of doing things, transitioning to Bun shouldn't be that difficult.

If you are a DevOps engineer, and your developer colleagues are quite excited to use Bun, what I have here could help you a bit. I've created a Docker Image based on Bun, which includes Node and Yarn. You can find it here:
https://hub.docker.com/r/bunlovesnode/bun

Here's a use case for it:

# Dockerfile
FROM bunlovesnode/bun:1.0.0-node18

RUN \
  if [ -f bun.lockb ]; then bun install --frozen-lockfile; \
  elif [ -f yarn.lock ]; then yarn --frozen-lockfile; \
  elif [ -f package-lock.json ]; then npm ci; \
  elif [ -f pnpm-lock.yaml ]; then yarn global add pnpm && pnpm i --frozen-lockfile; \
  else echo "Lockfile not found." && exit 1; \
  fi

I intend to keep this image updated initially, as we expect to replace everything if the intention is to use Bun.

I hope this can be of help.

How to use Chakra UI with Next.js 13 (React Server Components)

Railson Ferreira de Souza — Sat, 05 Nov 2022 21:48:11 +0000

Next.js 13 was released a short time ago, bringing great news, the /app directory, which works with React Server Components.

"Today, many components from npm packages that use client-only features do not yet have the directive" (Rendering: Server and Client Components | Next.js)

How can we use those components while we enjoy the new features available in /app directory?

This is quite easy to answer, here's a shortcut for the code that would work with Chakra UI:

`chakra-client-components.js`

"use client"
export * from "@chakra-ui/react";

So instead of importing from "@chakra-ui/react" in your code, you should import from "./chakra-client-components".

That's all folks 👋

Busca universal em PT-BR com RavenDB

Railson Ferreira de Souza — Fri, 21 May 2021 10:41:07 +0000

Na língua portuguesa podemos observar vários tipos de acentos presentes nas palavras, como nas palavras 'Macarrão' e 'Emoção', repare que além do acento, existem caracteres especiais como o 'ç'.

Quando queremos utilizar um filtro em uma busca, normalmente esperamos que estas particularidades da língua sejam ignoradas, assim como não queremos que uma letra maiúscula seja diferenciada de uma minúscula.

Nas buscas de index com RavenDB conseguimos definir um analisador case insensitive, mas para os acentos da língua portuguesa precisamos desenvolver um analisar personalizado. Para isto precisamos criar um projeto .NET vazio, no Visual Studio pode-se criar um projeto Console e apagar o 'Program.cs'. Com o projeto limpo, vamos adicionar dois analisadores, um que será usado no full-text search e outro para pesquisa de palavras simples ou composta.

1. Criar Analisadores

Com o projeto criado é necessário instalar a dependência de Lucene. Agora já podemos criar os dois analisadores, segue abaixo o código de cada um deles.
Analisador 1:

class AsciiAnalyzer : StandardAnalyzer
{
    public AsciiAnalyzer()
        : base(Version.LUCENE_30)
    { }

    public AsciiAnalyzer(Version matchVersion)
        : base(matchVersion)
    { }

    public AsciiAnalyzer(Version matchVersion, FileInfo stopWords)
        : base(matchVersion, stopWords)
    { }

    public AsciiAnalyzer(Version matchVersion, ISet<string> stopWords)
        : base(matchVersion, stopWords)
    { }

    public AsciiAnalyzer(Version matchVersion, TextReader stopWords)
        : base(matchVersion, stopWords)
    { }

    public override TokenStream TokenStream(string fieldName, TextReader reader)
    {
        //Usar tokenizer do StandardAnalyzer
        var stream = base.TokenStream(fieldName, reader);

        //Filtros
        stream = new LowerCaseFilter(stream);
        stream = new ASCIIFoldingFilter(stream);

        return stream;
    }

}

Analisador 2:

class AsciiSingleTokenAnalyzer : KeywordAnalyzer
{
    public override TokenStream TokenStream(string fieldName, TextReader reader)
    {
        //Usar tokenizer do KeywordAnalyzer
        var stream = base.TokenStream(fieldName, reader);

        //Filtros
        stream = new LowerCaseFilter(stream);
        stream = new ASCIIFoldingFilter(stream);

        return stream;
    }
}

2. Compilar e instalar analisadores

O projeto agora precisa ser compilado no modo 'release' para gerar um arquivo '.dll'. Realize a compilação e localize o arquivo '.dll' do seu projeto, em seguida copie apenas este arquivo e coloque na pasta 'Server' do RavenDB.

3. Criar Map-Reduce Index

Para utilizar os analisadores, devemos informar isto na criação de um Index. O código abaixo mostra um exemplo de um Map-Redude Index que usa o Analisador criado anteriormente.

public class Curriculo_Cargos : AbstractIndexCreationTask<Curriculo, Curriculo_Cargos.Result>
{
    public class Result
    {
        public string Nome { get; set; }
        public string[] Empresas { get; set; }
    }

    public Curriculo_Cargos()
    {
        Map = curriculos =>
                from curriculo in curriculos
                where curriculo.ExperienciasProfissionais != null
                from experienciaProfissional in curriculo.ExperienciasProfissionais
                select new Result
                {
                    Nome = experienciaProfissional.DescricaoDoCargo,
                    Empresas = new string[] {experienciaProfissional.NomeDaEmpresa}
                }
            ;

        Reduce = results => from result in results
            group result by result.Nome
            into g
            select new Result
            {
                Nome = g.First().Nome,
                Empresas = g.Select(x => x.Empresas).Select(x => x[0]).Distinct().ToArray()
            };

        Analyzers.Add(x => x.Nome, "NomeProjeto.Namespace.AsciiSingleTokenAnalyzer, NomeProjeto");
    }
}

Repare que neste caso eu utilizo o AsciiSingleTokenAnalyzer, pois quero analisar 'Nome' como um todo, ao invés de palavra por palavra(full-text search).

4. Realizar uma busca

Para realizar uma busca, eu utilizo RAW Query para escrever em linguagem RQL em vez de LINQ, visto que LINQ traz uma certa limitação de operações lógicas envolvendo 'where' e 'search' em uma mesma query. O código abaixo mostra um exemplo de uma query em um Index com o analisador personalizado.

var query = _dbSession.Query<Curriculo_Cargos.Result, Curriculo_Cargos>();
if (!String.IsNullOrEmpty(request.IniciaCom))
    query = query.Search(x => x.Nome, $"{request.IniciaCom}*");
if (!String.IsNullOrEmpty(request.Contem))
    query = query.Search(x => x.Nome, $"*{request.Contem}*");
if (!String.IsNullOrEmpty(request.TerminaCom))
    query = query.Search(x => x.Nome, $"*{request.TerminaCom}");
var resposta = await query.ToArrayAsync();

Obs.: Utilizo 'where' para busca exata de palavras compostas, pois o 'search', automaticamente separa a palavra composta da busca em um array de palavras.

Como converter Object para MultipartFormDataContent ASP.NET

Railson Ferreira de Souza — Fri, 19 Feb 2021 17:41:45 +0000

Quando queremos enviar um objeto com os parâmetros necessários para um requisição Post em uma API basta usar o método HttpClientJsonExtensions.PostAsJsonAsync(), mas as coisas mudam um pouco quando queremos enviar também arquivos nesta requisição, pois o formato json não suporta um parâmetro de arquivo.

A forma mais comum para enviar formulários que contém arquivos, para uma API, é utilizando multipart/form-data, que é suportado pelo protocolo http.

No ASP.NET não temos algo como PostAsMultipartFormDataAsync(). Eu utilizo o seguinte código para converter objetos, com parâmetros e arquivos, para um MultiPartFormDataContent, para então enviá-lo à API.

public class MultipartFormDataContentParser<T>
{
    private T _obj;
    public MultipartFormDataContentParser(T obj)
    {
        _obj = obj;
    }
    public MultipartFormDataContent Parse()
    {
        var formContent = new MultipartFormDataContent();
        var genericFileName = "Filename";

        var propertyInfos = typeof(T).GetProperties();
        // Mount MultipartForm
        foreach (var propertyInfo in propertyInfos)
        {
            var value = propertyInfo.GetValue(_obj);
            if (value is byte[] ||
                value is Stream ||
                value is List<Stream> ||
                value is List<byte[]>)
            {
                if (value is List<Stream> listStream)
                {
                    foreach (var file in listStream)
                        if(file != null)
                            formContent.Add(new StreamContent(file), propertyInfo.Name, genericFileName);
                }else if (value is List<byte[]> listByteArray)
                {
                    foreach (var file in listByteArray)
                        if(file != null)
                            formContent.Add(new ByteArrayContent(file), propertyInfo.Name, genericFileName);
                }else
                    formContent.Add(getFileContent(value), propertyInfo.Name, genericFileName);
            }
            else if(value != null)
            {
                string output = value.ToString();
                if (!String.IsNullOrEmpty(output))
                {
                    formContent.Add(new StringContent(output), propertyInfo.Name);
                }
            }
        }
        return formContent;
    }
    private HttpContent getFileContent(object obj)
    {
        if (obj is Stream stream)
        {
            return new StreamContent(stream);
        } else if (obj is byte[] byteArray)
        {
            return new ByteArrayContent(byteArray);
        }
        else
        {
            throw new Exception("Type not valid to create a HttpContent of file");
        }
    }
}

Veja que este código suporta Stream, byte[] e até mesmo uma lista destes tipos, como parâmetro de arquivo. Observe também que o foreach busca properties, este código não faz a conversão de fields.

O código abaixo mostra um exemplo de como utilizar.

class Program
{
    private static string _rootUrl = "http://localhost:8080/tests/formdata";

    public class ObjectForm
    {
        public string Param { get; set; }
        public List<Stream> File { get; set; }
        public ObjectForm()
        {
            File = new List<Stream>();
        }
    }
    static void Main(string[] args)
    {
        var client = new HttpClient();

        var obj = new ObjectForm();
        obj.Param = "String Param";
        obj.File.Add(new FileStream("Files/File1.txt", FileMode.Open, FileAccess.Read));
        obj.File.Add(new FileStream("Files/File2.json", FileMode.Open, FileAccess.Read));

        MultipartFormDataContent formdata = new MultipartFormDataContentParser<ObjectForm>(obj).Parse();

        HttpResponseMessage response = client.PostAsync(_rootUrl, formdata).Result;
        Console.WriteLine(response.Content.ReadAsStringAsync().Result);
    }
}