class Restt {
  constructor();
  use(service: Service);
}

class Service {
  constructor(service: ServiceConfiguration);
}

type ServiceConfiguration {
  origin: String,
  headers?: Object,
  passthrough?: Boolean,
  resources: [Resource]
}

// A URL Origin
origin: 'https://yourdomain.io'
// A URL Origin including a port
origin: 'https://yourdomain.io:3000'
// A URL Origin including a base path
origin: 'https://yourdomain.io/v1/api'

// An example set of response headers (sent to the client)
headers: {
  // Allow CORS from anywhere
  'access-control-allow-origin': '*',
  // Send a flag about the project service version
  'project-service-version': '0.0.1'
}

// Create a set of resources (contains only one resource)
resource: [
  new Resource({
    endpoint: '/helloworld',
    method: 'GET',
    response() {
      return new Response({
        body: {
          message: 'hello world!'
        },
        status: 200
      });
    }
  })
]

class Resource {
  constructor(configuration: ResourceConfiguration);
}

type ResourceConfiguration {
  endpoint: String,
  method: String,
  cache?: (Number | Boolean)
  fields?: [String],
  response: Response
}

// A simple static endpoint
endpoint: '/helloworld'
// A simple dynamic endpoint
endpoint: '/sqrt/{number}'
// A complex dynamic endpoint
endpoint: '/messages/{user}?search={query}&limit={limit}'

// GET method
method: 'GET'
// POST 
method: 'POST'

// Do not cache
cache: false
// Cache for the default number of seconds
cache: true
// Cache for 1 hour (3600 seconds)
cache: 3600

// A set of fields required in the request body
fields: ['email', 'password']

// A simple static response
response: () => {
  return new Response({ 
    body: { 
      message: 'hello world',
    },
    status: 200 
  });
}
// A simple dynamic response generating data from paramaters or fields
response: ({ number }) => {
  return new Response({ 
    body: { 
      message: Math.sqrt(number),
    },
    status: 200
  });
}
// A complex dynamic response generating data from paramaters, fields and headers
response: async({ email, password, headers }) => {
  // Check the authorization header (e.g. private internal platform)
  if (!headers.equals('authorization', 'your-auth-token')) {
    // Throw a 403 as the authorization header is incorrect
    return new Response({ status: 403 });
  }
  // Search the database for the customer
  const customer = await Customers.findOne({ email });
  // Check if the customer exists
  if (customer) {
    // Check whether the passwords match
    if (customer.password == password) {
      // Remove the password from the payload
      delete customer.password;
      // Return the customer
      return new Response({ 
        body: { 
          customer,
          success: true
        },
        status: 200
      });
    }
  }
  // Return an error response if there is no customer or invalid credentials
  return new Response({ 
    body: { 
      message: 'Invalid email and password combination',
      success: false
    },
    status: 403
  });
}

class Response {
  constructor(response: ResponseConfiguration);
}

type ResponseConfiguration {
  headers: Object?
  body: Object,
  status: Number
}

// An example set of response headers (sent back to the client)
headers: {
  // Set a cookie for this session
  'set-cookie': 'sessionid=SK302903; Secure'
}

// An example body
body: {
  message: 'hello world!'
}

// An example status(success)
status: 200

// Import the provider module from Restt
import { Provider, Action } from 'restt';
// Export the Stripe provider to be used by a Response
export const Stripe = new Provider({
  // Define the origin for the provider
  origin: 'https://api.stripe.com/v1',
  // Define the headers for the provider (load from the restt.config.json with Restt-CLI)
  headers: configuration.stripe.headers,
  // Add the actions to the providers
  actions: [
    // Create a customer action
    new Action({
      // Define the name for the action
      name: 'createCustomer',
      // Define the endpoint (https://api.stripe.com/v1/customers)
      endpoint: '/customers',
      // Define the method
      method: 'POST',
      // Define the minimum required fields to be called by the function
      fields: ['email']
    })
  ]
});

// Create a customer with Stripe (async / returns a promise)
Stripe.createCustomer({ email: 'example@yourdomain' });

class Provider {
  constructor(provider: ProviderConfiguration);
}

type ProviderConfiguration {
  origin: String,
  headers?: Object,
  resources: [Resource]
}

// A URL Origin
origin: 'https://api.example.io'
// A URL Origin (with a path)
origin: 'https://api.stripe.com/v1'

// An example set of headers (sent to the external service)
headers: {
    // Add the secret key token as require with Stripe
    'authorization': 'Bearer {your_secret_stripe_key}',
    // Add the content type (must be 'application/json' or 'application/x-www-form-urlencoded')
    'content-type': 'application/x-www-form-urlencoded'
}

// Add the set of actions
actions: [
  new Action({
    name: 'createCustomer',
    endpoint: '/customers',
    method: 'POST',
    fields['email']
  })
]

class Action {
  constructor(action: ActionConfiguration);
}

type ActionConfiguration {
  name: String,
  endpoint: String,
  headers: Headers?,
  method: String,
  fields?: [String]
  type?: String
}

// An example name for an action 
name: 'createCustomer'
// Another example name for an action
name: 'updateCustomer'
// Another example name for an action
name: 'findCustomer'

// A static endpoint
endpoint: '/customers'
// A dynamic endpoint
endpoint: '/customers/{id}'
// Anonther dynamic endpoint
endpoint: 'customers?email={email}'

// An example name for an action 
name: 'createCustomer'
// Another example name for an action
name: 'updateCustomer'
// Another example name for an action
name: 'findCustomer'

// POST method
method: 'POST'
// GET method
method: 'GET'

// An example set of fields required by the action
fields: ['email', 'description']

// An example headers object
headers: {
  'authorization': 'your-secret-key',
  'content-type': 'application/json'
}