Building Your First Application

# Create project
mkdir geode-tasks && cd geode-tasks
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install geode-client

# Create project structure
mkdir -p src/models src/repository tests
touch src/__init__.py
touch src/models/__init__.py src/models/models.py
touch src/repository/__init__.py src/repository/repository.py
touch src/main.py
touch tests/__init__.py tests/test_repository.py

geode-tasks/
├── venv/
├── src/
│   ├── __init__.py
│   ├── main.py
│   ├── models/
│   │   ├── __init__.py
│   │   └── models.py
│   └── repository/
│       ├── __init__.py
│       └── repository.py
└── tests/
    ├── __init__.py
    └── test_repository.py

# Create project
cargo new geode-tasks
cd geode-tasks

# Add dependencies to Cargo.toml
cat >> Cargo.toml << 'EOF'
[dependencies]
geode-client = "0.18"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
thiserror = "1"
chrono = { version = "0.4", features = ["serde"] }
EOF

# Create project structure
mkdir -p src/{models,repository}
touch src/models/mod.rs src/repository/mod.rs

geode-tasks/
├── Cargo.toml
├── Cargo.lock
└── src/
    ├── main.rs
    ├── models/
    │   └── mod.rs
    └── repository/
        └── mod.rs

# Create project
mkdir geode-tasks && cd geode-tasks
npm init -y

# Install dependencies
npm install @geodedb/client

# For TypeScript support
npm install -D typescript @types/node ts-node
npx tsc --init

# Create project structure
mkdir -p src/{models,repository}
touch src/index.ts
touch src/models/index.ts
touch src/repository/index.ts

geode-tasks/
├── package.json
├── tsconfig.json
└── src/
    ├── index.ts
    ├── models/
    │   └── index.ts
    └── repository/
        └── index.ts

# Create project
mkdir geode-tasks && cd geode-tasks
zig init

# Create project structure
mkdir -p src/{models,repository}
touch src/models.zig src/repository.zig

# Add geode-client to build.zig.zon (see Installation Guide)

geode-tasks/
├── build.zig
├── build.zig.zon
└── src/
    ├── main.zig
    ├── models.zig
    └── repository.zig

# src/repository/repository.py
from contextlib import asynccontextmanager
from geode_client import Client, Connection
from typing import AsyncIterator

class Repository:
    def __init__(self, host: str = "localhost", port: int = 3141):
        self.client = Client(
            host=host,
            port=port,
            skip_verify=True  # Set to False in production with proper certs
        )

    @asynccontextmanager
    async def connection(self) -> AsyncIterator[Connection]:
        """Get a connection from the pool."""
        async with self.client.connection() as conn:
            yield conn

    async def ping(self) -> bool:
        """Test connectivity."""
        async with self.connection() as conn:
            result = await conn.ping()
            return result is not None

# src/main.py
import asyncio
from repository.repository import Repository

async def main():
    repo = Repository("localhost", 3141)

    if await repo.ping():
        print("Connected to Geode!")
    else:
        print("Failed to connect")

if __name__ == "__main__":
    asyncio.run(main())

// src/repository/mod.rs
use geode_client::{Client, Connection, GeodeError};
use std::sync::Arc;

pub struct Repository {
    client: Arc<Client>,
}

impl Repository {
    pub fn new(host: &str, port: u16) -> Self {
        let client = Client::new(host, port).skip_verify(true);
        Repository {
            client: Arc::new(client),
        }
    }

    pub async fn connect(&self) -> Result<Connection, GeodeError> {
        self.client.connect().await
    }

    pub async fn ping(&self) -> Result<bool, GeodeError> {
        let mut conn = self.connect().await?;
        conn.ping().await?;
        Ok(true)
    }
}

// src/main.rs
mod repository;

use repository::Repository;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let repo = Repository::new("127.0.0.1", 3141);

    if repo.ping().await? {
        println!("Connected to Geode!");
    }

    Ok(())
}

// src/repository/index.ts
import { createClient, GeodeClient } from '@geodedb/client';

export class Repository {
    private client: GeodeClient | null = null;
    private connectionString: string;

    constructor(host: string = 'localhost', port: number = 3141) {
        this.connectionString = `quic://${host}:${port}`;
    }

    async connect(): Promise<void> {
        this.client = await createClient(this.connectionString);
    }

    async close(): Promise<void> {
        if (this.client) {
            await this.client.close();
            this.client = null;
        }
    }

    async ping(): Promise<boolean> {
        if (!this.client) {
            throw new Error('Not connected');
        }
        const result = await this.client.ping();
        return result !== null;
    }

    getClient(): GeodeClient {
        if (!this.client) {
            throw new Error('Not connected');
        }
        return this.client;
    }
}

// src/index.ts
import { Repository } from './repository';

async function main() {
    const repo = new Repository('localhost', 3141);
    await repo.connect();

    if (await repo.ping()) {
        console.log('Connected to Geode!');
    }

    await repo.close();
}

main().catch(console.error);

// src/repository.zig
const std = @import("std");
const geode = @import("geode_client");

pub const Repository = struct {
    allocator: std.mem.Allocator,
    client: geode.GeodeClient,
    connected: bool,

    pub fn init(allocator: std.mem.Allocator, host: []const u8, port: u16) Repository {
        return Repository{
            .allocator = allocator,
            .client = geode.GeodeClient.init(allocator, host, port, true),
            .connected = false,
        };
    }

    pub fn deinit(self: *Repository) void {
        self.client.deinit();
    }

    pub fn connect(self: *Repository) !void {
        try self.client.connect();
        try self.client.sendHello("geode-tasks", "1.0.0");
        _ = try self.client.receiveMessage(30000);
        self.connected = true;
    }

    pub fn ping(self: *Repository) !bool {
        if (!self.connected) return error.NotConnected;
        try self.client.sendPing();
        _ = try self.client.receiveMessage(30000);
        return true;
    }

    pub fn getClient(self: *Repository) *geode.GeodeClient {
        return &self.client;
    }
};

// src/main.zig
const std = @import("std");
const Repository = @import("repository.zig").Repository;

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var repo = Repository.init(allocator, "localhost", 3141);
    defer repo.deinit();

    try repo.connect();

    if (try repo.ping()) {
        std.debug.print("Connected to Geode!\n", .{});
    }
}

# src/models/models.py
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
from typing import Optional
import uuid

class TaskStatus(str, Enum):
    PENDING = "pending"
    IN_PROGRESS = "in_progress"
    COMPLETED = "completed"

class Priority(int, Enum):
    LOW = 1
    MEDIUM = 2
    HIGH = 3

@dataclass
class User:
    id: str = field(default_factory=lambda: str(uuid.uuid4()))
    email: str = ""
    name: str = ""
    created_at: datetime = field(default_factory=datetime.now)

@dataclass
class Project:
    id: str = field(default_factory=lambda: str(uuid.uuid4()))
    name: str = ""
    description: str = ""
    owner_id: str = ""
    created_at: datetime = field(default_factory=datetime.now)

@dataclass
class Task:
    id: str = field(default_factory=lambda: str(uuid.uuid4()))
    title: str = ""
    description: str = ""
    status: TaskStatus = TaskStatus.PENDING
    priority: Priority = Priority.MEDIUM
    due_date: Optional[datetime] = None
    project_id: str = ""
    assignee_id: Optional[str] = None
    created_at: datetime = field(default_factory=datetime.now)
    updated_at: datetime = field(default_factory=datetime.now)

// src/models/mod.rs
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TaskStatus {
    Pending,
    InProgress,
    Completed,
}

impl TaskStatus {
    pub fn as_str(&self) -> &str {
        match self {
            TaskStatus::Pending => "pending",
            TaskStatus::InProgress => "in_progress",
            TaskStatus::Completed => "completed",
        }
    }
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
#[repr(i32)]
pub enum Priority {
    Low = 1,
    Medium = 2,
    High = 3,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
    pub id: String,
    pub email: String,
    pub name: String,
    pub created_at: DateTime<Utc>,
}

impl User {
    pub fn new(email: String, name: String) -> Self {
        User {
            id: Uuid::new_v4().to_string(),
            email,
            name,
            created_at: Utc::now(),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Project {
    pub id: String,
    pub name: String,
    pub description: String,
    pub owner_id: String,
    pub created_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Task {
    pub id: String,
    pub title: String,
    pub description: String,
    pub status: TaskStatus,
    pub priority: Priority,
    pub due_date: Option<DateTime<Utc>>,
    pub project_id: String,
    pub assignee_id: Option<String>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

// src/models/index.ts
import { v4 as uuidv4 } from 'uuid';

export enum TaskStatus {
    Pending = 'pending',
    InProgress = 'in_progress',
    Completed = 'completed',
}

export enum Priority {
    Low = 1,
    Medium = 2,
    High = 3,
}

export interface User {
    id: string;
    email: string;
    name: string;
    createdAt: Date;
}

export interface Project {
    id: string;
    name: string;
    description: string;
    ownerId: string;
    createdAt: Date;
}

export interface Task {
    id: string;
    title: string;
    description: string;
    status: TaskStatus;
    priority: Priority;
    dueDate?: Date;
    projectId: string;
    assigneeId?: string;
    createdAt: Date;
    updatedAt: Date;
}

export function createUser(email: string, name: string): User {
    return {
        id: uuidv4(),
        email,
        name,
        createdAt: new Date(),
    };
}

export function createProject(name: string, description: string, ownerId: string): Project {
    return {
        id: uuidv4(),
        name,
        description,
        ownerId,
        createdAt: new Date(),
    };
}

export function createTask(
    title: string,
    description: string,
    projectId: string,
    priority: Priority = Priority.Medium
): Task {
    const now = new Date();
    return {
        id: uuidv4(),
        title,
        description,
        status: TaskStatus.Pending,
        priority,
        projectId,
        createdAt: now,
        updatedAt: now,
    };
}

// src/models.zig
const std = @import("std");

pub const TaskStatus = enum {
    pending,
    in_progress,
    completed,

    pub fn toString(self: TaskStatus) []const u8 {
        return switch (self) {
            .pending => "pending",
            .in_progress => "in_progress",
            .completed => "completed",
        };
    }
};

pub const Priority = enum(i32) {
    low = 1,
    medium = 2,
    high = 3,
};

pub const User = struct {
    id: []const u8,
    email: []const u8,
    name: []const u8,
    created_at: i64,
};

pub const Project = struct {
    id: []const u8,
    name: []const u8,
    description: []const u8,
    owner_id: []const u8,
    created_at: i64,
};

pub const Task = struct {
    id: []const u8,
    title: []const u8,
    description: []const u8,
    status: TaskStatus,
    priority: Priority,
    due_date: ?i64,
    project_id: []const u8,
    assignee_id: ?[]const u8,
    created_at: i64,
    updated_at: i64,
};

pub fn generateId(allocator: std.mem.Allocator) ![]u8 {
    var uuid: [36]u8 = undefined;
    std.crypto.random.bytes(&uuid);
    // Simple UUID-like format
    return try std.fmt.allocPrint(allocator, "{x:0>32}", .{std.crypto.random.int(u128)});
}

# src/repository/repository.py (continued)
from datetime import datetime
from typing import Optional
import uuid
from models.models import User, Project, Task, TaskStatus, Priority

class Repository:
    # ... previous connection code ...

    async def create_user(self, email: str, name: str) -> User:
        """Create a new user."""
        user = User(
            id=str(uuid.uuid4()),
            email=email,
            name=name,
            created_at=datetime.now()
        )

        async with self.connection() as conn:
            await conn.execute(
                """
                CREATE (:User {
                    id: $id,
                    email: $email,
                    name: $name,
                    created_at: $created_at
                })
                """,
                {
                    "id": user.id,
                    "email": user.email,
                    "name": user.name,
                    "created_at": int(user.created_at.timestamp())
                }
            )

        return user

    async def create_project(
        self, name: str, description: str, owner_id: str
    ) -> Project:
        """Create a new project with owner relationship."""
        project = Project(
            id=str(uuid.uuid4()),
            name=name,
            description=description,
            owner_id=owner_id,
            created_at=datetime.now()
        )

        async with self.connection() as conn:
            # Create project node
            await conn.execute(
                """
                CREATE (:Project {
                    id: $id,
                    name: $name,
                    description: $description,
                    created_at: $created_at
                })
                """,
                {
                    "id": project.id,
                    "name": project.name,
                    "description": project.description,
                    "created_at": int(project.created_at.timestamp())
                }
            )

            # Create OWNS relationship
            await conn.execute(
                """
                MATCH (u:User {id: $owner_id})
                MATCH (p:Project {id: $project_id})
                CREATE (u)-[:OWNS]->(p)
                """,
                {"owner_id": owner_id, "project_id": project.id}
            )

        return project

    async def create_task(
        self,
        title: str,
        description: str,
        project_id: str,
        priority: Priority = Priority.MEDIUM
    ) -> Task:
        """Create a new task in a project."""
        now = datetime.now()
        task = Task(
            id=str(uuid.uuid4()),
            title=title,
            description=description,
            status=TaskStatus.PENDING,
            priority=priority,
            project_id=project_id,
            created_at=now,
            updated_at=now
        )

        async with self.connection() as conn:
            # Create task node
            await conn.execute(
                """
                CREATE (:Task {
                    id: $id,
                    title: $title,
                    description: $description,
                    status: $status,
                    priority: $priority,
                    created_at: $created_at,
                    updated_at: $updated_at
                })
                """,
                {
                    "id": task.id,
                    "title": task.title,
                    "description": task.description,
                    "status": task.status.value,
                    "priority": task.priority.value,
                    "created_at": int(task.created_at.timestamp()),
                    "updated_at": int(task.updated_at.timestamp())
                }
            )

            # Create CONTAINS relationship
            await conn.execute(
                """
                MATCH (p:Project {id: $project_id})
                MATCH (t:Task {id: $task_id})
                CREATE (p)-[:CONTAINS]->(t)
                """,
                {"project_id": project_id, "task_id": task.id}
            )

        return task

// src/repository/mod.rs (continued)
use crate::models::{User, Project, Task, TaskStatus, Priority};
use std::collections::HashMap;
use geode_client::Value;
use chrono::Utc;
use uuid::Uuid;

impl Repository {
    pub async fn create_user(&self, email: String, name: String) -> Result<User, GeodeError> {
        let user = User::new(email, name);
        let mut conn = self.connect().await?;

        let mut params = HashMap::new();
        params.insert("id".to_string(), Value::string(&user.id));
        params.insert("email".to_string(), Value::string(&user.email));
        params.insert("name".to_string(), Value::string(&user.name));
        params.insert("created_at".to_string(), Value::int(user.created_at.timestamp()));

        conn.query_with_params(r#"
            CREATE (:User {
                id: $id,
                email: $email,
                name: $name,
                created_at: $created_at
            })
        "#, &params).await?;

        Ok(user)
    }

    pub async fn create_project(
        &self,
        name: String,
        description: String,
        owner_id: String,
    ) -> Result<Project, GeodeError> {
        let project = Project {
            id: Uuid::new_v4().to_string(),
            name,
            description,
            owner_id: owner_id.clone(),
            created_at: Utc::now(),
        };

        let mut conn = self.connect().await?;

        // Create project node
        let mut params = HashMap::new();
        params.insert("id".to_string(), Value::string(&project.id));
        params.insert("name".to_string(), Value::string(&project.name));
        params.insert("description".to_string(), Value::string(&project.description));
        params.insert("created_at".to_string(), Value::int(project.created_at.timestamp()));

        conn.query_with_params(r#"
            CREATE (:Project {
                id: $id,
                name: $name,
                description: $description,
                created_at: $created_at
            })
        "#, &params).await?;

        // Create OWNS relationship
        let mut rel_params = HashMap::new();
        rel_params.insert("owner_id".to_string(), Value::string(&owner_id));
        rel_params.insert("project_id".to_string(), Value::string(&project.id));

        conn.query_with_params(r#"
            MATCH (u:User {id: $owner_id})
            MATCH (p:Project {id: $project_id})
            CREATE (u)-[:OWNS]->(p)
        "#, &rel_params).await?;

        Ok(project)
    }

    pub async fn create_task(
        &self,
        title: String,
        description: String,
        project_id: String,
        priority: Priority,
    ) -> Result<Task, GeodeError> {
        let now = Utc::now();
        let task = Task {
            id: Uuid::new_v4().to_string(),
            title,
            description,
            status: TaskStatus::Pending,
            priority,
            due_date: None,
            project_id: project_id.clone(),
            assignee_id: None,
            created_at: now,
            updated_at: now,
        };

        let mut conn = self.connect().await?;

        // Create task node
        let mut params = HashMap::new();
        params.insert("id".to_string(), Value::string(&task.id));
        params.insert("title".to_string(), Value::string(&task.title));
        params.insert("description".to_string(), Value::string(&task.description));
        params.insert("status".to_string(), Value::string(task.status.as_str()));
        params.insert("priority".to_string(), Value::int(task.priority as i64));
        params.insert("created_at".to_string(), Value::int(task.created_at.timestamp()));
        params.insert("updated_at".to_string(), Value::int(task.updated_at.timestamp()));

        conn.query_with_params(r#"
            CREATE (:Task {
                id: $id,
                title: $title,
                description: $description,
                status: $status,
                priority: $priority,
                created_at: $created_at,
                updated_at: $updated_at
            })
        "#, &params).await?;

        // Create CONTAINS relationship
        let mut rel_params = HashMap::new();
        rel_params.insert("project_id".to_string(), Value::string(&project_id));
        rel_params.insert("task_id".to_string(), Value::string(&task.id));

        conn.query_with_params(r#"
            MATCH (p:Project {id: $project_id})
            MATCH (t:Task {id: $task_id})
            CREATE (p)-[:CONTAINS]->(t)
        "#, &rel_params).await?;

        Ok(task)
    }
}

// src/repository/index.ts (continued)
import { User, Project, Task, TaskStatus, Priority, createUser, createProject, createTask } from '../models';

export class Repository {
    // ... previous connection code ...

    async createUser(email: string, name: string): Promise<User> {
        const user = createUser(email, name);
        const client = this.getClient();

        await client.exec(
            `CREATE (:User {
                id: $id,
                email: $email,
                name: $name,
                created_at: $created_at
            })`,
            {
                params: {
                    id: user.id,
                    email: user.email,
                    name: user.name,
                    created_at: Math.floor(user.createdAt.getTime() / 1000),
                },
            }
        );

        return user;
    }

    async createProject(name: string, description: string, ownerId: string): Promise<Project> {
        const project = createProject(name, description, ownerId);
        const client = this.getClient();

        // Create project node
        await client.exec(
            `CREATE (:Project {
                id: $id,
                name: $name,
                description: $description,
                created_at: $created_at
            })`,
            {
                params: {
                    id: project.id,
                    name: project.name,
                    description: project.description,
                    created_at: Math.floor(project.createdAt.getTime() / 1000),
                },
            }
        );

        // Create OWNS relationship
        await client.exec(
            `MATCH (u:User {id: $owner_id})
             MATCH (p:Project {id: $project_id})
             CREATE (u)-[:OWNS]->(p)`,
            {
                params: { owner_id: ownerId, project_id: project.id },
            }
        );

        return project;
    }

    async createTask(
        title: string,
        description: string,
        projectId: string,
        priority: Priority = Priority.Medium
    ): Promise<Task> {
        const task = createTask(title, description, projectId, priority);
        const client = this.getClient();

        // Create task node
        await client.exec(
            `CREATE (:Task {
                id: $id,
                title: $title,
                description: $description,
                status: $status,
                priority: $priority,
                created_at: $created_at,
                updated_at: $updated_at
            })`,
            {
                params: {
                    id: task.id,
                    title: task.title,
                    description: task.description,
                    status: task.status,
                    priority: task.priority,
                    created_at: Math.floor(task.createdAt.getTime() / 1000),
                    updated_at: Math.floor(task.updatedAt.getTime() / 1000),
                },
            }
        );

        // Create CONTAINS relationship
        await client.exec(
            `MATCH (p:Project {id: $project_id})
             MATCH (t:Task {id: $task_id})
             CREATE (p)-[:CONTAINS]->(t)`,
            {
                params: { project_id: projectId, task_id: task.id },
            }
        );

        return task;
    }
}