@takaro/db 0.0.0-next.09a7ca1

package/src/migrations/sql/20250707205720-items-permissions-missing.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex('permission').insert([
+    {
+      permission: 'READ_ITEMS',
+      description: 'Can view item details',
+      friendlyName: 'Read Items',
+    },
+    {
+      permission: 'MANAGE_ITEMS',
+      description: 'Can create, update, and delete items',
+      friendlyName: 'Manage Items',
+    },
+  ]);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex('permission').whereIn('permission', ['READ_ITEMS', 'MANAGE_ITEMS']).del();
+}

package/src/migrations/sql/20250708095623-command-required-permissions.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('commands', (table) => {
+    table.jsonb('requiredPermissions').defaultTo('[]').notNullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropColumn('requiredPermissions');
+  });
+}

package/src/migrations/sql/20250710131445-add-shop-categories.ts

@@ -0,0 +1,98 @@
+import { Knex } from 'knex';
+
+const SHOP_CATEGORY_TABLE_NAME = 'shopCategory';
+const SHOP_LISTING_CATEGORY_TABLE_NAME = 'shopListingCategory';
+
+const DEFAULT_CATEGORIES = [
+  { name: 'Weapons', emoji: '⚔️' },
+  { name: 'Armor', emoji: '🛡️' },
+  { name: 'Building', emoji: '🏗️' },
+  { name: 'Tools', emoji: '🔧' },
+  { name: 'Consumables', emoji: '💊' },
+  { name: 'Resources', emoji: '📦' },
+  { name: 'Base', emoji: '🏠' },
+  { name: 'Vehicles', emoji: '🚗' },
+];
+
+export async function up(knex: Knex): Promise<void> {
+  // Create shopCategory table (hierarchical categories)
+  await knex.schema.createTable(SHOP_CATEGORY_TABLE_NAME, (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+    table.string('name', 50).notNullable();
+    table.string('emoji', 10).notNullable();
+    table.uuid('parentId').nullable();
+
+    // Add self-referencing foreign key for parent category
+    table.foreign('parentId').references('id').inTable(SHOP_CATEGORY_TABLE_NAME).onDelete('SET NULL');
+
+    // Indexes for performance
+    table.index('domain');
+    table.index('parentId');
+    table.index(['domain', 'name']);
+  });
+
+  // Add case-insensitive unique constraint on domain + name
+  await knex.raw(`
+    CREATE UNIQUE INDEX shopCategory_domain_name_unique 
+    ON "${SHOP_CATEGORY_TABLE_NAME}" ("domain", LOWER("name"))
+  `);
+
+  // Create shopListingCategory junction table (many-to-many)
+  await knex.schema.createTable(SHOP_LISTING_CATEGORY_TABLE_NAME, (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+    table.uuid('shopListingId').references('shopListing.id').onDelete('CASCADE').notNullable();
+    table.uuid('shopCategoryId').references('shopCategory.id').onDelete('CASCADE').notNullable();
+
+    // Indexes for performance
+    table.index('domain');
+    table.index('shopListingId');
+    table.index('shopCategoryId');
+    table.index(['shopListingId', 'shopCategoryId']);
+
+    // Ensure a listing can only be in a category once
+    table.unique(['shopListingId', 'shopCategoryId']);
+  });
+
+  // Insert default categories for all existing domains
+  const domains = await knex('domains').select('id');
+
+  for (const domain of domains) {
+    const categoriesToInsert = DEFAULT_CATEGORIES.map((cat) => ({
+      ...cat,
+      domain: domain.id,
+      parentId: null,
+    }));
+
+    // Insert categories, ignoring duplicates (in case some domains already have categories with these names)
+    for (const category of categoriesToInsert) {
+      const existing = await knex(SHOP_CATEGORY_TABLE_NAME)
+        .where('domain', category.domain)
+        .where('name', category.name)
+        .whereNull('parentId')
+        .first();
+
+      if (!existing) {
+        await knex(SHOP_CATEGORY_TABLE_NAME).insert(category);
+      }
+    }
+  }
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Remove default categories from all domains
+  await knex(SHOP_CATEGORY_TABLE_NAME)
+    .whereIn(
+      'name',
+      DEFAULT_CATEGORIES.map((c) => c.name),
+    )
+    .whereNull('parentId')
+    .delete();
+
+  // Drop tables in reverse dependency order
+  await knex.schema.dropTable(SHOP_LISTING_CATEGORY_TABLE_NAME);
+  await knex.schema.dropTable(SHOP_CATEGORY_TABLE_NAME);
+}

package/src/migrations/sql/20250718-fix-player-inventory-history-pk.ts

@@ -0,0 +1,161 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // First, drop the primary key constraint from the parent table
+  await knex.raw(`
+    ALTER TABLE "playerInventoryHistory" 
+    DROP CONSTRAINT IF EXISTS "playerInventoryHistory_pkey"
+  `);
+
+  // Get all existing partitions and drop their primary key constraints
+  const partitions = await knex.raw(`
+    SELECT 
+      inhrelid::regclass AS partition_name
+    FROM pg_inherits
+    WHERE inhparent = '"playerInventoryHistory"'::regclass
+  `);
+
+  for (const partition of partitions.rows) {
+    // partition_name already includes schema, need to extract just the table name
+    const fullName = partition.partition_name;
+    const partitionName = fullName.includes('.')
+      ? fullName.split('.').pop().replace(/"/g, '')
+      : fullName.replace(/"/g, '');
+    await knex.raw(`
+      ALTER TABLE "${partitionName}" 
+      DROP CONSTRAINT IF EXISTS "${partitionName}_pkey"
+    `);
+  }
+
+  // Create a regular (non-unique) composite index for query performance
+  // This replaces the primary key constraint functionality for lookups
+  await knex.raw(`
+    CREATE INDEX IF NOT EXISTS "playerInventoryHistory_createdAt_playerId_itemId_idx" 
+    ON "playerInventoryHistory" ("createdAt", "playerId", "itemId")
+  `);
+
+  // Update the partition creation function to not include the composite primary key
+  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;
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Drop the new index
+  await knex.raw(`
+    DROP INDEX IF EXISTS "playerInventoryHistory_createdAt_playerId_itemId_idx"
+  `);
+
+  // No need to drop any primary key since we didn't add one in the up migration
+
+  // Restore the original composite primary key on the parent table
+  await knex.raw(`
+    ALTER TABLE "playerInventoryHistory" 
+    ADD CONSTRAINT "playerInventoryHistory_pkey" PRIMARY KEY ("createdAt", "playerId", "itemId")
+  `);
+
+  // Get all existing partitions and restore their primary key constraints
+  const partitions = await knex.raw(`
+    SELECT 
+      inhrelid::regclass AS partition_name
+    FROM pg_inherits
+    WHERE inhparent = '"playerInventoryHistory"'::regclass
+  `);
+
+  for (const partition of partitions.rows) {
+    // partition_name already includes schema, need to extract just the table name
+    const fullName = partition.partition_name;
+    const partitionName = fullName.includes('.')
+      ? fullName.split('.').pop().replace(/"/g, '')
+      : fullName.replace(/"/g, '');
+    await knex.raw(`
+      ALTER TABLE "${partitionName}" 
+      ADD CONSTRAINT "${partitionName}_pkey" PRIMARY KEY ("createdAt", "playerId", "itemId")
+    `);
+  }
+
+  // Restore the original partition creation function with the composite primary key
+  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;
+  `);
+}

package/src/migrations/sql/20250719160409-add-module-author-supportedgames.ts

@@ -0,0 +1,31 @@
+import { Knex } from 'knex';
+
+/**
+ * This migration adds author and supportedGames fields to the modules table
+ * @param knex
+ */
+
+export async function up(knex: Knex): Promise<void> {
+  // Add author column
+  await knex.schema.alterTable('modules', (table) => {
+    table.string('author').nullable();
+  });
+
+  // Add supportedGames column as JSON array
+  await knex.schema.alterTable('modules', (table) => {
+    table.json('supportedGames').defaultTo('["all"]');
+  });
+
+  // Update existing modules to have default values
+  await knex('modules').update({
+    author: 'Unknown',
+    supportedGames: JSON.stringify(['all']),
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('modules', (table) => {
+    table.dropColumn('author');
+    table.dropColumn('supportedGames');
+  });
+}

package/src/migrations/sql/20250719175542-add-discord-permissions.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex('permission').insert([
+    {
+      permission: 'VIEW_DISCORD_INFO',
+      description: 'Can view Discord guild information including channels and roles',
+      friendlyName: 'View Discord Info',
+    },
+    {
+      permission: 'SEND_DISCORD_MESSAGE',
+      description: 'Can send messages to Discord channels',
+      friendlyName: 'Send Discord Messages',
+    },
+  ]);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex('permission').whereIn('permission', ['VIEW_DISCORD_INFO', 'SEND_DISCORD_MESSAGE']).del();
+}

package/src/migrations/sql/20250726000000-discord-role-sync.ts

@@ -0,0 +1,15 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Add linkedDiscordRoleId to roles table
+  await knex.schema.alterTable('roles', (table) => {
+    table.string('linkedDiscordRoleId').nullable();
+    table.index('linkedDiscordRoleId');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('roles', (table) => {
+    table.dropColumn('linkedDiscordRoleId');
+  });
+}

package/src/migrations/sql/20250727092719-add-quality-to-inventory.ts

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

package/src/migrations/sql/20250802124307-add-playeriphistory-composite-index.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerIpHistory', (table) => {
+    table.index(['domain', 'playerId', 'createdAt'], 'idx_playeriphistory_domain_playerid_createdat');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerIpHistory', (table) => {
+    table.dropIndex([], 'idx_playeriphistory_domain_playerid_createdat');
+  });
+}

package/src/migrations/sql/20250809122020-add-player-name-history.ts

@@ -0,0 +1,31 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('playerNameHistory', (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('players.id').onDelete('CASCADE').notNullable();
+    table.uuid('gameServerId').references('gameservers.id').onDelete('SET NULL').nullable();
+    table.string('name').notNullable();
+
+    // Indexes for performance
+    table.index(['playerId', 'createdAt'], 'idx_player_name_history_player_created');
+    table.index('name', 'idx_player_name_history_name');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Update players table with latest name from history before dropping
+  const latestNames = await knex('playerNameHistory')
+    .select('playerId', 'name')
+    .distinctOn('playerId')
+    .orderBy('playerId')
+    .orderBy('createdAt', 'desc');
+
+  for (const record of latestNames) {
+    await knex('players').where('id', record.playerId).update({ name: record.name });
+  }
+
+  await knex.schema.dropTable('playerNameHistory');
+}

package/src/migrations/sql/20250812163648-add-kpi-performance-indexes.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Add index for playerOnGameServer activity queries (DAU/WAU/MAU)
+  await knex.schema.raw(`
+    CREATE INDEX IF NOT EXISTS idx_pog_domain_lastseen 
+    ON "playerOnGameServer"(domain, "lastSeen" DESC)
+  `);
+
+  // Add index for user activity queries
+  await knex.schema.raw(`
+    CREATE INDEX IF NOT EXISTS idx_users_domain_lastseen
+    ON users(domain, "lastSeen" DESC)
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.raw('DROP INDEX IF EXISTS idx_pog_domain_lastseen');
+  await knex.schema.raw('DROP INDEX IF EXISTS idx_users_domain_lastseen');
+}

package/src/migrations/sql/20250814163747-shop-order-cascade-delete.ts

@@ -0,0 +1,27 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(`
+    ALTER TABLE "shopOrder" 
+    DROP CONSTRAINT IF EXISTS shoporder_playerid_foreign;
+  `);
+
+  await knex.raw(`
+    ALTER TABLE "shopOrder" 
+    ADD CONSTRAINT shoporder_playerid_foreign 
+    FOREIGN KEY ("playerId") REFERENCES players(id) ON DELETE CASCADE;
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw(`
+    ALTER TABLE "shopOrder" 
+    DROP CONSTRAINT IF EXISTS shoporder_playerid_foreign;
+  `);
+
+  await knex.raw(`
+    ALTER TABLE "shopOrder" 
+    ADD CONSTRAINT shoporder_playerid_foreign 
+    FOREIGN KEY ("playerId") REFERENCES players(id) ON DELETE NO ACTION;
+  `);
+}

package/src/migrations/sql/20250815120000-optimize-shop-analytics-indexes.ts

@@ -0,0 +1,46 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Index for filtering orders by domain, status, and date range
+  await knex.raw(`
+    CREATE INDEX IF NOT EXISTS idx_shoporder_analytics 
+    ON "shopOrder" (domain, status, "createdAt")
+    WHERE status IN ('COMPLETED', 'PAID')
+  `);
+
+  // Index for joining orders with listings and filtering by date
+  await knex.raw(`
+    CREATE INDEX IF NOT EXISTS idx_shoporder_listing_date 
+    ON "shopOrder" ("listingId", "createdAt")
+    WHERE status IN ('COMPLETED', 'PAID')
+  `);
+
+  // Index for customer analytics (unique players)
+  await knex.raw(`
+    CREATE INDEX IF NOT EXISTS idx_shoporder_player_analytics 
+    ON "shopOrder" (domain, "playerId", "createdAt")
+    WHERE status IN ('COMPLETED', 'PAID')
+  `);
+
+  // Composite index for shop listings to speed up joins
+  await knex.raw(`
+    CREATE INDEX IF NOT EXISTS idx_shoplisting_composite 
+    ON "shopListing" (id, "gameServerId", price)
+    WHERE "deletedAt" IS NULL AND draft = false
+  `);
+
+  // Index for filtering listings by game server and active status
+  await knex.raw(`
+    CREATE INDEX IF NOT EXISTS idx_shoplisting_active 
+    ON "shopListing" (domain, "gameServerId")
+    WHERE "deletedAt" IS NULL AND draft = false
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw('DROP INDEX IF EXISTS idx_shoporder_analytics');
+  await knex.raw('DROP INDEX IF EXISTS idx_shoporder_listing_date');
+  await knex.raw('DROP INDEX IF EXISTS idx_shoporder_player_analytics');
+  await knex.raw('DROP INDEX IF EXISTS idx_shoplisting_composite');
+  await knex.raw('DROP INDEX IF EXISTS idx_shoplisting_active');
+}

package/src/migrations/sql/20251014120000-shop-order-auto-cancel-on-listing-delete.ts

@@ -0,0 +1,75 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Step 1: Create trigger function that auto-cancels orders when listing is deleted
+  await knex.raw(`
+    CREATE OR REPLACE FUNCTION cancel_orders_on_listing_delete()
+    RETURNS TRIGGER AS $$
+    BEGIN
+      -- Only proceed if deletedAt changed from NULL to a value (soft-delete)
+      IF OLD."deletedAt" IS NULL AND NEW."deletedAt" IS NOT NULL THEN
+        -- Cancel all PAID orders for this listing and refund currency
+        -- Aggregate refunds by player to handle multiple orders correctly
+        WITH orders_to_cancel AS (
+          SELECT
+            so.id AS order_id,
+            so."playerId",
+            NEW."gameServerId",
+            NEW.domain AS domain,
+            NEW.price * so.amount AS refund_amount
+          FROM "shopOrder" so
+          WHERE so."listingId" = NEW.id
+            AND so.status = 'PAID'
+        ),
+        aggregated_refunds AS (
+          SELECT
+            "playerId",
+            "gameServerId",
+            domain,
+            SUM(refund_amount) AS total_refund
+          FROM orders_to_cancel
+          GROUP BY "playerId", "gameServerId", domain
+        )
+        -- Update playerOnGameServer currency with aggregated total
+        UPDATE "playerOnGameServer" pogs
+        SET currency = pogs.currency + ar.total_refund
+        FROM aggregated_refunds ar
+        WHERE pogs."playerId" = ar."playerId"
+          AND pogs."gameServerId" = ar."gameServerId"
+          AND pogs.domain = ar.domain;
+
+        -- Update order status to CANCELED
+        UPDATE "shopOrder"
+        SET status = 'CANCELED'
+        WHERE "listingId" = NEW.id
+          AND status = 'PAID';
+      END IF;
+
+      RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+
+  // Step 2: Create trigger on shopListing table
+  await knex.raw(`
+    CREATE TRIGGER auto_cancel_orders_on_listing_delete
+    AFTER UPDATE ON "shopListing"
+    FOR EACH ROW
+    WHEN (OLD."deletedAt" IS NULL AND NEW."deletedAt" IS NOT NULL)
+    EXECUTE FUNCTION cancel_orders_on_listing_delete();
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Drop trigger
+  await knex.raw(`
+    DROP TRIGGER IF EXISTS auto_cancel_orders_on_listing_delete ON "shopListing";
+  `);
+
+  // Drop function
+  await knex.raw(`
+    DROP FUNCTION IF EXISTS cancel_orders_on_listing_delete();
+  `);
+
+  // Note: We don't reverse the data cleanup since those were genuinely bad orders
+}

package/src/migrations/sql/20251101000000-add-deleted-domain-state.ts

@@ -0,0 +1,43 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // PostgreSQL requires a multi-step process to update enum constraints
+  // 1. Add a temporary column with the new enum values
+  // 2. Copy data from old column to new column
+  // 3. Drop old column
+  // 4. Rename new column to old column name
+
+  await knex.schema.alterTable('domains', (table) => {
+    table.enum('state_new', ['ACTIVE', 'DISABLED', 'MAINTENANCE', 'DELETED']).notNullable().defaultTo('ACTIVE');
+  });
+
+  await knex.raw(`UPDATE domains SET state_new = state::text::varchar`);
+
+  await knex.schema.alterTable('domains', (table) => {
+    table.dropColumn('state');
+  });
+
+  await knex.schema.alterTable('domains', (table) => {
+    table.renameColumn('state_new', 'state');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Revert to the original enum values (removing DELETED)
+  // First, ensure no domains are in DELETED state (or this will fail)
+  await knex.raw(`DELETE FROM domains WHERE state = 'DELETED'`);
+
+  await knex.schema.alterTable('domains', (table) => {
+    table.enum('state_new', ['ACTIVE', 'DISABLED', 'MAINTENANCE']).notNullable().defaultTo('ACTIVE');
+  });
+
+  await knex.raw(`UPDATE domains SET state_new = state::text::varchar`);
+
+  await knex.schema.alterTable('domains', (table) => {
+    table.dropColumn('state');
+  });
+
+  await knex.schema.alterTable('domains', (table) => {
+    table.renameColumn('state_new', 'state');
+  });
+}

package/src/migrations/sql/20251108214824-unique-player-per-server.ts

@@ -0,0 +1,30 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Delete duplicate rows where the same playerId has multiple different gameIds on the same server
+  // This violates the business rule that each player should have exactly one POG per server
+  // Keep the oldest POG (lowest id) for each (playerId, gameServerId) pair
+  await knex.raw(`
+    DELETE FROM "playerOnGameServer"
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id,
+               ROW_NUMBER() OVER (PARTITION BY "playerId", "gameServerId" ORDER BY id) as rnk
+        FROM "playerOnGameServer"
+      ) t
+      WHERE t.rnk > 1
+    )
+  `);
+
+  // Add unique constraint to prevent one player from having multiple POGs on the same server
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.unique(['playerId', 'gameServerId']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropUnique(['playerId', 'gameServerId']);
+  });
+}