omegga 1.2.8 → 1.3.0

package/dist/webserver/backend/database.js

@@ -1,635 +1,585 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const softconfig_1 = __importDefault(require("../../softconfig"));
-const pattern_1 = require("../../util/pattern");
-const time_1 = require("../../util/time");
-const bcryptjs_1 = __importDefault(require("bcryptjs"));
-const chokidar_1 = __importDefault(require("chokidar"));
-const events_1 = __importDefault(require("events"));
-const nedb_promises_1 = __importDefault(require("nedb-promises"));
-const path_1 = __importDefault(require("path"));
-const calendar_1 = __importDefault(require("./calendar"));
-// TODO: online users graph
-// TODO: player online times
-// TODO: bricks over time graph
-// TODO: minute server status for metrics
-// TODO: chat messages per min/hour/day check
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const softconfig = require("../../softconfig.js");
+const pattern = require("../../util/pattern.js");
+const time = require("../../util/time.js");
+const bcrypt = require("bcryptjs");
+const chokidar = require("chokidar");
+const EventEmitter = require("events");
+const Datastore = require("nedb-promises");
+const path = require("path");
+const calendar = require("./calendar.js");
 let serverInstance;
-// generate a punchcard (days x week)
-const createPunchcard = () => Array.from({ length: 7 }).map(() => Array.from({ length: 24 }).fill(0));
-// the database keeps track of metrics for omegga
-class Database extends events_1.default {
-    constructor(options, omegga) {
-        super();
-        this.options = options;
-        this.omegga = omegga;
-        this.calendar = new calendar_1.default();
-        // database
-        const dbOpts = {
-            autoload: true,
-            // case insensitive string comparison
-            compareStrings: (a, b) => a.localeCompare(b, 'en', { ignorePunctuation: true }),
-        };
-        // create all the stores
-        this.stores = {
-            users: nedb_promises_1.default.create({
-                filename: path_1.default.join(omegga.dataPath, softconfig_1.default.USER_STORE),
-                ...dbOpts,
-            }),
-            chat: nedb_promises_1.default.create({
-                filename: path_1.default.join(omegga.dataPath, softconfig_1.default.CHAT_STORE),
-                ...dbOpts,
-            }),
-            players: nedb_promises_1.default.create({
-                filename: path_1.default.join(omegga.dataPath, softconfig_1.default.PLAYER_STORE),
-                ...dbOpts,
-            }),
-            status: nedb_promises_1.default.create({
-                filename: path_1.default.join(omegga.dataPath, softconfig_1.default.STATUS_STORE),
-                ...dbOpts,
-            }),
-            server: nedb_promises_1.default.create({
-                filename: path_1.default.join(omegga.dataPath, softconfig_1.default.SERVER_STORE),
-                ...dbOpts,
-            }),
-        };
-    }
-    // make sure all the databases have valid store versions
-    async doMigrations() {
-        // current store versions
-        const storeVersions = {
-            users: 1,
-            chat: 1,
-            players: 1,
-            status: 1,
-            server: 1,
-            // example version
-            dummy: 10,
-        };
-        // migrations to/from certain store versions
-        const migrations = {
-            users: [],
-            chat: [],
-            players: [],
-            status: [],
-            server: [],
-            // example migration list (all version upgrades go up by 1)
-            dummy: [
-                {
-                    version: 1, // target version
-                    upgrade: async (_store) => { }, // upgrade function (does not include updating version)
-                },
-            ],
-        };
-        // loop through all stores to find if any need version upgrades
-        await Promise.all(Object.entries(this.stores).map(async ([name, store]) => {
-            const versionEntry = await store.findOne({
-                type: 'storeVersion',
-            });
-            const expected = storeVersions[name];
-            // if the version was not found, insert it
-            if (!versionEntry) {
-                store.insert({ type: 'storeVersion', version: expected });
-                // if the version was not what was expected
-            }
-            else if (expected !== versionEntry.version) {
-                // while the version is below the expected version
-                let { version } = versionEntry;
-                for (; version < expected; version++) {
-                    // find an available migration
-                    const migration = migrations[name].find(v => v.version === version);
-                    // no migration found, ignore
-                    if (!migration)
-                        break;
-                    // run the upgrade
-                    migration.upgrade(store);
-                }
-                // update the stored version
-                await store.update({ _id: versionEntry._id }, { version });
-            }
-        }));
-    }
-    // get the running instance id of this omegga
-    async getInstanceId() {
-        if (serverInstance)
-            return serverInstance._id;
-        const doc = await this.stores.server.insert({
-            type: 'app:start',
-            date: Date.now(),
-        });
-        serverInstance = doc;
-        // create a calendar of all previous chat messages
-        const dates = (await this.stores.chat.find({ type: 'chat' })).map(c => c.created);
-        for (const d of dates) {
-            this.calendar.addDate(d);
+const createPunchcard = () => Array.from({ length: 7 }).map(
+  () => Array.from({ length: 24 }).fill(0)
+);
+class Database extends EventEmitter {
+  constructor(options, omegga) {
+    super();
+    this.options = options;
+    this.omegga = omegga;
+    this.calendar = new calendar.default();
+    const dbOpts = {
+      autoload: true,
+      // case insensitive string comparison
+      compareStrings: (a, b) => a.localeCompare(b, "en", { ignorePunctuation: true })
+    };
+    this.stores = {
+      users: Datastore.create({
+        filename: path.join(omegga.dataPath, softconfig.default.USER_STORE),
+        ...dbOpts
+      }),
+      chat: Datastore.create({
+        filename: path.join(omegga.dataPath, softconfig.default.CHAT_STORE),
+        ...dbOpts
+      }),
+      players: Datastore.create({
+        filename: path.join(omegga.dataPath, softconfig.default.PLAYER_STORE),
+        ...dbOpts
+      }),
+      status: Datastore.create({
+        filename: path.join(omegga.dataPath, softconfig.default.STATUS_STORE),
+        ...dbOpts
+      }),
+      server: Datastore.create({
+        filename: path.join(omegga.dataPath, softconfig.default.SERVER_STORE),
+        ...dbOpts
+      })
+    };
+  }
+  // make sure all the databases have valid store versions
+  async doMigrations() {
+    const storeVersions = {
+      users: 1,
+      chat: 1,
+      players: 1,
+      status: 1,
+      server: 1,
+      // example version
+      dummy: 10
+    };
+    const migrations = {
+      users: [],
+      chat: [],
+      players: [],
+      status: [],
+      server: [],
+      // example migration list (all version upgrades go up by 1)
+      dummy: [
+        {
+          version: 1,
+          // target version
+          upgrade: async (_store) => {
+          }
+          // upgrade function (does not include updating version)
         }
-        const watcher = chokidar_1.default.watch(path_1.default.join(this.omegga.configPath, 'BanList.json'), { persistent: false });
-        watcher
-            .on('add', () => setTimeout(this.syncBanList.bind(this), 500))
-            .on('change', () => setTimeout(() => {
-            this.syncBanList();
-            this.emit('update.bans');
-        }, 500));
-        setTimeout(this.syncBanList.bind(this), 500);
-        const handleKick = (kicked, kicker, reason) => {
-            // time the event listener should expire
-            const eventExpire = Date.now() + 100;
-            // detect a single leave
-            this.omegga.once('leave', async (leavingPlayer) => {
-                const now = Date.now();
-                // if a player leaves more than 100ms from the kick command, it's bugged
-                if (now > eventExpire)
-                    return;
-                if (leavingPlayer.id === kicked.id) {
-                    const entry = {
-                        type: 'kickHistory',
-                        kicked: kicked.id,
-                        kickerId: kicker.id,
-                        created: now,
-                        reason,
-                    };
-                    // depending on implementation, this could potentially be a kick event
-                    await this.stores.players.update(entry, { $set: entry }, { upsert: true });
-                }
-            });
-        };
-        // for a5 is based on the chat event
-        this.omegga.on('kick', (kicked, kicker, reason) => {
-            const kickedPlayer = this.omegga.findPlayerByName(kicked);
-            const kickerPlayer = this.omegga.findPlayerByName(kicker);
-            // couldn't find kicked or kicker player
-            if (!kickedPlayer || !kickerPlayer)
-                return;
-            handleKick(kickedPlayer, kickerPlayer, reason);
+      ]
+    };
+    await Promise.all(
+      Object.entries(this.stores).map(async ([name, store]) => {
+        const versionEntry = await store.findOne({
+          type: "storeVersion"
         });
-        return doc._id;
-    }
-    // synchronize the ban list with the one in the database
-    syncBanList() {
-        var _a;
-        const banList = (_a = this.omegga.getBanList()) === null || _a === void 0 ? void 0 : _a.banList;
-        if (!banList)
-            return;
-        // upsert all bans
-        for (const banned in banList) {
-            const entry = {
-                type: 'banHistory',
-                banned,
-                bannerId: banList[banned].bannerId,
-                created: (0, time_1.parseBrickadiaTime)(banList[banned].created),
-                expires: (0, time_1.parseBrickadiaTime)(banList[banned].expires),
-                reason: banList[banned].reason,
-            };
-            this.stores.players.update(entry, { $set: entry }, { upsert: true });
+        const expected = storeVersions[name];
+        if (!versionEntry) {
+          store.insert({ type: "storeVersion", version: expected });
+        } else if (expected !== versionEntry.version) {
+          let { version } = versionEntry;
+          for (; version < expected; version++) {
+            const migration = migrations[name].find((v) => v.version === version);
+            if (!migration) break;
+            migration.upgrade(store);
+          }
+          await store.update({ _id: versionEntry._id }, { version });
         }
+      })
+    );
+  }
+  // get the running instance id of this omegga
+  async getInstanceId() {
+    if (serverInstance) return serverInstance._id;
+    const doc = await this.stores.server.insert({
+      type: "app:start",
+      date: Date.now()
+    });
+    serverInstance = doc;
+    const dates = (await this.stores.chat.find({ type: "chat" })).map((c) => c.created);
+    for (const d of dates) {
+      this.calendar.addDate(d);
     }
-    // determine if this user would be the first user (admin user)
-    async isFirstUser() {
-        return (await this.stores.users.count({ type: 'user' })) === 0;
-    }
-    // hash a password
-    async hash(password) {
-        return await bcryptjs_1.default.hash(password, 10);
-    }
-    // create an admin user account, username can be blank (no password)
-    async createAdminUser(username, password) {
-        const hash = await this.hash(password);
-        // create an owner user
-        const user = this.stores.users.insert({
-            // this is a user
-            type: 'user',
-            created: Date.now(),
-            lastOnline: Date.now(),
-            // credentials
-            username,
-            hash,
-            // permissions
-            isOwner: true,
-            roles: [],
-            // brickadia player uuid
-            playerId: '',
-        });
-        return user;
-    }
-    // determine if a user with this name exists
-    async userExists(username) {
-        return (await this.stores.users.count({ type: 'user', username })) > 0;
-    }
-    // create a regular  user account
-    async createUser(username, password) {
-        if (await this.userExists(username))
-            throw new Error('user already exists');
-        const hash = await this.hash(password);
-        // create an owner user
-        const user = this.stores.users.insert({
-            // this is a user
-            type: 'user',
-            created: Date.now(),
-            lastOnline: 0,
-            // credentials
-            username,
-            hash,
-            // permissions
-            isOwner: false,
-            roles: [],
-            // brickadia player uuid
-            playerId: '',
-        });
-        return user;
-    }
-    // set a user's password
-    async userPasswd(username, password) {
-        const hash = await this.hash(password);
-        if (!this.userExists(username))
-            throw new Error('user does not exist');
-        await this.stores.users.update({ type: 'user', username }, { $set: { hash } });
-    }
-    // get a user from credentials
-    async authUser(username, password) {
-        const user = await this.stores.users.findOne({ username });
-        // user not found
-        if (!user || user.isBanned)
-            return null;
-        // make sure the user's password hash is valid
-        if (await bcryptjs_1.default.compare(password, user.hash)) {
-            // update last online status
-            await this.stores.users.update({ _id: user._id }, { $set: { lastOnline: Date.now() } });
-            return user;
+    const watcher = chokidar.watch(
+      path.join(this.omegga.configPath, "BanList.json"),
+      { persistent: false }
+    );
+    watcher.on("add", () => setTimeout(this.syncBanList.bind(this), 500)).on(
+      "change",
+      () => setTimeout(() => {
+        this.syncBanList();
+        this.emit("update.bans");
+      }, 500)
+    );
+    setTimeout(this.syncBanList.bind(this), 500);
+    const handleKick = (kicked, kicker, reason) => {
+      const eventExpire = Date.now() + 100;
+      this.omegga.once("leave", async (leavingPlayer) => {
+        const now = Date.now();
+        if (now > eventExpire) return;
+        if (leavingPlayer.id === kicked.id) {
+          const entry = {
+            type: "kickHistory",
+            kicked: kicked.id,
+            kickerId: kicker.id,
+            created: now,
+            reason
+          };
+          await this.stores.players.update(
+            entry,
+            { $set: entry },
+            { upsert: true }
+          );
         }
-        // wrong password
-        return null;
-    }
-    // find a user by object id
-    async findUserById(id) {
-        return await this.stores.users.findOne({
-            $or: [
-                // the owner has no username, so everyone is the owner
-                { type: 'user', username: '', isOwner: true },
-                // the user exists and has an id
-                { type: 'user', _id: id },
-            ],
-        });
+      });
+    };
+    this.omegga.on("kick", (kicked, kicker, reason) => {
+      const kickedPlayer = this.omegga.findPlayerByName(kicked);
+      const kickerPlayer = this.omegga.findPlayerByName(kicker);
+      if (!kickedPlayer || !kickerPlayer) return;
+      handleKick(kickedPlayer, kickerPlayer, reason);
+    });
+    return doc._id;
+  }
+  // synchronize the ban list with the one in the database
+  syncBanList() {
+    const banList = this.omegga.getBanList()?.banList;
+    if (!banList) return;
+    for (const banned in banList) {
+      const entry = {
+        type: "banHistory",
+        banned,
+        bannerId: banList[banned].bannerId,
+        created: time.parseBrickadiaTime(banList[banned].created),
+        expires: time.parseBrickadiaTime(banList[banned].expires),
+        reason: banList[banned].reason
+      };
+      this.stores.players.update(entry, { $set: entry }, { upsert: true });
     }
-    // get a list of roles
-    // TODO: actually implement roles
-    getRoles() {
-        return this.stores.server.find({ type: 'role' });
+  }
+  // determine if this user would be the first user (admin user)
+  async isFirstUser() {
+    return await this.stores.users.count({ type: "user" }) === 0;
+  }
+  // hash a password
+  async hash(password) {
+    return await bcrypt.hash(password, 10);
+  }
+  // create an admin user account, username can be blank (no password)
+  async createAdminUser(username, password) {
+    const hash = await this.hash(password);
+    const user = this.stores.users.insert({
+      // this is a user
+      type: "user",
+      created: Date.now(),
+      lastOnline: Date.now(),
+      // credentials
+      username,
+      hash,
+      // permissions
+      isOwner: true,
+      roles: [],
+      // brickadia player uuid
+      playerId: ""
+    });
+    return user;
+  }
+  // determine if a user with this name exists
+  async userExists(username) {
+    return await this.stores.users.count({ type: "user", username }) > 0;
+  }
+  // create a regular  user account
+  async createUser(username, password) {
+    if (await this.userExists(username)) throw new Error("user already exists");
+    const hash = await this.hash(password);
+    const user = this.stores.users.insert({
+      // this is a user
+      type: "user",
+      created: Date.now(),
+      lastOnline: 0,
+      // credentials
+      username,
+      hash,
+      // permissions
+      isOwner: false,
+      roles: [],
+      // brickadia player uuid
+      playerId: ""
+    });
+    return user;
+  }
+  // set a user's password
+  async userPasswd(username, password) {
+    const hash = await this.hash(password);
+    if (!this.userExists(username)) throw new Error("user does not exist");
+    await this.stores.users.update(
+      { type: "user", username },
+      { $set: { hash } }
+    );
+  }
+  // get a user from credentials
+  async authUser(username, password) {
+    const user = await this.stores.users.findOne({ username });
+    if (!user || user.isBanned) return null;
+    if (await bcrypt.compare(password, user.hash)) {
+      await this.stores.users.update(
+        { _id: user._id },
+        { $set: { lastOnline: Date.now() } }
+      );
+      return user;
     }
-    // add a chat message to the chat log store
-    async addChatLog(action, user, message) {
-        this.calendar.addDate(Date.now());
-        return await this.stores.chat.insert({
-            type: 'chat',
-            created: Date.now(),
-            instanceId: await this.getInstanceId(),
-            action,
-            user,
-            ...(message ? { message } : {}),
-        });
-    }
-    // get recent chat activity
-    async getChats({ count = 50, sameServer, before, after, } = {}) {
-        return await this.stores.chat
-            .find({
-            type: 'chat',
-            ...(sameServer ? { instanceId: await this.getInstanceId() } : {}),
-            created: before
-                ? { $lt: before }
-                : after
-                    ? { $gt: after }
-                    : { $lt: Date.now() },
-        })
-            .sort({ created: !before && after ? 1 : -1 })
-            .limit(count)
-            .exec();
-    }
-    // get paginated players
-    async getPlayers({ count = 50, search = '', page = 0, sort = 'name', direction = '1', limitId = undefined, } = {}) {
-        const pattern = (0, pattern_1.explode)(search);
-        // the query used for finding which players are available
-        const query = {
-            type: 'userHistory',
-            // only filter if there's a query
-            $and: [
-                // if a limitId is passed in, the id must be in it
-                ...(limitId ? [{ id: { $in: limitId } }] : []),
-                // if there's a search, the search matches...
-                ...(search.length > 0
-                    ? [
-                        {
-                            $or: [
-                                // id was pasted in
-                                { id: search },
-                                // user's current name
-                                { name: { $regex: pattern } },
-                                { displayName: { $regex: pattern } },
-                                // user's past name
-                                {
-                                    nameHistory: { $elemMatch: { name: { $regex: pattern } } },
-                                },
-                                {
-                                    nameHistory: {
-                                        $elemMatch: { displayName: { $regex: pattern } },
-                                    },
-                                },
-                            ],
-                        },
-                    ]
-                    : []),
-            ],
-        };
-        // the query used for finding a specific player
-        const exactQuery = {
-            type: 'userHistory',
-            // only filter if there's a query
+    return null;
+  }
+  // find a user by object id
+  async findUserById(id) {
+    return await this.stores.users.findOne({
+      $or: [
+        // the owner has no username, so everyone is the owner
+        { type: "user", username: "", isOwner: true },
+        // the user exists and has an id
+        { type: "user", _id: id }
+      ]
+    });
+  }
+  // get a list of roles
+  // TODO: actually implement roles
+  getRoles() {
+    return this.stores.server.find({ type: "role" });
+  }
+  // add a chat message to the chat log store
+  async addChatLog(action, user, message) {
+    this.calendar.addDate(Date.now());
+    return await this.stores.chat.insert({
+      type: "chat",
+      created: Date.now(),
+      instanceId: await this.getInstanceId(),
+      action,
+      user,
+      ...message ? { message } : {}
+    });
+  }
+  // get recent chat activity
+  async getChats({
+    count = 50,
+    sameServer,
+    before,
+    after
+  } = {}) {
+    return await this.stores.chat.find({
+      type: "chat",
+      ...sameServer ? { instanceId: await this.getInstanceId() } : {},
+      created: before ? { $lt: before } : after ? { $gt: after } : { $lt: Date.now() }
+    }).sort({ created: !before && after ? 1 : -1 }).limit(count).exec();
+  }
+  // get paginated players
+  async getPlayers({
+    count = 50,
+    search = "",
+    page = 0,
+    sort = "name",
+    direction = "1",
+    limitId = void 0
+  } = {}) {
+    const pattern$1 = pattern.explode(search);
+    const query = {
+      type: "userHistory",
+      // only filter if there's a query
+      $and: [
+        // if a limitId is passed in, the id must be in it
+        ...limitId ? [{ id: { $in: limitId } }] : [],
+        // if there's a search, the search matches...
+        ...search.length > 0 ? [
+          {
             $or: [
-                // id was pasted in
-                { id: search },
-                // user's current name
-                { name: search },
-                // user's current display name
-                { displayName: search },
-            ],
-        };
-        // count players and query players
-        const [total, players, exactResult] = await Promise.all([
-            this.stores.players.count(query),
-            this.stores.players
-                .find(query)
-                // TODO: add other sorts and sort directions
-                .sort({ [sort]: direction })
-                .skip(count * page)
-                .limit(count)
-                .exec(),
-            // exact match detection
-            search.length > 0 && page === 0
-                ? this.stores.players.find(exactQuery)
-                : [],
-        ]);
-        // add exact matches to the beginning
-        if (exactResult.length > 0) {
-            // remove duplicates
-            for (const res of exactResult) {
-                const index = players.findIndex(p => p._id === res._id);
-                players.splice(index, 1);
-            }
-            // add results to the beginning
-            players.splice(0, 0, ...exactResult);
-        }
-        return {
-            pages: Math.ceil(total / count),
-            total,
-            players,
-        };
-    }
-    // get paginated users
-    async getUsers({ count = 50, search = '', page = 0, sort = 'name', direction = '1', } = {}) {
-        const pattern = (0, pattern_1.explode)(search);
-        // the query used for finding which players are available
-        const query = {
-            type: 'user',
-            // only filter if there's a query
-            ...(search.length > 0
-                ? {
-                    $or: [
-                        // id was pasted in
-                        { playerId: search },
-                        // user's current name
-                        { name: { $regex: pattern } },
-                    ],
+              // id was pasted in
+              { id: search },
+              // user's current name
+              { name: { $regex: pattern$1 } },
+              { displayName: { $regex: pattern$1 } },
+              // user's past name
+              {
+                nameHistory: { $elemMatch: { name: { $regex: pattern$1 } } }
+              },
+              {
+                nameHistory: {
+                  $elemMatch: { displayName: { $regex: pattern$1 } }
                 }
-                : {}),
-        };
-        // count players and query players
-        const [total, users] = await Promise.all([
-            this.stores.users.count(query),
-            this.stores.users
-                .find(query)
-                // TODO: add other sorts and sort directions
-                .sort({ [sort]: direction })
-                .skip(count * page)
-                .limit(count)
-                .exec(),
-        ]);
-        return {
-            pages: Math.ceil(total / count),
-            total,
-            users,
-        };
-    }
-    // get an individual player, ban and kick history, and notes
-    async getPlayer(id) {
-        const [player, banHistory, kickHistory, notes] = await Promise.all([
-            this.stores.players.findOne({ type: 'userHistory', id }),
-            this.stores.players
-                .find({ type: 'banHistory', banned: id })
-                .sort({ created: -1 })
-                .limit(25)
-                .exec(),
-            this.stores.players
-                .find({ type: 'kickHistory', kicked: id })
-                .sort({ created: -1 })
-                .limit(25)
-                .exec(),
-            this.stores.players
-                .find({ type: 'note', id })
-                .sort({ created: -1 })
-                .limit(25)
-                .exec(),
-        ]);
-        if (!player)
-            return null;
-        return { ...player, banHistory, kickHistory, notes };
+              }
+            ]
+          }
+        ] : []
+      ]
+    };
+    const exactQuery = {
+      type: "userHistory",
+      // only filter if there's a query
+      $or: [
+        // id was pasted in
+        { id: search },
+        // user's current name
+        { name: search },
+        // user's current display name
+        { displayName: search }
+      ]
+    };
+    const [total, players, exactResult] = await Promise.all([
+      this.stores.players.count(query),
+      this.stores.players.find(query).sort({ [sort]: direction }).skip(count * page).limit(count).exec(),
+      // exact match detection
+      search.length > 0 && page === 0 ? this.stores.players.find(exactQuery) : []
+    ]);
+    if (exactResult.length > 0) {
+      for (const res of exactResult) {
+        const index = players.findIndex((p) => p._id === res._id);
+        players.splice(index, 1);
+      }
+      players.splice(0, 0, ...exactResult);
     }
-    // add a user to the visit history, returns true if this is a first visit
-    async addVisit(user) {
-        const existing = await this.stores.players.findOne({
-            type: 'userHistory',
-            id: user.id,
-        });
-        const now = Date.now();
-        const instanceId = await this.getInstanceId();
-        if (!existing) {
-            // create the player
-            // TODO: add some form of admin note tool for moderators to leave notes
-            // on troublesome players + warnings
-            await this.stores.players.insert({
-                type: 'userHistory',
-                // base brickadia user info
-                id: user.id,
+    return {
+      pages: Math.ceil(total / count),
+      total,
+      players
+    };
+  }
+  // get paginated users
+  async getUsers({
+    count = 50,
+    search = "",
+    page = 0,
+    sort = "name",
+    direction = "1"
+  } = {}) {
+    const pattern$1 = pattern.explode(search);
+    const query = {
+      type: "user",
+      // only filter if there's a query
+      ...search.length > 0 ? {
+        $or: [
+          // id was pasted in
+          { playerId: search },
+          // user's current name
+          { name: { $regex: pattern$1 } }
+        ]
+      } : {}
+    };
+    const [total, users] = await Promise.all([
+      this.stores.users.count(query),
+      this.stores.users.find(query).sort({ [sort]: direction }).skip(count * page).limit(count).exec()
+    ]);
+    return {
+      pages: Math.ceil(total / count),
+      total,
+      users
+    };
+  }
+  // get an individual player, ban and kick history, and notes
+  async getPlayer(id) {
+    const [player, banHistory, kickHistory, notes] = await Promise.all([
+      this.stores.players.findOne({ type: "userHistory", id }),
+      this.stores.players.find({ type: "banHistory", banned: id }).sort({ created: -1 }).limit(25).exec(),
+      this.stores.players.find({ type: "kickHistory", kicked: id }).sort({ created: -1 }).limit(25).exec(),
+      this.stores.players.find({ type: "note", id }).sort({ created: -1 }).limit(25).exec()
+    ]);
+    if (!player) return null;
+    return { ...player, banHistory, kickHistory, notes };
+  }
+  // add a user to the visit history, returns true if this is a first visit
+  async addVisit(user) {
+    const existing = await this.stores.players.findOne({
+      type: "userHistory",
+      id: user.id
+    });
+    const now = Date.now();
+    const instanceId = await this.getInstanceId();
+    if (!existing) {
+      await this.stores.players.insert({
+        type: "userHistory",
+        // base brickadia user info
+        id: user.id,
+        name: user.name,
+        displayName: user.displayName,
+        // list of names and when they were first used
+        nameHistory: [
+          { name: user.name, displayName: user.displayName, date: now }
+        ],
+        // list of ips this player has been on
+        ips: [],
+        // first time player was seen
+        created: now,
+        // last time player was seen
+        lastSeen: now,
+        // last server this player has been on
+        lastInstanceId: instanceId,
+        // number of status checks this player has observed
+        heartbeats: 0,
+        // number of sessions (at least an hour apart) this player has had
+        sessions: 1,
+        // number of instances (times omegga was started) this player has joined
+        instances: 1
+      });
+      return true;
+    } else {
+      await this.stores.players.update(
+        { _id: existing._id },
+        {
+          $inc: {
+            // increment number of sessions if the player hasn't been seen for an hour
+            sessions: existing.lastSeen < now - 60 * 60 * 1e3 ? 1 : 0,
+            // increment the number of instances this player has joined
+            instances: existing.lastInstanceId === instanceId ? 1 : 0
+          },
+          $set: {
+            // update last seen time and user name
+            lastSeen: now,
+            name: user.name,
+            displayName: user.displayName,
+            // set the last joined instance
+            lastInstanceId: instanceId
+          },
+          // add the name to the history if it was not already in it
+          ...existing.nameHistory.some(
+            (h) => h.name === user.name && h.displayName === user.displayName
+          ) ? {} : {
+            $addToSet: {
+              nameHistory: {
                 name: user.name,
                 displayName: user.displayName,
-                // list of names and when they were first used
-                nameHistory: [
-                    { name: user.name, displayName: user.displayName, date: now },
-                ],
-                // list of ips this player has been on
-                ips: [],
-                // first time player was seen
-                created: now,
-                // last time player was seen
-                lastSeen: now,
-                // last server this player has been on
-                lastInstanceId: instanceId,
-                // number of status checks this player has observed
-                heartbeats: 0,
-                // number of sessions (at least an hour apart) this player has had
-                sessions: 1,
-                // number of instances (times omegga was started) this player has joined
-                instances: 1,
-            });
-            return true;
-        }
-        else {
-            await this.stores.players.update({ _id: existing._id }, {
-                $inc: {
-                    // increment number of sessions if the player hasn't been seen for an hour
-                    sessions: existing.lastSeen < now - 60 * 60 * 1000 ? 1 : 0,
-                    // increment the number of instances this player has joined
-                    instances: existing.lastInstanceId === instanceId ? 1 : 0,
-                },
-                $set: {
-                    // update last seen time and user name
-                    lastSeen: now,
-                    name: user.name,
-                    displayName: user.displayName,
-                    // set the last joined instance
-                    lastInstanceId: instanceId,
-                },
-                // add the name to the history if it was not already in it
-                ...(existing.nameHistory.some(h => h.name === user.name && h.displayName === user.displayName)
-                    ? {}
-                    : {
-                        $addToSet: {
-                            nameHistory: {
-                                name: user.name,
-                                displayName: user.displayName,
-                                date: now,
-                            },
-                        },
-                    }),
-            });
-            return false;
-        }
-    }
-    // use data from minutely heartbeats to fuel metrics
-    async addHeartbeat(data) {
-        const now = Date.now();
-        // add the heartbeat to the server status store
-        await this.stores.status.insert({
-            type: 'heartbeat',
-            created: now,
-            bricks: data.bricks,
-            players: data.players,
-        });
-        // update player heartbeats and last seens
-        await this.stores.players.update({
-            // all players in the status update
-            id: { $in: data.players },
-        }, {
-            // update last seen
-            $set: { lastSeen: now },
-            // increment heartbeats
-            $inc: { heartbeats: 1 },
-        }, { multi: true });
-        // get all players in the status update
-        const players = await this.stores.players.find({
-            id: { $in: data.players },
-        });
-        await Promise.all(players
-            // find players without the discovered ip
-            .filter(p => !(p.ips || []).includes(data.ips[p.id]))
-            // insert the IP into the player's ip list
-            .map(p => this.stores.players.update({ _id: p._id }, {
-            $addToSet: { ips: data.ips[p.id] },
-        })));
-    }
-    async getAutoRestartConfig() {
-        var _a, _b, _c;
-        let config = await this.stores.server.findOne({
-            type: 'autoRestartConfig',
-        });
-        if (!config) {
-            config = await this.stores.server.insert({
-                type: 'autoRestartConfig',
-                maxUptime: 48,
-                maxUptimeEnabled: false,
-                emptyUptime: 24,
-                emptyUptimeEnabled: false,
-                dailyHour: 2,
-                dailyHourEnabled: false,
-                autoUpdateEnabled: true,
-                autoUpdateIntervalMins: 60,
-                announcementEnabled: true,
-                playersEnabled: true,
-                saveWorld: true,
-            });
+                date: now
+              }
+            }
+          }
         }
-        (_a = config.autoUpdateEnabled) !== null && _a !== void 0 ? _a : (config.autoUpdateEnabled = true);
-        (_b = config.autoUpdateIntervalMins) !== null && _b !== void 0 ? _b : (config.autoUpdateIntervalMins = 60);
-        (_c = config.saveWorld) !== null && _c !== void 0 ? _c : (config.saveWorld = true);
-        return config;
+      );
+      return false;
     }
-    async setAutoRestartConfig(config) {
-        var _a, _b;
-        config.maxUptime = Math.round(Math.max(1, Math.min(config.maxUptime, 168)));
-        config.emptyUptime = Math.round(Math.max(1, Math.min(config.emptyUptime, 168)));
-        config.dailyHour = Math.round(Math.max(0, Math.min(config.dailyHour, 23)));
-        config.autoUpdateIntervalMins = Math.round(Math.max(10, Math.min((_a = config.autoUpdateIntervalMins) !== null && _a !== void 0 ? _a : 60, Infinity)));
-        (_b = config.autoUpdateEnabled) !== null && _b !== void 0 ? _b : (config.autoUpdateEnabled = true);
-        await this.stores.server.update({ type: 'autoRestartConfig' }, {
-            $set: {
-                ...config,
-            },
-        }, { upsert: false });
+  }
+  // use data from minutely heartbeats to fuel metrics
+  async addHeartbeat(data) {
+    const now = Date.now();
+    await this.stores.status.insert({
+      type: "heartbeat",
+      created: now,
+      bricks: data.bricks,
+      players: data.players
+    });
+    await this.stores.players.update(
+      {
+        // all players in the status update
+        id: { $in: data.players }
+      },
+      {
+        // update last seen
+        $set: { lastSeen: now },
+        // increment heartbeats
+        $inc: { heartbeats: 1 }
+      },
+      { multi: true }
+    );
+    const players = await this.stores.players.find({
+      id: { $in: data.players }
+    });
+    await Promise.all(
+      players.filter((p) => !(p.ips || []).includes(data.ips[p.id])).map(
+        (p) => this.stores.players.update(
+          { _id: p._id },
+          {
+            $addToSet: { ips: data.ips[p.id] }
+          }
+        )
+      )
+    );
+  }
+  async getAutoRestartConfig() {
+    let config = await this.stores.server.findOne({
+      type: "autoRestartConfig"
+    });
+    if (!config) {
+      config = await this.stores.server.insert({
+        type: "autoRestartConfig",
+        maxUptime: 48,
+        maxUptimeEnabled: false,
+        emptyUptime: 24,
+        emptyUptimeEnabled: false,
+        dailyHour: 2,
+        dailyHourEnabled: false,
+        autoUpdateEnabled: true,
+        autoUpdateIntervalMins: 60,
+        announcementEnabled: true,
+        playersEnabled: true,
+        saveWorld: true
+      });
     }
-    // update player online-time punchcard
-    async updatePlayerPunchcard(numNewPlayers) {
-        // get date, utc hour, and utc day
-        const now = new Date();
-        const time = now.getTime();
-        const hour = now.getUTCHours();
-        const day = now.getUTCDay();
-        const month = now.getUTCMonth();
-        const year = now.getUTCFullYear();
-        // find the punchcard
-        const card = await this.stores.status.findOne({
-            type: 'punchcard',
-            kind: 'playerCount',
-            month,
-            year,
-        });
-        // create a new punchcard if one does not exist for this month
-        if (!card) {
-            const punchcard = createPunchcard();
-            punchcard[day][hour] = numNewPlayers;
-            // insert it
-            await this.stores.status.insert({
-                type: 'punchcard',
-                kind: 'playerCount',
-                created: time,
-                updated: time,
-                month,
-                year,
-                punchcard,
-            });
-            // if the card exists, check if it was already updated this hour
+    config.autoUpdateEnabled ??= true;
+    config.autoUpdateIntervalMins ??= 60;
+    config.saveWorld ??= true;
+    return config;
+  }
+  async setAutoRestartConfig(config) {
+    config.maxUptime = Math.round(Math.max(1, Math.min(config.maxUptime, 168)));
+    config.emptyUptime = Math.round(
+      Math.max(1, Math.min(config.emptyUptime, 168))
+    );
+    config.dailyHour = Math.round(Math.max(0, Math.min(config.dailyHour, 23)));
+    config.autoUpdateIntervalMins = Math.round(
+      Math.max(10, Math.min(config.autoUpdateIntervalMins ?? 60, Infinity))
+    );
+    config.autoUpdateEnabled ??= true;
+    await this.stores.server.update(
+      { type: "autoRestartConfig" },
+      {
+        $set: {
+          ...config
         }
-        else {
-            // add the players to this slot
-            card.punchcard[day][hour] += numNewPlayers;
-            // update the punchcard
-            await this.stores.status.update({ _id: card._id }, {
-                $set: {
-                    punchcard: card.punchcard,
-                    updated: time,
-                },
-            });
+      },
+      { upsert: false }
+    );
+  }
+  // update player online-time punchcard
+  async updatePlayerPunchcard(numNewPlayers) {
+    const now = /* @__PURE__ */ new Date();
+    const time2 = now.getTime();
+    const hour = now.getUTCHours();
+    const day = now.getUTCDay();
+    const month = now.getUTCMonth();
+    const year = now.getUTCFullYear();
+    const card = await this.stores.status.findOne({
+      type: "punchcard",
+      kind: "playerCount",
+      month,
+      year
+    });
+    if (!card) {
+      const punchcard = createPunchcard();
+      punchcard[day][hour] = numNewPlayers;
+      await this.stores.status.insert({
+        type: "punchcard",
+        kind: "playerCount",
+        created: time2,
+        updated: time2,
+        month,
+        year,
+        punchcard
+      });
+    } else {
+      card.punchcard[day][hour] += numNewPlayers;
+      await this.stores.status.update(
+        { _id: card._id },
+        {
+          $set: {
+            punchcard: card.punchcard,
+            updated: time2
+          }
         }
+      );
     }
+  }
 }
 exports.default = Database;
-//# sourceMappingURL=database.js.map
+//# sourceMappingURL=database.js.map