1st pass, tests are shit atm

Author: euri10

docs/examples/usage/usage_framework_integrations_1.py

@@ -0,0 +1,25 @@
+# start-example
+from litestar import Litestar, get
+
+from sqlspec import SQLSpec
+from sqlspec.adapters.asyncpg import AsyncpgConfig
+from sqlspec.extensions.litestar import SQLSpecPlugin
+
+# Configure database and create plugin
+spec = SQLSpec()
+db = spec.add_config(AsyncpgConfig(pool_config={"dsn": "postgresql://localhost/mydb", "min_size": 10, "max_size": 20}))
+sqlspec_plugin = SQLSpecPlugin(sqlspec=spec)
+
+
+@get("/")
+async def index() -> str:
+    return "integrated"
+
+
+# Create Litestar app
+app = Litestar(route_handlers=[index], plugins=[sqlspec_plugin])
+# end-example
+
+
+def test_app_exists() -> None:
+    assert app is not None

docs/examples/usage/usage_framework_integrations_10.py

@@ -0,0 +1,32 @@
+# start-example
+from fastapi import FastAPI, Depends
+from contextlib import asynccontextmanager
+from sqlspec import SQLSpec
+from sqlspec.adapters.asyncpg import AsyncpgConfig
+from sqlspec.driver import AsyncDriverAdapterBase
+
+# Configure database
+spec = SQLSpec()
+db = spec.add_config(
+    AsyncpgConfig(
+        pool_config={
+            "dsn": "postgresql://localhost/mydb",
+            "min_size": 10,
+            "max_size": 20,
+        }
+    )
+)
+
+# Lifespan context manager
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    yield
+    # Shutdown
+    await spec.close_all_pools()
+
+app = FastAPI(lifespan=lifespan)
+# end-example
+
+def test_stub():
+    assert app is not None

docs/examples/usage/usage_framework_integrations_11.py

@@ -0,0 +1,22 @@
+# start-example
+from typing import AsyncGenerator
+
+async def get_db_session() -> AsyncGenerator[AsyncDriverAdapterBase, None]:
+    async with spec.provide_session(config) as session:
+        yield session
+
+# Use in route handlers
+@app.get("/users/{user_id}")
+async def get_user(
+    user_id: int,
+    db: AsyncDriverAdapterBase = Depends(get_db_session)
+) -> dict:
+    result = await db.execute(
+        "SELECT id, name, email FROM users WHERE id = $1",
+        user_id
+    )
+    return result.one()
+# end-example
+
+def test_stub():
+    assert True

docs/examples/usage/usage_framework_integrations_12.py

@@ -0,0 +1,27 @@
+# start-example
+@app.post("/users")
+async def create_user(
+    user_data: dict,
+    db: AsyncDriverAdapterBase = Depends(get_db_session)
+) -> dict:
+    async with db.begin_transaction():
+        result = await db.execute(
+            "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id",
+            user_data["name"],
+            user_data["email"]
+        )
+
+        user_id = result.scalar()
+
+        # Additional operations in same transaction
+        await db.execute(
+            "INSERT INTO audit_log (action, user_id) VALUES ($1, $2)",
+            "user_created",
+            user_id
+        )
+
+        return result.one()
+# end-example
+
+def test_stub():
+    assert True

docs/examples/usage/usage_framework_integrations_13.py

@@ -0,0 +1,32 @@
+# start-example
+# Main database
+main_db = spec.add_config(AsyncpgConfig(pool_config={"dsn": "postgresql://localhost/main"}))
+
+# Analytics database
+analytics_db = spec.add_config(AsyncpgConfig(pool_config={"dsn": "postgresql://localhost/analytics"}))
+
+# Dependency functions
+async def get_main_db():
+    async with spec.provide_session(main_db) as session:
+        yield session
+
+async def get_analytics_db():
+    async with spec.provide_session(analytics_db) as session:
+        yield session
+
+# Use in handlers
+@app.get("/report")
+async def generate_report(
+    main_db: AsyncDriverAdapterBase = Depends(get_main_db),
+    analytics_db: AsyncDriverAdapterBase = Depends(get_analytics_db)
+) -> dict:
+    users = await main_db.execute("SELECT COUNT(*) FROM users")
+    events = await analytics_db.execute("SELECT COUNT(*) FROM events")
+    return {
+        "users": users.scalar(),
+        "events": events.scalar()
+    }
+# end-example
+
+def test_stub():
+    assert True

docs/examples/usage/usage_framework_integrations_14.py

@@ -0,0 +1,23 @@
+# start-example
+from sanic import Sanic, Request, json
+from sqlspec import SQLSpec
+from sqlspec.adapters.asyncpg import AsyncpgConfig
+
+app = Sanic("MyApp")
+
+# Initialize SQLSpec
+spec = SQLSpec()
+db = spec.add_config(AsyncpgConfig(pool_config={"dsn": "postgresql://localhost/db"}))
+
+# Store in app context
+app.ctx.sqlspec = spec
+app.ctx.db_config = db
+
+# Cleanup on shutdown
+@app.before_server_stop
+async def close_db(app, loop):
+    await app.ctx.sqlspec.close_all_pools()
+# end-example
+
+def test_stub():
+    assert app is not None

docs/examples/usage/usage_framework_integrations_15.py

@@ -0,0 +1,13 @@
+# start-example
+@app.get("/users/<user_id:int>")
+async def get_user(request: Request, user_id: int):
+    async with request.app.ctx.sqlspec.provide_session(request.app.ctx.db_config) as db:
+        result = await db.execute(
+            "SELECT id, name, email FROM users WHERE id = $1",
+            user_id
+        )
+        return json(result.one())
+# end-example
+
+def test_stub():
+    assert True

docs/examples/usage/usage_framework_integrations_16.py

@@ -0,0 +1,21 @@
+# start-example
+@app.middleware("request")
+async def add_db_session(request):
+    request.ctx.db = await request.app.ctx.sqlspec.provide_session(
+        request.app.ctx.db_config
+    ).__aenter__()
+
+@app.middleware("response")
+async def cleanup_db_session(request, response):
+    if hasattr(request.ctx, "db"):
+        await request.ctx.db.__aexit__(None, None, None)
+
+# Use in handlers
+@app.get("/users")
+async def list_users(request: Request):
+    result = await request.ctx.db.execute("SELECT * FROM users")
+    return json(result.rows)
+# end-example
+
+def test_stub():
+    assert True

docs/examples/usage/usage_framework_integrations_17.py

@@ -0,0 +1,14 @@
+# start-example
+from flask import Flask, g
+from sqlspec import SQLSpec
+from sqlspec.adapters.sqlite import SqliteConfig
+
+app = Flask(__name__)
+
+# Initialize SQLSpec
+spec = SQLSpec()
+db = spec.add_config(SqliteConfig(pool_config={"database": "app.db"}))
+# end-example
+
+def test_stub():
+    assert app is not None

docs/examples/usage/usage_framework_integrations_18.py

@@ -0,0 +1,22 @@
+# start-example
+def get_db():
+    if 'db' not in g:
+        g.db = spec.provide_session(db).__enter__()
+    return g.db
+
+@app.teardown_appcontext
+def close_db(error):
+    db = g.pop('db', None)
+    if db is not None:
+        db.__exit__(None, None, None)
+
+# Use in routes
+@app.route('/users/<int:user_id>')
+def get_user(user_id):
+    db = get_db()
+    result = db.execute("SELECT * FROM users WHERE id = ?", user_id)
+    return result.one()
+# end-example
+
+def test_stub():
+    assert True