Social Network Guide

package main

import (
    "context"
    "database/sql"
    "log"
    "github.com/google/uuid"
    _ "geodedb.com/geode"
)

type User struct {
    ID          string
    Username    string
    Email       string
    DisplayName string
    Bio         string
    AvatarURL   string
}

func CreateUser(ctx context.Context, db *sql.DB, user User) error {
    user.ID = uuid.New().String()

    _, err := db.ExecContext(ctx, `
        CREATE (u:User {
            id: ?,
            username: ?,
            email: ?,
            display_name: ?,
            bio: ?,
            avatar_url: ?,
            privacy: 'public',
            verified: false,
            created_at: timestamp(),
            last_active: timestamp()
        })
    `, user.ID, user.Username, user.Email, user.DisplayName, user.Bio, user.AvatarURL)

    return err
}

func main() {
    db, err := sql.Open("geode", "localhost:3141")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    ctx := context.Background()

    err = CreateUser(ctx, db, User{
        Username:    "alice",
        Email:       "[email protected]",
        DisplayName: "Alice Johnson",
        Bio:         "Software engineer and coffee enthusiast",
        AvatarURL:   "https://example.com/avatars/alice.jpg",
    })
    if err != nil {
        log.Fatal(err)
    }

    log.Println("User created successfully")
}

import asyncio
from datetime import datetime
from uuid import uuid4
from geode_client import Client

async def create_user(client, username: str, email: str, display_name: str,
                      bio: str = "", avatar_url: str = "") -> dict:
    """Create a new user in the social network."""
    user_id = str(uuid4())

    async with client.connection() as conn:
        result, _ = await conn.query("""
            CREATE (u:User {
                id: $id,
                username: $username,
                email: $email,
                display_name: $display_name,
                bio: $bio,
                avatar_url: $avatar_url,
                privacy: 'public',
                verified: false,
                created_at: timestamp(),
                last_active: timestamp()
            })
            RETURN u
        """, {
            "id": user_id,
            "username": username,
            "email": email,
            "display_name": display_name,
            "bio": bio,
            "avatar_url": avatar_url
        })

        return {"id": user_id, "username": username}

async def main():
    client = Client(host="localhost", port=3141, skip_verify=True)

    user = await create_user(
        client,
        username="alice",
        email="[email protected]",
        display_name="Alice Johnson",
        bio="Software engineer and coffee enthusiast",
        avatar_url="https://example.com/avatars/alice.jpg"
    )

    print(f"Created user: {user}")

asyncio.run(main())

use geode_client::{Client, Value};
use std::collections::HashMap;
use uuid::Uuid;

#[derive(Debug)]
struct User {
    id: String,
    username: String,
    email: String,
    display_name: String,
    bio: String,
    avatar_url: String,
}

async fn create_user(
    conn: &mut geode_client::Connection,
    username: &str,
    email: &str,
    display_name: &str,
    bio: &str,
    avatar_url: &str,
) -> Result<User, Box<dyn std::error::Error>> {
    let user_id = Uuid::new_v4().to_string();

    let mut params = HashMap::new();
    params.insert("id".to_string(), Value::string(&user_id));
    params.insert("username".to_string(), Value::string(username));
    params.insert("email".to_string(), Value::string(email));
    params.insert("display_name".to_string(), Value::string(display_name));
    params.insert("bio".to_string(), Value::string(bio));
    params.insert("avatar_url".to_string(), Value::string(avatar_url));

    conn.query_with_params(r#"
        CREATE (u:User {
            id: $id,
            username: $username,
            email: $email,
            display_name: $display_name,
            bio: $bio,
            avatar_url: $avatar_url,
            privacy: 'public',
            verified: false,
            created_at: timestamp(),
            last_active: timestamp()
        })
    "#, &params).await?;

    Ok(User {
        id: user_id,
        username: username.to_string(),
        email: email.to_string(),
        display_name: display_name.to_string(),
        bio: bio.to_string(),
        avatar_url: avatar_url.to_string(),
    })
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new("127.0.0.1", 3141).skip_verify(true);
    let mut conn = client.connect().await?;

    let user = create_user(
        &mut conn,
        "alice",
        "[email protected]",
        "Alice Johnson",
        "Software engineer and coffee enthusiast",
        "https://example.com/avatars/alice.jpg",
    ).await?;

    println!("Created user: {:?}", user);
    Ok(())
}

import { createClient, Client } from '@geodedb/client';
import { v4 as uuidv4 } from 'uuid';

interface User {
  id: string;
  username: string;
  email: string;
  displayName: string;
  bio: string;
  avatarUrl: string;
}

async function createUser(
  client: Client,
  username: string,
  email: string,
  displayName: string,
  bio: string = '',
  avatarUrl: string = ''
): Promise<User> {
  const userId = uuidv4();

  await client.exec(`
    CREATE (u:User {
      id: $id,
      username: $username,
      email: $email,
      display_name: $display_name,
      bio: $bio,
      avatar_url: $avatar_url,
      privacy: 'public',
      verified: false,
      created_at: timestamp(),
      last_active: timestamp()
    })
  `, {
    params: {
      id: userId,
      username,
      email,
      display_name: displayName,
      bio,
      avatar_url: avatarUrl,
    }
  });

  return {
    id: userId,
    username,
    email,
    displayName,
    bio,
    avatarUrl,
  };
}

async function main() {
  const client = await createClient('quic://localhost:3141');

  const user = await createUser(
    client,
    'alice',
    '[email protected]',
    'Alice Johnson',
    'Software engineer and coffee enthusiast',
    'https://example.com/avatars/alice.jpg'
  );

  console.log('Created user:', user);
  await client.close();
}

main();

const std = @import("std");
const geode = @import("geode_client");
const uuid = @import("uuid");

pub fn createUser(
    client: *geode.GeodeClient,
    allocator: std.mem.Allocator,
    username: []const u8,
    email: []const u8,
    display_name: []const u8,
    bio: []const u8,
    avatar_url: []const u8,
) ![]const u8 {
    const user_id = uuid.v4();

    var params = std.json.ObjectMap.init(allocator);
    defer params.deinit();

    try params.put("id", .{ .string = &user_id });
    try params.put("username", .{ .string = username });
    try params.put("email", .{ .string = email });
    try params.put("display_name", .{ .string = display_name });
    try params.put("bio", .{ .string = bio });
    try params.put("avatar_url", .{ .string = avatar_url });

    try client.sendRunGql(1,
        \\CREATE (u:User {
        \\  id: $id,
        \\  username: $username,
        \\  email: $email,
        \\  display_name: $display_name,
        \\  bio: $bio,
        \\  avatar_url: $avatar_url,
        \\  privacy: 'public',
        \\  verified: false,
        \\  created_at: timestamp(),
        \\  last_active: timestamp()
        \\})
    , .{ .object = params });

    _ = try client.receiveMessage(30000);

    return &user_id;
}

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

    var client = geode.GeodeClient.init(allocator, "localhost", 3141, true);
    defer client.deinit();

    try client.connect();
    try client.sendHello("social-network", "1.0.0");
    _ = try client.receiveMessage(30000);

    const user_id = try createUser(
        &client,
        allocator,
        "alice",
        "[email protected]",
        "Alice Johnson",
        "Software engineer and coffee enthusiast",
        "https://example.com/avatars/alice.jpg",
    );

    std.debug.print("Created user: {s}\n", .{user_id});
}

async def follow_user(client, follower_id: str, followed_id: str) -> bool:
    """Follow another user."""
    async with client.connection() as conn:
        result, _ = await conn.query("""
            MATCH (follower:User {id: $follower_id})
            MATCH (followed:User {id: $followed_id})
            WHERE NOT (follower)-[:FOLLOWS]->(followed)
              AND NOT (follower)-[:BLOCKS]->(followed)
              AND NOT (followed)-[:BLOCKS]->(follower)
            CREATE (follower)-[:FOLLOWS {
                since: timestamp(),
                notifications: true
            }]->(followed)
            RETURN follower.username AS follower, followed.username AS followed
        """, {"follower_id": follower_id, "followed_id": followed_id})

        return len(result.rows) > 0

async fn follow_user(
    conn: &mut geode_client::Connection,
    follower_id: &str,
    followed_id: &str,
) -> Result<bool, Box<dyn std::error::Error>> {
    let mut params = HashMap::new();
    params.insert("follower_id".to_string(), Value::string(follower_id));
    params.insert("followed_id".to_string(), Value::string(followed_id));

    let (page, _) = conn.query_with_params(r#"
        MATCH (follower:User {id: $follower_id})
        MATCH (followed:User {id: $followed_id})
        WHERE NOT (follower)-[:FOLLOWS]->(followed)
          AND NOT (follower)-[:BLOCKS]->(followed)
          AND NOT (followed)-[:BLOCKS]->(follower)
        CREATE (follower)-[:FOLLOWS {
            since: timestamp(),
            notifications: true
        }]->(followed)
        RETURN follower.username, followed.username
    "#, &params).await?;

    Ok(!page.rows.is_empty())
}

async function followUser(
  client: Client,
  followerId: string,
  followedId: string
): Promise<boolean> {
  const result = await client.queryAll(`
    MATCH (follower:User {id: $follower_id})
    MATCH (followed:User {id: $followed_id})
    WHERE NOT (follower)-[:FOLLOWS]->(followed)
      AND NOT (follower)-[:BLOCKS]->(followed)
      AND NOT (followed)-[:BLOCKS]->(follower)
    CREATE (follower)-[:FOLLOWS {
      since: timestamp(),
      notifications: true
    }]->(followed)
    RETURN follower.username, followed.username
  `, { params: { follower_id: followerId, followed_id: followedId } });

  return result.length > 0;
}

pub fn followUser(
    client: *geode.GeodeClient,
    allocator: std.mem.Allocator,
    follower_id: []const u8,
    followed_id: []const u8,
) !bool {
    var params = std.json.ObjectMap.init(allocator);
    defer params.deinit();

    try params.put("follower_id", .{ .string = follower_id });
    try params.put("followed_id", .{ .string = followed_id });

    try client.sendRunGql(1,
        \\MATCH (follower:User {id: $follower_id})
        \\MATCH (followed:User {id: $followed_id})
        \\WHERE NOT (follower)-[:FOLLOWS]->(followed)
        \\  AND NOT (follower)-[:BLOCKS]->(followed)
        \\  AND NOT (followed)-[:BLOCKS]->(follower)
        \\CREATE (follower)-[:FOLLOWS {
        \\    since: timestamp(),
        \\    notifications: true
        \\}]->(followed)
        \\RETURN follower.username, followed.username
    , .{ .object = params });

    const result = try client.receiveMessage(30000);
    defer allocator.free(result);

    // Parse result to check if follow was created
    return std.mem.indexOf(u8, result, "BINDINGS") != null;
}

import re
from typing import List, Optional

def extract_hashtags(content: str) -> List[str]:
    """Extract hashtags from content."""
    return [tag.lower() for tag in re.findall(r'#(\w+)', content)]

def extract_mentions(content: str) -> List[str]:
    """Extract @mentions from content."""
    return re.findall(r'@(\w+)', content)

async def create_post(
    client,
    author_id: str,
    content: str,
    media_urls: Optional[List[str]] = None,
    visibility: str = "public"
) -> dict:
    """Create a new post with automatic hashtag and mention extraction."""
    post_id = str(uuid4())
    hashtags = extract_hashtags(content)
    mentions = extract_mentions(content)

    async with client.connection() as conn:
        await conn.begin()

        try:
            # Create the post
            await conn.execute("""
                MATCH (author:User {id: $author_id})
                CREATE (p:Post {
                    id: $post_id,
                    content: $content,
                    media_urls: $media_urls,
                    visibility: $visibility,
                    reply_count: 0,
                    like_count: 0,
                    share_count: 0,
                    created_at: timestamp()
                })
                CREATE (author)-[:POSTED {timestamp: timestamp()}]->(p)
            """, {
                "author_id": author_id,
                "post_id": post_id,
                "content": content,
                "media_urls": media_urls or [],
                "visibility": visibility
            })

            # Link hashtags
            for tag in hashtags:
                await conn.execute("""
                    MATCH (p:Post {id: $post_id})
                    MERGE (h:Hashtag {name: $tag})
                    ON CREATE SET h.usage_count = 1
                    ON MATCH SET h.usage_count = h.usage_count + 1
                    CREATE (p)-[:TAGGED]->(h)
                """, {"post_id": post_id, "tag": tag})

            # Link mentions
            for username in mentions:
                await conn.execute("""
                    MATCH (p:Post {id: $post_id})
                    MATCH (mentioned:User {username: $username})
                    CREATE (p)-[:MENTIONS]->(mentioned)
                """, {"post_id": post_id, "username": username})

            await conn.commit()

        except Exception as e:
            await conn.rollback()
            raise e

    return {
        "id": post_id,
        "content": content,
        "hashtags": hashtags,
        "mentions": mentions
    }

use regex::Regex;

fn extract_hashtags(content: &str) -> Vec<String> {
    let re = Regex::new(r"#(\w+)").unwrap();
    re.captures_iter(content)
        .map(|cap| cap[1].to_lowercase())
        .collect()
}

fn extract_mentions(content: &str) -> Vec<String> {
    let re = Regex::new(r"@(\w+)").unwrap();
    re.captures_iter(content)
        .map(|cap| cap[1].to_string())
        .collect()
}

async fn create_post(
    conn: &mut geode_client::Connection,
    author_id: &str,
    content: &str,
    visibility: &str,
) -> Result<String, Box<dyn std::error::Error>> {
    let post_id = Uuid::new_v4().to_string();
    let hashtags = extract_hashtags(content);
    let mentions = extract_mentions(content);

    conn.begin().await?;

    // Create post
    let mut params = HashMap::new();
    params.insert("author_id".to_string(), Value::string(author_id));
    params.insert("post_id".to_string(), Value::string(&post_id));
    params.insert("content".to_string(), Value::string(content));
    params.insert("visibility".to_string(), Value::string(visibility));

    conn.query_with_params(r#"
        MATCH (author:User {id: $author_id})
        CREATE (p:Post {
            id: $post_id,
            content: $content,
            visibility: $visibility,
            reply_count: 0,
            like_count: 0,
            share_count: 0,
            created_at: timestamp()
        })
        CREATE (author)-[:POSTED {timestamp: timestamp()}]->(p)
    "#, &params).await?;

    // Link hashtags
    for tag in &hashtags {
        let mut tag_params = HashMap::new();
        tag_params.insert("post_id".to_string(), Value::string(&post_id));
        tag_params.insert("tag".to_string(), Value::string(tag));

        conn.query_with_params(r#"
            MATCH (p:Post {id: $post_id})
            MERGE (h:Hashtag {name: $tag})
            ON CREATE SET h.usage_count = 1
            ON MATCH SET h.usage_count = h.usage_count + 1
            CREATE (p)-[:TAGGED]->(h)
        "#, &tag_params).await?;
    }

    // Link mentions
    for username in &mentions {
        let mut mention_params = HashMap::new();
        mention_params.insert("post_id".to_string(), Value::string(&post_id));
        mention_params.insert("username".to_string(), Value::string(username));

        let _ = conn.query_with_params(r#"
            MATCH (p:Post {id: $post_id})
            MATCH (mentioned:User {username: $username})
            CREATE (p)-[:MENTIONS]->(mentioned)
        "#, &mention_params).await;
    }

    conn.commit().await?;

    Ok(post_id)
}

function extractHashtags(content: string): string[] {
  const matches = content.match(/#(\w+)/g) || [];
  return matches.map(tag => tag.slice(1).toLowerCase());
}

function extractMentions(content: string): string[] {
  const matches = content.match(/@(\w+)/g) || [];
  return matches.map(mention => mention.slice(1));
}

async function createPost(
  client: Client,
  authorId: string,
  content: string,
  visibility: string = 'public'
): Promise<{ id: string; hashtags: string[]; mentions: string[] }> {
  const postId = uuidv4();
  const hashtags = extractHashtags(content);
  const mentions = extractMentions(content);

  await client.withTransaction(async (tx) => {
    // Create post
    await tx.exec(`
      MATCH (author:User {id: $author_id})
      CREATE (p:Post {
        id: $post_id,
        content: $content,
        visibility: $visibility,
        reply_count: 0,
        like_count: 0,
        share_count: 0,
        created_at: timestamp()
      })
      CREATE (author)-[:POSTED {timestamp: timestamp()}]->(p)
    `, { params: { author_id: authorId, post_id: postId, content, visibility } });

    // Link hashtags
    for (const tag of hashtags) {
      await tx.exec(`
        MATCH (p:Post {id: $post_id})
        MERGE (h:Hashtag {name: $tag})
        ON CREATE SET h.usage_count = 1
        ON MATCH SET h.usage_count = h.usage_count + 1
        CREATE (p)-[:TAGGED]->(h)
      `, { params: { post_id: postId, tag } });
    }

    // Link mentions
    for (const username of mentions) {
      await tx.exec(`
        MATCH (p:Post {id: $post_id})
        MATCH (mentioned:User {username: $username})
        CREATE (p)-[:MENTIONS]->(mentioned)
      `, { params: { post_id: postId, username } });
    }
  });

  return { id: postId, hashtags, mentions };
}

const std = @import("std");
const geode = @import("geode_client");

fn extractHashtags(allocator: std.mem.Allocator, content: []const u8) !std.ArrayList([]const u8) {
    var hashtags = std.ArrayList([]const u8).init(allocator);

    var i: usize = 0;
    while (i < content.len) : (i += 1) {
        if (content[i] == '#') {
            const start = i + 1;
            var end = start;
            while (end < content.len and std.ascii.isAlphanumeric(content[end])) : (end += 1) {}
            if (end > start) {
                const tag = try allocator.dupe(u8, content[start..end]);
                try hashtags.append(tag);
            }
            i = end;
        }
    }

    return hashtags;
}

pub fn createPost(
    client: *geode.GeodeClient,
    allocator: std.mem.Allocator,
    author_id: []const u8,
    content: []const u8,
    visibility: []const u8,
) ![]const u8 {
    const post_id = uuid.v4();
    var hashtags = try extractHashtags(allocator, content);
    defer hashtags.deinit();

    // Begin transaction
    try client.sendBegin();
    _ = try client.receiveMessage(30000);

    // Create post
    var params = std.json.ObjectMap.init(allocator);
    defer params.deinit();
    try params.put("author_id", .{ .string = author_id });
    try params.put("post_id", .{ .string = &post_id });
    try params.put("content", .{ .string = content });
    try params.put("visibility", .{ .string = visibility });

    try client.sendRunGql(1,
        \\MATCH (author:User {id: $author_id})
        \\CREATE (p:Post {
        \\    id: $post_id,
        \\    content: $content,
        \\    visibility: $visibility,
        \\    reply_count: 0,
        \\    like_count: 0,
        \\    share_count: 0,
        \\    created_at: timestamp()
        \\})
        \\CREATE (author)-[:POSTED {timestamp: timestamp()}]->(p)
    , .{ .object = params });
    _ = try client.receiveMessage(30000);

    // Link hashtags
    for (hashtags.items) |tag| {
        var tag_params = std.json.ObjectMap.init(allocator);
        defer tag_params.deinit();
        try tag_params.put("post_id", .{ .string = &post_id });
        try tag_params.put("tag", .{ .string = tag });

        try client.sendRunGql(2,
            \\MATCH (p:Post {id: $post_id})
            \\MERGE (h:Hashtag {name: $tag})
            \\ON CREATE SET h.usage_count = 1
            \\ON MATCH SET h.usage_count = h.usage_count + 1
            \\CREATE (p)-[:TAGGED]->(h)
        , .{ .object = tag_params });
        _ = try client.receiveMessage(30000);
    }

    // Commit transaction
    try client.sendCommit();
    _ = try client.receiveMessage(30000);

    return &post_id;
}