Reactive Through Services

[shumy]

Titulo do Projecto: Reactive Through Services (RTS)

Última Versão: 0.3.0

Site Oficial: https://github.com/shumy/reactive-through-services para já

Licença: Apache 2.0

Líder do Projecto: shumy

Membros Actuais do Projecto: shumy

Descrição do Projecto:

Programação Funcional Reactiva (PFR) é um paradigma de desenvolvimento de software tendo em atenção ao controle dos fluxos de dados.  Esta forma de desenvolvimento está recebendo alguma visibilidade através de integração com frameworks como Angular2 e React via ReactiveX, por exemplo. No entanto existe um desfasamento entre "front-end" e os serviços de "back-end", nomeadamente REST a arquitectura mais conhecida. Serviços REST são essencialmente baseados em modelos de Pull request, existindo algumas tecnologias mais antigas como Ajax Push Engine (APE) mas que não evoluíram para integrar corretamente com novas tecnologias como ReactiveX.

O RTS surge para tentar preencher esta lacuna. Embora possam existir outros projectos do género, se estiverem dispostos a trabalhar com linguagens como Xtend e Typescript (embora não cingido apenas a estas no futuro) dificilmente encontrarão algum em que possam construir serviços reactivos de forma fácil, e integrando com ReactiveX (Observable pattern).

O RTS está também envolto numa arquitectura que permite separar as interfaces de acesso (endpoints) dos serviços, permitindo para o mesmo serviço ter tanto interfaces em RTS como em REST (ou outra) para questões de compatibilidade, apenas com algumas configurações.

A wiki está em progresso, e enquanto os tutoriais não vem, podem verificar uma projecto que está a ser construído utilizando a framework. Podem começar por analizar as configurações de um servidor (que um dia poderão ser apenas em files de configuração) em DpfServerStarter.xtend. Um pouco sobre o que está aqui:

O servidor precisa de um pipeline de processamento, que é configurado com interceptores e serviços.

server.pipeline => [
	addInterceptor(...)
	addService(...)
	failHandler = [ println('PIPELINE-FAIL: ' + message) ]
]

O interceptor que está instalado, apanha tokens JWT e insere no contexto de processamento informação sobre o user do token. Estes tokens estão a ser gerados por um servidor OpenId Connect -> Keycloak.

val jwtAuth = JwtAuthInterceptor.B => [
  jwksUrl = 'http://localhost:8081/auth/realms/dev/protocol/openid-connect/certs'
  issuer = 'http://localhost:8081/auth/realms/dev'
  audience = 'screen-dr'
]

No servidor que está como implementação de referência, existem 2 "routers" que fornecem "endpoints" (interfaces de acesso aos serviços). Um wsRouter com interface RTS sobre WebSockets, e o webRouter que permite configurar os "endpoints" de HTTP e REST.

server => [
	webRouter => [
		route(...)
				
		get(...)		
		post(...)
		...
	]	
]

 

Por exemplo, um serviço simples que pode ser implementado apenas com:

@Service
class TestService {

    @Public
    def hello(String firstName, String lastName) {
        return '''Hello «firstName» «lastName»!'''
    }

}

Instalado no pipeline com:

addService('test', new TestService)

Além de ter uma interface RTS disponível via wsRouter, e que não necessita de qualquer configuração. Também pode ser configurada uma interface REST apenas com uma linha de código:

get('/ping/:firstName/:lastName', 'test' -> 'hello')

Isto configura um GET no path /ping/:firstName/:lasttName e 2 parâmetros que serão automaticamente mapeados para os  parâmetros do método 'hello'.

Alem disso alguns meta dados serão gerados, de forma que é possível criar descritores destes serviços, assim como disponibilizar os mesmos via:

server.pipeline.addService('specs', DescriptorService.B => [
	pipeline = server.pipeline
	autoDetect = true
])
		
server.pipeline.addService('routes', RouterService.B => [
	router = server.webRouter
])

Assim como criar interfaces REST para os mesmos descritores.

Existe uma lib cliente para Typescript (sendo também para JavaScript) no projecto modulo rts-ts-client. É possível com esta lib aceder a este serviço definindo apenas uma interface:

interface TestProxy {
  hello(firstName: string, lastName: string): Promise<string>
}

E utilizando, criando uma implementação "Proxy":

let testProxy = router.createProxy('test') as TestProxy
testProxy.hello('Micael', 'Pedrosa').then(_ => {})

Sendo que o router terá de ser previamente instanciado na fase de inicialização, podem ver aqui: app.module.ts

Com isto tudo temos ainda a cereja no bolo! É possível criar serviços assíncronos que retornam Promise<...> ou Observable<...>. E utilizar o mesmo Promise em Typescript ou um Promise<Observable<...>>. Este Observable é o do ReactiveX (que é também utilizado no Angular2), tendo esta dependência do lado cliente. Basta saber como funciona, e estão habilitados a trabalhar com serviços reactivos RTS.

Obrigado, subscrevam...

Código fonte: https://github.com/shumy/reactive-through-services

Edited September 30, 2016 at 09:39 PM by shumy