API Reference

local client = MongoDB.Client(connectionString)

local client = MongoDB.Client("mongodb://localhost:27017")

local client = MongoDB.ClientWithOptions(connectionString, options)

local client = MongoDB.ClientWithOptions("mongodb://localhost:27017", {
    app_name = "MyGModServer",
    max_pool_size = 50,
    retry_writes = true
})

local version = MongoDB.Version()

print("gmsv_mongo version:", MongoDB.Version())

MongoDB.SuppressMessages(suppress)

MongoDB.SuppressMessages(true)  -- Suppress info messages

local database = client:Database(name)

local db = client:Database("gameserver")

local databases = client:ListDatabases()

local dbs = client:ListDatabases()
for i, name in ipairs(dbs) do
    print(i .. ". " .. name)
end

local collection = database:Collection(name)

local players = db:Collection("players")

local collections = database:ListCollections()

local cols = db:ListCollections()
for i, name in ipairs(cols) do
    print(i .. ". " .. name)
end

local success = database:CreateCollection(name)

local created = db:CreateCollection("new_collection")

local success = database:DropCollection(name)

local dropped = db:DropCollection("old_collection")

local stats = database:Stats(collectionName)

local stats = db:Stats("players")
if stats then
    print("Documents:", stats.count)
    print("Size:", stats.size, "bytes")
end

local success = database:Drop()

-- ⚠️ DANGER: Deletes all data
local dropped = testDB:Drop()

local id = collection:InsertOne(document)

local id = players:InsertOne({
    steamid = "STEAM_0:1:12345",
    username = "Player1",
    level = 1
})

local ids = collection:InsertMany(documents)

local ids = players:InsertMany({
    { username = "Player1", level = 1 },
    { username = "Player2", level = 2 },
    { username = "Player3", level = 3 }
})

local documents = collection:Find(filter, limit)

local results = players:Find({ level = { ["$gte"] = 10 } }, 20)

local document = collection:FindOne(filter)

local player = players:FindOne({ steamid = "STEAM_0:1:12345" })

local count = collection:UpdateOne(filter, update, upsert)

local updated = players:UpdateOne(
    { steamid = "STEAM_0:1:12345" },
    { ["$set"] = { level = 10 } },
    false
)

local count = collection:UpdateMany(filter, update, upsert)

local updated = players:UpdateMany(
    { active = true },
    { ["$inc"] = { bonus_credits = 100 } }
)

local count = collection:DeleteOne(filter)

local deleted = players:DeleteOne({ steamid = "STEAM_0:1:12345" })

local count = collection:DeleteMany(filter)

local deleted = logs:DeleteMany({
    created_at = { ["$lt"] = os.time() - (30 * 24 * 60 * 60) }
})

local count = collection:Count(filter)

local total = players:Count({})
local active = players:Count({ active = true })

local results = collection:Aggregate(pipeline)

local stats = players:Aggregate({
    {
        ["$group"] = {
            _id = "$rank",
            count = { ["$sum"] = 1 },
            avgLevel = { ["$avg"] = "$level" }
        }
    },
    {
        ["$sort"] = { count = -1 }
    }
})

local indexName = collection:CreateIndex(keys, unique, name)

-- Simple index
players:CreateIndex({ steamid = 1 }, true, "steamid_unique")

-- Compound index
players:CreateIndex({ level = -1, score = -1 }, false, "level_score")

local indexes = collection:ListIndexes()

local indexes = players:ListIndexes()
for i, index in ipairs(indexes) do
    print(index.name)
end

local success = collection:DropIndex(name)

local dropped = players:DropIndex("old_index")