@takaro/db 0.0.0-next.09a7ca1

package/src/migrations/sql/20250305210650-more-module-metadata.ts

@@ -0,0 +1,49 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('hooks', (table) => {
+    table.text('description').nullable();
+  });
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.text('description').nullable();
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.text('description').nullable();
+  });
+
+  await knex.schema.alterTable('functions', (table) => {
+    table.text('description').nullable();
+  });
+
+  await knex.raw('ALTER TABLE hooks ADD CONSTRAINT description_length_check CHECK (length(description) <= 131072)');
+  await knex.raw('ALTER TABLE commands ADD CONSTRAINT description_length_check CHECK (length(description) <= 131072)');
+  await knex.raw(
+    'ALTER TABLE "cronJobs" ADD CONSTRAINT description_length_check CHECK (length(description) <= 131072)',
+  );
+  await knex.raw('ALTER TABLE functions ADD CONSTRAINT description_length_check CHECK (length(description) <= 131072)');
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw('ALTER TABLE hooks DROP CONSTRAINT description_length_check');
+  await knex.raw('ALTER TABLE commands DROP CONSTRAINT description_length_check');
+  await knex.raw('ALTER TABLE "cronJobs" DROP CONSTRAINT description_length_check');
+  await knex.raw('ALTER TABLE functions DROP CONSTRAINT description_length_check');
+
+  await knex.schema.alterTable('hooks', (table) => {
+    table.dropColumn('description');
+  });
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropColumn('description');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.dropColumn('description');
+  });
+
+  await knex.schema.alterTable('functions', (table) => {
+    table.dropColumn('description');
+  });
+}

package/src/migrations/sql/20250307162855-default-systemconfig.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('moduleVersions', (table) => {
+    table.jsonb('defaultSystemConfig').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('moduleVersions', (table) => {
+    table.dropColumn('defaultSystemConfig');
+  });
+}

package/src/migrations/sql/20250312184104-unique-external-reference.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.unique(['externalReference']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.dropUnique(['externalReference']);
+  });
+}

package/src/migrations/sql/20250314185501-root-users-not-dashboard-user.ts

@@ -0,0 +1,17 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(`
+    UPDATE users
+    SET "isDashboardUser" = false
+    WHERE name = 'root'
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw(`
+    UPDATE users
+    SET "isDashboardUser" = true
+    WHERE name = 'root'
+  `);
+}

package/src/migrations/sql/20250315191707-fix-constraint-module-items.ts

@@ -0,0 +1,26 @@
+import { Knex } from 'knex';
+
+/**
+ * This migration ensures that all commands,hooks,cronjobs have a unique name inside their module version
+ * @param knex
+ */
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(
+    `ALTER TABLE "commands" ADD CONSTRAINT "commands_unique_name_versionId" UNIQUE ("name", "versionId");`,
+  );
+  await knex.raw(`ALTER TABLE "hooks" ADD CONSTRAINT "hooks_unique_name_versionId" UNIQUE ("name", "versionId");`);
+  await knex.raw(
+    `ALTER TABLE "cronJobs" ADD CONSTRAINT "cronJobs_unique_name_versionId" UNIQUE ("name", "versionId");`,
+  );
+  await knex.raw(
+    `ALTER TABLE "functions" ADD CONSTRAINT "functions_unique_name_versionId" UNIQUE ("name", "versionId");`,
+  );
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw(`ALTER TABLE "commands" DROP CONSTRAINT "commands_unique_name_versionId";`);
+  await knex.raw(`ALTER TABLE "hooks" DROP CONSTRAINT "hooks_unique_name_versionId";`);
+  await knex.raw(`ALTER TABLE "cronJobs" DROP CONSTRAINT "cronJobs_unique_name_versionId";`);
+  await knex.raw(`ALTER TABLE "functions" DROP CONSTRAINT "functions_unique_name_versionId";`);
+}

package/src/migrations/sql/20250519185149-add-item-indexes.ts

@@ -0,0 +1,42 @@
+import { Knex } from 'knex';
+
+/**
+ * These indexes singificantly improve performance of the gameserver delete operation
+ * CREATE INDEX idx_itemonshoplisting_itemid ON "itemOnShopListing" ("itemId");
+ * CREATE INDEX idx_playerinventory_itemid ON "playerInventory" ("itemId");
+ * CREATE INDEX idx_playeriphistory_gameserverid ON "playerIpHistory" ("gameServerId");
+ * CREATE INDEX idx_shoplisting_gameserverid ON "shopListing" ("gameServerId");
+ *
+ * @param knex
+ */
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema
+    .alterTable('itemOnShopListing', (table) => {
+      table.index(['itemId'], 'idx_itemonshoplisting_itemid');
+    })
+    .alterTable('playerInventory', (table) => {
+      table.index(['itemId'], 'idx_playerinventory_itemid');
+    })
+    .alterTable('playerIpHistory', (table) => {
+      table.index(['gameServerId'], 'idx_playeriphistory_gameserverid');
+    })
+    .alterTable('shopListing', (table) => {
+      table.index(['gameServerId'], 'idx_shoplisting_gameserverid');
+    });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema
+    .alterTable('itemOnShopListing', (table) => {
+      table.dropIndex([], 'idx_itemonshoplisting_itemid');
+    })
+    .alterTable('playerInventory', (table) => {
+      table.dropIndex([], 'idx_playerinventory_itemid');
+    })
+    .alterTable('playerIpHistory', (table) => {
+      table.dropIndex([], 'idx_playeriphistory_gameserverid');
+    })
+    .alterTable('shopListing', (table) => {
+      table.dropIndex([], 'idx_shoplisting_gameserverid');
+    });
+}

package/src/migrations/sql/20250524054924-tracking.ts

@@ -0,0 +1,79 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Create partitioned table using raw SQL since Knex doesn't have native partition support
+  await knex.raw(`
+    CREATE TABLE "playerLocation" (
+      id UUID DEFAULT gen_random_uuid() NOT NULL,
+      "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP NOT NULL,
+      "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP NOT NULL,
+      domain VARCHAR(255) NOT NULL,
+      "playerId" UUID NOT NULL,
+      x NUMERIC(10,3) NOT NULL,
+      y NUMERIC(10,3) NOT NULL,
+      z NUMERIC(10,3) NOT NULL,
+      CONSTRAINT "playerLocation_pkey" PRIMARY KEY ("createdAt", "playerId"),
+      CONSTRAINT "playerLocation_domain_foreign" FOREIGN KEY (domain) REFERENCES domains(id) ON DELETE CASCADE,
+      CONSTRAINT "playerLocation_playerId_foreign" FOREIGN KEY ("playerId") REFERENCES "playerOnGameServer"(id) ON DELETE CASCADE
+    ) PARTITION BY RANGE ("createdAt")
+  `);
+
+  // Create function to ensure partition exists for given date
+  await knex.raw(`
+    CREATE OR REPLACE FUNCTION ensure_player_location_partition(date_param VARCHAR DEFAULT NULL)
+    RETURNS VOID AS $$
+    DECLARE
+      current_day_start DATE;
+      next_day_start DATE;
+      partition_name TEXT;
+      partition_exists BOOLEAN;
+      target_date DATE;
+    BEGIN
+      -- Parse date parameter or use current date
+      IF date_param IS NOT NULL THEN
+        target_date := DATE(date_param::TIMESTAMP);
+      ELSE
+        target_date := CURRENT_DATE;
+      END IF;
+      
+      -- Calculate day boundaries for target date
+      current_day_start := DATE_TRUNC('day', target_date);
+      next_day_start := current_day_start + INTERVAL '1 day';
+      
+      -- Generate partition name (format: playerLocation_YYYY_MM_DD)
+      partition_name := 'playerLocation_' || TO_CHAR(current_day_start, 'YYYY_MM_DD');
+      
+      -- Check if partition exists
+      SELECT EXISTS (
+        SELECT 1 FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = partition_name
+          AND n.nspname = 'public'
+      ) INTO partition_exists;
+      
+      -- Create partition if it doesn't exist
+      IF NOT partition_exists THEN
+        EXECUTE format(
+          'CREATE TABLE %I PARTITION OF "playerLocation"
+           FOR VALUES FROM (%L) TO (%L)',
+          partition_name,
+          current_day_start,
+          next_day_start
+        );
+        
+        RAISE NOTICE 'Created partition: % for date: %',
+          partition_name, current_day_start;
+      END IF;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+
+  // Create indexes
+  await knex.raw(`CREATE INDEX "playerLocation_domain_createdAt_idx" ON "playerLocation" (domain, "createdAt")`);
+  await knex.raw(`CREATE INDEX "playerLocation_playerId_idx" ON "playerLocation" ("playerId")`);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw('DROP FUNCTION IF EXISTS ensure_player_location_partition(VARCHAR)');
+  await knex.raw('DROP TABLE IF EXISTS "playerLocation" CASCADE');
+}

package/src/migrations/sql/20250525135204-ban-reason-length.ts

@@ -0,0 +1,35 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('bans', (table) => {
+    table.text('reason').alter();
+  });
+
+  await knex.raw(`
+    CREATE OR REPLACE FUNCTION truncate_reason()
+    RETURNS TRIGGER AS $$
+    BEGIN
+      IF char_length(NEW.reason) > 10000 THEN
+        NEW.reason = left(NEW.reason, 10000);
+      END IF;
+      RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+
+  await knex.raw(`
+    CREATE TRIGGER truncate_reason_trigger
+      BEFORE INSERT OR UPDATE ON "bans"
+      FOR EACH ROW
+      EXECUTE FUNCTION truncate_reason();
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw('DROP TRIGGER IF EXISTS truncate_reason_trigger ON "bans"');
+  await knex.raw('DROP FUNCTION IF EXISTS truncate_reason()');
+
+  await knex.schema.alterTable('bans', (table) => {
+    table.string('reason', 255).alter();
+  });
+}

package/src/migrations/sql/20250605201140-shop-permissions-missing.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex('permission').insert([
+    {
+      permission: 'MANAGE_SHOP_LISTINGS',
+      description: 'Manage shop listings',
+      friendlyName: 'Manage Shop Listings',
+    },
+    {
+      permission: 'MANAGE_SHOP_ORDERS',
+      description: 'Manage shop orders, allowing administrative actions on orders not belonging to the user',
+      friendlyName: 'Manage Shop Orders',
+    },
+  ]);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex('permission').whereIn('permission', ['MANAGE_SHOP_LISTINGS', 'MANAGE_SHOP_ORDERS']).del();
+}

package/src/migrations/sql/20250606060546-inventory-tracking.ts

@@ -0,0 +1,96 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(`
+    CREATE TABLE "playerInventoryHistory" (
+      id UUID DEFAULT gen_random_uuid() NOT NULL,
+      "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP NOT NULL,
+      "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP NOT NULL,
+      domain VARCHAR(255) NOT NULL,
+      "playerId" UUID NOT NULL,
+      "itemId" UUID NOT NULL,
+      quantity INTEGER NOT NULL,
+      CONSTRAINT "playerInventoryHistory_pkey" PRIMARY KEY ("createdAt", "playerId", "itemId"),
+      CONSTRAINT "playerInventoryHistory_domain_foreign" FOREIGN KEY (domain) REFERENCES domains(id) ON DELETE CASCADE,
+      CONSTRAINT "playerInventoryHistory_playerId_foreign" FOREIGN KEY ("playerId") REFERENCES "playerOnGameServer"(id) ON DELETE CASCADE,
+      CONSTRAINT "playerInventoryHistory_itemId_foreign" FOREIGN KEY ("itemId") REFERENCES items(id) ON DELETE CASCADE,
+      CONSTRAINT "playerInventoryHistory_quantity_check" CHECK (quantity >= 0)
+    ) PARTITION BY RANGE ("createdAt")
+  `);
+
+  await knex.raw(`
+    CREATE OR REPLACE FUNCTION ensure_player_inventory_history_partition(date_param VARCHAR DEFAULT NULL)
+    RETURNS VOID AS $$
+    DECLARE
+      current_day_start DATE;
+      next_day_start DATE;
+      partition_name TEXT;
+      partition_exists BOOLEAN;
+      target_date DATE;
+    BEGIN
+      IF date_param IS NOT NULL THEN
+        target_date := DATE(date_param::TIMESTAMP);
+      ELSE
+        target_date := CURRENT_DATE;
+      END IF;
+      
+      current_day_start := DATE_TRUNC('day', target_date);
+      next_day_start := current_day_start + INTERVAL '1 day';
+      
+      partition_name := 'playerInventoryHistory_' || TO_CHAR(current_day_start, 'YYYY_MM_DD');
+      
+      SELECT EXISTS (
+        SELECT 1 FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = partition_name
+          AND n.nspname = 'public'
+      ) INTO partition_exists;
+      
+      IF NOT partition_exists THEN
+        EXECUTE format(
+          'CREATE TABLE %I PARTITION OF "playerInventoryHistory"
+           FOR VALUES FROM (%L) TO (%L)',
+          partition_name,
+          current_day_start,
+          next_day_start
+        );
+        
+        RAISE NOTICE 'Created partition: % for date: %',
+          partition_name, current_day_start;
+      END IF;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+
+  await knex.raw(
+    `CREATE INDEX "playerInventoryHistory_domain_createdAt_idx" ON "playerInventoryHistory" (domain, "createdAt")`,
+  );
+  await knex.raw(`CREATE INDEX "playerInventoryHistory_playerId_idx" ON "playerInventoryHistory" ("playerId")`);
+  await knex.raw(`CREATE INDEX "playerInventoryHistory_itemId_idx" ON "playerInventoryHistory" ("itemId")`);
+  await knex.raw(
+    `CREATE INDEX "playerInventoryHistory_playerId_createdAt_idx" ON "playerInventoryHistory" ("playerId", "createdAt" DESC)`,
+  );
+  await knex.raw(
+    `CREATE INDEX "playerInventoryHistory_itemId_createdAt_idx" ON "playerInventoryHistory" ("itemId", "createdAt" DESC)`,
+  );
+  await knex.raw(
+    `CREATE INDEX "playerInventoryHistory_domain_itemId_createdAt_idx" ON "playerInventoryHistory" (domain, "itemId", "createdAt" DESC)`,
+  );
+
+  // Delete the old playerInventory table
+  await knex.raw('DROP TABLE IF EXISTS "playerInventory" CASCADE');
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.createTable('playerInventory', (table) => {
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.timestamps(true, true, true);
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+    table.uuid('playerId').references('playerOnGameServer.id').onDelete('CASCADE').notNullable();
+    table.uuid('itemId').references('items.id').onDelete('CASCADE').notNullable();
+    table.integer('quantity').notNullable();
+  });
+
+  await knex.raw('DROP FUNCTION IF EXISTS ensure_player_inventory_history_partition(VARCHAR)');
+  await knex.raw('DROP TABLE IF EXISTS "playerInventoryHistory" CASCADE');
+}

package/src/migrations/sql/20250613110835-add-platform-id-to-players.ts

@@ -0,0 +1,51 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Add platformId column to players table
+  await knex.schema.alterTable('players', (table) => {
+    table.string('platformId').nullable();
+  });
+
+  // Add unique constraint for domain + platformId
+  await knex.schema.alterTable('players', (table) => {
+    table.unique(['domain', 'platformId']);
+  });
+
+  // Drop the existing unique constraint
+  await knex.raw(`
+    ALTER TABLE players
+    DROP CONSTRAINT players_domain_steam_xbox_eos_unique;
+  `);
+
+  // Add new unique constraint that includes platformId
+  await knex.raw(`
+    ALTER TABLE players
+    ADD CONSTRAINT players_domain_steam_xbox_eos_platform_unique
+    UNIQUE NULLS NOT DISTINCT (domain, "steamId", "xboxLiveId", "epicOnlineServicesId", "platformId");
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Drop the new unique constraint
+  await knex.raw(`
+    ALTER TABLE players
+    DROP CONSTRAINT players_domain_steam_xbox_eos_platform_unique;
+  `);
+
+  // Drop the individual platformId unique constraint
+  await knex.schema.alterTable('players', (table) => {
+    table.dropUnique(['domain', 'platformId']);
+  });
+
+  // Remove platformId column
+  await knex.schema.alterTable('players', (table) => {
+    table.dropColumn('platformId');
+  });
+
+  // Re-add the original unique constraint
+  await knex.raw(`
+    ALTER TABLE players
+    ADD CONSTRAINT players_domain_steam_xbox_eos_unique
+    UNIQUE NULLS NOT DISTINCT (domain, "steamId", "xboxLiveId", "epicOnlineServicesId");
+  `);
+}

package/src/migrations/sql/20250613203142-add-dimension-to-position.ts

@@ -0,0 +1,25 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Add dimension column to playerOnGameServer table
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.string('dimension').nullable();
+  });
+
+  // Add dimension column to playerLocation table
+  await knex.schema.alterTable('playerLocation', (table) => {
+    table.string('dimension').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Remove dimension column from playerOnGameServer table
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropColumn('dimension');
+  });
+
+  // Remove dimension column from playerLocation table
+  await knex.schema.alterTable('playerLocation', (table) => {
+    table.dropColumn('dimension');
+  });
+}

package/src/migrations/sql/20250614113157-entities.ts

@@ -0,0 +1,40 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('entities', (table) => {
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.timestamps(true, true, true);
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+    table.uuid('gameserverId').references('gameservers.id').onDelete('CASCADE').notNullable();
+    table.string('name').notNullable();
+    table.string('code').notNullable();
+    table.text('description').nullable();
+    table.enum('type', ['hostile', 'friendly', 'neutral']).nullable();
+    table.jsonb('metadata').nullable();
+    // Add index on code since we'll use that in queries a lot
+    table.index('code');
+    // Add unique constraint to prevent duplicates
+    table.unique(['code', 'gameserverId', 'domain']);
+  });
+
+  // Insert entity permissions
+  await knex('permission').insert([
+    {
+      permission: 'READ_ENTITIES',
+      description: 'Can view entity details',
+      friendlyName: 'Read Entities',
+    },
+    {
+      permission: 'MANAGE_ENTITIES',
+      description: 'Can create, update, and delete entities',
+      friendlyName: 'Manage Entities',
+    },
+  ]);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Remove entity permissions
+  await knex('permission').whereIn('permission', ['READ_ENTITIES', 'MANAGE_ENTITIES']).del();
+
+  await knex.schema.dropTable('entities');
+}

package/src/migrations/sql/20250629090822-player-query-performance-indices.ts

@@ -0,0 +1,38 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Create optimized indices for the slow player count query:
+  // SELECT COUNT(DISTINCT players.id)
+  // FROM players
+  // INNER JOIN playerOnGameServer ON playerOnGameServer.playerId = players.id
+  // WHERE players.domain = $1 AND playerOnGameServer.lastSeen > $2
+
+  // Primary optimization: Composite index on playerOnGameServer for efficient join + filter
+  // This allows PostgreSQL to use the index for both the JOIN and WHERE clause
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.index(['playerId', 'lastSeen'], 'idx_playerongameserver_playerid_lastseen');
+  });
+
+  // Secondary optimization: Index on players.domain for the WHERE clause
+  await knex.schema.alterTable('players', (table) => {
+    table.index(['domain'], 'idx_players_domain');
+  });
+
+  // Covering index on players(domain, id) to avoid table lookups after index scan
+  await knex.schema.alterTable('players', (table) => {
+    table.index(['domain', 'id'], 'idx_players_domain_id');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Drop all indices created in the up function
+
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropIndex([], 'idx_playerongameserver_playerid_lastseen');
+  });
+
+  await knex.schema.alterTable('players', (table) => {
+    table.dropIndex([], 'idx_players_domain');
+    table.dropIndex([], 'idx_players_domain_id');
+  });
+}

package/src/migrations/sql/20250701-command-query-performance-indices.ts

@@ -0,0 +1,53 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Optimize the getTriggeredCommands query performance
+  // The query joins multiple tables and performs complex JSONB operations
+
+  // 1. Case-insensitive index on commands.trigger for efficient trigger matching
+  // This allows the LOWER(commands.trigger) = ? condition to use an index
+  await knex.raw('CREATE INDEX idx_commands_trigger_lower ON commands (LOWER(trigger))');
+
+  // 2. Index on moduleInstallations.gameserverId for efficient filtering
+  // The query filters by gameserverId through the join chain
+  await knex.schema.alterTable('moduleInstallations', (table) => {
+    table.index(['gameserverId'], 'idx_moduleinstallations_gameserverid');
+  });
+
+  // 3. Index on moduleInstallations.versionId for join optimization
+  // This helps the join between moduleInstallations and moduleVersions
+  await knex.schema.alterTable('moduleInstallations', (table) => {
+    table.index(['versionId'], 'idx_moduleinstallations_versionid');
+  });
+
+  // 4. GIN index on moduleInstallations.systemConfig for JSONB queries
+  // This optimizes the complex EXISTS subquery that searches command aliases
+  await knex.raw(`
+    CREATE INDEX idx_moduleinstallations_systemconfig_commands_gin 
+    ON "moduleInstallations" 
+    USING gin (("systemConfig" -> 'commands'))
+  `);
+
+  // 5. Composite index on commands for better join performance
+  // This helps when joining from moduleVersions to commands
+  await knex.schema.alterTable('commands', (table) => {
+    table.index(['versionId', 'domain'], 'idx_commands_versionid_domain');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Drop all indices created in the up function
+
+  await knex.raw('DROP INDEX IF EXISTS idx_commands_trigger_lower');
+
+  await knex.schema.alterTable('moduleInstallations', (table) => {
+    table.dropIndex([], 'idx_moduleinstallations_gameserverid');
+    table.dropIndex([], 'idx_moduleinstallations_versionid');
+  });
+
+  await knex.raw('DROP INDEX IF EXISTS idx_moduleinstallations_systemconfig_commands_gin');
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropIndex([], 'idx_commands_versionid_domain');
+  });
+}

package/src/migrations/sql/20250702181214-platform-id-and-pog-indexes.ts

@@ -0,0 +1,31 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Add indexes for platform ID lookups in resolveRef
+  await knex.schema.alterTable('players', (table) => {
+    table.index(['domain', 'steamId'], 'idx_players_domain_steamid');
+    table.index(['domain', 'epicOnlineServicesId'], 'idx_players_domain_epiconlineservicesid');
+    table.index(['domain', 'xboxLiveId'], 'idx_players_domain_xboxliveid');
+    table.index(['domain', 'platformId'], 'idx_players_domain_platformid');
+  });
+
+  // Add composite index for playerOnGameServer findAssociations query
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.index(['domain', 'gameId', 'gameServerId'], 'idx_pog_domain_gameid_gameserverid');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Drop platform ID indexes
+  await knex.schema.alterTable('players', (table) => {
+    table.dropIndex([], 'idx_players_domain_steamid');
+    table.dropIndex([], 'idx_players_domain_epiconlineservicesid');
+    table.dropIndex([], 'idx_players_domain_xboxliveid');
+    table.dropIndex([], 'idx_players_domain_platformid');
+  });
+
+  // Drop playerOnGameServer composite index
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropIndex([], 'idx_pog_domain_gameid_gameserverid');
+  });
+}

package/src/migrations/sql/20250703175326-add-ip-to-player-on-gameserver.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.string('ip').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropColumn('ip');
+  });
+}