atlas.js

@Atlas.js

Construído com ❤️ em strv

O Atlas.js é uma plataforma feita principalmente para reutilizar peças de código entre vários projetos e reduzir o placa de caldeira comuns, como as seqüências de inicialização e desligamento de um aplicativo padrão node.js. Você escreve componentes (ou usa o nosso) que fornecem funcionalidade (como um componente de banco de dados), o coloca em uma instância do Atlas e o Atlas cuidará do restante. Usando o ATLAS, você reduz o seu aplicativo inicialização e sequência de desligamento em um objeto de configuração e uma linha de código.

Componentes disponíveis

Aqui está uma lista de componentes mantidos pela STRV.

Componente	Versão	Informações
@Atlas.js/Atlas		O pacote principal com tudo o necessário para rolar
@Atlas.JS/CLI		Um utilitário da CLI para gerenciar seu aplicativo Atlas
@Atlas.js/gerador-atlas		Yeoman Generator para rapidamente andaime seu novo aplicativo Atlas
@Atlas.js/AWS		Para interface com a AWS
@Atlas.js/Braintree		Para interface com os pagamentos Braintree
@Atlas.js/Firebase		Para interface com os serviços de Firebase
@Atlas.js/koa		Serviço e ganchos para implementar APIs HTTP baseadas em KOA
@Atlas.js/Mongoose		Serviço e ganchos para trabalhar com modelos MongoDB e Mongoose
@Atlas.js/objeção		Serviço e ganchos para trabalhar com objeção.js
@Atlas.js/Sequelizar		Serviço e ganchos para trabalhar com sequelizar
@Atlas.js/NodeMailer		Serviço de email genérico com suporte para vários provedores
@atlas.js/repl		Um componente para cair em uma concha interativa com atlas carregado
@Atlas.js/modelos		Ação para renderizar modelos em strings html usando consolidate.js

Não encontrou o que você estava procurando? Escreva o seu! Verifique os tutoriais vinculados abaixo.

Tutoriais

Precisar de ajuda? Confira a pasta Tutoriais para ... bem ... tutoriais. ?

Sobre

Motivações

A seção a seguir fala sobre as motivações por trás da existência do Atlas.js.

REUSIBILIDADE DE CÓDIGO

Quando você se familiarizar com o Atlas.js e os componentes fabricados pela STRV, você começará a ver e até sentirá que um grande esforço foi feito para garantir que você possa compartilhar muito código entre os projetos. Sempre que possível, o Atlas.js tentará guiá-lo de tal maneira que você poderá escrever bastante código de uma maneira que não seja específica de negócios e apenas publicá-lo no NPM como um módulo e, mais tarde, quando você precisar novamente em um projeto diferente, basta instalá-lo novamente e tudo funcionar.

Gerenciando a inicialização/desligamento

Gerenciar a sequência de inicialização nem sempre é fácil. Às vezes, nem está claro por que alguém deve se incomodar com uma sequência de inicialização correta de um aplicativo - hoje em dia muitas bibliotecas que exigem alguma inicialização assíncrona suportam algum tipo de cache de solicitação, onde você simplesmente começa a usar a biblioteca e ele fornecerá os resultados quando estiver pronto.

Isso tem vários problemas:

• Alguns serviços podem ser iniciados mais cedo que outros

  Quando você inicia um servidor HTTP antes de ter uma conexão de banco de dados pronta, pode acontecer que você receba tráfego que ainda não está pronto para servir. Para cargas pequenas, isso pode não ser um problema, mas para sites de tráfego alto, isso pode significar vários segundos de atrasos e você pode até esgotar a memória disponível apenas armazenando os pedidos pendentes por muito tempo. Caso esse tipo de cache de solicitação não seja suportado, é possível que seu aplicativo traga.

• Alguns serviços podem ser interrompidos mais cedo que outros

  O que acontece com o seu aplicativo quando você fecha a conexão do banco de dados antes de fechar o servidor HTTP? Claro, é facilmente gerenciável com apenas dois serviços, mas e se você tiver mais? Talvez você tenha algum servidor Redis em algum lugar lá, talvez alguma conexão de cluster do Elasticsearch e outros outros - isso pode ficar bastante complicado. Com o Atlas, você fornece o pedido intuitivamente e ele é feito - o Atlas interromperá os serviços um por um.

• Alguns desenvolvedores não se importam e apenas process.exit() a coisa

  Alguns desenvolvedores não querem se incomodar com a limpeza adequada de seus recursos, como tempo limite, soquetes, ouvintes etc. e quando chegar a hora, eles apenas forçam o processo. No entanto, isso pode resultar em que algumas solicitações de clientes sejam encerradas antes de fornecer uma resposta, resultando em erros estranhos, páginas vazias, dados incompletos etc.

Arquitetura semelhante entre projetos

Quando você decide fazer tudo sobre o que o Atlas.js oferece e usa os componentes ao máximo, você perceberá em breve que é muito fácil navegar uma base de código completamente desconhecida com relativa facilidade - você sabe o que é onde e onde procurar uma funcionalidade específica. Quando você trabalha para uma empresa como a STRV, não é incomum mudar de projeto a cada poucos meses. Quando você pode reduzir o tempo necessário para a bordo de um novo cara/gal para sua equipe, todas as partes envolvidas serão mais felizes.

Uso

Este é um exemplo de uso completo. Os aplicativos do mundo real dividiriam pelo menos a parte da configuração em seu próprio módulo, em vez de escrevê -lo em linha como este.

Além disso, convém conferir Atlas.init() , que inicializa todos os componentes para você com base no layout de arquivo/pasta que você especificar. ?

Se você deseja seguir a estrada fácil, confira nosso gerador Yeoman para gerar rapidamente a estrutura básica da pasta e instalar todas as coisas necessárias.

 // We start by importing the required components...
import { Atlas } from '@atlas.js/atlas'
import * as Koa from '@atlas.js/koa'

// Now we need an instance of Atlas, so let's make one
const atlas = new Atlas ( {
  // We MUST specify the root folder where our app resides
  // This should usually point to the folder where your package.json resides
  root : __dirname ,
  // Setting env is optional and it fallbacks to NODE_ENV, of course
  env : process . env . NODE_ENV ,
  // This is where all the configuration data should be specified, for all the components
  config : {
    // Configuration for services
    services : {
      // The `http` configuration will be given to the service which we will name as `http`
      // (see the `atlas.service()` call below)
      http : {
        // This goes to the `listen()` function call
        listen : {
          port : 3000 ,
        } ,
        // Any properties which Koa supports can be set here
        koa : {
          proxy : true ,
        } ,
      } ,
    } ,
    // Configuration for actions
    actions : { } ,
    // ...aaand configuration for hooks
    hooks : { } ,
  } ,
} )

// We need to add the components we want to use to the application
// The first argument is the component's name - it will be used to locate the component's
// configuration and also the service will be exposed on that property:
// `atlas.services.http`
atlas . service ( 'http' , Koa . Service )

// Great, we can finally start the app!
atlas . start ( )
  . then ( ( ) => console . log ( 'ready!' ) )
  . catch ( err => console . error ( err ) )

export default atlas

As opções de configuração que cada componente aceita estão documentadas em seu próprio repositório/pasta de pacotes.

Ótimo ... e agora?

Então você tem um aplicativo com um serviço KOA configurado e em execução ... ótimo! Mas você provavelmente se pergunta onde definir seu middleware e rotas e todas as outras coisas importantes? Você deve conferir a pasta Tutoriais para muito mais informações!

Licença

Consulte o arquivo de licença para obter informações.