lagun 0.1.0__tar.gz

lagun-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anudeep Dhavaleswarapu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lagun-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: lagun
+Version: 0.1.0
+Summary: A web-based MySQL/MariaDB GUI editor
+Author-email: Anudeep Dhavaleswarapu <anudeepd2@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/anudeepd/lagun
+Project-URL: Repository, https://github.com/anudeepd/lagun
+Project-URL: Issues, https://github.com/anudeepd/lagun/issues
+Keywords: mysql,mariadb,gui,web,database
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database :: Front-Ends
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.111.0
+Requires-Dist: uvicorn[standard]>=0.29.0
+Requires-Dist: aiomysql>=0.2.0
+Requires-Dist: aiosqlite>=0.20.0
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: keyring>=25.0.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: pydantic>=2.7.0
+Requires-Dist: python-multipart>=0.0.9
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Requires-Dist: testcontainers[mysql]>=4.0; extra == "dev"
+Dynamic: license-file
+
+<p align="center">
+  <img src="assets/logo.svg" alt="Lagun" width="120"/>
+</p>
+
+<h1 align="center">Lagun</h1>
+
+<p align="center">A minimal, web-based MySQL/MariaDB GUI editor. Install it, run it, use it.</p>
+
+## Features
+
+- **Web-based SQL editor** with syntax highlighting, autocompletion, and multi-tab support
+- **Schema browser** — explore databases, tables, columns, and indexes
+- **Schema management** — create, modify, and drop tables, columns, and indexes
+- **In-line data editing** — edit cells, insert rows, delete rows directly in the grid
+- **Import & export** — CSV and SQL formats with streaming for large datasets
+- **Query history** — track past queries with execution time and row counts
+- **Secure connections** — SSL/TLS, credentials stored in OS keyring, encrypted session backup
+
+## Install
+
+```bash
+pip install git+https://github.com/anudeepd/lagun
+```
+
+## Usage
+
+```bash
+lagun serve
+```
+
+Opens the GUI in your browser. Connect to any MySQL or MariaDB database from there.
+
+## Development
+
+Requires [uv](https://github.com/astral-sh/uv).
+
+```bash
+git clone https://github.com/anudeepd/lagun
+cd lagun
+uv sync
+uv run lagun serve
+```
+
+## License
+
+MIT

lagun-0.1.0/README.md

@@ -0,0 +1,46 @@
+<p align="center">
+  <img src="assets/logo.svg" alt="Lagun" width="120"/>
+</p>
+
+<h1 align="center">Lagun</h1>
+
+<p align="center">A minimal, web-based MySQL/MariaDB GUI editor. Install it, run it, use it.</p>
+
+## Features
+
+- **Web-based SQL editor** with syntax highlighting, autocompletion, and multi-tab support
+- **Schema browser** — explore databases, tables, columns, and indexes
+- **Schema management** — create, modify, and drop tables, columns, and indexes
+- **In-line data editing** — edit cells, insert rows, delete rows directly in the grid
+- **Import & export** — CSV and SQL formats with streaming for large datasets
+- **Query history** — track past queries with execution time and row counts
+- **Secure connections** — SSL/TLS, credentials stored in OS keyring, encrypted session backup
+
+## Install
+
+```bash
+pip install git+https://github.com/anudeepd/lagun
+```
+
+## Usage
+
+```bash
+lagun serve
+```
+
+Opens the GUI in your browser. Connect to any MySQL or MariaDB database from there.
+
+## Development
+
+Requires [uv](https://github.com/astral-sh/uv).
+
+```bash
+git clone https://github.com/anudeepd/lagun
+cd lagun
+uv sync
+uv run lagun serve
+```
+
+## License
+
+MIT

lagun-0.1.0/lagun/__init__.py

@@ -0,0 +1,2 @@
+"""Lagun — web-based MySQL/MariaDB editor."""
+__version__ = "0.1.0"

lagun-0.1.0/lagun/api/config.py

@@ -0,0 +1,140 @@
+"""Config export/import: backup and restore saved connection sessions."""
+import base64
+import json
+import os
+import secrets
+import tempfile
+from datetime import datetime, timezone
+from typing import Optional
+
+from cryptography.fernet import InvalidToken
+from fastapi import APIRouter, Form, HTTPException, UploadFile
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from starlette.background import BackgroundTask
+
+from lagun.db import session_store
+from lagun.db.crypto import decrypt_password, encrypt_with_passphrase, decrypt_with_passphrase
+from lagun.models.session import SessionCreate
+
+router = APIRouter(tags=["config"])
+
+_EXPORT_VERSION = 1
+_KDF_ITERATIONS = 600_000
+
+
+class ExportRequest(BaseModel):
+    passphrase: str
+
+
+class ImportResult(BaseModel):
+    imported: int
+    skipped: int
+
+
+@router.post("/config/export")
+async def export_config(req: ExportRequest):
+    if not req.passphrase:
+        raise HTTPException(400, "A passphrase is required to protect the exported passwords")
+
+    raw_rows = await session_store.list_sessions_raw()
+    salt_bytes = secrets.token_bytes(16)
+    salt_b64 = base64.b64encode(salt_bytes).decode()
+
+    sessions_out = []
+    for s in raw_rows:
+        plaintext = decrypt_password(s["password_enc"])
+        sessions_out.append({
+            "name":               s["name"],
+            "host":               s["host"],
+            "port":               s["port"],
+            "username":           s["username"],
+            "password_enc":       encrypt_with_passphrase(plaintext, req.passphrase, salt_bytes),
+            "default_db":         s["default_db"],
+            "query_limit":        s["query_limit"],
+            "ssl_enabled":        bool(s["ssl_enabled"]),
+            "selected_databases": json.loads(s["selected_databases"] or "[]"),
+        })
+
+    payload = {
+        "version":        _EXPORT_VERSION,
+        "exported_at":    datetime.now(timezone.utc).isoformat(),
+        "kdf":            "pbkdf2-hmac-sha256",
+        "kdf_salt":       salt_b64,
+        "kdf_iterations": _KDF_ITERATIONS,
+        "sessions":       sessions_out,
+    }
+
+    tmp = tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False, encoding="utf-8")
+    try:
+        json.dump(payload, tmp, indent=2, ensure_ascii=False)
+        tmp.flush()
+        tmp.close()
+    except Exception:
+        os.unlink(tmp.name)
+        raise
+
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    filename = f"lagun_sessions_{ts}.json"
+    return FileResponse(
+        tmp.name,
+        media_type="application/json",
+        filename=filename,
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+        background=BackgroundTask(lambda: os.unlink(tmp.name) if os.path.exists(tmp.name) else None),
+    )
+
+
+@router.post("/config/import", response_model=ImportResult)
+async def import_config(
+    file: UploadFile,
+    passphrase: str = Form(...),
+):
+    if not passphrase:
+        raise HTTPException(400, "A passphrase is required to decrypt the imported passwords")
+
+    raw = await file.read()
+    if len(raw) > 5 * 1024 * 1024:
+        raise HTTPException(413, "File too large (max 5 MB)")
+
+    try:
+        payload = json.loads(raw.decode("utf-8"))
+    except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+        raise HTTPException(400, f"Invalid JSON: {exc}")
+
+    if payload.get("version") != _EXPORT_VERSION:
+        raise HTTPException(400, f"Unsupported export version: {payload.get('version')}")
+
+    try:
+        salt_bytes = base64.b64decode(payload["kdf_salt"])
+    except Exception as exc:
+        raise HTTPException(400, f"Malformed kdf_salt: {exc}")
+
+    imported = 0
+    skipped = 0
+
+    for entry in payload.get("sessions", []):
+        try:
+            try:
+                plaintext_password = decrypt_with_passphrase(entry["password_enc"], passphrase, salt_bytes)
+            except InvalidToken:
+                raise HTTPException(400, "Wrong passphrase — could not decrypt passwords")
+
+            await session_store.create_session(SessionCreate(
+                name=              entry["name"],
+                host=              entry.get("host", "localhost"),
+                port=              entry.get("port", 3306),
+                username=          entry.get("username", ""),
+                password=          plaintext_password,
+                default_db=        entry.get("default_db"),
+                query_limit=       entry.get("query_limit", 100),
+                ssl_enabled=       bool(entry.get("ssl_enabled", False)),
+                selected_databases=entry.get("selected_databases", []),
+            ))
+            imported += 1
+        except HTTPException:
+            raise
+        except Exception:
+            skipped += 1
+
+    return ImportResult(imported=imported, skipped=skipped)

lagun-0.1.0/lagun/api/export.py

@@ -0,0 +1,238 @@
+"""Streaming export: INSERT SQL, DELETE SQL, CSV."""
+import csv
+import io
+import re
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+from lagun.db.pool import get_pool
+from lagun.db.session_store import get_session
+from lagun.db.utils import quote_ident, escape_value
+
+router = APIRouter(tags=["export"])
+
+
+class ExportRequest(BaseModel):
+    database: str
+    table: Optional[str] = None
+    sql: Optional[str] = None        # custom SELECT; overrides table
+    format: str = "insert"           # "insert" | "delete" | "delete+insert" | "csv"
+    batch_size: int = 500
+    pk_values: Optional[list] = None  # list of dicts: [{pk_col: val, ...}, ...]
+    # CSV-specific options (ignored for other formats)
+    csv_delimiter: str = ","
+    csv_quotechar: str = '"'
+    csv_escapechar: str = '"'
+    csv_lineterminator: str = "\r\n"
+    csv_encoding: str = "utf-8"      # "utf-8" | "utf-8-sig" | "ascii"
+
+
+@router.post("/sessions/{session_id}/export")
+async def export_data(session_id: str, req: ExportRequest):
+    s = await get_session(session_id)
+    if not s:
+        raise HTTPException(404, "Session not found")
+    pool = await get_pool(session_id)
+
+    if req.sql:
+        # Only allow SELECT statements for security
+        stripped = req.sql.strip().rstrip(";").strip()
+        if not re.match(r'^\s*SELECT\b', stripped, re.IGNORECASE):
+            raise HTTPException(400, "Only SELECT statements are allowed for export")
+        select_sql = req.sql
+    elif req.table:
+        select_sql = f"SELECT * FROM {quote_ident(req.database)}.{quote_ident(req.table)}"
+        if req.pk_values:
+            conditions = []
+            for pk_dict in req.pk_values:
+                parts = [f"{quote_ident(col)} = {escape_value(val)}" for col, val in pk_dict.items()]
+                conditions.append(f"({' AND '.join(parts)})")
+            select_sql += f" WHERE {' OR '.join(conditions)}"
+    else:
+        raise HTTPException(400, "Provide either 'table' or 'sql'")
+
+    async def _generate_insert():
+        async with pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                await cur.execute(f"USE {quote_ident(req.database)}")
+                await cur.execute(select_sql)
+                cols = [d[0] for d in cur.description]
+                cols_sql = ", ".join(quote_ident(c) for c in cols)
+                tbl = req.table or "exported_data"
+                tbl_q = quote_ident(tbl)
+
+                yield f"-- Lagun export: {req.database}.{tbl}\n"
+                yield f"-- Format: INSERT\n\n"
+
+                batch = []
+                while True:
+                    rows = await cur.fetchmany(req.batch_size)
+                    if not rows:
+                        break
+                    for row in rows:
+                        vals = ", ".join(escape_value(v) for v in row)
+                        batch.append(f"({vals})")
+                    yield (
+                        f"INSERT INTO {tbl_q} ({cols_sql}) VALUES\n"
+                        + ",\n".join(batch)
+                        + ";\n"
+                    )
+                    batch = []
+
+    async def _generate_delete():
+        # Need PK columns from information_schema
+        async with pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                await cur.execute(f"USE {quote_ident(req.database)}")
+                await cur.execute(
+                    """SELECT COLUMN_NAME FROM information_schema.KEY_COLUMN_USAGE
+                       WHERE TABLE_SCHEMA=%s AND TABLE_NAME=%s
+                       AND CONSTRAINT_NAME='PRIMARY'
+                       ORDER BY ORDINAL_POSITION""",
+                    (req.database, req.table),
+                )
+                pk_rows = await cur.fetchall()
+                pk_cols = [r[0] for r in pk_rows]
+                if not pk_cols:
+                    raise HTTPException(400, "Table has no primary key — cannot generate DELETE export")
+
+                tbl_q = f"{quote_ident(req.database)}.{quote_ident(req.table or 'tbl')}"
+                await cur.execute(select_sql)
+
+                yield f"-- Lagun export: {req.database}.{req.table}\n-- Format: DELETE\n\n"
+
+                while True:
+                    rows = await cur.fetchmany(req.batch_size)
+                    if not rows:
+                        break
+                    cols = [d[0] for d in cur.description]
+                    for row in rows:
+                        row_dict = dict(zip(cols, row))
+                        where = " AND ".join(
+                            f"{quote_ident(pk)} = {escape_value(row_dict[pk])}"
+                            for pk in pk_cols
+                        )
+                        yield f"DELETE FROM {tbl_q} WHERE {where};\n"
+
+    async def _generate_delete_insert():
+        # Need PK columns from information_schema
+        async with pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                await cur.execute(f"USE {quote_ident(req.database)}")
+                await cur.execute(
+                    """SELECT COLUMN_NAME FROM information_schema.KEY_COLUMN_USAGE
+                       WHERE TABLE_SCHEMA=%s AND TABLE_NAME=%s
+                       AND CONSTRAINT_NAME='PRIMARY'
+                       ORDER BY ORDINAL_POSITION""",
+                    (req.database, req.table),
+                )
+                pk_rows = await cur.fetchall()
+                pk_cols = [r[0] for r in pk_rows]
+                if not pk_cols:
+                    raise HTTPException(400, "Table has no primary key — cannot generate DELETE+INSERT export")
+
+                tbl_q = f"{quote_ident(req.database)}.{quote_ident(req.table or 'tbl')}"
+                await cur.execute(select_sql)
+
+                cols = None
+                cols_sql = None
+                yield f"-- Lagun export: {req.database}.{req.table}\n-- Format: DELETE+INSERT\n\n"
+
+                while True:
+                    rows = await cur.fetchmany(req.batch_size)
+                    if not rows:
+                        break
+                    if cols is None:
+                        cols = [d[0] for d in cur.description]
+                        cols_sql = ", ".join(quote_ident(c) for c in cols)
+                    for row in rows:
+                        row_dict = dict(zip(cols, row))
+                        where = " AND ".join(
+                            f"{quote_ident(pk)} = {escape_value(row_dict[pk])}"
+                            for pk in pk_cols
+                        )
+                        vals = ", ".join(escape_value(v) for v in row)
+                        yield f"DELETE FROM {tbl_q} WHERE {where};\n"
+                        yield f"INSERT INTO {tbl_q} ({cols_sql}) VALUES ({vals});\n"
+
+    async def _generate_csv():
+        writer_kwargs: dict = dict(
+            delimiter=req.csv_delimiter,
+            lineterminator=req.csv_lineterminator,
+        )
+        escapechar = req.csv_escapechar or None  # empty string → no escape char
+        if req.csv_quotechar:
+            writer_kwargs["quoting"] = csv.QUOTE_ALL
+            writer_kwargs["quotechar"] = req.csv_quotechar
+            if escapechar and escapechar != req.csv_quotechar:
+                writer_kwargs["escapechar"] = escapechar
+        else:
+            writer_kwargs["quoting"] = csv.QUOTE_NONE
+            writer_kwargs["escapechar"] = escapechar or "\\"
+
+        encoding = req.csv_encoding
+        # Determine byte encoding and error handling
+        if encoding == "ascii":
+            byte_enc, enc_errors = "ascii", "replace"
+        else:
+            byte_enc, enc_errors = "utf-8", "strict"
+
+        def to_bytes(text: str) -> bytes:
+            return text.encode(byte_enc, errors=enc_errors)
+
+        def clean_row(row: tuple) -> list:
+            # None → empty string so NULL doesn't export as the string "None"
+            return ["" if v is None else v for v in row]
+
+        async with pool.acquire() as conn:
+            async with conn.cursor() as cur:
+                await cur.execute(f"USE {quote_ident(req.database)}")
+                await cur.execute(select_sql)
+                cols = [d[0] for d in cur.description]
+
+                # Emit BOM bytes for utf-8-sig
+                if encoding == "utf-8-sig":
+                    yield b"\xef\xbb\xbf"
+
+                buf = io.StringIO()
+                writer = csv.writer(buf, **writer_kwargs)
+                writer.writerow(cols)
+                yield to_bytes(buf.getvalue())
+
+                while True:
+                    rows = await cur.fetchmany(req.batch_size)
+                    if not rows:
+                        break
+                    buf = io.StringIO()
+                    writer = csv.writer(buf, **writer_kwargs)
+                    writer.writerows(clean_row(row) for row in rows)
+                    yield to_bytes(buf.getvalue())
+
+    if req.format == "insert":
+        gen = _generate_insert()
+        media = "text/plain"
+        filename = f"{req.database}_{req.table}_insert.sql"
+    elif req.format == "delete":
+        gen = _generate_delete()
+        media = "text/plain"
+        filename = f"{req.database}_{req.table}_delete.sql"
+    elif req.format == "delete+insert":
+        gen = _generate_delete_insert()
+        media = "text/plain"
+        filename = f"{req.database}_{req.table}_delete_insert.sql"
+    elif req.format == "csv":
+        gen = _generate_csv()
+        enc = req.csv_encoding.replace("-sig", "")
+        media = f"text/csv; charset={enc}"
+        filename = f"{req.database}_{req.table or 'query'}.csv"
+    else:
+        raise HTTPException(400, f"Unknown format: {req.format!r}")
+
+    return StreamingResponse(
+        gen,
+        media_type=media,
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )