Tendo um banco de dados para controle de despesas:

1

select * from despesas

Agora queremos exibir na mesma consulta, a despesa anterior, a atual e a próxima despesa do mês.
Para isso precisamos saber qual o valor da linha anterior e o valor da linha posterior do select.

Para isso precisamos fazer LEFT JOIN com a própria tabela. Veja o exemplo:

1
2
3
4
5
6
7
8
9

select 
    prev.descricao as DESPESA_ANTERIOR,
    main.descricao DESPESA_ATUAL,
    next.descricao as DESPESA_POSTERIOR
from 
    despesas main 
    left join despesas next on main.id = next.id - 1
    left join despesas prev on main.id = prev.id + 1
    order by main.dia;

Resultado:

Para saber as despesas anterioes e posteriores ao dia 3:

1
2
3
4
5
6
7
8
9
10
11

select 
    prev.descricao as DESPESA_ANTERIOR,
    main.descricao DESPESA_ATUAL,
    next.descricao as DESPESA_POSTERIOR
from 
    despesas main 
    left join despesas next on main.id = next.id - 1
    left join despesas prev on main.id = prev.id + 1
    where
        main.dia = 3
    order by main.dia;

Resultado:

Para debugar códigos que estão na pasta node_modules, basta informar no launch.json, na propriedade outFiles, o caminho dos arquivos que o debugger deve colocar no seu escopo.

Pode exemplo, se quizermos que o debugger pare em algum breakpoint no módulo express:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

{
    // Use IntelliSense to learn about possible Node.js debug attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "type": "node",
            "request": "launch",
            "name": "Launch Program",
            "program": "${workspaceRoot}/dist/main.js",
            "sourceMaps": true,
            "outFiles": [
                "${workspaceRoot}/node_modules/express/lib/**/*.js"
            ],
            "console": "integratedTerminal"
        }
    ]
}

O trecho abaixo faz com que o debugger do node inclua todos arquivos javascript da pasta lib do módulo express, assim podemos colocar breakpoints neles.

1
2
3
4
5
6
7

{
    ...
    "outFiles": [
        "${workspaceRoot}/node_modules/express/lib/**/*.js"
    ],
    ...
}

O que é Integração Contínua?

Em termos simples, integração contínua é a forma de garantir que seu projeto está funcionando a cada modificação do reposítorio, commit ou build. Este processo possibilita testar e fazer build do seu projeto em várias versões de runtime ou em vários ambientes de forma frequente, garantindo a qualidade e o funcionamento daquele módulo. Por exêmplo, a cada push para o GitHub a ferramenta irá clonar o projeto, baixar as dependências e executar os testes.
A ferramenta de integração contínua será tão eficiente quanto os testes implementados no seu projeto. Por isso é importante ter uma boa cobertura de testes.

A ferramenta Travis CI faz isso de forma fácil, rápida e simples de configurar. Para habilitar o Travis no seu repositório github é só seguir os passos a baixo.

Pré-requisitos

• Um projeto nodejs no github
• Implementação de testes

Caso queira poderá clonar ou consultar o repositório de exemplo deste post no GitHub do Devlog

1

git clone git@github.com:DevLogger/travis-ci-example.git

Configurar execução dos testes do projeto NodeJS

O Travis CI roda por padrão o comando npm test para executar os testes do projeto.
Configure o sript test no seu package.json para executar os testes com sua ferramenta preferida. No exemplo abaixo usamos o Mocha para execução dos testes.

1
2
3

"scripts": {
    "test": "mocha"
}

Criar arquivo .travis.yml na raiz do projeto

1
2
3
4
5

language: node_js
node_js:
  - "5"
  - "6"
  - "7"

O campo node_js indica para quais versões do NodeJS queremos que o Travis CI rode o processo de integração contínua. Neste caso ele fará o build e rodará os testes 3 vezes: uma para versão 5, outra para versão 6 e outra para a versão 7 do NodeJS.

Agora faça push de todas as alterações par ao GitHub

Criar uma conta no Travis

• Acesse o site do Travis CI
• Crie uma conta. Podemos fazer o login através da conta do GitHub
• Habilite seu projeto

Teste

Agora faça uma modificação em algum arquivo, commite e faça um push para o GitHub.
Pronto, verifique lá no site do Travis CI que ele está executando o build do seu projeto e executando os testes.

Pronto! Seu projeto já estará rodando uma Integraçao Contínua.

Exibindo Status do Build no GitHub

• No site do travis clique na imagem:
  

• Escola a opção markdown
  

• Coloque no seu readme.md

  1 2 3

  [](https://travis-ci.org/linck/protontype) Exemplo de Integração Contínua com Travis CI

• Resultado
  

Obs: Verifique se o parâmetro ?branch=develop está apontando para branch correta

Preparando o projeto

• Criar um repositório no github
• Criar um projeto npm com a dependência do express

1
2

npm init
npm install express --save

• Copiar a pasta www do projeto ionic para o projeto criado
• Criar um servidor em node + express para servir o index.html da pasta www
• Crie um arquivo server.js na raiz do projeto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

var express = require('express'),
    app = express();

app.use(express.static('www'));

// CORS (Cross-Origin Resource Sharing) headers to support Cross-site HTTP requests
app.all('*', function(req, res, next) {
    res.header("Access-Control-Allow-Origin", "*");
    res.header("Access-Control-Allow-Headers", "X-Requested-With");
    next();
});

app.set('port', process.env.PORT || 5000);

app.listen(app.get('port'), function () {
    console.log('Express server listening on port ' + app.get('port'));
});

• Commit e push seu projeto no repositório criado

Fazendo Deploy no Heroku

• Crie uma conta no Heroku
• Acesse https://dashboard.heroku.com/
• Vá na opção new > create new app
• Dê um nome pro projeto e clique em “Create new app”
• Na sessão “Deployment method” escolha GitHub
• Escolha o projeto criado nos passos a cima
• Clique em “Automatic Deploy” para fazer o deploy sempre que fizer um push
• Clique em em “Deploy Branch”
• Clique em View

Pronto! Agora é só aproveitar

Repositório Exemplo

https://github.com/DevLogger/heroku-github

Simples não é?

Agora é só se divertir olhando a infinidade de expressões que podemos usar aqui: http://docs.emmet.io/cheat-sheet/

Para saber mais:

• http://docs.emmet.io/ (Dá uma olhada no vídeo de demonstração)
• https://code.visualstudio.com/Docs/languages/html

O que normalmente faríamos assim:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Task {
    public title: string;
    public done: boolean;
    public creationDate: Date;
    public finishDate: Date;

    constructor(title: string, done: boolean, creationDate: Date, finishDate: Date) {
        this.title = title;
        this.done = done;
        this.creationDate = creationDate;
        this.finishDate = finishDate;
    }

}

var task: Task = new Task('My Task', false, new Date(), new Date());
console.log(task.title); //> My Task

Podemos fazer assim:

1
2
3
4
5
6
7

class Task {
 constructor(public title: string, public done: boolean, public creationDate: Date, public finishDate: Date) {}

}

var task: Task = new Task('My Task', false, new Date(), new Date());
console.log(task.title); //> My Task

Simples! Resumimos o conteudo da classe em uma linha de código.

Obrigado Plínio Naves pela dica!

Agora sim, podemos testar nossa API com o este fantástico chrome app: Postman

Instalação

Como já disse ali em cima, o Postman é um Chrome App, então, caso esteja usando Windows ou Linux você precisara ter o Chrome instalado. Caso esteja usando Mac poderá usar o app feito com o Electron disponibilizado no site do Postman. Então:

1. Baixe o Postman aqui: https://www.getpostman.com/
2. Divirta-se

Levantando API para teste

Vamos usar uma API de exemplo já pronta criada em cima do projeto ProtonType. Falei um pouco sobre ele aqui neste post.

Você precisará do NodeJS 6.x ou maior para usar esta API de exemplo. Claro que poderá usar qualquer API que você tenha controle para testar. Caso queira usar esta sugerida siga os passos abaixo:

Clone o projeto

1

git clone https://github.com/linck/protontype-example.git

Levante a api

1
2
3

cd protontype-example
npm install
npm start

Esta API nos possibilita criar, alterar, deletar e consultar Tasks e Users.
Para ver os endpoints disponíveis acesse no seu browser:

1

https://localhost:3000

Usando o Mr. Postman!

Nossa API está escutando na porta 3000 e usa https, portanto a base da nossa URL será https://locahost:3000

Ao abrir o Postman iremos nos deparar com a tela a baixo:

Criando um Usuário

Na tela inicial:

• Escolha a opçao POST
• Coloque a url: https://localhost:3000/users
• Vá para a aba body escolha a opção raw e JSON

No campo de texto a baixo adicione o JSON abaixo:

1
2
3
4
5

{
    "name": "DevLog",
    "password": "123456",
    "email": "devlog@devlog.com.br"
}

Sua configuração ficará como na figura abaixo:

Depois clique em Send para cadastrar um usuário.

Testando Autenticação do Usuário

Agora vamos testar a autenticação deste usuário cadastrado. Nossa API implementa um tipo de autenticação chamada JWT. Vejamos como fazer isso no Postman.

Gerando o Token

Primeiro devemos solicitar a um token através da url https://localhost:3000/token.

Coloque esta url no Postman assim como foi feito com o usuário, através do método POST, e enviando o JSON:

1
2
3
4

{
    "password": "123456",
    "email": "devlog@devlog.com.br"
}

Sua configuração ficará assim:

Clique em send e receberá a resposta com um token:

Pronto, agora você está autenticado. Copie este token e guarde para o próximo passo.

Criando uma Task

Agora vamos criar um task. Usando o método POST envie uma solicitação para url https://localhost:3000/tasks com o JSON abaixo:

1
2
3

{
"title": "Task Teste";
}

Após clicar em Send, receberemos o resultado:

Isso aconteceu porque não informamos na requisição http o token de autenticação gerado no passo anterior. Então vamos configurar.

• Vá na aba Headers
• No campo key digite Authorization.
• No campo value coloque JWT [token_gerado] (por exemplo: JWT eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6MX0.otx8FgAk8oHHmqY9-dOKmnF3kXOpm2Fxs5Krl985JKI)

Com esta configuração, estamos enviado o token que geramos no cabeçalho Authorization do http, possibilitando nossa API autenticar sua requisição.

Agora sim, clique em Send e teremos uma Task criada!

Com o Postman você terá uma ótima ferramente para testes de sua API. Agora você pode desbravar as suas outras funcionalidades de acordo com sua necessidade. Teste os outros endpoints da API. Faça bom uso!

Um dos problemas mais chatos que você pode encontrar quando for usar TypeScript é:

1

Duplicate identifier...

Isto acontece quando o compilador tenta carregar o mesmo módulo ou definição (.d.ts) mais de uma vez, identificando que este está duplicado. Quando se instala uma dependência via npm install, o npm já identifica se o módulo está baixado evitando duplicação, mas, se você esta usando módulos locais com npm link, é quase certo que terá este problema.

Este erro não impede que o JavaScript seja gerado, mas aqui pra nós, é muito chato ver milhares de erro no seu console quando mandamos executar ou compilar algo.

Resolução

Atualize a versao do TypeScript

1

npm install typescript -g

Configuração do compilador

Coloque esta configuração do seu tsconfig.json:

1
2
3
4
5
6
7
8

"compilerOptions" {
     ....
    "baseUrl": "./",
    "paths": {
        "*": [ "node_modules/@types/*", "*"]
    }
   ...
}

Isto informará ao compilador que quando ele for resolver um módulo qualquer, procure primeiro em .\node_modules\@types\ e so depois nos demais locais, evitando a duplicidade do carregamento.

Referências

• https://www.typescriptlang.org/docs/handbook/module-resolution.html
• https://github.com/Microsoft/TypeScript/issues/11916#event-853609143

Obrigado @mhegazy pela dica!!

Quick Start - Criando uma API em 5 passos

Estrutura de pastas e configurações iniciais

1
2
3
4
5
6

mkdir proton-quickstart
cd proton-quickstart
npm init
mkdir src
npm install protontype --save

Criar o arquivo tsconfig.json na raiz do projeto

1
2
3
4
5
6
7
8
9
10
11
12
13
14

{
  "compilerOptions": {
    "target": "es5",
    "module": "commonjs",
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "outDir": "dist"
  },
  "exclude": [
    "node_modules",
    "dist"
  ]
}

Model

Criar um arquivo ParticlesModel.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import { BaseModel, SequelizeBaseModelAttr, Model, DataTypes } from 'protontype';

@Model({
    name: "Particles",
    definition: {
        name: {
            type: DataTypes.STRING
        },
        symbol: {
            type: DataTypes.STRING
        },
        mass: {
            type: DataTypes.BIGINT
        }

    }
})
export class ParticlesModel extends BaseModel<Particle> {

}

export interface Particle extends SequelizeBaseModelAttr {
    name: string;
    symbol: string;
    mass: number;
}

Router

Criar arquivo ParticlesRouter.ts

1
2
3
4
5
6
7
8
9
10
11

import { ParticlesModel } from './ParticlesModel';
import { BaseCrudRouter, RouterClass } from 'protontype';

@RouterClass({
    baseUrl: '/particles',
    modelInstances: [new ParticlesModel()]
})
export class ParticlesRouter extends BaseCrudRouter {

}

Main

Criar arquivo Main.ts

1
2
3
4
5
6
7

import { ParticlesRouter } from './ParticlesRouter';
import { ProtonApplication } from 'protontype';

new ProtonApplication()
    .addRouter(new ParticlesRouter())
    .bootstrap();

Compilando e Rodando Aplicação

1
2
3

tsc
node dist/Main.ts

Testando a API

Por padrão, a aplicação usará um banco de dados sqlite.
Será criado um arquivo proton.sqlite na raiz do projeto.

Os endpoints abaixo já estarão disponíveis:

• GET /particles - Lista todos os registos da tabela Particles
• POST /particles - Cria um registro na tabela Particles
• GET /particles/:id - Consulta um registro da tabela Particles
• PUT /particles/:id - Atualiza um registro da tabela Particles
• DELETE /particles/:id - Remove um registro da tabela Particles

Podera testar através do app Postman ou outro da sua preferência.

Código completo do quick start

https://github.com/linck/proton-quickstart

Exemplo

https://github.com/linck/protontype-example

Projeto

https://github.com/linck/protontype

Documentação

https://linck.github.io/protontype-docs