@takaro/db 0.0.0-next.0da151e

package/src/migrations/sql/20231118082301-add-new-permissions.ts

@@ -0,0 +1,200 @@
+import { Knex } from 'knex';
+
+export enum PERMISSIONS {
+  'ROOT' = 'ROOT',
+  'MANAGE_USERS' = 'MANAGE_USERS',
+  'READ_USERS' = 'READ_USERS',
+  'MANAGE_ROLES' = 'MANAGE_ROLES',
+  'READ_ROLES' = 'READ_ROLES',
+  'MANAGE_GAMESERVERS' = 'MANAGE_GAMESERVERS',
+  'READ_GAMESERVERS' = 'READ_GAMESERVERS',
+  'READ_FUNCTIONS' = 'READ_FUNCTIONS',
+  'MANAGE_FUNCTIONS' = 'MANAGE_FUNCTIONS',
+  'READ_CRONJOBS' = 'READ_CRONJOBS',
+  'MANAGE_CRONJOBS' = 'MANAGE_CRONJOBS',
+  'READ_HOOKS' = 'READ_HOOKS',
+  'MANAGE_HOOKS' = 'MANAGE_HOOKS',
+  'READ_COMMANDS' = 'READ_COMMANDS',
+  'MANAGE_COMMANDS' = 'MANAGE_COMMANDS',
+  'READ_MODULES' = 'READ_MODULES',
+  'MANAGE_MODULES' = 'MANAGE_MODULES',
+  'READ_PLAYERS' = 'READ_PLAYERS',
+  'MANAGE_PLAYERS' = 'MANAGE_PLAYERS',
+  'MANAGE_SETTINGS' = 'MANAGE_SETTINGS',
+  'READ_SETTINGS' = 'READ_SETTINGS',
+  'READ_VARIABLES' = 'READ_VARIABLES',
+  'MANAGE_VARIABLES' = 'MANAGE_VARIABLES',
+  'READ_EVENTS' = 'READ_EVENTS',
+  'MANAGE_EVENTS' = 'MANAGE_EVENTS',
+}
+
+export interface IPermissionDetails {
+  permission: string;
+  friendlyName: string;
+  description: string;
+}
+
+export const PERMISSION_DETAILS: Record<PERMISSIONS, IPermissionDetails> = {
+  [PERMISSIONS.ROOT]: {
+    permission: PERMISSIONS.ROOT,
+    friendlyName: 'Root Access',
+    description: 'Full access to all systems and resources',
+  },
+  [PERMISSIONS.MANAGE_USERS]: {
+    permission: PERMISSIONS.MANAGE_USERS,
+    friendlyName: 'Manage Users',
+    description: 'Can create, update, and delete users',
+  },
+  [PERMISSIONS.READ_USERS]: {
+    permission: PERMISSIONS.READ_USERS,
+    friendlyName: 'Read Users',
+    description: 'Can view user details',
+  },
+  [PERMISSIONS.MANAGE_ROLES]: {
+    permission: PERMISSIONS.MANAGE_ROLES,
+    friendlyName: 'Manage Roles',
+    description: 'Can create, update, and delete roles',
+  },
+  [PERMISSIONS.READ_ROLES]: {
+    permission: PERMISSIONS.READ_ROLES,
+    friendlyName: 'Read Roles',
+    description: 'Can view role details',
+  },
+  [PERMISSIONS.MANAGE_GAMESERVERS]: {
+    permission: PERMISSIONS.MANAGE_GAMESERVERS,
+    friendlyName: 'Manage Game Servers',
+    description: 'Can create, update, and delete game servers',
+  },
+  [PERMISSIONS.READ_GAMESERVERS]: {
+    permission: PERMISSIONS.READ_GAMESERVERS,
+    friendlyName: 'Read Game Servers',
+    description: 'Can view game server details',
+  },
+  [PERMISSIONS.READ_FUNCTIONS]: {
+    permission: PERMISSIONS.READ_FUNCTIONS,
+    friendlyName: 'Read Functions',
+    description: 'Can view function details',
+  },
+  [PERMISSIONS.MANAGE_FUNCTIONS]: {
+    permission: PERMISSIONS.MANAGE_FUNCTIONS,
+    friendlyName: 'Manage Functions',
+    description: 'Can create, update, and delete functions',
+  },
+  [PERMISSIONS.READ_CRONJOBS]: {
+    permission: PERMISSIONS.READ_CRONJOBS,
+    friendlyName: 'Read Cron Jobs',
+    description: 'Can view cron job details',
+  },
+  [PERMISSIONS.MANAGE_CRONJOBS]: {
+    permission: PERMISSIONS.MANAGE_CRONJOBS,
+    friendlyName: 'Manage Cron Jobs',
+    description: 'Can create, update, and delete cron jobs',
+  },
+  [PERMISSIONS.READ_HOOKS]: {
+    permission: PERMISSIONS.READ_HOOKS,
+    friendlyName: 'Read Hooks',
+    description: 'Can view hook details',
+  },
+  [PERMISSIONS.MANAGE_HOOKS]: {
+    permission: PERMISSIONS.MANAGE_HOOKS,
+    friendlyName: 'Manage Hooks',
+    description: 'Can create, update, and delete hooks',
+  },
+  [PERMISSIONS.READ_COMMANDS]: {
+    permission: PERMISSIONS.READ_COMMANDS,
+    friendlyName: 'Read Commands',
+    description: 'Can view command details',
+  },
+  [PERMISSIONS.MANAGE_COMMANDS]: {
+    permission: PERMISSIONS.MANAGE_COMMANDS,
+    friendlyName: 'Manage Commands',
+    description: 'Can create, update, and delete commands',
+  },
+  [PERMISSIONS.READ_MODULES]: {
+    permission: PERMISSIONS.READ_MODULES,
+    friendlyName: 'Read Modules',
+    description: 'Can view module details',
+  },
+  [PERMISSIONS.MANAGE_MODULES]: {
+    permission: PERMISSIONS.MANAGE_MODULES,
+    friendlyName: 'Manage Modules',
+    description: 'Can create, update, and delete modules',
+  },
+  [PERMISSIONS.READ_PLAYERS]: {
+    permission: PERMISSIONS.READ_PLAYERS,
+    friendlyName: 'Read Players',
+    description: 'Can view player details',
+  },
+  [PERMISSIONS.MANAGE_PLAYERS]: {
+    permission: PERMISSIONS.MANAGE_PLAYERS,
+    friendlyName: 'Manage Players',
+    description: 'Can create, update, and delete players',
+  },
+  [PERMISSIONS.MANAGE_SETTINGS]: {
+    permission: PERMISSIONS.MANAGE_SETTINGS,
+    friendlyName: 'Manage Settings',
+    description: 'Can modify settings',
+  },
+  [PERMISSIONS.READ_SETTINGS]: {
+    permission: PERMISSIONS.READ_SETTINGS,
+    friendlyName: 'Read Settings',
+    description: 'Can view settings',
+  },
+  [PERMISSIONS.READ_VARIABLES]: {
+    permission: PERMISSIONS.READ_VARIABLES,
+    friendlyName: 'Read Variables',
+    description: 'Can view variables',
+  },
+  [PERMISSIONS.MANAGE_VARIABLES]: {
+    permission: PERMISSIONS.MANAGE_VARIABLES,
+    friendlyName: 'Manage Variables',
+    description: 'Can create, update, and delete variables',
+  },
+  [PERMISSIONS.READ_EVENTS]: {
+    permission: PERMISSIONS.READ_EVENTS,
+    friendlyName: 'Read Events',
+    description: 'Can view event details',
+  },
+  [PERMISSIONS.MANAGE_EVENTS]: {
+    permission: PERMISSIONS.MANAGE_EVENTS,
+    friendlyName: 'Manage Events',
+    description: 'Can create, update, and delete events',
+  },
+};
+
+export async function up(knex: Knex): Promise<void> {
+  // For all system permissions, find the record in the DB
+  // And update the description and friendly name
+
+  const permissions = Object.values(PERMISSIONS);
+
+  for (const permission of permissions) {
+    const details = PERMISSION_DETAILS[permission];
+    await knex('permission').where({ permission }).update({
+      description: details.description,
+      friendlyName: details.friendlyName,
+    });
+  }
+
+  // get permissions from the DB
+  const existingPermissions = await knex('permission').select('permission');
+
+  // filter out existing permissions
+  const newPermissions = permissions.filter((permission) => {
+    return !existingPermissions.find((existing) => existing.permission === permission);
+  });
+
+  // add new permissions
+  for (const permission of newPermissions) {
+    await knex('permission').insert({
+      permission: permission,
+      friendlyName: PERMISSION_DETAILS[permission].friendlyName,
+      description: PERMISSION_DETAILS[permission].description,
+    });
+  }
+}
+
+export async function down(_knex: Knex): Promise<void> {
+  // For all system permissions, find the record in the DB
+  // And update the description and friendly name
+}

package/src/migrations/sql/20231119115037-timedRoles.ts

@@ -0,0 +1,23 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('roleOnPlayer', (table) => {
+    table.timestamp('expiresAt').nullable();
+  });
+
+  await knex.schema.alterTable('roleOnUser', (table) => {
+    table.timestamp('expiresAt').nullable();
+    table.uuid('id').defaultTo(knex.raw('gen_random_uuid ()'));
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('roleOnPlayer', (table) => {
+    table.dropColumn('expiresAt');
+  });
+
+  await knex.schema.alterTable('roleOnUser', (table) => {
+    table.dropColumn('expiresAt');
+    table.dropColumn('id');
+  });
+}

package/src/migrations/sql/20231123150854-economy-base.ts

@@ -0,0 +1,15 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.integer('currency').defaultTo(0);
+    table.check('currency >= 0', [], 'currency_positive');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropChecks('currency_positive');
+    table.dropColumn('currency');
+  });
+}

package/src/migrations/sql/20231123171611-economy-settings.ts

@@ -0,0 +1,15 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('settings', (table) => {
+    table.string('economyEnabled').defaultTo('false');
+    table.string('currencyName').defaultTo('Takaro coins');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropColumn('economyEnabled');
+    table.dropColumn('currencyName');
+  });
+}

package/src/migrations/sql/20231124140441-json-module-assignments.ts

@@ -0,0 +1,29 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Change moduleAssignments.systemConfig from json to jsonb
+  await knex.raw(`
+  ALTER TABLE "moduleAssignments"
+  ALTER COLUMN "systemConfig" TYPE jsonb USING "systemConfig"::jsonb;
+`);
+
+  // same for userConfig
+  await knex.raw(`
+  ALTER TABLE "moduleAssignments"
+  ALTER COLUMN "userConfig" TYPE jsonb USING "userConfig"::jsonb;
+`);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Change moduleAssignments.systemConfig from jsonb to json
+  await knex.raw(`
+  ALTER TABLE "moduleAssignments"
+  ALTER COLUMN "systemConfig" TYPE json USING "systemConfig"::json;
+`);
+
+  // same for userConfig
+  await knex.raw(`
+  ALTER TABLE "moduleAssignments"
+  ALTER COLUMN "userConfig" TYPE json USING "userConfig"::json;
+`);
+}

package/src/migrations/sql/20231208114507-settings-refactor.ts

@@ -0,0 +1,114 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('new_settings', (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('id').inTable('gameservers').onDelete('CASCADE');
+    table.string('key').notNullable();
+    table.string('value').notNullable();
+    // Setting key should be unique with gameServerId
+    table.unique(['domain', 'key', 'gameServerId']);
+  });
+
+  // Migrate data from settings to new_settings
+  const settings = await knex.select('*').from('settings');
+
+  for (const setting of settings) {
+    const domain = setting.domain;
+    for (const [key, value] of Object.entries(setting)) {
+      if (key !== 'id' && key !== 'createdAt' && key !== 'updatedAt' && key !== 'domain') {
+        const existing = await knex.select('*').from('new_settings').where({ key, domain }).first();
+
+        if (existing) {
+          continue;
+        }
+
+        await knex('new_settings').insert({
+          key,
+          value: String(value),
+          domain,
+        });
+      }
+    }
+  }
+
+  const gameServerSettings = await knex.select('*').from('gameServerSettings');
+
+  for (const setting of gameServerSettings) {
+    const gameServerId = setting.gameServerId;
+    const domain = setting.domain;
+
+    for (const [key, value] of Object.entries(setting)) {
+      if (key !== 'id' && key !== 'createdAt' && key !== 'updatedAt' && key !== 'gameServerId' && key !== 'domain') {
+        const existing = await knex.select('*').from('new_settings').where({ key, domain, gameServerId }).first();
+
+        if (existing) {
+          continue;
+        }
+
+        await knex('new_settings').insert({
+          key,
+          value: String(value),
+          gameServerId,
+          domain,
+        });
+      }
+    }
+  }
+
+  await knex.schema.dropTable('gameServerSettings');
+  await knex.schema.dropTable('settings');
+  await knex.schema.renameTable('new_settings', 'settings');
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.renameTable('settings', 'new_settings');
+  await knex.schema.createTable('settings', (table) => {
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('key').notNullable();
+    table.string('value').notNullable();
+    table.timestamps(true, true);
+  });
+
+  await knex.schema.createTable('gameServerSettings', (table) => {
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.uuid('gameServerId').references('id').inTable('gameservers').onDelete('CASCADE');
+    table.string('key').notNullable();
+    table.string('value').notNullable();
+    table.timestamps(true, true);
+  });
+
+  // Migrate data from new_settings to settings
+  const settings = await knex.select('*').from('new_settings');
+
+  for (const setting of settings) {
+    for (const [key, value] of Object.entries(setting)) {
+      if (key !== 'id' && key !== 'createdAt' && key !== 'updatedAt') {
+        await knex('settings').insert({
+          key,
+          value: String(value),
+        });
+      }
+    }
+  }
+
+  const gameServerSettings = await knex.select('*').from('new_settings').whereNotNull('gameServerId');
+
+  for (const setting of gameServerSettings) {
+    const gameServerId = setting.gameServerId;
+
+    for (const [key, value] of Object.entries(setting)) {
+      if (key !== 'id' && key !== 'createdAt' && key !== 'updatedAt' && key !== 'gameServerId') {
+        await knex('gameServerSettings').insert({
+          key,
+          value: String(value),
+          gameServerId,
+        });
+      }
+    }
+  }
+
+  await knex.schema.dropTable('new_settings');
+}

package/src/migrations/sql/20231208171234-game-items.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('items', (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.text('icon').nullable();
+    // Add index on code since we'll use that in queries a lot
+    table.index('code');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('items');
+}

package/src/migrations/sql/20231216100720-player-inventory.ts

@@ -0,0 +1,16 @@
+import { Knex } from 'knex';
+
+export async function up(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();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('playerInventory');
+}

package/src/migrations/sql/20231222180438-steam-data.ts

@@ -0,0 +1,27 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('players', (table) => {
+    table.string('steamAvatar').nullable();
+    table.timestamp('steamLastFetch').nullable();
+    table.timestamp('steamAccountCreated').nullable();
+    table.boolean('steamCommunityBanned').nullable();
+    table.string('steamEconomyBan').nullable();
+    table.boolean('steamVacBanned').nullable();
+    table.string('steamsDaysSinceLastBan').nullable();
+    table.string('steamNumberOfVACBans').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('players', (table) => {
+    table.dropColumn('steamAvatar');
+    table.dropColumn('steamLastFetch');
+    table.dropColumn('steamAccountCreated');
+    table.dropColumn('steamCommunityBanned');
+    table.dropColumn('steamEconomyBan');
+    table.dropColumn('steamVacBanned');
+    table.dropColumn('steamsDaysSinceLastBan');
+    table.dropColumn('steamNumberOfVACBans');
+  });
+}

package/src/migrations/sql/20231223132631-pog-online.ts

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

package/src/migrations/sql/20231223212031-unique-index-item-def.ts

@@ -0,0 +1,27 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Delete duplicates while keeping the first occurrence
+  await knex.raw(`
+    DELETE FROM items
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id,
+               ROW_NUMBER() OVER (PARTITION BY code, "gameserverId", domain ORDER BY id) as rnk
+        FROM items
+      ) t
+      WHERE t.rnk > 1
+    )
+  `);
+
+  await knex.schema.alterTable('items', (table) => {
+    table.unique(['code', 'gameserverId', 'domain']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('items', (table) => {
+    table.dropUnique(['code', 'gameserverId', 'domain']);
+  });
+}

package/src/migrations/sql/20231224135126-gameserver-online-status.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('gameservers', (table) => {
+    table.boolean('reachable').defaultTo(true);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('gameservers', (table) => {
+    table.dropColumn('reachable');
+  });
+}

package/src/migrations/sql/20231224155226-unique-pog.ts

@@ -0,0 +1,27 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Delete duplicate rows first
+  await knex.raw(`
+    DELETE FROM "playerOnGameServer"
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id,
+               ROW_NUMBER() OVER (PARTITION BY "gameId", "gameServerId" ORDER BY id) as rnk
+        FROM "playerOnGameServer"
+      ) t
+      WHERE t.rnk > 1
+    )
+  `);
+
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.unique(['gameId', 'gameServerId']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropUnique(['gameId', 'gameServerId']);
+  });
+}

package/src/migrations/sql/20231225140650-extra-ip-info.ts

@@ -0,0 +1,27 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropColumn('ip');
+  });
+
+  await knex.schema.createTable('playerOnGameServerIp', (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('pogId').references('playerOnGameServer.id').onDelete('CASCADE').notNullable();
+    table.specificType('ip', 'inet').notNullable();
+    table.string('country');
+    table.string('city');
+    table.string('longitude');
+    table.string('latitude');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('playerOnGameServerIp');
+
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.specificType('ip', 'inet').nullable();
+  });
+}

package/src/migrations/sql/20231227144315-unique-constraints-player.ts

@@ -0,0 +1,74 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Delete any duplicate rows first
+  // Retain the record where createdAt is the oldest
+  await knex.raw(`
+    DELETE FROM "players"
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id,
+               ROW_NUMBER() OVER (PARTITION BY domain, "steamId" ORDER BY "createdAt") as rnk
+        FROM "players"
+        WHERE "steamId" IS NOT NULL
+      ) t
+      WHERE t.rnk > 1
+    )
+  `);
+
+  // Also for epicOnlineServicesId
+  await knex.raw(`
+    DELETE FROM "players"
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id,
+               ROW_NUMBER() OVER (PARTITION BY domain, "epicOnlineServicesId" ORDER BY "createdAt") as rnk
+        FROM "players"
+        WHERE "epicOnlineServicesId" IS NOT NULL
+      ) t
+      WHERE t.rnk > 1
+    )
+  `);
+
+  // And xbox
+  await knex.raw(`
+    DELETE FROM "players"
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id,
+               ROW_NUMBER() OVER (PARTITION BY domain, "xboxLiveId" ORDER BY "createdAt") as rnk
+        FROM "players"
+        WHERE "xboxLiveId" IS NOT NULL
+      ) t
+      WHERE t.rnk > 1
+    )
+  `);
+
+  await knex.schema.alterTable('players', (table) => {
+    table.unique(['domain', 'steamId']);
+    table.unique(['domain', 'epicOnlineServicesId']);
+    table.unique(['domain', 'xboxLiveId']);
+  });
+
+  await knex.raw(`
+  ALTER TABLE players
+  ADD CONSTRAINT players_domain_steam_xbox_eos_unique
+  UNIQUE NULLS NOT DISTINCT (domain, "steamId", "xboxLiveId", "epicOnlineServicesId");
+`);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('players', (table) => {
+    table.dropUnique(['domain', 'steamId']);
+    table.dropUnique(['domain', 'epicOnlineServicesId']);
+    table.dropUnique(['domain', 'xboxLiveId']);
+  });
+
+  await knex.raw(`
+    ALTER TABLE players
+    DROP CONSTRAINT players_domain_steam_xbox_eos_unique;
+  `);
+}

package/src/migrations/sql/20231229144707-more-player-constraints.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Find all players that have epicOnlineServicesId starting with EOS_ and delete them
+  await knex.raw(`
+    DELETE FROM "players"
+    WHERE "epicOnlineServicesId" LIKE 'EOS_%'
+  `);
+
+  await knex.schema.alterTable('players', (table) => {
+    // epicOnlineServicesId is always 32 chars
+    table.string('epicOnlineServicesId', 32).alter();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('players', (table) => {
+    table.string('epicOnlineServicesId', 255).alter();
+  });
+}