Provision a database for rapid development

# Create a simple app database
gibson modify "Create a simple todo app with users and tasks. Users can create multiple tasks with title, description, due date, and completion status"

# Generate Pydantic schemas for validation
gibson code schemas

# Generate SQLAlchemy models for database operations
gibson code models

# Generate all Python code
gibson code base

# Create a social media prototype
gibson modify "Create a social media prototype with users, posts, likes, and follows. Users can create posts, like posts, and follow other users"

-- Users table
CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    display_name VARCHAR(100),
    bio TEXT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Posts table
CREATE TABLE posts (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    content TEXT NOT NULL,
    image_url VARCHAR(500),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

-- Likes table
CREATE TABLE likes (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    post_id INT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id),
    FOREIGN KEY (post_id) REFERENCES posts(id),
    UNIQUE KEY unique_user_post (user_id, post_id)
);

-- Follows table
CREATE TABLE follows (
    id INT AUTO_INCREMENT PRIMARY KEY,
    follower_id INT NOT NULL,
    following_id INT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (follower_id) REFERENCES users(id),
    FOREIGN KEY (following_id) REFERENCES users(id),
    UNIQUE KEY unique_follow (follower_id, following_id)
);

from pydantic import BaseModel, EmailStr
from datetime import datetime
from typing import Optional

class User(BaseModel):
    id: Optional[int] = None
    username: str
    email: EmailStr
    display_name: Optional[str] = None
    bio: Optional[str] = None
    created_at: Optional[datetime] = None

class Post(BaseModel):
    id: Optional[int] = None
    user_id: int
    content: str
    image_url: Optional[str] = None
    created_at: Optional[datetime] = None

class Like(BaseModel):
    id: Optional[int] = None
    user_id: int
    post_id: int
    created_at: Optional[datetime] = None

class Follow(BaseModel):
    id: Optional[int] = None
    follower_id: int
    following_id: int
    created_at: Optional[datetime] = None

from sqlalchemy import Column, Integer, String, Text, DateTime, ForeignKey, UniqueConstraint
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from datetime import datetime

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(50), unique=True, nullable=False)
    email = Column(String(255), unique=True, nullable=False)
    display_name = Column(String(100))
    bio = Column(Text)
    created_at = Column(DateTime, default=datetime.utcnow)

    posts = relationship("Post", back_populates="user")
    likes = relationship("Like", back_populates="user")
    followers = relationship("Follow", foreign_keys="Follow.following_id", back_populates="following")
    following = relationship("Follow", foreign_keys="Follow.follower_id", back_populates="follower")

class Post(Base):
    __tablename__ = 'posts'

    id = Column(Integer, primary_key=True, autoincrement=True)
    user_id = Column(Integer, ForeignKey('users.id'), nullable=False)
    content = Column(Text, nullable=False)
    image_url = Column(String(500))
    created_at = Column(DateTime, default=datetime.utcnow)

    user = relationship("User", back_populates="posts")
    likes = relationship("Like", back_populates="post")

class Like(Base):
    __tablename__ = 'likes'

    id = Column(Integer, primary_key=True, autoincrement=True)
    user_id = Column(Integer, ForeignKey('users.id'), nullable=False)
    post_id = Column(Integer, ForeignKey('posts.id'), nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)

    __table_args__ = (UniqueConstraint('user_id', 'post_id', name='unique_user_post'),)

    user = relationship("User", back_populates="likes")
    post = relationship("Post", back_populates="likes")

class Follow(Base):
    __tablename__ = 'follows'

    id = Column(Integer, primary_key=True, autoincrement=True)
    follower_id = Column(Integer, ForeignKey('users.id'), nullable=False)
    following_id = Column(Integer, ForeignKey('users.id'), nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)

    __table_args__ = (UniqueConstraint('follower_id', 'following_id', name='unique_follow'),)

    follower = relationship("User", foreign_keys=[follower_id], back_populates="following")
    following = relationship("User", foreign_keys=[following_id], back_populates="followers")

import requests

# Create a user
user_data = {
    "username": "developer123",
    "email": "dev@example.com",
    "display_name": "Developer",
    "bio": "Building awesome stuff!"
}
response = requests.post("https://api.gibsonai.com/v1/-/users", json=user_data)
new_user = response.json()

# Create a post
post_data = {
    "user_id": new_user["id"],
    "content": "Just provisioned a database in seconds with GibsonAI!",
    "image_url": "https://example.com/screenshot.png"
}
response = requests.post("https://api.gibsonai.com/v1/-/posts", json=post_data)
new_post = response.json()

# Like the post
like_data = {
    "user_id": new_user["id"],
    "post_id": new_post["id"]
}
response = requests.post("https://api.gibsonai.com/v1/-/likes", json=like_data)

from sqlalchemy import create_engine, func
from sqlalchemy.orm import sessionmaker

# Use connection string from GibsonAI UI
engine = create_engine("your-connection-string-from-ui")
Session = sessionmaker(bind=engine)
session = Session()

# Get popular posts
popular_posts = session.query(
    Post.content,
    User.username,
    func.count(Like.id).label('like_count')
).join(User).outerjoin(Like).group_by(
    Post.id
).order_by(
    func.count(Like.id).desc()
).limit(10).all()

# Get user feed with followed users' posts
user_id = 1
feed = session.query(Post).join(
    Follow, Post.user_id == Follow.following_id
).filter(
    Follow.follower_id == user_id
).order_by(Post.created_at.desc()).limit(20).all()

# Use text-to-SQL for quick insights
query = """
SELECT u.username, COUNT(p.id) as post_count, COUNT(l.id) as total_likes
FROM users u
LEFT JOIN posts p ON u.id = p.user_id
LEFT JOIN likes l ON p.id = l.post_id
GROUP BY u.id, u.username
ORDER BY total_likes DESC
LIMIT 10
"""

response = requests.post("https://api.gibsonai.com/v1/-/query", json={"query": query})
top_users = response.json()

# Create a voting app for hackathons
gibson modify "Create a voting app with users, proposals, and votes. Users can submit proposals and vote on them. Each user can only vote once per proposal"

# Create an e-commerce MVP
gibson modify "Create an e-commerce MVP with products, users, orders, and reviews. Users can browse products, place orders, and leave reviews"

# Create a learning management system
gibson modify "Create a learning platform with students, courses, lessons, and progress tracking. Students can enroll in courses and track their progress"