@takaro/db 0.0.0-next.0da151e

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');
+  });
+}

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;
+  `);
+}