import {Route, Controller} from 'primavera/web'
import {ValidateSchema} from 'primavera/validations'

@Controller({prefix: 'links'})
class LinksServicesEndpoints {
    @Route.GET()
    listLinks () { ... }
    
    @Session('someSessionAttribute')
    get sessionAttribute() {}
    
    @ValidateSchema({}, CreateLinkSchema)
    @Route.POST()
    createLink(params, body) { 
        this.sessionAttribute // contains session attribute
    }
}

import {Route, Controller} from 'primavera/web'
import {ValidateSchema} from 'primavera/validations'
import {RequestAuth} from 'primavera/web-security'

@Middleware({prefix: 'links'})
class LinksServicesSecurityMiddleware {
    @RequestAuth
    @Route.USE('*')
    checkAuth () { ... }
}

import {Inject, Injectable} from 'primavera/core'

@Injectable('services/injectable')
class InjectableService {
    someMethod() { ... }
}

class DependantService {
    @Inject('services/injectable')
    get injectable() {}
    
    doSomething() {
        injectable.someMethod() // uses injected dependency
    }
}

import {Before, After} from 'primavera/core'

class InterceptorsTest {
    @Before((...args) => debug(...args))
    withBefore() {
        /// this is logging before the method hits
    }
    
    @Before((...args) => { return ['altered'] }
    alteredArguments (value) {
        /// value will always be "altered"
    }
    
    @After((returnValue) => debug('returnvalue was', returnValue))
    loggingAfter() {
        return "unaltered" // logging is okay, but doesn't alter the return value
    }
    
    @After((returnValue) => { return returnValue+1 }))
    alteredValue() {
        return 1 // actual return value will be altered by @After, so it will be 2
    }

import {Transform, After} from 'primavera/transform'

class TransformExample {

    @Transform.OUT((raw) => { raw.altered = true; return raw; })
    alteredValue() { return { altered: false } }
    
    checkValue() {
        this.alteredValue().altered // true
    }
}

import {ValidateSchema} from 'primavera/validations'

class ValidationsExample {

    @ValidateSchema(JSONSCHEMA)
    validatedValue(value) { 
        debug(':value valid according to provided JSONSCHEMA')
    }
}

class LinkServices {
    @Resolve({ domain: 'links', action: 'create' })
    function resolverService(...args) {
        ...
    }
}

class LinksCLient {
    @ResolveWith({domain:'links', action: 'create'})
    function transparentServiceResolving(serviceParams) { 
        // you can alter those params here to match the service
        // your return value will be the service's input
        // the service output will be served to the caller
        // you can transform the output using @Transform.OUT 
    }
}