cinchdb 0.1.0__tar.gz → 0.1.1__tar.gz

{cinchdb-0.1.0 → cinchdb-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinchdb
-Version: 0.1.0
+Version: 0.1.1
 Summary: A Git-like SQLite database management system with branching and multi-tenancy
 Project-URL: Homepage, https://github.com/russellromney/cinchdb
 Project-URL: Documentation, https://russellromney.github.io/cinchdb
@@ -34,11 +34,11 @@ Description-Content-Type: text/markdown
 
 NOTE: CinchDB is in early alpha. This is project to test out an idea. Do not use this in production.
 
-CinchDB is for projects that need to isolate data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4) and/or want to test out changes to structure safely in branchces. Plus, queries can be super, super fast because data is separated per tenant so it's <data_size>/<n_tenants> instead of <data_size>
+CinchDB is for projects that need fast queries, data isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database.
 
 On a meta level, I made this because I wanted a database structure that I felt comfortable letting AI agents take full control over, safely, and I didn't want to run my own Postgres instance somewhere or pay for it on e.g. Neon - I don't need hyperscaling, I just need super fast queries.
 
-Because it's so lightweight and its only dependencies are FastAPI, pydantic, requests, and Typer, it is super cheap to run on a small VM like from [Fly.io](https://fly.io) and I don't need to SSH into it to connect - I can just store an API key in my local projects. 
+Because it's so lightweight and its only dependencies are FastAPI, pydantic, requests, and Typer, it is super cheap to run on a small VM like from [Fly.io](https://fly.io) and I don't need to SSH into it to make changes - I can just store an API key in my local projects and hit the remote instance.
 
 
 ```bash

{cinchdb-0.1.0 → cinchdb-0.1.1}/README.md

@@ -4,11 +4,11 @@
 
 NOTE: CinchDB is in early alpha. This is project to test out an idea. Do not use this in production.
 
-CinchDB is for projects that need to isolate data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4) and/or want to test out changes to structure safely in branchces. Plus, queries can be super, super fast because data is separated per tenant so it's <data_size>/<n_tenants> instead of <data_size>
+CinchDB is for projects that need fast queries, data isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database.
 
 On a meta level, I made this because I wanted a database structure that I felt comfortable letting AI agents take full control over, safely, and I didn't want to run my own Postgres instance somewhere or pay for it on e.g. Neon - I don't need hyperscaling, I just need super fast queries.
 
-Because it's so lightweight and its only dependencies are FastAPI, pydantic, requests, and Typer, it is super cheap to run on a small VM like from [Fly.io](https://fly.io) and I don't need to SSH into it to connect - I can just store an API key in my local projects. 
+Because it's so lightweight and its only dependencies are FastAPI, pydantic, requests, and Typer, it is super cheap to run on a small VM like from [Fly.io](https://fly.io) and I don't need to SSH into it to make changes - I can just store an API key in my local projects and hit the remote instance.
 
 
 ```bash

{cinchdb-0.1.0 → cinchdb-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cinchdb"
-version = "0.1.0"
+version = "0.1.1"
 description = "A Git-like SQLite database management system with branching and multi-tenancy"
 readme = "README.md"
 requires-python = ">=3.10"

{cinchdb-0.1.0 → cinchdb-0.1.1}/src/cinchdb/api/routers/databases.py

@@ -11,6 +11,7 @@ from cinchdb.api.auth import (
     require_write_permission,
     require_read_permission,
 )
+from cinchdb.utils.name_validator import validate_name, InvalidNameError
 
 
 router = APIRouter()
@@ -68,6 +69,12 @@ async def create_database(
     auth: AuthContext = Depends(require_write_permission),
 ):
     """Create a new database."""
+    # Validate database name
+    try:
+        validate_name(request.name, "database")
+    except InvalidNameError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    
     config = Config(auth.project_dir)
 
     # Create database directory structure

{cinchdb-0.1.0 → cinchdb-0.1.1}/src/cinchdb/cli/commands/branch.py

@@ -14,6 +14,7 @@ from cinchdb.cli.utils import (
     set_active_branch,
     validate_required_arg,
 )
+from cinchdb.utils.name_validator import validate_name, InvalidNameError
 
 app = typer.Typer(help="Branch management commands", invoke_without_command=True)
 console = Console()
@@ -80,6 +81,14 @@ def create(
 ):
     """Create a new branch."""
     name = validate_required_arg(name, "name", ctx)
+    
+    # Validate branch name
+    try:
+        validate_name(name, "branch")
+    except InvalidNameError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+        
     config, config_data = get_config_with_data()
     db_name = config_data.active_database
     source_branch = source or config_data.active_branch

{cinchdb-0.1.0 → cinchdb-0.1.1}/src/cinchdb/cli/commands/database.py

@@ -12,6 +12,7 @@ from cinchdb.cli.utils import (
     set_active_branch,
     validate_required_arg,
 )
+from cinchdb.utils.name_validator import validate_name, InvalidNameError
 
 app = typer.Typer(help="Database management commands", invoke_without_command=True)
 console = Console()
@@ -64,6 +65,14 @@ def create(
 ):
     """Create a new database."""
     name = validate_required_arg(name, "name", ctx)
+    
+    # Validate database name
+    try:
+        validate_name(name, "database")
+    except InvalidNameError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+    
     config, config_data = get_config_with_data()
 
     # Create database directory structure

{cinchdb-0.1.0 → cinchdb-0.1.1}/src/cinchdb/cli/commands/tenant.py

@@ -10,6 +10,7 @@ from cinchdb.config import Config
 from cinchdb.core.path_utils import get_project_root
 from cinchdb.managers.tenant import TenantManager
 from cinchdb.cli.utils import get_config_with_data, validate_required_arg
+from cinchdb.utils.name_validator import validate_name, InvalidNameError
 
 app = typer.Typer(help="Tenant management commands", invoke_without_command=True)
 console = Console()
@@ -70,6 +71,14 @@ def create(
 ):
     """Create a new tenant."""
     name = validate_required_arg(name, "name", ctx)
+    
+    # Validate tenant name
+    try:
+        validate_name(name, "tenant")
+    except InvalidNameError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+        
     config, config_data = get_config_with_data()
     db_name = config_data.active_database
     branch_name = config_data.active_branch
@@ -155,6 +164,14 @@ def rename(
     """Rename a tenant."""
     old_name = validate_required_arg(old_name, "old_name", ctx)
     new_name = validate_required_arg(new_name, "new_name", ctx)
+    
+    # Validate new tenant name
+    try:
+        validate_name(new_name, "tenant")
+    except InvalidNameError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+        
     config, config_data = get_config_with_data()
     db_name = config_data.active_database
     branch_name = config_data.active_branch

{cinchdb-0.1.0 → cinchdb-0.1.1}/src/cinchdb/managers/branch.py

@@ -13,6 +13,7 @@ from cinchdb.core.path_utils import (
     get_branch_path,
     list_branches,
 )
+from cinchdb.utils.name_validator import validate_name
 
 
 class BranchManager:
@@ -63,7 +64,11 @@ class BranchManager:
 
         Raises:
             ValueError: If source doesn't exist or new branch already exists
+            InvalidNameError: If new branch name is invalid
         """
+        # Validate new branch name
+        validate_name(new_branch_name, "branch")
+        
         # Validate source branch exists
         if source_branch not in list_branches(self.project_root, self.database):
             raise ValueError(f"Source branch '{source_branch}' does not exist")

{cinchdb-0.1.0 → cinchdb-0.1.1}/src/cinchdb/managers/tenant.py

@@ -12,6 +12,7 @@ from cinchdb.core.path_utils import (
 )
 from cinchdb.core.connection import DatabaseConnection
 from cinchdb.core.maintenance import check_maintenance_mode
+from cinchdb.utils.name_validator import validate_name
 
 
 class TenantManager:
@@ -64,8 +65,12 @@ class TenantManager:
 
         Raises:
             ValueError: If tenant already exists
+            InvalidNameError: If tenant name is invalid
             MaintenanceError: If branch is in maintenance mode
         """
+        # Validate tenant name
+        validate_name(tenant_name, "tenant")
+        
         # Check maintenance mode
         check_maintenance_mode(self.project_root, self.database, self.branch)
 
@@ -158,8 +163,12 @@ class TenantManager:
 
         Raises:
             ValueError: If source doesn't exist or target already exists
+            InvalidNameError: If target tenant name is invalid
             MaintenanceError: If branch is in maintenance mode
         """
+        # Validate target tenant name
+        validate_name(target_tenant, "tenant")
+        
         # Check maintenance mode
         check_maintenance_mode(self.project_root, self.database, self.branch)
 
@@ -200,7 +209,11 @@ class TenantManager:
 
         Raises:
             ValueError: If old doesn't exist, new already exists, or trying to rename main
+            InvalidNameError: If new tenant name is invalid
         """
+        # Validate new tenant name
+        validate_name(new_name, "tenant")
+        
         # Can't rename main tenant
         if old_name == "main":
             raise ValueError("Cannot rename the main tenant")

{cinchdb-0.1.0 → cinchdb-0.1.1}/src/cinchdb/models/branch.py

@@ -1,8 +1,9 @@
 """Branch model for CinchDB."""
 
 from typing import List, Optional, Dict, Any
-from pydantic import Field
+from pydantic import Field, field_validator
 from .base import CinchDBBaseModel
+from ..utils.name_validator import validate_name
 
 
 class Branch(CinchDBBaseModel):
@@ -21,6 +22,13 @@ class Branch(CinchDBBaseModel):
     )
     is_main: bool = Field(default=False, description="Whether this is the main branch")
 
+    @field_validator('name')
+    @classmethod
+    def validate_name_field(cls, v: str) -> str:
+        """Validate branch name meets naming requirements."""
+        validate_name(v, "branch")
+        return v
+
     def can_delete(self) -> bool:
         """Check if this branch can be deleted."""
         return self.name != "main" and not self.is_main

{cinchdb-0.1.0 → cinchdb-0.1.1}/src/cinchdb/models/database.py

@@ -1,8 +1,9 @@
 """Database model for CinchDB."""
 
 from typing import List, Optional
-from pydantic import Field
+from pydantic import Field, field_validator
 from .base import CinchDBBaseModel
+from ..utils.name_validator import validate_name
 
 
 class Database(CinchDBBaseModel):
@@ -15,6 +16,13 @@ class Database(CinchDBBaseModel):
     active_branch: str = Field(default="main", description="Currently active branch")
     description: Optional[str] = Field(default=None, description="Database description")
 
+    @field_validator('name')
+    @classmethod
+    def validate_name_field(cls, v: str) -> str:
+        """Validate database name meets naming requirements."""
+        validate_name(v, "database")
+        return v
+
     def can_delete(self) -> bool:
         """Check if this database can be deleted."""
         return self.name != "main"

{cinchdb-0.1.0 → cinchdb-0.1.1}/src/cinchdb/models/tenant.py

@@ -1,8 +1,9 @@
 """Tenant model for CinchDB."""
 
 from typing import Optional
-from pydantic import Field
+from pydantic import Field, field_validator
 from .base import CinchDBBaseModel
+from ..utils.name_validator import validate_name
 
 
 class Tenant(CinchDBBaseModel):
@@ -14,6 +15,13 @@ class Tenant(CinchDBBaseModel):
     description: Optional[str] = Field(default=None, description="Tenant description")
     is_main: bool = Field(default=False, description="Whether this is the main tenant")
 
+    @field_validator('name')
+    @classmethod
+    def validate_name_field(cls, v: str) -> str:
+        """Validate tenant name meets naming requirements."""
+        validate_name(v, "tenant")
+        return v
+
     def can_delete(self) -> bool:
         """Check if this tenant can be deleted."""
         return self.name != "main" and not self.is_main

{cinchdb-0.1.0 → cinchdb-0.1.1}/src/cinchdb/utils/__init__.py

@@ -6,10 +6,20 @@ from cinchdb.utils.sql_validator import (
     SQLValidationError,
     SQLOperation
 )
+from cinchdb.utils.name_validator import (
+    validate_name,
+    clean_name,
+    is_valid_name,
+    InvalidNameError
+)
 
 __all__ = [
     "validate_sql_query",
     "validate_query_safe",
     "SQLValidationError",
-    "SQLOperation"
+    "SQLOperation",
+    "validate_name",
+    "clean_name", 
+    "is_valid_name",
+    "InvalidNameError"
 ]

cinchdb-0.1.1/src/cinchdb/utils/name_validator.py

@@ -0,0 +1,129 @@
+"""Name validation utilities for CinchDB entities.
+
+Ensures branch, database, and tenant names are safe for filesystem operations
+and follow consistent naming conventions.
+"""
+
+import re
+from typing import Optional
+
+
+# Regex pattern for valid names: lowercase letters, numbers, dash, underscore, period
+VALID_NAME_PATTERN = re.compile(r'^[a-z0-9][a-z0-9\-._]*[a-z0-9]$|^[a-z0-9]$')
+
+# Reserved names that cannot be used
+RESERVED_NAMES = {'con', 'prn', 'aux', 'nul', 'com1', 'com2', 'com3', 'com4',
+                  'com5', 'com6', 'com7', 'com8', 'com9', 'lpt1', 'lpt2',
+                  'lpt3', 'lpt4', 'lpt5', 'lpt6', 'lpt7', 'lpt8', 'lpt9'}
+
+
+class InvalidNameError(ValueError):
+    """Raised when a name doesn't meet validation requirements."""
+    pass
+
+
+def validate_name(name: str, entity_type: str = "entity") -> None:
+    """Validate that a name meets CinchDB naming requirements.
+    
+    Valid names must:
+    - Contain only lowercase letters (a-z), numbers (0-9), dash (-), underscore (_), and period (.)
+    - Start and end with alphanumeric characters
+    - Be at least 1 character long
+    - Not exceed 255 characters (filesystem limit)
+    - Not be a reserved name
+    
+    Args:
+        name: The name to validate
+        entity_type: Type of entity (branch, database, tenant) for error messages
+        
+    Raises:
+        InvalidNameError: If the name is invalid
+    """
+    if not name:
+        raise InvalidNameError(f"{entity_type.capitalize()} name cannot be empty")
+    
+    if len(name) > 255:
+        raise InvalidNameError(
+            f"{entity_type.capitalize()} name cannot exceed 255 characters"
+        )
+    
+    # Check for lowercase requirement
+    if name != name.lower():
+        raise InvalidNameError(
+            f"{entity_type.capitalize()} name must be lowercase. "
+            f"Use '{name.lower()}' instead of '{name}'"
+        )
+    
+    # Check pattern
+    if not VALID_NAME_PATTERN.match(name):
+        raise InvalidNameError(
+            f"Invalid {entity_type} name '{name}'. "
+            f"Names must contain only lowercase letters (a-z), numbers (0-9), "
+            f"dash (-), underscore (_), and period (.). "
+            f"Names must start and end with alphanumeric characters."
+        )
+    
+    # Check for consecutive special characters
+    if '..' in name or '--' in name or '__' in name or '.-' in name or '-.' in name:
+        raise InvalidNameError(
+            f"Invalid {entity_type} name '{name}'. "
+            f"Names cannot contain consecutive special characters."
+        )
+    
+    # Check reserved names
+    if name.lower() in RESERVED_NAMES:
+        raise InvalidNameError(
+            f"'{name}' is a reserved name and cannot be used as a {entity_type} name"
+        )
+
+
+def clean_name(name: str) -> str:
+    """Clean a name to make it valid if possible.
+    
+    This performs basic cleaning:
+    - Convert to lowercase
+    - Replace spaces with dashes
+    - Remove invalid characters
+    
+    Args:
+        name: The name to clean
+        
+    Returns:
+        Cleaned name
+        
+    Note:
+        This is a best-effort cleaning. The result should still be validated
+        with validate_name() before use.
+    """
+    # Convert to lowercase
+    cleaned = name.lower()
+    
+    # Replace spaces with dashes
+    cleaned = cleaned.replace(' ', '-')
+    
+    # Remove invalid characters
+    cleaned = re.sub(r'[^a-z0-9\-._]', '', cleaned)
+    
+    # Remove consecutive special characters
+    cleaned = re.sub(r'[-._]{2,}', '-', cleaned)
+    
+    # Remove leading/trailing special characters
+    cleaned = cleaned.strip('-._')
+    
+    return cleaned
+
+
+def is_valid_name(name: str) -> bool:
+    """Check if a name is valid without raising an exception.
+    
+    Args:
+        name: The name to check
+        
+    Returns:
+        True if valid, False otherwise
+    """
+    try:
+        validate_name(name)
+        return True
+    except InvalidNameError:
+        return False