List

Create a list endpoint that fetches and returns records to the end client.

Overview
model_class
readable_column_names
sortable_column_names
default_sort_column_name
default_sort_direction
default_limit
maximum_limit
where
joins
url
request_methods
response_headers
output_map
output_schema
column_overrides
group_by_column_name
internal_casing
external_casing
security_headers
description
authentication
authorization

Overview

A list endpoint has four required parameters:

Name	Value
`model_class`	The model class for the endpoint to use to find and return records.
`readable_column_names`	A list of columns from the model class that the endpoint should return to the client.
`sortable_column_names`	A list of columns that the client is allowed to sort by.
`default_sort_column_name`	The default column to sort by.

Here’s a basic working example:

import clearskies

class User(clearskies.Model):
    id_column_name = "id"
    backend = clearskies.backends.MemoryBackend()
    id = clearskies.columns.Uuid()
    name = clearskies.columns.String()


list_users = clearskies.endpoints.List(
    model_class=User,
    readable_column_names=["id", "name"],
    sortable_column_names=["id", "name"],
    default_sort_column_name="name",
)

wsgi = clearskies.contexts.WsgiRef(
    list_users,
    classes=[User],
    bindings={
        "memory_backend_default_data": [
            {
                "model_class": User,
                "records": [
                    {"id": "1-2-3-4", "name": "Bob"},
                    {"id": "1-2-3-5", "name": "Jane"},
                    {"id": "1-2-3-6", "name": "Greg"},
                ],
            },
        ]
    },
)
wsgi()

You can then fetch your records:

$ curl 'http://localhost:8080/' | jq
{
    "status": "success",
    "error": "",
    "data": [
        {"id": "1-2-3-4", "name": "Bob"},
        {"id": "1-2-3-6", "name": "Greg"},
        {"id": "1-2-3-5", "name": "Jane"},
    ],
    "pagination": {
        "number_results": 3,
        "limit": 50,
        "next_page": {}
    },
    "input_errors": {}
}

Pagination can be set via query parameters or the JSON body:

$ curl 'http://localhost:8080/?sort=name&direction=desc&limit=2' | jq
{
    "status": "success",
    "error": "",
    "data": [
        {"id": "1-2-3-5", "name": "Jane"},
        {"id": "1-2-3-6", "name": "Greg"},
    ],
    "pagination": {
        "number_results": 3,
        "limit": 2,
        "next_page": {"start": 2}
    },
    "input_errors": {}
}

In the response, ‘.pagination.next_page is a dictionary that returns the query parameters to set in order to fetch the next page of results. Note that the pagination method depends on the backend. The memory backend supports pagination via start/limit, while other backends may support alternate pagination schemes. Clearskies automatically handles the difference, so it's important to use .pagination.next_page` to fetch the next page of results.

Use where, joins, and group_by to automatically adjust the query used by the list endpoint. In particular, where is a list of either conditions (as a string) or a callable that can modify the query directly via the model class. For example:

list_users = clearskies.endpoints.List(
    model_class=User,
    readable_column_names=["id", "name"],
    sortable_column_names=["id", "name"],
    default_sort_column_name="name",
    where=[User.name.equals("Jane")],  # equivalent: where=["name=Jane"]
)

With the above definition, the list endpoint will only ever return records with a name of “Jane”. The following uses standard dependency injection rules to execute a similar filter based on arbitrary logic required:

import datetime

list_users = clearskies.endpoints.List(
    model_class=User,
    readable_column_names=["id", "name"],
    sortable_column_names=["id", "name"],
    default_sort_column_name="name",
    where=[
        lambda model, now: model.where("name=Jane")
        if now > datetime.datetime(2025, 1, 1)
        else model
    ],
)

As shown in the above example, a function called in this way can request additional dependencies as needed, per the standard dependency rules. The function needs to return the adjusted model object, which is usually as simple as returning the result of model.where(?). While the above example uses a lambda function, of course you can attach any other kind of callable - a function, a method of a class, etc…

model_class

Required

The model class used by this endpoint.

The endpoint will use this to fetch/save/validate incoming data as needed.

readable_column_names

Required

Columns from the model class that should be returned to the client.

Most endpoints use a model to build the return response to the user. In this case, readable_column_names instructs the model what columns should be sent back to the user. This information is similarly used when generating the documentation for the endpoint.

import clearskies

class User(clearskies.Model):
    id_column_name = "id"
    backend = clearskies.backends.MemoryBackend()
    id = clearskies.columns.Uuid()
    name = clearskies.columns.String()
    secret = clearskies.columns.String()

list_users = clearskies.endpoints.List(
    model_class=User,
    readable_column_names=["id", "name"],
    sortable_column_names=["id", "name"],
    default_sort_column_name="name",
)

wsgi = clearskies.contexts.WsgiRef(
    list_users,
    classes=[User],
    bindings={
        "memory_backend_default_data": [
            {
                "model_class": User,
                "records": [
                    {"id": "1-2-3-4", "name": "Bob", "secret": "Awesome dude"},
                    {"id": "1-2-3-5", "name": "Jane", "secret": "Gets things done"},
                    {"id": "1-2-3-6", "name": "Greg", "secret": "Loves chocolate"},
                ]
            },
        ]
    }
)
wsgi()

And then:

$ curl 'http://localhost:8080'
{
    "status": "success",
    "error": "",
    "data": [
        {
            "id": "1-2-3-4",
            "name": "Bob"
        },
        {
            "id": "1-2-3-6",
            "name": "Greg"
        },
        {
            "id": "1-2-3-5",
            "name": "Jane"
        }
    ],
    "pagination": {
        "number_results": 3,
        "limit": 50,
        "next_page": {}
    },
    "input_errors": {}
}

sortable_column_names

Required

default_sort_column_name

Required

The default column to sort by.

default_sort_direction

Optional

The default sort direction (ASC or DESC).

default_limit

Optional

The number of records returned if the client doesn’t specify a different number of records (default: 50).

maximum_limit

Optional

The maximum number of records the client is allowed to request (0 == no limit)

where

Optional

joins

Optional

url

Optional

Set the URL for the endpoint

When an endpoint is attached directly to a context, then the endpoint’s URL becomes the exact URL to invoke the endpoint. If it is instead attached to an endpoint group, then the URL of the endpoint becomes a suffix on the URL of the group. This is described in more detail in the documentation for endpoint groups, so here’s an example of attaching endpoints directly and setting the URL:

import clearskies

endpoint = clearskies.endpoints.Callable(
    lambda: {"hello": "World"},
    url="/hello/world",
)

wsgi = clearskies.contexts.WsgiRef(endpoint)
wsgi()

Which then acts as expected:

$ curl 'http://localhost:8080/hello/asdf' | jq
{
    "status": "client_error",
    "error": "Not Found",
    "data": [],
    "pagination": {},
    "input_errors": {}
}

$ curl 'http://localhost:8080/hello/world' | jq
{
    "status": "success",
    "error": "",
    "data": {
        "hello": "world"
    },
    "pagination": {},
    "input_errors": {}
}

Some endpoints allow or require the use of named routing parameters. Named routing paths are created using either the /{name}/ syntax or /:name/. These parameters can be injected into any callable via the routing_data dependency injection name, as well as via their name:

import clearskies

endpoint = clearskies.endpoints.Callable(
    lambda first_name, last_name: {"hello": f"{first_name} {last_name}"},
    url="/hello/:first_name/{last_name}",
)

wsgi = clearskies.contexts.WsgiRef(endpoint)
wsgi()

Which you can then invoke in the usual way:

$ curl 'http://localhost:8080/hello/bob/brown' | jq
{
    "status": "success",
    "error": "",
    "data": {
        "hello": "bob brown"
    },
    "pagination": {},
    "input_errors": {}
}

request_methods

Optional

The allowed request methods for this endpoint.

By default, only GET is allowed.

import clearskies

endpoint = clearskies.endpoints.Callable(
    lambda: {"hello": "world"},
    request_methods=["POST"],
)

wsgi = clearskies.contexts.WsgiRef(endpoint)
wsgi()

And to execute:

$ curl 'http://localhost:8080/' -X POST | jq
{
    "status": "success",
    "error": "",
    "data": {
        "hello": "world"
    },
    "pagination": {},
    "input_errors": {}
}

$ curl 'http://localhost:8080/' -X GET | jq
{
    "status": "client_error",
    "error": "Not Found",
    "data": [],
    "pagination": {},
    "input_errors": {}
}

response_headers

Optional

Set some response headers that should be returned for this endpoint.

Provide a list of response headers to return to the caller when this endpoint is executed. This should be given a list containing a combination of strings or callables that return a list of strings. The strings in question should be headers formatted as “key: value”. If you attach a callable, it can accept any of the standard dependencies or context-specific values like any other callable in a clearskies application:

def custom_headers(query_parameters):
    some_value = "yes" if query_parameters.get("stuff") else "no"
    return [f"x-custom: {some_value}", "content-type: application/custom"]

endpoint = clearskies.endpoints.Callable(
    lambda: {"hello": "world"},
    response_headers=custom_headers,
)

wsgi = clearskies.contexts.WsgiRef(endpoint)
wsgi()

output_map

Optional

An override of the default model-to-json mapping for endpoints that auto-convert models to json.

Many endpoints allow you to return a model which is then automatically converted into a JSON response. When this is the case, you can provide a callable in the output_map parameter which will be called instead of following the usual method for JSON conversion. Note that if you use this method, you should also specify output_schema, which the autodocumentation will then use to document the endpoint.

Your function can request any named dependency injection parameter as well as the standard context parameters for the request.

import clearskies
import datetime
from dateutil.relativedelta import relativedelta

class User(clearskies.Model):
    id_column_name = "id"
    backend = clearskies.backends.MemoryBackend()
    id = clearskies.columns.Uuid()
    name = clearskies.columns.String()
    dob = clearskies.columns.Datetime()

class UserResponse(clearskies.Schema):
    id = clearskies.columns.String()
    name = clearskies.columns.String()
    age = clearskies.columns.Integer()
    is_special = clearskies.columns.Boolean()

def user_to_json(model: User, utcnow: datetime.datetime, special_person: str):
    return {
        "id": model.id,
        "name": model.name,
        "age": relativedelta(utcnow, model.dob).years,
        "is_special": model.name.lower() == special_person.lower(),
    }

list_users = clearskies.endpoints.List(
    model_class=User,
    url="/{special_person}",
    output_map = user_to_json,
    output_schema = UserResponse,
    readable_column_names=["id", "name"],
    sortable_column_names=["id", "name", "dob"],
    default_sort_column_name="dob",
    default_sort_direction="DESC",
)

wsgi = clearskies.contexts.WsgiRef(
    list_users,
    classes=[User],
    bindings={
        "special_person": "jane",
        "memory_backend_default_data": [
            {
                "model_class": User,
                "records": [
                    {"id": "1-2-3-4", "name": "Bob", "dob": datetime.datetime(1990, 1, 1)},
                    {"id": "1-2-3-5", "name": "Jane", "dob": datetime.datetime(2020, 1, 1)},
                    {"id": "1-2-3-6", "name": "Greg", "dob": datetime.datetime(1980, 1, 1)},
                ]
            },
        ]
    }
)
wsgi()

Which gives:

$ curl 'http://localhost:8080/jane' | jq
{
    "status": "success",
    "error": "",
    "data": [
        {
            "id": "1-2-3-5",
            "name": "Jane",
            "age": 5,
            "is_special": true
        }
        {
            "id": "1-2-3-4",
            "name": "Bob",
            "age": 35,
            "is_special": false
        },
        {
            "id": "1-2-3-6",
            "name": "Greg",
            "age": 45,
            "is_special": false
        },
    ],
    "pagination": {
        "number_results": 3,
        "limit": 50,
        "next_page": {}
    },
    "input_errors": {}
}

output_schema

Optional

A schema that describes the expected output to the client.

This is used to build the auto-documentation. See the documentation for clearskies.endpoint.output_map for examples. Note that this is typically not required - when returning models and relying on clearskies to auto-convert to JSON, it will also automatically generate your documentation.

column_overrides

Optional

A dictionary with columns that should override columns in the model.

This is typically used to change column definitions on specific endpoints to adjust behavior: for intstance a model might use a created_by_* column to auto-populate some data, but an admin endpoint may need to override that behavior so the user can set it directly.

This should be a dictionary with the column name as a key and the column itself as the value. Note that you cannot use this to remove columns from the model. In general, if you want a column not to be exposed through an endpoint, then all you have to do is remove that column from the list of writeable columns.

import clearskies

endpoint = clearskies.Endpoint(
    column_overrides = {
        "name": clearskies.columns.String(validators=clearskies.validators.Required()),
    }
)

group_by_column_name

Optional

A column to group by.

internal_casing

Optional

Used in conjunction with external_casing to change the casing of the key names in the outputted JSON of the endpoint.

To use these, set internal_casing to the casing scheme used in your model, and then set external_casing to the casing scheme you want for your API endpoints. clearskies will then automatically convert all output key names accordingly. Note that for callables, this only works when you return a model and set readable_columns. If you set writeable_columns, it will also map the incoming data.

The allowed casing schemas are:

snake_case
camelCase
TitleCase

By default internal_casing and external_casing are both set to ‘snake_case’, which means that no conversion happens.

import clearskies
import datetime

class User(clearskies.Model):
    id_column_name = "id"
    backend = clearskies.backends.MemoryBackend()
    id = clearskies.columns.Uuid()
    name = clearskies.columns.String()
    date_of_birth = clearskies.columns.Date()

send_user = clearskies.endpoints.Callable(
    lambda users: users.create({"name":"Example","date_of_birth": datetime.datetime(2050, 1, 15)}),
    readable_column_names=["name", "date_of_birth"],
    internal_casing="snake_case",
    external_casing="TitleCase",
    model_class=User,
)

# because we're using name-based injection in our lambda callable (instead of type hinting) we have to explicitly
# add the user model to the dependency injection container
wsgi = clearskies.contexts.WsgiRef(send_user, classes=[User])
wsgi()

And then when called:

$ curl http://localhost:8080  | jq
{
    "Status": "Success",
    "Error": "",
    "Data": {
        "Name": "Example",
        "DateOfBirth": "2050-01-15"
    },
    "Pagination": {},
    "InputErrors": {}
}

external_casing

Optional

Used in conjunction with internal_casing to change the casing of the key names in the outputted JSON of the endpoint.

See the docs for internal_casing for more details and usage examples.

security_headers

Optional

Configure standard security headers to be sent along in the response from this endpoint.

Note that, with CORS, you generally only have to specify the origin. The routing system will automatically add in the appropriate HTTP verbs, and the authorization classes will add in the appropriate headers.

import clearskies

hello_world = clearskies.endpoints.Callable(
    lambda: {"hello": "world"},
    request_methods=["PATCH", "POST"],
    authentication=clearskies.authentication.SecretBearer(environment_key="MY_SECRET"),
    security_headers=[
        clearskies.security_headers.Hsts(),
        clearskies.security_headers.Cors(origin="https://example.com"),
    ],
)

wsgi = clearskies.contexts.WsgiRef(hello_world)
wsgi()

And then execute the options endpoint to see all the security headers:

$ curl -v http://localhost:8080 -X OPTIONS
* Host localhost:8080 was resolved.
< HTTP/1.0 200 Ok
< Server: WSGIServer/0.2 CPython/3.11.6
< ACCESS-CONTROL-ALLOW-METHODS: PATCH, POST
< ACCESS-CONTROL-ALLOW-HEADERS: Authorization
< ACCESS-CONTROL-MAX-AGE: 5
< ACCESS-CONTROL-ALLOW-ORIGIN: https://example.com
< STRICT-TRANSPORT-SECURITY: max-age=31536000 ;
< CONTENT-TYPE: application/json; charset=UTF-8
< Content-Length: 0
<
* Closing connection

description

Optional

A description for this endpoint. This is added to any auto-documentation

authentication

Optional

The authentication for this endpoint (default is public)

Use this to attach an instance of clearskies.authentication.Authentication to an endpoint, which enforces authentication. For more details, see the dedicated documentation section on authentication and authorization. By default, all endpoints are public.

authorization

Optional

The authorization rules for this endpoint

Use this to attach an instance of clearskies.authentication.Authorization to an endpoint, which enforces authorization. For more details, see the dedicated documentation section on authentication and authorization. By default, no authorization is enforced.