mdb-engine 0.1.6__py3-none-any.whl

mdb_engine/cli/commands/generate.py

@@ -0,0 +1,105 @@
+"""
+Generate command for CLI.
+
+Generates a template manifest.json file.
+
+This module is part of MDB_ENGINE - MongoDB Engine.
+"""
+
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+import click
+
+from ...core.manifest import CURRENT_SCHEMA_VERSION
+from ..utils import save_manifest_file
+
+
+@click.command()
+@click.option(
+    "--slug",
+    "-s",
+    prompt="App slug",
+    help="App slug (lowercase alphanumeric, underscores, hyphens)",
+)
+@click.option(
+    "--name",
+    "-n",
+    prompt="App name",
+    help="Human-readable app name",
+)
+@click.option(
+    "--description",
+    "-d",
+    default="",
+    help="App description",
+)
+@click.option(
+    "--output",
+    "-o",
+    default="manifest.json",
+    type=click.Path(path_type=Path),
+    help="Output file path (default: manifest.json)",
+)
+@click.option(
+    "--minimal",
+    "-m",
+    is_flag=True,
+    help="Generate minimal template (basic fields only)",
+)
+def generate(
+    slug: str,
+    name: str,
+    description: str,
+    output: Path,
+    minimal: bool,
+) -> None:
+    """
+    Generate a template manifest.json file.
+
+    Examples:
+        mdb generate --slug my-app --name "My App"
+        mdb generate --slug my-app --name "My App" --output custom.json
+        mdb generate --slug my-app --name "My App" --minimal
+    """
+    try:
+        # Validate slug format
+        if not slug or not all(c.isalnum() or c in ("_", "-") for c in slug):
+            raise click.ClickException(
+                "Invalid slug format. Use lowercase alphanumeric, underscores, or hyphens."
+            )
+
+        # Generate template manifest
+        manifest: Dict[str, Any] = {
+            "schema_version": CURRENT_SCHEMA_VERSION,
+            "slug": slug,
+            "name": name,
+            "status": "draft",
+        }
+
+        if description:
+            manifest["description"] = description
+
+        if not minimal:
+            # Add common sections
+            manifest["auth"] = {
+                "policy": {
+                    "provider": "casbin",
+                    "required": False,
+                    "allow_anonymous": True,
+                    "authorization": {
+                        "model": "rbac",
+                        "link_users_roles": True,
+                    },
+                },
+            }
+            manifest["managed_indexes"] = {}
+            manifest["websockets"] = {}
+
+        # Save manifest
+        save_manifest_file(output, manifest)
+        click.echo(click.style(f"✅ Generated manifest template: {output}", fg="green"))
+        sys.exit(0)
+    except click.ClickException:
+        raise

mdb_engine/cli/commands/migrate.py

@@ -0,0 +1,83 @@
+"""
+Migrate command for CLI.
+
+Migrates a manifest to a target schema version.
+
+This module is part of MDB_ENGINE - MongoDB Engine.
+"""
+
+import sys
+from pathlib import Path
+
+import click
+
+from ...core.manifest import CURRENT_SCHEMA_VERSION, migrate_manifest
+from ..utils import load_manifest_file, save_manifest_file
+
+
+@click.command()
+@click.argument("manifest_file", type=click.Path(exists=True, path_type=Path))
+@click.option(
+    "--target-version",
+    "-t",
+    default=CURRENT_SCHEMA_VERSION,
+    help=f"Target schema version (default: {CURRENT_SCHEMA_VERSION})",
+)
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(path_type=Path),
+    help="Output file path (default: stdout)",
+)
+@click.option(
+    "--in-place",
+    "-i",
+    is_flag=True,
+    help="Update manifest file in place",
+)
+def migrate(
+    manifest_file: Path,
+    target_version: str,
+    output: Path | None,
+    in_place: bool,
+) -> None:
+    """
+    Migrate a manifest.json file to a target schema version.
+
+    MANIFEST_FILE: Path to manifest.json file to migrate
+
+    Examples:
+        mdb migrate manifest.json
+        mdb migrate manifest.json --target-version 2.0 --output manifest.v2.json
+        mdb migrate manifest.json --in-place
+    """
+    try:
+        # Load manifest
+        manifest = load_manifest_file(manifest_file)
+
+        # Migrate
+        migrated_manifest = migrate_manifest(manifest, target_version=target_version)
+
+        # Determine output
+        if in_place:
+            output_path = manifest_file
+        elif output:
+            output_path = output
+        else:
+            # Output to stdout
+            import json
+
+            click.echo(json.dumps(migrated_manifest, indent=2, ensure_ascii=False))
+            sys.exit(0)
+
+        # Save to file
+        save_manifest_file(output_path, migrated_manifest)
+        click.echo(
+            click.style(
+                f"✅ Migrated manifest to version {target_version}: {output_path}",
+                fg="green",
+            )
+        )
+        sys.exit(0)
+    except click.ClickException:
+        raise

mdb_engine/cli/commands/show.py

@@ -0,0 +1,70 @@
+"""
+Show command for CLI.
+
+Displays manifest information.
+
+This module is part of MDB_ENGINE - MongoDB Engine.
+"""
+
+import sys
+from pathlib import Path
+
+import click
+
+from ...core.manifest import ManifestValidator
+from ..utils import format_manifest_output, load_manifest_file
+
+
+@click.command()
+@click.argument("manifest_file", type=click.Path(exists=True, path_type=Path))
+@click.option(
+    "--format",
+    "-f",
+    type=click.Choice(["json", "yaml", "pretty"], case_sensitive=False),
+    default="json",
+    help="Output format (default: json)",
+)
+@click.option(
+    "--validate",
+    "-v",
+    is_flag=True,
+    help="Validate manifest before showing",
+)
+def show(manifest_file: Path, format: str, validate: bool) -> None:
+    """
+    Display manifest information.
+
+    MANIFEST_FILE: Path to manifest.json file to display
+
+    Examples:
+        mdb show manifest.json
+        mdb show manifest.json --format pretty
+        mdb show manifest.json --format yaml --validate
+    """
+    try:
+        # Load manifest
+        manifest = load_manifest_file(manifest_file)
+
+        # Validate if requested
+        if validate:
+            validator = ManifestValidator()
+            is_valid, error_message, error_paths = validator.validate(manifest)
+            if not is_valid:
+                click.echo(
+                    click.style(
+                        f"⚠️  Warning: Manifest is invalid: {error_message}",
+                        fg="yellow",
+                    ),
+                    err=True,
+                )
+                if error_paths:
+                    click.echo("Error paths:", err=True)
+                    for path in error_paths:
+                        click.echo(f"  - {path}", err=True)
+
+        # Format and display
+        output = format_manifest_output(manifest, format.lower())
+        click.echo(output)
+        sys.exit(0)
+    except click.ClickException:
+        raise

mdb_engine/cli/commands/validate.py

@@ -0,0 +1,63 @@
+"""
+Validate command for CLI.
+
+Validates a manifest against the schema.
+
+This module is part of MDB_ENGINE - MongoDB Engine.
+"""
+
+import sys
+from pathlib import Path
+
+import click
+
+from ...core.manifest import ManifestValidator
+from ..utils import load_manifest_file
+
+
+@click.command()
+@click.argument("manifest_file", type=click.Path(exists=True, path_type=Path))
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Show detailed validation errors",
+)
+def validate(manifest_file: Path, verbose: bool) -> None:
+    """
+    Validate a manifest.json file against the schema.
+
+    MANIFEST_FILE: Path to manifest.json file to validate
+
+    Examples:
+        mdb validate manifest.json
+        mdb validate path/to/manifest.json --verbose
+    """
+    try:
+        # Load manifest
+        manifest = load_manifest_file(manifest_file)
+
+        # Validate
+        validator = ManifestValidator()
+        is_valid, error_message, error_paths = validator.validate(manifest)
+
+        if is_valid:
+            click.echo(
+                click.style(f"✅ Manifest '{manifest_file}' is valid!", fg="green")
+            )
+            sys.exit(0)
+        else:
+            click.echo(
+                click.style(f"❌ Manifest '{manifest_file}' is invalid!", fg="red")
+            )
+            if error_message:
+                click.echo(click.style(f"Error: {error_message}", fg="red"))
+            if error_paths and verbose:
+                click.echo("\nError paths:")
+                for path in error_paths:
+                    click.echo(f"  - {path}")
+            sys.exit(1)
+    except click.ClickException:
+        raise
+    except (FileNotFoundError, ValueError, KeyError) as e:
+        raise click.ClickException(str(e))

mdb_engine/cli/main.py

@@ -0,0 +1,41 @@
+"""
+Main CLI entry point for MDB_ENGINE.
+
+This module provides the command-line interface for manifest management.
+
+This module is part of MDB_ENGINE - MongoDB Engine.
+"""
+
+import click
+
+from .commands.generate import generate
+from .commands.migrate import migrate
+from .commands.show import show
+from .commands.validate import validate
+
+
+@click.group()
+@click.version_option(version="0.1.6", prog_name="mdb")
+def cli() -> None:
+    """
+    MDB_ENGINE CLI - Manifest management tool.
+
+    Manage your MDB_ENGINE manifests with validation, migration, and generation.
+    """
+    pass
+
+
+# Register commands
+cli.add_command(validate)
+cli.add_command(migrate)
+cli.add_command(generate)
+cli.add_command(show)
+
+
+def main() -> None:
+    """Entry point for the CLI."""
+    cli()
+
+
+if __name__ == "__main__":
+    main()

mdb_engine/cli/utils.py

@@ -0,0 +1,92 @@
+"""
+Utility functions for CLI commands.
+
+This module provides shared utilities for CLI operations.
+
+This module is part of MDB_ENGINE - MongoDB Engine.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict
+
+import click
+
+
+def load_manifest_file(file_path: Path) -> Dict[str, Any]:
+    """
+    Load a manifest JSON file.
+
+    Args:
+        file_path: Path to manifest.json file
+
+    Returns:
+        Manifest dictionary
+
+    Raises:
+        click.ClickException: If file doesn't exist or is invalid JSON
+    """
+    if not file_path.exists():
+        raise click.ClickException(f"Manifest file not found: {file_path}")
+
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except json.JSONDecodeError as e:
+        raise click.ClickException(f"Invalid JSON in manifest file: {e}")
+
+
+def save_manifest_file(file_path: Path, manifest: Dict[str, Any]) -> None:
+    """
+    Save a manifest dictionary to a JSON file.
+
+    Args:
+        file_path: Path to save manifest.json file
+        manifest: Manifest dictionary
+
+    Raises:
+        click.ClickException: If file cannot be written
+    """
+    try:
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(manifest, f, indent=2, ensure_ascii=False)
+    except OSError as e:
+        raise click.ClickException(f"Failed to write manifest file: {e}")
+
+
+def format_manifest_output(manifest: Dict[str, Any], format_type: str) -> str:
+    """
+    Format manifest for output.
+
+    Args:
+        manifest: Manifest dictionary
+        format_type: Output format ('json', 'yaml', 'pretty')
+
+    Returns:
+        Formatted string representation
+    """
+    if format_type == "json":
+        return json.dumps(manifest, indent=2, ensure_ascii=False)
+    elif format_type == "yaml":
+        try:
+            import yaml
+
+            return yaml.dump(manifest, default_flow_style=False, sort_keys=False)
+        except ImportError:
+            click.echo(
+                "Warning: PyYAML not installed. Falling back to JSON format.",
+                err=True,
+            )
+            return json.dumps(manifest, indent=2, ensure_ascii=False)
+    elif format_type == "pretty":
+        # Pretty print with key information
+        lines = []
+        lines.append(f"Schema Version: {manifest.get('schema_version', '2.0')}")
+        lines.append(f"Slug: {manifest.get('slug', 'N/A')}")
+        lines.append(f"Name: {manifest.get('name', 'N/A')}")
+        lines.append(f"Status: {manifest.get('status', 'draft')}")
+        if manifest.get("description"):
+            lines.append(f"Description: {manifest.get('description')}")
+        return "\n".join(lines)
+    else:
+        return json.dumps(manifest, indent=2, ensure_ascii=False)

mdb_engine/config.py

@@ -0,0 +1,217 @@
+"""
+Configuration management for MDB_ENGINE.
+
+This module provides optional configuration management using Pydantic.
+It's designed to be non-breaking - the MongoDBEngine can still be used
+with direct parameters as before.
+"""
+
+import os
+from typing import Optional
+
+try:
+    from pydantic import BaseSettings, Field
+
+    PYDANTIC_AVAILABLE = True
+except ImportError:
+    PYDANTIC_AVAILABLE = False
+
+    # Create a dummy BaseSettings for when Pydantic is not available
+    class BaseSettings:
+        pass
+
+
+class EngineConfig:
+    """
+    MongoDB Engine configuration.
+
+    This class provides configuration management with environment variable
+    support. It's optional - MongoDBEngine can still be initialized with
+    direct parameters for backward compatibility.
+
+    Example:
+        # Using environment variables
+        config = EngineConfig()
+        engine = MongoDBEngine(
+            mongo_uri=config.mongo_uri,
+            db_name=config.db_name
+        )
+
+        # Or using direct parameters (backward compatible)
+        engine = MongoDBEngine(
+            mongo_uri="mongodb://localhost:27017",
+            db_name="my_db"
+        )
+    """
+
+    def __init__(
+        self,
+        mongo_uri: Optional[str] = None,
+        db_name: Optional[str] = None,
+        max_pool_size: Optional[int] = None,
+        min_pool_size: Optional[int] = None,
+        server_selection_timeout_ms: Optional[int] = None,
+        authz_cache_ttl: Optional[int] = None,
+    ):
+        """
+        Initialize configuration.
+
+        Args:
+            mongo_uri: MongoDB connection URI (defaults to MONGO_URI env var)
+            db_name: Database name (defaults to DB_NAME env var)
+            max_pool_size: Maximum connection pool size (defaults to 50 or MONGO_MAX_POOL_SIZE)
+            min_pool_size: Minimum connection pool size (defaults to 10 or MONGO_MIN_POOL_SIZE)
+            server_selection_timeout_ms: Server selection timeout in ms (defaults to 5000)
+            authz_cache_ttl: Authorization cache TTL in seconds (defaults to 300)
+        """
+        self.mongo_uri = mongo_uri or os.getenv("MONGO_URI", "")
+        self.db_name = db_name or os.getenv("DB_NAME", "")
+        self.max_pool_size = max_pool_size or int(
+            os.getenv("MONGO_MAX_POOL_SIZE", "50")
+        )
+        self.min_pool_size = min_pool_size or int(
+            os.getenv("MONGO_MIN_POOL_SIZE", "10")
+        )
+        self.server_selection_timeout_ms = server_selection_timeout_ms or int(
+            os.getenv("MONGO_SERVER_SELECTION_TIMEOUT_MS", "5000")
+        )
+        self.authz_cache_ttl = authz_cache_ttl or int(
+            os.getenv("AUTHZ_CACHE_TTL", "300")
+        )
+
+    def validate(self) -> None:
+        """
+        Validate configuration values.
+
+        Raises:
+            ValueError: If required configuration is missing or invalid
+        """
+        if not self.mongo_uri:
+            raise ValueError(
+                "mongo_uri is required (set MONGO_URI environment variable or pass directly)"
+            )
+
+        if not self.db_name:
+            raise ValueError(
+                "db_name is required (set DB_NAME environment variable or pass directly)"
+            )
+
+        if self.max_pool_size < 1:
+            raise ValueError(f"max_pool_size must be >= 1, got {self.max_pool_size}")
+
+        if self.min_pool_size < 1:
+            raise ValueError(f"min_pool_size must be >= 1, got {self.min_pool_size}")
+
+        if self.min_pool_size > self.max_pool_size:
+            raise ValueError(
+                f"min_pool_size ({self.min_pool_size}) cannot be greater than "
+                f"max_pool_size ({self.max_pool_size})"
+            )
+
+        if self.server_selection_timeout_ms < 1000:
+            raise ValueError(
+                f"server_selection_timeout_ms must be >= 1000, got "
+                f"{self.server_selection_timeout_ms}"
+            )
+
+        if self.authz_cache_ttl < 0:
+            raise ValueError(
+                f"authz_cache_ttl must be >= 0, got {self.authz_cache_ttl}"
+            )
+
+
+# Pydantic-based configuration (optional, only if Pydantic is available)
+if PYDANTIC_AVAILABLE:
+
+    class EngineConfigPydantic(BaseSettings):
+        """
+        Pydantic-based configuration with automatic validation.
+
+        This is an optional alternative to EngineConfig that provides
+        automatic validation and type checking via Pydantic.
+
+        Usage:
+            config = EngineConfigPydantic()
+            engine = MongoDBEngine(
+                mongo_uri=config.mongo_uri,
+                db_name=config.db_name
+            )
+        """
+
+        mongo_uri: str = Field(
+            ..., env="MONGO_URI", description="MongoDB connection URI"
+        )
+        db_name: str = Field(..., env="DB_NAME", description="Database name")
+        max_pool_size: int = Field(
+            50,
+            env="MONGO_MAX_POOL_SIZE",
+            ge=1,
+            description="Maximum connection pool size",
+        )
+        min_pool_size: int = Field(
+            10,
+            env="MONGO_MIN_POOL_SIZE",
+            ge=1,
+            description="Minimum connection pool size",
+        )
+        server_selection_timeout_ms: int = Field(
+            5000,
+            env="MONGO_SERVER_SELECTION_TIMEOUT_MS",
+            ge=1000,
+            description="Server selection timeout in milliseconds",
+        )
+        authz_cache_ttl: int = Field(
+            300,
+            env="AUTHZ_CACHE_TTL",
+            ge=0,
+            description="Authorization cache TTL in seconds",
+        )
+
+        class Config:
+            env_file = ".env"
+            case_sensitive = False
+
+
+# ============================================================================
+# DEMO MODE CONSTANTS
+# ============================================================================
+
+DEMO_ENABLED: bool = os.getenv("DEMO_ENABLED", "false").lower() == "true"
+"""Whether demo mode is enabled."""
+
+DEMO_EMAIL_DEFAULT: str = os.getenv("DEMO_EMAIL_DEFAULT", "demo@example.com")
+"""Default email for demo user."""
+
+DEMO_PASSWORD_DEFAULT: str = os.getenv("DEMO_PASSWORD_DEFAULT", "demo123")
+"""Default password for demo user."""
+
+# MongoDB connection defaults (for backward compatibility)
+MONGO_URI: str = os.getenv("MONGO_URI", "")
+"""MongoDB connection URI (from environment variable)."""
+
+DB_NAME: str = os.getenv("DB_NAME", "")
+"""Database name (from environment variable)."""
+
+# ============================================================================
+# TOKEN MANAGEMENT CONFIGURATION
+# ============================================================================
+
+# Token lifetimes (can be overridden via environment variables)
+ACCESS_TOKEN_TTL: int = int(os.getenv("ACCESS_TOKEN_TTL", "900"))  # 15 minutes
+"""Access token TTL in seconds (default: 900 / 15 minutes)."""
+
+REFRESH_TOKEN_TTL: int = int(os.getenv("REFRESH_TOKEN_TTL", "604800"))  # 7 days
+"""Refresh token TTL in seconds (default: 604800 / 7 days)."""
+
+TOKEN_ROTATION_ENABLED: bool = (
+    os.getenv("TOKEN_ROTATION_ENABLED", "true").lower() == "true"
+)
+"""Whether to rotate refresh tokens on each use (default: true)."""
+
+MAX_SESSIONS_PER_USER: int = int(os.getenv("MAX_SESSIONS_PER_USER", "10"))
+"""Maximum number of concurrent sessions per user (default: 10)."""
+
+SESSION_INACTIVITY_TIMEOUT: int = int(
+    os.getenv("SESSION_INACTIVITY_TIMEOUT", "1800")
+)  # 30 minutes
+"""Session inactivity timeout in seconds (default: 1800 / 30 minutes)."""