import re import sys from types import ModuleType from typing import Any, Literal from django.conf import settings from django.urls import URLResolver from django_pgschemas.routing.info import DomainInfo, HeadersInfo, SessionInfo from django_pgschemas.schema import Schema, get_current_schema DYNAMIC_URLCONF_SUFFIX = "_dynamically_tenant_prefixed" class TenantPrefixPattern: converters: dict = {} @property def tenant_prefix(self) -> str: current_schema = get_current_schema() return ( f"{current_schema.routing.folder}/" if isinstance(current_schema.routing, DomainInfo) and current_schema.routing.folder else "" ) @property def regex(self) -> re.Pattern: # This is only used by reverse() and cached in _reverse_dict. return re.compile(self.tenant_prefix) def match(self, path: str) -> tuple | None: tenant_prefix = self.tenant_prefix if path.startswith(tenant_prefix): return path[len(tenant_prefix) :], (), {} return None def check(self) -> list: return [] def describe(self) -> str: return f"'{self}'" def __str__(self) -> str: return self.tenant_prefix def get_dynamic_tenant_prefixed_urlconf(urlconf: str, dynamic_path: str) -> ModuleType: """ Generates a new urlconf module with all patterns prefixed with tenant. """ class LazyURLConfModule(ModuleType): def __getattr__(self, attr: str) -> Any: if attr == "urlpatterns": return [URLResolver(TenantPrefixPattern(), urlconf)] return self.__getattribute__(attr) return LazyURLConfModule(dynamic_path) def _get_urlconf_from_schema( schema: Schema, config_key: Literal["URLCONF", "WS_URLCONF"] ) -> str | None: match schema.routing: case DomainInfo(domain, _): # Checking for static tenants if not schema.is_dynamic: for schema_name, data in settings.TENANTS.items(): if schema_name in ["public", "default"]: continue if domain in data.get("DOMAINS", []): return data.get(config_key) if domain in data.get("FALLBACK_DOMAINS", []): return data.get(config_key) return None # Checking for dynamic tenants urlconf = settings.TENANTS.get("default", {}).get(config_key) if urlconf is not None and schema.routing.folder: dynamic_path = urlconf + DYNAMIC_URLCONF_SUFFIX if not sys.modules.get(dynamic_path): sys.modules[dynamic_path] = get_dynamic_tenant_prefixed_urlconf( urlconf, dynamic_path ) urlconf = dynamic_path return urlconf case SessionInfo(reference): # Checking for static tenants if not schema.is_dynamic: for schema_name, data in settings.TENANTS.items(): if schema_name in ["public", "default"]: continue if reference == data.get("SESSION_KEY"): return data.get(config_key) return None # Checking for dynamic tenants return settings.TENANTS.get("default", {}).get(config_key) case HeadersInfo(reference): # Checking for static tenants if not schema.is_dynamic: for schema_name, data in settings.TENANTS.items(): if schema_name in ["public", "default"]: continue if reference == data.get("HEADER"): return data.get(config_key) return None # Checking for dynamic tenants return settings.TENANTS.get("default", {}).get(config_key) case _: return None def get_urlconf_from_schema(schema: Schema) -> str | None: return _get_urlconf_from_schema(schema, "URLCONF") def get_ws_urlconf_from_schema(schema: Schema) -> str | None: return _get_urlconf_from_schema(schema, "WS_URLCONF")