half-orm-gen 1.0.0a1__py3-none-any.whl

half_orm_gen/gen_store/__init__.py

@@ -0,0 +1,34 @@
+"""
+Frontend store generator for halfORM/Litestar projects.
+"""
+
+from pathlib import Path
+from half_orm_gen.gen_store.base import StoreGenerator
+
+
+class GenStore:
+    """
+    Generate frontend stores from CRUD_ACCESS introspection.
+
+    Parameters
+    ----------
+    repo:
+        A ``half_orm_dev.repo.Repo`` instance.
+    generator:
+        A :class:`StoreGenerator` subclass instance (e.g. SvelteGenerator).
+    output_dir:
+        Directory where the generated files will be written.
+    api_version:
+        Integer API version (used to build route prefixes).
+    """
+
+    def __init__(
+        self,
+        repo,
+        *,
+        generator: StoreGenerator,
+        output_dir: Path,
+        api_version: int | None = None,
+    ):
+        classes = list(repo.model.classes())
+        generator.generate(classes, api_version, output_dir)

half_orm_gen/gen_store/base.py

@@ -0,0 +1,88 @@
+"""
+Abstract base class for frontend store generators.
+"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+class StoreGenerator(ABC):
+
+    PY_TO_TS = {
+        'str':               'string',
+        'int':               'number',
+        'float':             'number',
+        'bool':              'boolean',
+        'uuid.UUID':         'string',
+        'datetime.datetime': 'string',
+        'datetime.date':     'string',
+        'datetime.time':     'string',
+        'datetime.timedelta':'string',
+        'decimal.Decimal':   'number',
+    }
+
+    def ts_type(self, py_type_str: str) -> str:
+        return self.PY_TO_TS.get(py_type_str, 'unknown')
+
+    def resource_name(self, schema: str, table: str) -> str:
+        """blogAuthor (camelCase)"""
+        parts = schema.split('_') + table.split('_')
+        return parts[0].lower() + ''.join(p.capitalize() for p in parts[1:])
+
+    def interface_name(self, schema: str, table: str) -> str:
+        """BlogAuthor (PascalCase)"""
+        parts = schema.split('_') + table.split('_')
+        return ''.join(p.capitalize() for p in parts)
+
+    def _fk_deps(self, inst, out_names: list, crud_resources: set) -> list:
+        """Return (local_field, remote_schema, remote_table, remote_pk) for each
+        simple non-reverse FK whose local field is in out_names and whose remote
+        table is in crud_resources."""
+        deps = []
+        for fk in getattr(inst, '_ho_fkeys', {}).values():
+            if fk.is_reverse:
+                continue
+            local_fields = fk.names
+            remote_pks   = fk.fk_names
+            if len(local_fields) != 1 or len(remote_pks) != 1:
+                continue
+            local_field = local_fields[0]
+            if local_field not in out_names:
+                continue
+            fqtn = fk.remote['fqtn']
+            remote_schema = fqtn[0].replace('.', '_')
+            remote_table  = fqtn[1]
+            if (remote_schema, remote_table) not in crud_resources:
+                continue
+            deps.append((local_field, remote_schema, remote_table, remote_pks[0]))
+        return deps
+
+    def _reverse_fk_deps(self, inst, pk_field: str | None, crud_resources: set) -> list:
+        """Return (remote_schema, remote_table, fk_field) for each simple reverse FK
+        whose remote table is in crud_resources. Deduplicated by remote table."""
+        if not pk_field:
+            return []
+        deps = []
+        seen: set[tuple[str, str]] = set()
+        for fk in getattr(inst, '_ho_fkeys', {}).values():
+            if not fk.is_reverse:
+                continue
+            our_pk_fields    = fk.names
+            remote_fk_fields = fk.fk_names
+            if len(our_pk_fields) != 1 or len(remote_fk_fields) != 1:
+                continue
+            if our_pk_fields[0] != pk_field:
+                continue
+            fqtn = fk.remote['fqtn']
+            remote_schema = fqtn[0].replace('.', '_')
+            remote_table  = fqtn[1]
+            if (remote_schema, remote_table) not in crud_resources:
+                continue
+            if (remote_schema, remote_table) in seen:
+                continue
+            seen.add((remote_schema, remote_table))
+            deps.append((remote_schema, remote_table, remote_fk_fields[0]))
+        return deps
+
+    @abstractmethod
+    def generate(self, classes, api_version, output_dir: Path) -> None: ...

half_orm_gen/gen_store/svelte.py

@@ -0,0 +1,282 @@
+"""
+Svelte 5 / TypeScript store generator (.svelte.ts, $state runes).
+"""
+
+import importlib
+import shutil
+from pathlib import Path
+
+from half_orm_gen.crud_routes import (
+    _gen_out_fields,
+    _gen_in_fields,
+    _pk_info,
+    _simple_pk,
+    _instance,
+    _py_type_str,
+)
+from half_orm_gen.gen_store.base import StoreGenerator
+
+
+class SvelteGenerator(StoreGenerator):
+
+    def generate(self, classes, api_version, output_dir: Path) -> None:
+        if output_dir.exists():
+            shutil.rmtree(output_dir)
+        output_dir.mkdir(parents=True)
+        self._write_base(output_dir)
+        version_prefix = f'/v{api_version}' if api_version is not None else ''
+
+        # Pass 1: collect resources that have CRUD_ACCESS
+        resources = []
+        crud_resources: set[tuple[str, str]] = set()
+
+        for relation, _relation_type in classes:
+            module_str = relation.__module__
+            try:
+                mod = importlib.import_module(module_str)
+            except ImportError:
+                continue
+            crud_access = getattr(mod, 'CRUD_ACCESS', None) or {'GET': {}, 'POST': {}, 'PUT': {}, 'DELETE': {}}
+            schema_name = relation._t_fqrn[1]
+            table_name  = relation._t_fqrn[2]
+            crud_resources.add((schema_name, table_name))
+            resources.append((relation, mod, crud_access, schema_name, table_name))
+
+        # Pass 2: generate one .svelte.ts per resource
+        stems = []
+
+        for relation, mod, crud_access, schema_name, table_name in resources:
+            api_excluded = getattr(mod, 'API_EXCLUDED_FIELDS', [])
+            inst         = _instance(relation)
+            all_fields   = getattr(inst, '_ho_fields', {})
+            all_names    = list(all_fields.keys())
+            pk_cols      = _pk_info(relation)
+            pk_info      = pk_cols  # truthy iff non-empty
+            if len(pk_cols) == 1:
+                pk_field    = pk_cols[0][0]
+                pk_ts_type  = self.ts_type(pk_cols[0][2])
+                pk_extractor = f'i => String(i.{pk_field})'
+            elif len(pk_cols) > 1:
+                pk_field    = pk_cols[0][0]
+                pk_ts_type  = 'string'
+                pk_extractor = 'i => [' + ', '.join(f'i.{f}' for f, _, _ in pk_cols) + '].map(String).join("::")'
+            else:
+                pk_field = pk_ts_type = pk_extractor = None
+
+            iname     = self.interface_name(schema_name, table_name)
+            rname     = self.resource_name(schema_name, table_name)
+            base_path = f'{version_prefix}/{schema_name}/{table_name}'
+            stem      = f'{schema_name}_{table_name}'
+
+            out_names = _gen_out_fields(crud_access, 'GET', api_excluded, all_names)
+            if not out_names:
+                out_names = [f for f in all_names if f not in api_excluded]
+
+            has_post = 'POST' in crud_access and pk_info
+            has_put  = 'PUT'  in crud_access and pk_info
+            has_del  = 'DELETE' in crud_access and pk_info
+
+            post_in_names = _gen_in_fields(
+                crud_access, 'POST', pk_field, api_excluded, all_names
+            ) if has_post else []
+            put_in_names = _gen_in_fields(
+                crud_access, 'PUT', pk_field, api_excluded, all_names
+            ) if has_put else []
+
+            fk_deps = self._fk_deps(inst, out_names, crud_resources)
+
+            lines = []
+
+            # Imports
+            lines.append("import { BaseState } from './base.svelte.ts';")
+            lines.append("import { auth } from '$lib/auth.svelte.ts';")
+            lines.append("import { registerClear } from '$lib/stateRegistry';")
+            lines.append('')
+
+            # FK imports (deduplicated: skip self-referential FKs and multi-FK to same table)
+            seen_stems: set[str] = {stem}
+            for local_field, remote_schema, remote_table, remote_pk in fk_deps:
+                remote_stem = f'{remote_schema}_{remote_table}'
+                if remote_stem in seen_stems:
+                    continue
+                seen_stems.add(remote_stem)
+                remote_rname = self.resource_name(remote_schema, remote_table)
+                lines.append(
+                    f"import {{ {remote_rname}State }} from './{remote_stem}.svelte.ts';"
+                )
+            if fk_deps:
+                lines.append('')
+
+            # Interfaces
+            lines.append(self._interface(f'{iname}Out', out_names, all_fields))
+            if has_post:
+                lines.append(self._interface(f'{iname}PostIn', post_in_names, all_fields))
+            if has_put:
+                lines.append(self._interface(f'{iname}PutIn', put_in_names, all_fields))
+
+            # State class
+            if pk_info:
+                lines.append(f'class {iname}State extends BaseState<{iname}Out> {{')
+                lines.append(f'    constructor() {{ super({pk_extractor}); }}')
+            else:
+                lines.append(f'class {iname}State {{')
+                lines.append(f'    items = $state<{iname}Out[]>([]);')
+                lines.append(f'    setItems(data: {iname}Out[]) {{ this.items = data; }}')
+                lines.append(f'    mergeItems(data: {iname}Out[]) {{ this.items = data; }}')
+
+            if fk_deps:
+                lines.append('')
+                for local_field, remote_schema, remote_table, remote_pk in fk_deps:
+                    remote_rname = self.resource_name(remote_schema, remote_table)
+                    map_name = f'_{local_field}Map'
+                    lines.append(
+                        f'    {map_name} = $derived('
+                        f'Object.fromEntries({remote_rname}State.items.map('
+                        f'r => [r.{remote_pk}, r])));'
+                    )
+                lines.append('')
+                enriched = ', '.join(
+                    f'_{lf}: this._{lf}Map[item.{lf}] ?? null'
+                    for lf, _, _, _ in fk_deps
+                )
+                lines.append(
+                    f'    itemsWithRelations = $derived('
+                    f'this.items.map(item => ({{...item, {enriched}}})));'
+                )
+
+            lines.append('}')
+            lines.append('')
+            lines.append(f'export const {rname}State = new {iname}State();')
+            if pk_field:
+                lines.append(f'registerClear(() => {rname}State.clear());')
+            lines.append('')
+
+            # API
+            lines.append(f"const _BASE = '{base_path}';")
+            lines.append("const _hdrs = (extra?: Record<string, string>) => ({")
+            lines.append("    ...(auth.token ? { Authorization: `Bearer ${auth.token}` } : {}),")
+            lines.append("    ...extra,")
+            lines.append("});")
+            lines.append("const _fetch = (url: string, opts?: RequestInit) => {")
+            lines.append("    const method = opts?.method ?? 'GET';")
+            lines.append("    if (method === 'GET') auth.fetchedRoutes.add(url);")
+            lines.append("    return fetch(url, opts);")
+            lines.append("};")
+            lines.append('')
+            api_entries = []
+            if 'GET' in crud_access:
+                api_entries.append(
+                    f"    listUrl: (params: Partial<{iname}Out> = {{}}) =>\n"
+                    f"                 _BASE + '?' + new URLSearchParams(params as any),"
+                )
+                api_entries.append(
+                    f"    list:    (params: Partial<{iname}Out> = {{}}) =>\n"
+                    f"                 _fetch(_BASE + '?' + new URLSearchParams(params as any),\n"
+                    f"                        {{ headers: _hdrs() }}),"
+                )
+                if pk_info:
+                    api_entries.append(
+                        f"    getUrl:  (id: {pk_ts_type}) => `${{_BASE}}/${{id}}`,"
+                    )
+                    api_entries.append(
+                        f"    get:     (id: {pk_ts_type}) => {{\n"
+                        f"                 const _c = {rname}State.byId.get(String(id));\n"
+                        f"                 if (_c) return Promise.resolve(new Response(JSON.stringify(_c),\n"
+                        f"                     {{ status: 200, headers: {{ 'Content-Type': 'application/json' }} }}));\n"
+                        f"                 return _fetch(`${{_BASE}}/${{id}}`, {{ headers: _hdrs() }});\n"
+                        f"             }},"
+                    )
+            if has_post:
+                api_entries.append(
+                    f"    create:  (data: {iname}PostIn) =>\n"
+                    f"                 _fetch(_BASE, {{ method: 'POST',\n"
+                    f"                                headers: _hdrs({{'Content-Type': 'application/json'}}),\n"
+                    f"                                body: JSON.stringify(data) }}),"
+                )
+            if has_put:
+                api_entries.append(
+                    f"    update:  (id: {pk_ts_type}, data: {iname}PutIn) =>\n"
+                    f"                 _fetch(`${{_BASE}}/${{id}}`, {{ method: 'PUT',\n"
+                    f"                                               headers: _hdrs({{'Content-Type': 'application/json'}}),\n"
+                    f"                                               body: JSON.stringify(data) }}),"
+                )
+            if has_del:
+                api_entries.append(
+                    f"    remove:  (id: {pk_ts_type}) =>\n"
+                    f"                 _fetch(`${{_BASE}}/${{id}}`,\n"
+                    f"                        {{ method: 'DELETE', headers: _hdrs() }}),"
+                )
+            lines.append(f'export const {rname}Api = {{')
+            lines.extend(api_entries)
+            lines.append('};')
+            lines.append('')
+
+            out_file = output_dir / f'{stem}.svelte.ts'
+            out_file.write_text('\n'.join(lines), encoding='utf-8')
+            print(f'  {out_file}')
+            stems.append(stem)
+
+        if stems:
+            self._write_index(output_dir, stems, version_prefix)
+
+    def _write_base(self, output_dir: Path) -> None:
+        content = """\
+export class BaseState<V> {
+    byId  = $state(new Map<string, V>());
+    items = $derived([...this.byId.values()]);
+
+    constructor(private readonly pk: (item: V) => string) {}
+
+    clear() {
+        this.byId = new Map();
+    }
+    setItems(data: V[]) {
+        this.byId = new Map(data.map(i => [this.pk(i), i]));
+    }
+    mergeItems(data: V[]) {
+        const m = new Map(this.byId);
+        data.forEach(i => m.set(this.pk(i), i));
+        this.byId = m;
+    }
+    setItem(item: V) {
+        const m = new Map(this.byId);
+        m.set(this.pk(item), item);
+        this.byId = m;
+    }
+    removeItem(id: string) {
+        const m = new Map(this.byId);
+        m.delete(id);
+        this.byId = m;
+    }
+}
+"""
+        base_file = output_dir / 'base.svelte.ts'
+        base_file.write_text(content, encoding='utf-8')
+        print(f'  {base_file}')
+
+    def _interface(self, name: str, field_names: list, all_fields: dict) -> str:
+        if not field_names:
+            return f'export interface {name} {{}}\n'
+        props = '\n'.join(
+            f'    {f}: {self.ts_type(_py_type_str(all_fields[f].py_type))};'
+            for f in field_names if f in all_fields
+        )
+        return f'export interface {name} {{\n{props}\n}}\n'
+
+    def _write_index(self, output_dir: Path, stems: list, version_prefix: str) -> None:
+        lines = [f"export * from './{s}.svelte.ts';" for s in stems]
+        lines += [
+            '',
+            'export async function hoAccess(token?: string): Promise<Record<string, any>> {',
+            '    const headers: Record<string, string> = token',
+            '        ? { Authorization: `Bearer ${token}` }',
+            '        : {};',
+            f"    const res = await fetch('{version_prefix}/ho_access', {{ headers }});",
+            "    if (!res.ok) throw new Error(`ho_access: ${res.status}`);",
+            '    return res.json();',
+            '}',
+            '',
+        ]
+        index = output_dir / 'index.svelte.ts'
+        index.write_text('\n'.join(lines), encoding='utf-8')
+        print(f'  {index}')

half_orm_gen/generate.py

@@ -0,0 +1,120 @@
+"""
+Litestar API generator for halfORM projects.
+
+Orchestrates generation of api/app.py by combining:
+- @api_* decorated route handlers  (api_routes.py)
+- Auto-CRUD handlers from CRUD_ACCESS  (crud_routes.py)
+- Scaffolding of missing api/ files  (scaffold.py)
+"""
+
+import os
+from pathlib import Path
+from typing import Iterable, Tuple, Type
+
+from half_orm.relation import Relation
+
+from half_orm_gen import templates as T
+from half_orm_gen.scaffold import scaffold_api_dir
+from half_orm_gen.api_routes import generate_api_routes
+from half_orm_gen.crud_routes import generate_crud_routes
+
+
+class GenApi:
+    """
+    Generate ``api/app.py`` from a halfORM project.
+
+    Parameters
+    ----------
+    repo:
+        A ``half_orm_dev.repo.Repo`` instance.  When *None*, supply
+        *relation_classes*, *module_name*, and *base_dir* directly.
+    relation_classes:
+        Iterable of ``(RelationClass, relation_type)`` pairs (used when
+        *repo* is *None*).
+    module_name:
+        Top-level Python package name of the halfORM model (e.g. ``"mydb"``).
+    base_dir:
+        Root directory of the project (``api/`` is created inside it).
+    api_version:
+        Integer API version (written as ``/vN/`` prefix in routes).
+    """
+
+    def __init__(
+        self,
+        repo=None,
+        *,
+        relation_classes: Iterable[Tuple[Type[Relation], str]] | None = None,
+        module_name: str | None = None,
+        base_dir: str | None = None,
+        api_version: int | None = None,
+        framework: str = 'litestar',
+    ):
+        if repo is not None:
+            self._module_name = repo.name
+            self._base_dir = Path(repo.base_dir)
+            self._classes = list(repo.model.classes())
+        else:
+            if relation_classes is None or module_name is None or base_dir is None:
+                raise ValueError(
+                    "Provide either a repo or (relation_classes, module_name, base_dir)."
+                )
+            self._module_name = module_name
+            self._base_dir = Path(base_dir)
+            self._classes = list(relation_classes)
+
+        self._api_version = api_version
+        self._framework = framework
+        self._api_dir = self._base_dir / 'api'
+        self._generate()
+
+    def _generate(self) -> None:
+        os.environ.setdefault('API_GEN_MODE', '1')
+
+        if self._framework == 'fastapi':
+            from half_orm_gen import templates_fastapi as templates
+            api_blocks, api_handlers, covered = [], [], set()
+        else:
+            templates = T
+            api_blocks, api_handlers, covered = generate_api_routes(
+                self._classes, self._api_version
+            )
+
+        # --- auto-CRUD routes ---
+        crud_blocks, crud_handlers = generate_crud_routes(
+            self._classes, self._api_version, covered, templates=templates
+        )
+
+        # --- assemble app.py ---
+        openapi_config = (
+            templates.OPENAPI_CONFIG.format(
+                title=self._module_name,
+                version=f'v{self._api_version}',
+            )
+            if self._api_version is not None
+            else ''
+        )
+
+        output = (
+            templates.HEADER.format(module=self._module_name)
+            + (templates.CRUD_HELPERS if crud_blocks else '')
+            + ''.join(api_blocks)
+            + ''.join(crud_blocks)
+        )
+
+        if self._framework == 'fastapi':
+            output += templates.FOOTER.format(openapi_config=openapi_config)
+        else:
+            route_handlers_str = ', '.join(api_handlers + crud_handlers)
+            output += templates.FOOTER.format(
+                route_handlers=route_handlers_str,
+                openapi_config=openapi_config,
+            )
+            # --- scaffold missing api/ files ---
+            print(f'\nScaffolding {self._api_dir} ...')
+            scaffold_api_dir(self._api_dir)
+
+        # --- write app.py ---
+        self._api_dir.mkdir(parents=True, exist_ok=True)
+        app_py = self._api_dir / 'app.py'
+        app_py.write_text(output, encoding='utf-8')
+        print(f'\nGenerated {app_py}')

half_orm_gen/scaffold.py

@@ -0,0 +1,37 @@
+"""
+Scaffolding helpers for half-orm-litestar.
+
+Creates missing api/ files on first generate. Never overwrites existing files.
+"""
+
+import shutil
+from pathlib import Path
+
+_SCAFFOLDING_DIR = Path(__file__).parent / 'scaffolding'
+
+
+def scaffold_api_dir(api_dir: Path) -> None:
+    """Create missing api/ scaffolding files. Never overwrites existing files."""
+    files = {
+        api_dir / 'guards.py':
+            _SCAFFOLDING_DIR / 'guards.py',
+        api_dir / '__init__.py':
+            _SCAFFOLDING_DIR / 'api_init.py',
+        api_dir / 'custom' / 'routes.py':
+            _SCAFFOLDING_DIR / 'custom_routes.py',
+        api_dir / 'custom' / '__init__.py':
+            _SCAFFOLDING_DIR / 'custom_init.py',
+        api_dir / 'custom' / 'middlewares' / '__init__.py':
+            _SCAFFOLDING_DIR / 'custom_middlewares_init.py',
+        api_dir / 'custom' / 'middlewares' / 'authorization.py':
+            _SCAFFOLDING_DIR / 'custom_authorization.py',
+        api_dir / 'roles' / 'core.py':
+            _SCAFFOLDING_DIR / 'roles_core.py',
+    }
+    for dest, src in files.items():
+        if not dest.exists():
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(src, dest)
+            print(f'  created  {dest}')
+        else:
+            print(f'  exists   {dest}')

half_orm_gen/scaffolding/api_init.py

@@ -0,0 +1 @@
+# api package

half_orm_gen/scaffolding/custom_authorization.py

@@ -0,0 +1,36 @@
+"""
+Authorization middleware.
+
+Implement the ``Authorization`` class below to handle authentication for your
+API (JWT, session cookies, API keys, etc.).
+
+When present, it is automatically placed first in the middleware stack by
+``api/main.py``.
+
+Example (JWT bearer token)::
+
+    import jwt
+    from litestar.middleware import AbstractAuthenticationMiddleware, AuthenticationResult
+    from litestar.connection import ASGIConnection
+
+    SECRET = "change-me"
+
+    class Authorization(AbstractAuthenticationMiddleware):
+        async def authenticate_request(self, connection: ASGIConnection) -> AuthenticationResult:
+            token = connection.headers.get("Authorization", "").removeprefix("Bearer ").strip()
+            try:
+                payload = jwt.decode(token, SECRET, algorithms=["HS256"])
+                return AuthenticationResult(user=payload["sub"], auth=token)
+            except Exception:
+                return AuthenticationResult(user=None, auth=None)
+
+See https://docs.litestar.dev/latest/usage/security/abstract-authentication-middleware.html
+"""
+
+# TODO: implement Authorization
+# from litestar.middleware import AbstractAuthenticationMiddleware, AuthenticationResult
+# from litestar.connection import ASGIConnection
+#
+# class Authorization(AbstractAuthenticationMiddleware):
+#     async def authenticate_request(self, connection: ASGIConnection) -> AuthenticationResult:
+#         raise NotImplementedError

half_orm_gen/scaffolding/custom_init.py

@@ -0,0 +1 @@
+# api/custom package

half_orm_gen/scaffolding/custom_middlewares_init.py

@@ -0,0 +1,18 @@
+"""
+Custom Litestar middlewares for this project.
+
+Add your middleware classes here and list them in ``middlewares``.
+They will be prepended to the middleware stack (after the optional
+``Authorization`` middleware).
+
+Example::
+
+    from litestar.middleware import AbstractMiddleware
+
+    class MyMiddleware(AbstractMiddleware):
+        ...
+
+    middlewares = [MyMiddleware]
+"""
+
+middlewares = []

half_orm_gen/scaffolding/custom_routes.py

@@ -0,0 +1,18 @@
+"""
+Custom Litestar route handlers for this project.
+
+Add any hand-written route handlers here and list them in ``routes``.
+They will be registered alongside the auto-generated routes.
+
+Example::
+
+    from litestar import get
+
+    @get('/health')
+    async def health_check() -> dict:
+        return {'status': 'ok'}
+
+    routes = [health_check]
+"""
+
+routes = []

half_orm_gen/scaffolding/guards.py

@@ -0,0 +1,40 @@
+"""
+API guards for this project.
+
+A guard is an async callable with the signature::
+
+    async def my_guard(connection: ASGIConnection, handler: BaseRouteHandler) -> None:
+        ...
+
+It should raise ``NotAuthorizedException`` or ``HTTPException`` to deny access,
+or return ``None`` to allow it.
+
+Reference the guards by name in your ``@tools.api_*`` decorators::
+
+    @tools.api_get('/items/{id: uuid}', guards=['connected'])
+    async def get_item(self, request):
+        ...
+
+See https://docs.litestar.dev/latest/usage/security/guards.html
+"""
+
+from litestar.connection import ASGIConnection
+from litestar.handlers.base import BaseRouteHandler
+from litestar.exceptions import NotAuthorizedException, HTTPException
+
+
+async def public(connection: ASGIConnection, handler: BaseRouteHandler = None) -> None:
+    """Allow all requests."""
+    return
+
+
+async def connected(connection: ASGIConnection, handler: BaseRouteHandler = None) -> None:
+    """Allow only authenticated users."""
+    if connection.user:
+        return
+    raise NotAuthorizedException()
+
+
+# ---------------------------------------------------------------------------
+# Add your project-specific guards below.
+# ---------------------------------------------------------------------------