Multiple Catalogs per database instance

[vincentsarago]

Discussion started on Slack with @ranchodeluxe

Sometimes user could want to have distinct endpoint per schema instead of having a set of endpoint pointing to all schemas. This is to avoid the /collections endpoint to return collections for multiple schemas.

# Now
/collections/{schema}.{table}/items

# Possible solution
/{schema}/collections/{schema}.{table}/items

A possible solution is to add /{schema} prefix on all the Factory routes and have a custom collection dependency which will use the schema path parameter to select the collection from the schema's catalog.

This 👇 is a code sample which tries to do it (not fully tested)

import re
from contextlib import asynccontextmanager

from typing_extensions import Annotated

from tipg import model
from tipg.collections import Catalog, Collection, get_collection_index
from tipg.database import close_db_connection, connect_to_db
from tipg.errors import (
    DEFAULT_STATUS_CODES,
    MissingCollectionCatalog,
    add_exception_handlers,
)
from tipg.factory import Endpoints
from tipg.middleware import CacheControlMiddleware
from tipg.settings import APISettings, PostgresSettings

from fastapi import FastAPI, HTTPException, Path, Request

from starlette.middleware.cors import CORSMiddleware
from starlette_cramjam.middleware import CompressionMiddleware

settings = APISettings()
postgres_settings = PostgresSettings()


@asynccontextmanager
async def lifespan(app: FastAPI):
    """FastAPI Lifespan."""
    await connect_to_db(
        app,
        settings=postgres_settings,
        schemas=["public", "schema2"],
    )

    # Register Catalog for schema 1
    app.state.public = await get_collection_index(app.state.pool, schemas=["public"])

    # Register Catalog for schema 2
    app.state.schema2 = await get_collection_index(app.state.pool, schemas=["schema2"])

    yield

    # Close the Connection Pool
    await close_db_connection(app)


def CatalogParams(
    request: Request,
    catalogId: Annotated[str, Path(description="catalog name")],
) -> Catalog:
    """Return Collections Catalog."""
    collection_catalog: Catalog = getattr(request.app.state, catalogId, None)
    if not collection_catalog:
        raise MissingCollectionCatalog(f"Could not find {catalogId} catalog.")

    return collection_catalog


def CollectionParams(
    request: Request,
    catalogId: Annotated[str, Path(description="catalog name")],
    collectionId: Annotated[str, Path(description="Collection identifier")],
) -> Collection:
    """Return Layer Object."""
    collection_pattern = re.match(  # type: ignore
        r"^(?P<schema>.+)\.(?P<collection>.+)$", collectionId
    )
    if not collection_pattern:
        raise HTTPException(
            status_code=422, detail=f"Invalid Collection format '{collectionId}'."
        )

    assert collection_pattern.groupdict()["schema"]
    assert collection_pattern.groupdict()["collection"]

    collection_catalog: Catalog = getattr(request.app.state, catalogId, None)
    if not collection_catalog:
        raise MissingCollectionCatalog(f"Could not find {catalogId} catalog.")

    if collectionId in collection_catalog["collections"]:
        return collection_catalog["collections"][collectionId]

    raise HTTPException(
        status_code=404, detail=f"Table/Function '{collectionId}' not found."
    )


app = FastAPI(
    title=settings.name,
    version="0.1.0",
    openapi_url="/api",
    docs_url="/api.html",
    lifespan=lifespan,
)

endpoints = Endpoints(
    catalog_dependency=CatalogParams,
    collection_dependency=CollectionParams,
    router_prefix="/{catalogId}",
    with_common=True,
)
app.include_router(endpoints.router, prefix="/{catalogId}")


# Set all CORS enabled origins
if settings.cors_origins:
    app.add_middleware(
        CORSMiddleware,
        allow_origins=settings.cors_origins,
        allow_credentials=True,
        allow_methods=["GET"],
        allow_headers=["*"],
    )

app.add_middleware(CacheControlMiddleware, cachecontrol=settings.cachecontrol)
app.add_middleware(CompressionMiddleware)
add_exception_handlers(app, DEFAULT_STATUS_CODES)

Notes:

• you still need to pass {schema}.{table} as the collection parameter (because of the pg_temp functions)
• in the catalog the collection's id will be in form of {schema}.{table}

☝️ could be easily solved by updating the catalog's collection ids

We could also add a landing / page which could list the different catalogs

What the specification says

The OGC specification do not have catalog notions so this will mostly break the specs

[vincentsarago]