edgefunctions.yaml

openapi: 3.0.0
info:
  description: >-
    ## Welcome to the Azion API!


    With the following APIs you can check, remove or update existing settings,
    besides creating new ones.


    * * *


    ## Overview


    The Azion API is a RESTful API, based on HTTPS requests, that allows you to
    integrate your systems with our platform, simply, quickly, and securely.


    Here you will find instructions on how our API works and what functionality
    is available.


    This documentation is being constantly updated. Make sure you verify if
    there are any updates or changes before you perform any development in your
    application, even if you are familiar with our API.


    * * *


    Both HTTPS requests and responses must be in JavaScript Object Notation
    (JSON) format. All HTTPS requests and responses must follow these
    conventions.


    **Base URL**


    The base URL of the API, which must be used, is:


    [**https://api.azionapi.net/**](https://api.azionapi.net/)


    **HTTP Methods**


    Each HTTP method defines the type of operation that will be run.


    | HTTP Method | CRUD | Whole Collection (e.g. /items) | Specific Item (e.g.
    /items/:item_id) |

    | --- | --- | --- | --- |

    | GET | Read | It retrieves the list of items in a Collection. | It
    retrieves a specific item in a Collection. |

    | POST | Create | It creates a new item in the Collection. | \- |

    | PUT | Update/Replace | It replaces a whole Collection with a new one. | It
    replaces an item in a Collection with a new one. |

    | PATCH | Update/Modify | It partially updates a Collection. | It partially
    updates an item in a Collection |

    | DELETE | Delete | It deletes a whole Collection. | It deletes an item in a
    Collection. |


    * * *


    **Status Codes**


    The HTTP return code defines the status – successful or not – after the
    requested operation is run.


    | Status Code | Meaning |

    | --- | --- |

    | 200 OK | General Status for a successful operation. |

    | 201 CREATED | Successfully created a collection or item, by means of POST
    or PUT. |

    | 204 NO CONTENT | Successful operation, but without any content to be
    return to the Body. Generally used for DELETE or PUT operations. |

    | 207 MULTI-STATUS | A batch of operations were triggered by a single
    request, which resulted in different return codes when it was run, for some
    of the operations. The codes are displayed in the “status” field, in the
    body of the response, for each sub-batch of operations for whichever are
    applicable. |

    | 400 BAD REQUEST | Request error, such as invalid parameters, missing
    mandatory parameters or others. |

    | 401 UNAUTHORIZED | Error caused by a missing HTTP Authentication header. |

    | 403 FORBIDDEN | User does not have the permissions to run the requested
    operation. |

    | 404 NOT FOUND | The requested resource does not exist. |

    | 405 METHOD NOT ALLOWED | The requested method is not applicable with the
    URL. |

    | 406 NOT ACCEPTABLE | Accept header missing from the HTTP request or the
    header contains formatting or the version is not supported by the API. |

    | 409 CONFLICT | Conflict generated in running the request, such as a
    request to create an already existing record. |

    | 429 TOO MANY REQUESTS | The request was temporarily rejected, due to
    exceeding the limit on operations. Wait for the time defined in the
    X-Ratelimit-Reset header and try again. |

    | 500 INTERNAL SERVER ERROR | Unintentional error, due to an unidentified
    failure in the request process. |

    | \--- |  |

    | **HTTP Headers** |  |


    All requests must be generated with the HTTP header specifying the desired
    code format for responses and the API version used. The current version of
    the API is 3 and the format is application/json.


    ```

    Accept: application/json; version=3


    ```


    * * *


    **Rate Limit**


    The limit of operations that can be run via the API is defined by 3 HTTP
    response headers:


    *   **X-ratelimit-limit:** number of operations allowed in one time-frame;

    *   **X-ratelimit-remaining:** number of operations still available in one
    time-frame;

    *   **X-ratelimit-reset:** is the date and time, in IOS 8601 format, which
    represents the point in the future when the time-frame will be closed and
    when the limits will, therefore, be reset.
        

    Example of HTTP response headers and a request:


    ```

    Date: Thu, 02 Nov 2017 12:30:28 GMT

    X-ratelimit-remaining: 199

    X-ratelimit-limit: 200

    X-ratelimit-reset: 2017-11-02T12:31:28.675446


    ```


    In the example provided, 200 operations are allowed within a 1-minute time
    frame. Of those, there are 199 still available, because one has already been
    run. The total limit will be reset after 1 minute.


    When the X-ratelimit-limit is reached, or in other words, when the
    X-ratelimit-remaining reaches zero, the API will give the error, HTTP 429
    TOO MANY REQUESTS. If your application receives this error, you will need to
    wait until the time defined in X-ratelimit-reset has passed, to make another
    request.


    *   **X-ratelimit-limit by product**
        

    The *X-ratelimit limit* variations by product are the following:


    *   **Real-Time Metrics:** 20 requests per minute.

    *   **Real-Time Purge:** 200 requests per minute; except for the Wildcard,
    which is 2000 a day.
        

    > The rate-limit values are based on the client_id.


    * * *


    **Optional Parameters**


    In this version, it is possible to include some optional parameters as part
    of the GET method, which can help and modify the form in which your data
    will be returned.


    You can combine these parameters to get the result you want.


    They are:


    | Parameter | Description | Accepted values: |

    | --- | --- | --- |

    | order_by | Identifies which field the return should be sorted by. The
    default ordering is ascending. | Depends on the fields available from the
    endpoint structure |

    | sort | Defines which ordering to be used: ascending or descending. | asc 
    <br>  <br>desc |

    | page | Identifies which page should be returned, if the return is
    paginated. The default value is 1. | Page number. |

    | page_size | Identifies how many items should be returned per page. The
    default value is 10. | Desired number of items. |


    * * *


    **Request Exemple**


    You can use one parameter, or a combination. See the example below, which
    uses all of them in the same request.


    ```

    GET /domains?order_by=name&page_size=20&sort=desc&page=3

    Accept: application/json; version=3

    Authorization: token 2909f3932069047f4736dc87e72baaddd19c9f75


    ```


    * * *


    # Authentication


    Authentication and authorization of operations via Azion API is done through
    Tokens.


    The first step is to create the Token through authenticating a user
    registered in [Real-Time Manager](https://sso.azion.com/login).


    * * *


    ## Encoding Username and Password in Base64


    Only token creation and cancelling operations are performed through Basic
    Authentication, that is, with a username and password. You can create and
    cancel the token through the API itself, but for that you need to encode
    your username and password in base64.


    Base64 encoding can be done from the command line on a Unix terminal:


    ```

    $ echo 'user@domain:password'|base64

    dXNlckBkb21haW46cGFzc3dvcmQK


    ```


  title: Edge Function
  version: 1.0.0
servers:
- url: https://api.azionapi.net
- url: https://stage-api.azionapi.net
tags:
- name: edge_functions
  description: "Manages serverless functions on the Edge Functions library"
paths:
  /edge_functions:
    get:
      parameters:
        - in: query
          name: page
          required: false
          schema:
            format: int64
            type: integer
        - in: query
          name: page_size
          required: false
          schema:
            format: int64
            type: integer
        - in: query
          name: sort
          required: false
          schema:
            type: string
        - in: query
          name: order_by
          required: false
          schema:
            type: string
      responses:
        "200":
          content:
            application/json; version=3:
              example:
                count: 1
                total_pages: 1
                schema_version: 3
                links:
                  previous: ''
                  next: ''
                results:
                - id: 4184
                  name: Teste
                  language: javascript
                  code: "async function handleRequest(request) {\r\n     return new\
                    \ Response(\"Hello World!\",\r\n       {\r\n           status:200\r\
                    \n       })\r\n    }\r\n    addEventListener(\"fetch\", event\
                    \ => {\r\n     event.respondWith(handleRequest(event.request))\r\
                    \n    })"
                  json_args: {}
                  function_to_run: ""
                  initiator_type: edge_application
                  active: true
                  last_editor: teste@gmail.com
                  modified: 2021-12-27T19:44:04.427738Z
                  reference_count: 0
              schema:
                $ref: '#/components/schemas/ListEdgeFunctionResponse'
          description: Success
        default:
          content:
            application/json:
              example:
                detail: Sorry unable to perform operation.
              schema:
                $ref: "#/components/schemas/ErrorResponse"
          description: Unexpected error
      security:
        - JWT: []
      summary: edge_functions
      tags:
         - edge_functions
      operationId: getFunctions
    post:
      parameters: []
      requestBody:
        $ref: '#/components/requestBodies/CreateEdgeFunctionRequest'
        content:
          application/json:
            example:
              name: Teste2
              language: javascript
              code: "async function handleRequest(request) {\r\n     return new Response(\"\
                Hello World!\",\r\n       {\r\n           status:200\r\n       })\r\
                \n    }\r\n    addEventListener(\"fetch\", event => {\r\n     event.respondWith(handleRequest(event.request))\r\
                \n    })"
              json_args: {}
              active: true
            schema:
              properties:
                name:
                  type: string
                language:
                  type: string
                code:
                  type: string
                json_args: {}
                active:
                  type: boolean
              type: object
        required: true
      responses:
        "201":
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/EdgeFunctionResponse"
          description: Success
        "400":
          content:
            application/json:
              example:
                name:
                - This field may not be blank
                active:
                - This field is required.
                code:
                - This field is required.
                language:
                - This field is required.
              schema:
                $ref: '#/components/schemas/BadRequestResponse'
          description: Invalid request
        default:
          content:
            application/json:
              example:
                message: Sorry unable to perform operation.
              schema:
                $ref: "#/components/schemas/ErrorResponse"
          description: Unexpected error
      security:
      - JWT: []
      summary: edge_functions
      tags:
      - edge_functions
      operationId: postFunction
  /edge_functions/{id}:
    delete:
      parameters:
      - explode: false
        in: path
        name: id
        required: true
        schema:
          type: integer
          format: int64
        style: simple
      responses:
        "204":
          description: Success
        default:
          content:
            application/json:
              example:
                message: Sorry unable to perform operation.
              schema:
                $ref: "#/components/schemas/ErrorResponse"
          description: Unexpected error
      security:
      - JWT: []
      summary: edge_functions
      tags:
      - edge_functions
      operationId: deleteFunction
    get:
      parameters:
      - explode: false
        in: path
        name: id
        required: true
        schema:
          type: integer
          format: int64
        style: simple
      responses:
        "200":
          description: Success
          content:
            application/json:
              example:
                results:
                  id: 4184
                  name: Teste
                  language: javascript
                  code: "async function handleRequest(request) {\r\n     return new\
                    \ Response(\"Hello World!\",\r\n       {\r\n           status:200\r\
                    \n       })\r\n    }\r\n    addEventListener(\"fetch\", event\
                    \ => {\r\n     event.respondWith(handleRequest(event.request))\r\
                    \n    })"
                  json_args: {}
                  function_to_run: ""
                  initiator_type: edge_application
                  active: true
                  last_editor: lehdermann@gmail.com
                  modified: 2021-12-27T20:49:25.373356Z
                  reference_count: 0
                schema_version: 3
              schema:
                $ref: '#/components/schemas/EdgeFunctionResponse'
        default:
          content:
            application/json:
              example:
                message: Sorry unable to perform operation.
              schema:
                $ref: "#/components/schemas/ErrorResponse"
          description: Unexpected error
      security:
      - JWT: []
      summary: edge_functions
      tags:
      - edge_functions
      operationId: getFunction
    patch:
      parameters:
      - explode: false
        in: path
        name: id
        required: true
        schema:
          type: integer
          format: int64
        style: simple
      requestBody:
        $ref: '#/components/requestBodies/PatchEdgeFunctionRequest'
        content:
          application/json; version=3:
            example:
              name: Teste
              code: "async function handleRequest(request) {\r\n     return new Response(\"\
                Hello World!\",\r\n       {\r\n           status:200\r\n       })\r\
                \n    }\r\n    addEventListener(\"fetch\", event => {\r\n     event.respondWith(handleRequest(event.request))\r\
                \n    })"
              json_args: {}
              active: true
            schema:
              properties:
                name:
                  type: string
                code:
                  type: string
                json_args: {}
                active:
                  type: boolean
              type: object
        required: true
      responses:
        "200":
          content:
            application/json:
              example:
                results:
                  id: 4184
                  name: Teste
                  language: javascript
                  code: "async function handleRequest(request) {\r\n     return new\
                    \ Response(\"Hello World!\",\r\n       {\r\n           status:200\r\
                    \n       })\r\n    }\r\n    addEventListener(\"fetch\", event\
                    \ => {\r\n     event.respondWith(handleRequest(event.request))\r\
                    \n    })"
                  json_args: {}
                  function_to_run: ""
                  initiator_type: edge_application
                  active: true
                  last_editor: lehdermann@gmail.com
                  modified: 2021-12-27T20:49:25.373356Z
                  reference_count: 0
                schema_version: 3
              schema:
                $ref: '#/components/schemas/EdgeFunctionResponse'
          description: Success
        "400":
          content:
            application/json:
              example:
                name:
                - This field may not be blank
                active:
                - This field is required.
                code:
                - This field is required.
                language:
                - This field is required.
              schema:
                $ref: '#/components/schemas/BadRequestResponse'
          description: Invalid request
        default:
          content:
            application/json:
              example:
                message: Sorry unable to perform operation.
              schema:
                $ref: "#/components/schemas/ErrorResponse"
          description: Unexpected error
      security:
      - JWT: []
      summary: edge_functions
      tags:
      - edge_functions
      operationId: patchFunction
    put:
      parameters:
      - explode: false
        in: path
        name: id
        required: true
        schema:
          type: integer
          format: int64
        style: simple
      requestBody:
        $ref: '#/components/requestBodies/PutEdgeFunctionRequest'
        content:
          application/json; version=3:
            example:
              name: Teste
              code: "async function handleRequest(request) {\r\n     return new Response(\"\
                Hello World!\",\r\n       {\r\n           status:200\r\n       })\r\
                \n    }\r\n    addEventListener(\"fetch\", event => {\r\n     event.respondWith(handleRequest(event.request))\r\
                \n    })"
              json_args: {}
              active: true
            schema:
              properties:
                name:
                  type: string
                code:
                  type: string
                json_args: {}
                active:
                  type: boolean
              type: object
        required: true
      responses:
        "200":
          content:
            application/json:
              example:
                results:
                  id: 4184
                  name: Teste
                  language: javascript
                  code: "async function handleRequest(request) {\r\n     return new\
                    \ Response(\"Hello World!\",\r\n       {\r\n           status:200\r\
                    \n       })\r\n    }\r\n    addEventListener(\"fetch\", event\
                    \ => {\r\n     event.respondWith(handleRequest(event.request))\r\
                    \n    })"
                  json_args: {}
                  function_to_run: ""
                  initiator_type: edge_application
                  active: true
                  last_editor: lehdermann@gmail.com
                  modified: 2021-12-27T20:49:25.373356Z
                  reference_count: 0
                schema_version: 3
              schema:
                $ref: '#/components/schemas/EdgeFunctionResponse'
          description: Success
        "400":
          content:
            application/json:
              example:
                name:
                - This field may not be blank
                active:
                - This field is required.
                code:
                - This field is required.
                language:
                - This field is required.
              schema:
                $ref: '#/components/schemas/BadRequestResponse'
          description: Invalid request
        default:
          content:
            application/json:
              example:
                message: Sorry unable to perform operation.
              schema:
                $ref: "#/components/schemas/ErrorResponse"
          description: Unexpected error
      security:
      - JWT: []
      summary: edge_functions
      tags:
      - edge_functions
      operationId: putFunction
components:
  requestBodies:
    PutEdgeFunctionRequest:
      content:
        application/json; version=3:
          schema:
            $ref: '#/components/schemas/PutEdgeFunctionRequest'
      required: true
    PatchEdgeFunctionRequest:
      content:
        application/json; version=3:
          schema:
            $ref: '#/components/schemas/PatchEdgeFunctionRequest'
      required: true
    CreateEdgeFunctionRequest:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/CreateEdgeFunctionRequest'
      required: true
  schemas:
    ErrorModel:
      properties:
        code:
          type: string
      type: object
    ErrorResponse:
      properties:
        detail:
          type: string
      type: object
    Links:
      example:
        next: next
        previous: previous
      properties:
        previous:
          type: string
        next:
          type: string
      type: object
    Results:
      example:
        code: "function foo() { console.log('hello world');"
        last_editor: user@azion.com
        name: MyFunction
        active: true
        modified: modified
        language: javascript
        json_args: '{"a": 1, "b": 2}'
        id: 5
        function_to_run: function_to_run
        reference_count: 5
        initiator_type: edge_application
      properties:
        id:
          type: integer
          format: int64
        name:
          type: string
        language:
          type: string
        code:
          type: string
        json_args: {}
        function_to_run:
          type: string
        initiator_type:
          type: string
        active:
          type: boolean
        last_editor:
          type: string
        modified:
          type: string
        reference_count:
          type: integer
          format: int64
      type: object
    ListEdgeFunctionResponse:
      example:
        schema_version: 1
        count: 1
        links:
          next: next
          previous: previous
        total_pages: 6
        results:
        - code: code
          last_editor: last_editor
          name: name
          active: true
          modified: modified
          language: language
          json_args: '{}'
          id: 5
          function_to_run: function_to_run
          reference_count: 5
          initiator_type: initiator_type
        - code: code
          last_editor: last_editor
          name: name
          active: true
          modified: modified
          language: language
          json_args: '{}'
          id: 5
          function_to_run: function_to_run
          reference_count: 5
          initiator_type: initiator_type
      properties:
        count:
          type: integer
          format: int64
        total_pages:
          type: integer
          format: int64
        schema_version:
          type: integer
          format: int64
        links:
          $ref: '#/components/schemas/Links'
        results:
          items:
            $ref: '#/components/schemas/Results'
          type: array
      type: object
    CreateEdgeFunctionRequest:
      properties:
        name:
          type: string
        language:
          type: string
        code:
          type: string
        json_args: {}
        active:
          type: boolean
      type: object
    BadRequestResponse:
      properties:
        name:
          items:
            type: string
          type: array
        active:
          items:
            type: string
          type: array
        code:
          items:
            type: string
          type: array
        language:
          items:
            type: string
          type: array
      type: object
    EdgeFunctionResponse:
      example:
        schema_version: 1
        results:
          code: code
          last_editor: last_editor
          name: name
          active: true
          modified: modified
          language: language
          json_args: '{}'
          id: 5
          function_to_run: function_to_run
          reference_count: 5
          initiator_type: initiator_type
      properties:
        results:
          $ref: '#/components/schemas/Results'
        schema_version:
          type: number
      type: object
    PutEdgeFunctionRequest:
      properties:
        name:
          type: string
        code:
          type: string
        json_args: {}
        active:
          type: boolean
        initiator_type:
          type: string
        language:
          type: string
      type: object
    PatchEdgeFunctionRequest:
      properties:
        name:
          type: string
        code:
          type: string
        json_args: {}
        active:
          type: boolean
      type: object
  securitySchemes:
    JWT:
      description: |
        You must inform a token to auth.
        Usage format: `Token <TOKEN>`
      in: header
      name: Authorization
      type: apiKey