chore: PostgreSQL migration compatibility and infrastructure improvements

Database & Migrations:
- Update all Alembic migrations for PostgreSQL compatibility
- Remove SQLite-specific syntax (AUTOINCREMENT, etc.)
- Add database utility helpers for PostgreSQL operations
- Fix services to use PostgreSQL-compatible queries

Documentation:
- Add comprehensive Docker deployment guide
- Add production deployment documentation
- Add infrastructure architecture documentation
- Update database setup guide for PostgreSQL-only
- Expand troubleshooting guide

Architecture & Validation:
- Add migration.yaml rules for SQL compatibility checking
- Enhance validate_architecture.py with migration validation
- Update architecture rules to validate Alembic migrations

Development:
- Fix duplicate install-all target in Makefile
- Add Celery/Redis validation to install.py script
- Add docker-compose.test.yml for CI testing
- Add squash_migrations.py utility script
- Update tests for PostgreSQL compatibility
- Improve test fixtures in conftest.py

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

tests/conftest.py

@@ -1,14 +1,17 @@
-# tests/conftest.py - Updated main conftest with core fixtures only
+# tests/conftest.py - PostgreSQL test configuration
 """
 Core pytest configuration and fixtures.
 
+This project uses PostgreSQL for testing. Start the test database with:
+    make test-db-up
+
 IMPORTANT - Fixture Best Practices:
 ===================================
 1. DO NOT use db.expunge() on fixtures - it detaches objects from the session
    and breaks lazy loading of relationships (e.g., product.marketplace_product).
 
-2. Test isolation is achieved through the db fixture which drops and recreates
-   all tables after each test - no need to manually detach objects.
+2. Test isolation is achieved through TRUNCATE CASCADE after each test,
+   which is much faster than dropping/recreating tables.
 
 3. If you need to ensure an object has fresh data, use db.refresh(obj) instead
    of expunge/re-query patterns.
@@ -19,31 +22,53 @@ IMPORTANT - Fixture Best Practices:
 See docs/testing/testing-guide.md for comprehensive testing documentation.
 """
 
+import os
+
 import pytest
 from fastapi.testclient import TestClient
-from sqlalchemy import create_engine
+from sqlalchemy import create_engine, text
 from sqlalchemy.orm import sessionmaker
-from sqlalchemy.pool import StaticPool
 
 from app.core.database import Base, get_db
 from main import app
 
-# Import all models to ensure they're registered with Base metadata
-
-# Use in-memory SQLite database for tests
-SQLALCHEMY_TEST_DATABASE_URL = "sqlite:///:memory:"
+# PostgreSQL test database URL
+# Use environment variable or default to local Docker test database
+TEST_DATABASE_URL = os.getenv(
+    "TEST_DATABASE_URL",
+    "postgresql://test_user:test_password@localhost:5433/wizamart_test"
+)
 
 
 @pytest.fixture(scope="session")
 def engine():
-    """Create test database engine."""
-    return create_engine(
-        SQLALCHEMY_TEST_DATABASE_URL,
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
+    """Create test database engine.
+
+    Verifies PostgreSQL connection on startup and provides helpful
+    error message if the test database is not running.
+    """
+    engine = create_engine(
+        TEST_DATABASE_URL,
+        pool_pre_ping=True,
         echo=False,  # Set to True for SQL debugging
     )
 
+    # Verify connection on startup
+    try:
+        with engine.connect() as conn:
+            conn.execute(text("SELECT 1"))
+    except Exception as e:
+        pytest.exit(
+            f"\n\nCannot connect to test database at {TEST_DATABASE_URL}\n"
+            f"Error: {e}\n\n"
+            "Start the test database with:\n"
+            "    make test-db-up\n\n"
+            "Or manually:\n"
+            "    docker-compose -f docker-compose.test.yml up -d\n"
+        )
+
+    return engine
+
 
 @pytest.fixture(scope="session")
 def testing_session_local(engine):
@@ -62,32 +87,42 @@ def testing_session_local(engine):
     )
 
 
+@pytest.fixture(scope="session", autouse=True)
+def setup_database(engine):
+    """Create all tables once at the start of the test session."""
+    Base.metadata.create_all(bind=engine)
+    yield
+    # Optionally drop tables after all tests (commented out for debugging)
+    # Base.metadata.drop_all(bind=engine)
+
+
 @pytest.fixture(scope="function")
 def db(engine, testing_session_local):
     """
     Create a database session for each test function.
 
     Provides test isolation by:
-    - Creating fresh tables before each test
-    - Dropping all tables after each test completes
+    - Using a fresh session for each test
+    - Truncating all tables after each test (fast cleanup)
 
     Note: Fixtures should NOT use db.expunge() as this detaches objects
-    from the session and breaks lazy loading. The table drop/create cycle
-    provides sufficient isolation between tests.
+    from the session and breaks lazy loading. The TRUNCATE provides
+    sufficient isolation between tests.
     """
-    # Create all tables
-    Base.metadata.create_all(bind=engine)
-
-    # Create session
     db_session = testing_session_local()
 
     try:
         yield db_session
     finally:
         db_session.close()
-        # Clean up all data after each test
-        Base.metadata.drop_all(bind=engine)
-        Base.metadata.create_all(bind=engine)
+        # Fast cleanup with TRUNCATE CASCADE
+        with engine.connect() as conn:
+            # Disable FK checks temporarily for fast truncation
+            conn.execute(text("SET session_replication_role = 'replica'"))
+            for table in reversed(Base.metadata.sorted_tables):
+                conn.execute(text(f'TRUNCATE TABLE "{table.name}" CASCADE'))
+            conn.execute(text("SET session_replication_role = 'origin'"))
+            conn.commit()
 
 
 @pytest.fixture(scope="function")