quillsql 2.1.5__py3-none-any.whl → 2.2.0__py3-none-any.whl

quillsql/db/cached_connection.py

@@ -1,11 +1,10 @@
 import psycopg2
-from psycopg2.extras import RealDictCursor
 import json
 import redis
 from quillsql.error import PgQueryError
 from quillsql.db.db_helper import connect_to_db, run_query_by_db
 
-## The TTL for new cache entries (default: 1h)
+# The TTL for new cache entries (default: 1h)
 DEFAULT_CACHE_TTL = 24 * 60 * 60
 
 
@@ -33,7 +32,9 @@ class CachedConnection:
     def exec_with_reconnect(self, sql):
         reconnect_count = 0
         while True:
-            self.connection = connect_to_db(self.database_type, self.config, self.using_connection_string)
+            self.connection = connect_to_db(
+                self.database_type, self.config, self.using_connection_string
+            )
             try:
                 return run_query_by_db(self.database_type, sql, self.connection)
             except psycopg2.Error as err:
@@ -57,9 +58,9 @@ class CachedConnection:
         cached_result = self.cache.get(key)
         if cached_result:
             cached = json.loads(cached_result)
-            return {"rows": cached, "fields": cached['fields']}
+            return {"rows": cached, "fields": cached["fields"]}
         else:
             new_result = self.exec(sql)
             new_result_string = json.dumps(new_result)
             self.cache.set(key, new_result_string, "EX", DEFAULT_CACHE_TTL)
-            return {"rows": new_result, "fields": new_result['fields']}
+            return {"rows": new_result, "fields": new_result["fields"]}

quillsql/db/db_helper.py

@@ -1,42 +1,61 @@
-from quillsql.db.postgres import format_postgres, connect_to_postgres, get_schema_column_info_postgres, get_tables_by_schema_postgres, run_query_postgres, disconnect_from_postgres
-from quillsql.db.bigquery import format_bigquery_config, connect_to_bigquery, get_schema_column_info_big_query, get_tables_by_schema_big_query, run_query_big_query
+from quillsql.db.postgres import (
+    format_postgres,
+    connect_to_postgres,
+    get_schema_column_info_postgres,
+    get_tables_by_schema_postgres,
+    run_query_postgres,
+    disconnect_from_postgres,
+)
+from quillsql.db.bigquery import (
+    format_bigquery_config,
+    connect_to_bigquery,
+    get_schema_column_info_big_query,
+    get_tables_by_schema_big_query,
+    run_query_big_query,
+)
+
 
 def get_db_credentials(database_type, connection_string):
-  if(database_type.lower() == 'postgresql'):
-    return format_postgres(connection_string)
-  elif(database_type.lower() == 'bigquery'):
-    return format_bigquery_config(connection_string)
-  return {}
+    if database_type.lower() == "postgresql":
+        return format_postgres(connection_string)
+    elif database_type.lower() == "bigquery":
+        return format_bigquery_config(connection_string)
+    return {}
+
 
 def connect_to_db(database_type, config, using_connection_string):
-    if(database_type.lower() == 'postgresql'):
+    if database_type.lower() == "postgresql":
         return connect_to_postgres(config, using_connection_string)
-    elif(database_type.lower() == 'bigquery'):
+    elif database_type.lower() == "bigquery":
         return connect_to_bigquery(config, using_connection_string)
     return None
 
+
 def run_query_by_db(database_type, query, connection):
-    if (database_type.lower() == 'postgresql'):
+    if database_type.lower() == "postgresql":
         return run_query_postgres(query, connection)
-    elif (database_type.lower() == 'bigquery'):
+    elif database_type.lower() == "bigquery":
         return run_query_big_query(query, connection)
     return None
 
+
 def disconnect_from_db(database_type, connection):
-    if (database_type.lower() == 'postgresql'):
+    if database_type.lower() == "postgresql":
         return disconnect_from_postgres(connection)
     return None
 
+
 def get_schema_tables_by_db(database_type, connection, schema_name):
-    if (database_type.lower() == 'postgresql'):
+    if database_type.lower() == "postgresql":
         return get_tables_by_schema_postgres(connection, schema_name)
-    elif (database_type.lower() == 'bigquery'):
+    elif database_type.lower() == "bigquery":
         return get_tables_by_schema_big_query(connection, schema_name)
     return None
 
+
 def get_schema_column_info_by_db(database_type, connection, schema_name, table_names):
-    if (database_type.lower() == 'postgresql'):
+    if database_type.lower() == "postgresql":
         return get_schema_column_info_postgres(connection, schema_name, table_names)
-    elif (database_type.lower() == 'bigquery'):
+    elif database_type.lower() == "bigquery":
         return get_schema_column_info_big_query(connection, schema_name, table_names)
-    return None
+    return None

quillsql/db/postgres.py

@@ -1,72 +1,127 @@
+import os
 import psycopg2
 from psycopg2.extensions import make_dsn
 from quillsql.assets.pgtypes import PG_TYPES
 
-def format_postgres(connection_string ):
-    to_dsn = lambda conn: make_dsn(conn) if "://" in conn else conn
+
+def format_postgres(connection_string):
+    def to_dsn(conn):
+        return make_dsn(conn) if "://" in conn else conn
+
     return to_dsn(connection_string)
 
+
 def connect_to_postgres(config, usingConnectionString):
+    os.environ['PGGSSENCMODE'] = 'disable' # https://github.com/psycopg/psycopg2/issues/1084
     if usingConnectionString:
-      return psycopg2.connect(config)
+        return psycopg2.connect(config)
     else:
-      return psycopg2.connect(
-        database=config['dbname'],
-        user=config['user'],
-        password=config['password'],
-        host=config['host'],
-        port=config['port']
-      )
+        return psycopg2.connect(
+            database=config["dbname"],
+            user=config["user"],
+            password=config["password"],
+            host=config["host"],
+            port=config["port"],
+        )
+
 
 def run_query_postgres(query, connection):
     cursor = connection.cursor()
     cursor.execute(query)
     result = cursor.fetchall()
-    fields = [
-            {"name": desc[0], "dataTypeID": desc[1]} for desc in cursor.description
-        ]
+    fields = [{"name": desc[0], "dataTypeID": desc[1]} for desc in cursor.description]
     cursor.close()
-    rows_dict = [dict(zip([field['name'] for field in fields], row)) for row in result]
+    rows_dict = [dict(zip([field["name"] for field in fields], row)) for row in result]
     return {"rows": rows_dict, "fields": fields}
 
+
 def disconnect_from_postgres(connection):
     connection.close()
     return
 
+
 # getTablesBySchemaPostgres
+
+
 def get_tables_by_schema_postgres(connection, schema_names):
     all_tables = []
     for schema_name in schema_names:
-      query = f"SELECT table_name, table_schema FROM information_schema.tables WHERE table_schema = '{schema_name}'"
-      results = run_query_postgres(query, connection)
-      for row in results['rows']:
-        cur_table = {}
-        cur_table['table_name'] = row['table_name']
-        cur_table['schema_name'] = row['table_schema']
-        all_tables.append(cur_table)
+        query = f"""
+            SELECT table_name, table_schema
+            FROM information_schema.tables
+            WHERE table_schema = '{schema_name}'
+
+            UNION
+
+            SELECT c.relname as table_name, n.nspname as table_schema
+            FROM pg_class c
+            JOIN pg_namespace n ON c.relnamespace = n.oid
+            WHERE n.nspname = '{schema_name}' 
+            AND c.relkind = 'm';
+            """
+        results = run_query_postgres(query, connection)
+        for row in results["rows"]:
+            cur_table = {}
+            cur_table["table_name"] = row["table_name"]
+            cur_table["schema_name"] = row["table_schema"]
+            all_tables.append(cur_table)
     return all_tables
 
-# getSchemaColumnInfoPostgress
+
+# getSchemaColumnInfoPostgres
+
+
 def get_schema_column_info_postgres(connection, schema_name, table_names):
     all_columns = []
     for table_name in table_names:
-        query = f"SELECT column_name, udt_name FROM information_schema.columns WHERE table_schema = '{table_name['schema_name']}' AND table_name = '{table_name['table_name']}' ORDER BY ordinal_position"
+        query = f"""
+            SELECT column_name as "column_name", udt_name as "field_type", ordinal_position as "sort_number"
+            FROM information_schema.columns
+            WHERE table_schema = '{table_name['schema_name']}' 
+            AND table_name = '{table_name['table_name']}'
+            
+            UNION
+
+            SELECT a.attname as "column_name", t.typname as "field_type", a.attnum as "sort_number"
+            FROM pg_attribute a
+            JOIN pg_class c ON a.attrelid = c.oid
+            JOIN pg_namespace n ON c.relnamespace = n.oid
+            JOIN pg_type t ON a.atttypid = t.oid
+            WHERE n.nspname = '{table_name['schema_name']}'
+                AND c.relname = '{table_name['table_name']}'
+                AND c.relkind = 'm'
+                AND a.attnum > 0
+                AND NOT a.attisdropped
+            ORDER BY "sort_number"
+            """
         results = run_query_postgres(query, connection)
         columns = []
-        for row in results['rows']:
-            # Convert row['udt_name'] to postgresql oid
-            pg_type = next((pg_type for pg_type in PG_TYPES if pg_type['typname'] == row['udt_name']), None)
-            if pg_type == None:
+        for row in results["rows"]:
+            pg_type = next(
+                (
+                    pg_type
+                    for pg_type in PG_TYPES
+                    if pg_type["typname"] == row["field_type"]
+                ),
+                None,
+            )
+            if pg_type is None:
                 pg_type = 1043
-            columns.append({
-                'columnName': row['column_name'],
-                'displayName': row['column_name'],
-                'dataTypeID': pg_type['oid'],
-                'fieldType': row['udt_name'],
-            })
-        all_columns.append({
-            'tableName': table_name['schema_name']+'.'+table_name['table_name'],
-            'displayName': table_name['schema_name']+'.'+table_name['table_name'],
-            'columns': columns
-        })
-    return all_columns
+            columns.append(
+                {
+                    "columnName": row["column_name"],
+                    "displayName": row["column_name"],
+                    "dataTypeID": pg_type["oid"],
+                    "fieldType": row["field_type"],
+                }
+            )
+        all_columns.append(
+            {
+                "tableName": table_name["schema_name"] + "." + table_name["table_name"],
+                "displayName": table_name["schema_name"]
+                + "."
+                + table_name["table_name"],
+                "columns": columns,
+            }
+        )
+    return all_columns

quillsql/error.py

@@ -1,5 +1,5 @@
 class PgQueryError(Exception):
-  def __init__(self, message, query, position):
-    super().__init__(message)
-    self.query = query
-    self.position = position
+    def __init__(self, message, query, position):
+        super().__init__(message)
+        self.query = query
+        self.position = position

quillsql/utils/__init__.py

@@ -1,3 +1,4 @@
 # __init__.py
 
-from .run_query_processes import remove_fields, array_to_map
+from .run_query_processes import remove_fields, array_to_map
+from .filters import Filter, FilterType, FieldType, StringOperator, NumberOperator, NullOperator, DateOperator, convert_custom_filter

quillsql/utils/filters.py

@@ -0,0 +1,180 @@
+from enum import Enum
+from typing import Union, Any, Optional
+from dataclasses import dataclass, asdict
+
+# Constants
+IS_EXACTLY = 'is exactly'
+IS_NOT_EXACTLY = 'is not exactly'
+CONTAINS = 'contains'
+IS = 'is'
+IS_NOT = 'is not'
+IS_NOT_NULL = 'is not null'
+IS_NULL = 'is null'
+
+IN_THE_LAST = 'in the last'
+IN_THE_PREVIOUS = 'in the previous'
+IN_THE_CURRENT = 'in the current'
+
+EQUAL_TO = 'equal to'
+NOT_EQUAL_TO = 'not equal to'
+GREATER_THAN = 'greater than'
+LESS_THAN = 'less than'
+GREATER_THAN_OR_EQUAL_TO = 'greater than or equal to'
+LESS_THAN_OR_EQUAL_TO = 'less than or equal to'
+
+YEAR = 'year'
+QUARTER = 'quarter'
+MONTH = 'month'
+WEEK = 'week'
+DAY = 'day'
+HOUR = 'hour'
+
+NUMBER = 'number'
+STRING = 'string'
+DATE = 'date'
+NULL = 'null'
+CUSTOM = 'custom'
+BOOLEAN = 'boolean'
+
+# Enums
+class StringOperator(Enum):
+    IS_EXACTLY = IS_EXACTLY
+    IS_NOT_EXACTLY = IS_NOT_EXACTLY
+    CONTAINS = CONTAINS
+    IS = IS
+    IS_NOT = IS_NOT
+
+class DateOperator(Enum):
+    CUSTOM = CUSTOM
+    IN_THE_LAST = IN_THE_LAST
+    IN_THE_PREVIOUS = IN_THE_PREVIOUS
+    IN_THE_CURRENT = IN_THE_CURRENT
+    EQUAL_TO = EQUAL_TO
+    NOT_EQUAL_TO = NOT_EQUAL_TO
+    GREATER_THAN = GREATER_THAN
+    LESS_THAN = LESS_THAN
+    GREATER_THAN_OR_EQUAL_TO = GREATER_THAN_OR_EQUAL_TO
+    LESS_THAN_OR_EQUAL_TO = LESS_THAN_OR_EQUAL_TO
+
+class NumberOperator(Enum):
+    EQUAL_TO = EQUAL_TO
+    NOT_EQUAL_TO = NOT_EQUAL_TO
+    GREATER_THAN = GREATER_THAN
+    LESS_THAN = LESS_THAN
+    GREATER_THAN_OR_EQUAL_TO = GREATER_THAN_OR_EQUAL_TO
+    LESS_THAN_OR_EQUAL_TO = LESS_THAN_OR_EQUAL_TO
+
+class NullOperator(Enum):
+    IS_NOT_NULL = IS_NOT_NULL
+    IS_NULL = IS_NULL
+
+class BoolOperator(Enum):
+    EQUAL_TO = EQUAL_TO
+    NOT_EQUAL_TO = NOT_EQUAL_TO
+
+class TimeUnit(Enum):
+    YEAR = YEAR
+    QUARTER = QUARTER
+    MONTH = MONTH
+    WEEK = WEEK
+    DAY = DAY
+    HOUR = HOUR
+
+class FieldType(Enum):
+    STRING = STRING
+    NUMBER = NUMBER
+    DATE = DATE
+    NULL = NULL
+    BOOLEAN = BOOLEAN
+
+class FilterType(Enum):
+    STRING_FILTER = 'string-filter'
+    DATE_FILTER = 'date-filter'
+    DATE_CUSTOM_FILTER = 'date-custom-filter'
+    DATE_COMPARISON_FILTER = 'date-comparison-filter'
+    NUMERIC_FILTER = 'numeric-filter'
+    NULL_FILTER = 'null-filter'
+    STRING_IN_FILTER = 'string-in-filter'
+    BOOLEAN_FILTER = 'boolean-filter'
+
+# Types
+Operator = Union[StringOperator, DateOperator, NumberOperator, NullOperator, BoolOperator]
+
+# Base Filter Interface
+@dataclass
+class DateRange:
+    startDate: str
+    endDate: str
+
+@dataclass
+class DateValue:
+    value: int
+    unit: TimeUnit
+@dataclass
+class BaseFilter:
+    filterType: FilterType
+    fieldType: FieldType
+    operator: Operator
+    field: str
+    value: Union[bool, int, str, list[str], DateRange, DateValue, None]
+    table: Optional[str] = None
+
+@dataclass
+class Filter:
+    filter_type: FilterType
+    operator: Operator
+    value: Union[bool, int, str, list[str], DateRange, DateValue, None]
+    field: str
+    table: str
+
+def convert_custom_filter(filter: Filter) -> dict:
+    if filter.filter_type == FilterType.STRING_FILTER:
+        if not isinstance(filter.value, str):
+            raise ValueError('Invalid value for StringFilter, expected string')
+        if filter.operator not in StringOperator:
+            raise ValueError('Invalid operator for StringFilter, expected StringOperator')
+        return asdict(BaseFilter(filter.filter_type, FieldType.STRING, filter.operator, filter.field, filter.value, filter.table)) 
+    elif filter.filter_type == FilterType.STRING_IN_FILTER:
+        if not isinstance(filter.value, list):
+            raise ValueError('Invalid value for StringInFilter, expected list')
+        if filter.operator not in StringOperator:
+            raise ValueError('Invalid operator for StringInFilter, expected StringOperator')
+        return asdict(BaseFilter(filter.filter_type, FieldType.STRING, filter.operator, filter.field, filter.value, filter.table))
+    elif filter.filter_type == FilterType.NUMERIC_FILTER:
+        if not isinstance(filter.value, int):
+            raise ValueError('Invalid value for NumericFilter, expected int')
+        if filter.operator not in NumberOperator:
+            raise ValueError('Invalid operator for NumericFilter, expected NumberOperator')
+        return asdict(BaseFilter(filter.filter_type, FieldType.NUMBER, filter.operator, filter.field, filter.value, filter.table))
+    elif filter.filter_type == FilterType.DATE_FILTER:
+        if not isinstance(filter.value, DateValue) or filter.value is None:
+            raise ValueError('Invalid value for DateFilter, expected DateValue')
+        if filter.operator not in DateOperator:
+            raise ValueError('Invalid operator for DateFilter, expected DateOperator')
+        return asdict(BaseFilter(filter.filter_type, FieldType.DATE, filter.operator, filter.field, filter.value, filter.table))
+    elif filter.filter_type == FilterType.DATE_CUSTOM_FILTER:
+        if not isinstance(filter.value, DateRange) or filter.value is None:
+            raise ValueError('Invalid value for DateCustomFilter, expected DateRange')
+        if filter.operator not in DateOperator:
+            raise ValueError('Invalid operator for DateCustomFilter, expected DateOperator')
+        return asdict(BaseFilter(filter.filter_type, FieldType.DATE, filter.operator, filter.field, filter.value, filter.table))
+    elif filter.filter_type == FilterType.DATE_COMPARISON_FILTER:
+        if not isinstance(filter.value, str):
+            raise ValueError('Invalid value for DateComparisonFilter, expected str')
+        if filter.operator not in DateOperator:
+            raise ValueError('Invalid operator for DateComparisonFilter, expected DateOperator')
+        return asdict(BaseFilter(filter.filter_type, FieldType.DATE, filter.operator, filter.field, filter.value, filter.table))
+    elif filter.filter_type == FilterType.NULL_FILTER:
+        if filter.value is not None:
+            raise ValueError('Invalid value for NullFilter, expected None')
+        if filter.operator not in NullOperator:
+            raise ValueError('Invalid operator for NullFilter, expected NullOperator')
+        return asdict(BaseFilter(filter.filter_type, FieldType.NULL, filter.operator, filter.field, filter.value, filter.table))
+    elif filter.filter_type == FilterType.BOOLEAN_FILTER:
+        if not isinstance(filter.value, bool):
+            raise ValueError('Invalid value for BooleanFilter, expected bool')
+        if filter.operator not in BoolOperator:
+            raise ValueError('Invalid operator for BooleanFilter, expected BoolOperator')
+        return asdict(BaseFilter(filter.filter_type, FieldType.BOOLEAN, filter.operator, filter.field, filter.value, filter.table))
+    else:
+        raise ValueError(f'Unknown filter type: {filter.filter_type}')

quillsql/utils/run_query_processes.py

@@ -1,19 +1,20 @@
-import json
-
 def remove_fields(query_result, fields_to_remove):
-  fields = [
-      {"name": field['name'], "dataTypeID": field['dataTypeID']}
-      for field in query_result['fields']
-      if field['name'] not in fields_to_remove
-  ]
-  rows = [row for row in query_result['rows']]
-  for row in rows:
-    for field in fields_to_remove:
-      if field in row:
-          del row[field]
-  return {"fields": fields, "rows": rows}
+    fields = [
+        {"name": field["name"], "dataTypeID": field["dataTypeID"]}
+        for field in query_result["fields"]
+        if field["name"] not in fields_to_remove
+    ]
+    rows = [row for row in query_result["rows"]]
+    for row in rows:
+        for field in fields_to_remove:
+            if field in row:
+                del row[field]
+    return {"fields": fields, "rows": rows}
+
 
 def array_to_map(queries, array_to_map, metadata, target_pool):
-  for i in range(len(queries)):
-    query_result = target_pool.query(queries[i])
-    metadata[array_to_map.get("arrayName")][i][array_to_map.get("field")] = query_result.get("rows")
+    mapped_array = []
+    for i in range(len(queries)):
+        query_result = target_pool.query(queries[i])
+        mapped_array.append(query_result.get("rows"))
+    return mapped_array

quillsql/utils/schema_conversion.py

@@ -1,6 +1,9 @@
 from quillsql.assets.pgtypes import PG_TYPES
 
+
 def convert_type_to_postgres(data_type_id):
-   # find the object in PG_TYPES that matches the type
-    pg_type = next((pg_type for pg_type in PG_TYPES if pg_type['oid'] == data_type_id), None)
-    return pg_type['typname'] if pg_type else data_type_id
+    # find the object in PG_TYPES that matches the type
+    pg_type = next(
+        (pg_type for pg_type in PG_TYPES if pg_type["oid"] == data_type_id), None
+    )
+    return pg_type["typname"] if pg_type else data_type_id

quillsql/utils/tenants.py

@@ -0,0 +1,60 @@
+from typing import Union, List, Dict
+
+# Type aliases for clarity
+TenantId = Union[str, int]
+TenantInfo = Dict[str, Union[str, List[TenantId]]]
+Tenants = Union[List[TenantId], List[TenantInfo]]
+
+def extract_tenant_ids(tenants: Tenants) -> List[TenantId]:
+    """
+    Extract tenant IDs from the tenants parameter, which can be either a list of IDs
+    or a list of tenant info dictionaries.
+    
+    Args:
+        tenants: Either a list of tenant IDs (strings/integers) or a list of tenant info dictionaries
+        
+    Returns:
+        List of tenant IDs
+        
+    Raises:
+        ValueError: If the tenants parameter format is invalid
+    """
+    if not tenants:
+        raise ValueError("Invalid format for tenants: empty list")
+
+    first_tenant = tenants[0]
+    
+    if isinstance(first_tenant, (str, int)):
+        return tenants  # type: ignore
+    elif isinstance(first_tenant, dict) and "tenantIds" in first_tenant:
+        # TODO: support multiple tenants in future
+        return first_tenant["tenantIds"]
+    else:
+        raise ValueError("Invalid format for tenants")
+
+def extract_tenant_field(tenants: Tenants, dashboard_owner: str) -> str:
+    """
+    Extract tenant field from the tenants parameter, falling back to dashboard_owner
+    if tenants is a simple list of IDs.
+    
+    Args:
+        tenants: Either a list of tenant IDs (strings/integers) or a list of tenant info dictionaries
+        dashboard_owner: The default tenant field to use if tenants is a simple list
+        
+    Returns:
+        The tenant field string
+        
+    Raises:
+        ValueError: If the tenants parameter format is invalid
+    """
+    if not tenants:
+        raise ValueError("Invalid format for tenants: empty list")
+
+    first_tenant = tenants[0]
+    
+    if isinstance(first_tenant, (str, int)):
+        return dashboard_owner
+    elif isinstance(first_tenant, dict) and "tenantField" in first_tenant:
+        return first_tenant["tenantField"]
+    else:
+        raise ValueError("Invalid format for tenants") 

quillsql-2.2.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: quillsql
+Version: 2.2.0
+Summary: Quill SDK for Python.
+Home-page: https://github.com/quill-sql/quill-python
+Author: Quill
+Author-email: shawn@quill.co
+Description-Content-Type: text/markdown
+Requires-Dist: psycopg2-binary
+Requires-Dist: requests
+Requires-Dist: redis
+Requires-Dist: python-dotenv
+Requires-Dist: pytest
+Requires-Dist: google-cloud-bigquery
+Requires-Dist: google-auth
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
+
+# Quill Python SDK
+
+## Quickstart
+
+First, install the quillsql package by running:
+
+```bash
+$ pip install quillsql
+```
+
+Then, add a `/quill` endpoint to your existing python server. For example, if
+you were running a FASTAPI app, you would just add the endpoint like this:
+
+```python
+from quillsql import Quill
+
+quill = Quill(
+    private_key=os.getenv("QULL_PRIVATE_KEY"),
+    database_connection_string=os.getenv("POSTGRES_READ"),
+    database_type="postgresql"
+)
+
+security = HTTPBearer()
+
+async def authenticate_jwt(token: str = Depends(security)):
+    # Your JWT validation logic here
+    # Return user object or raise HTTPException
+    user = validate_jwt_token(token.credentials)
+    return user
+
+@app.post("/quill")
+async def quill_post(data: Request, user: dict = Depends(authenticate_jwt)):
+    # assuming user fetched via auth middleware has an userId
+    user_id = user["user_id"]
+    body = await data.json()
+    metadata = body.get("metadata")
+
+    result = quill.query(
+        tenants=[{"tenantField": "user_id", "tenantIds": [user_id]}],
+        metadata=metadata
+    )
+    return result
+```
+
+Then you can run your app like normally. Pass in this route to our react library
+on the frontend and you all set!