@takaro/db 0.0.0-next.0da151e

package/src/migrations/sql/20240908185212-domain-name-not-unique.ts

@@ -0,0 +1,12 @@
+import ms from 'ms';
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.dropUnique(['name'], 'domains_name_unique');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // None, this is a one-way migration
+}

package/src/migrations/sql/20240922110414-player-playtime.ts

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

package/src/migrations/sql/20240922133738-add-bans.ts

@@ -0,0 +1,25 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('bans', (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.index('domain');
+
+    table.uuid('gameServerId').references('gameservers.id').onDelete('CASCADE').notNullable();
+    table.uuid('playerId').references('players.id').onDelete('CASCADE').notNullable();
+    // PlayerId and gameServerId should be unique combined
+    table.unique(['playerId', 'gameServerId']);
+
+    table.boolean('takaroManaged').notNullable();
+    table.boolean('isGlobal').notNullable().defaultTo(false);
+
+    table.timestamp('until').nullable();
+    table.string('reason').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('bans');
+}

package/src/migrations/sql/20240929090313-global-playtime.ts

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

package/src/migrations/sql/20240929143849-player-name-null.ts

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

package/src/migrations/sql/20241012183754-shop-orders-belong-to-player.ts

@@ -0,0 +1,44 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('shopOrder', (table) => {
+    table.uuid('playerId').references('id').inTable('players');
+  });
+
+  // Migrate existing userId values to playerId by looking up the playerId from users
+  const shopOrders = await knex('shopOrder').select('id', 'userId');
+  for (const order of shopOrders) {
+    const user = await knex('users').where('id', order.userId).first();
+    if (user && user.playerId) {
+      await knex('shopOrder').where('id', order.id).update('playerId', user.playerId);
+    }
+  }
+
+  await knex.schema.alterTable('shopOrder', (table) => {
+    table.dropColumn('userId');
+    table.uuid('playerId').notNullable().alter();
+    table.index('playerId');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Add userId column back to the shopOrder table
+  await knex.schema.alterTable('shopOrder', (table) => {
+    table.uuid('userId').references('id').inTable('users');
+  });
+
+  // Migrate playerId values back to userId by looking up the user from players
+  const shopOrders = await knex('shopOrder').select('id', 'playerId');
+  for (const order of shopOrders) {
+    const player = await knex('players').where('id', order.playerId).first();
+    if (player) {
+      await knex('shopOrder').where('id', order.id).update('userId', player.id);
+    }
+  }
+
+  // Drop playerId column
+  await knex.schema.alterTable('shopOrder', (table) => {
+    table.dropColumn('playerId');
+    table.uuid('userId').notNullable().alter();
+  });
+}

package/src/migrations/sql/20241013173159-add-indexen-for-moduleId.ts

@@ -0,0 +1,57 @@
+import { Knex } from 'knex';
+
+// This follows some research done with https://github.com/ankane/pghero
+
+export async function up(knex: Knex): Promise<void> {
+  // Remove duplicate indexes
+  await knex.schema.alterTable('events', (table) => {
+    table.dropIndex('domain', 'events_domain_index');
+  });
+  await knex.schema.alterTable('items', (table) => {
+    table.dropIndex('code', 'items_code_index');
+  });
+  await knex.schema.alterTable('players', (table) => {
+    table.dropIndex('domain', 'players_domain_index');
+  });
+
+  // Add indexes
+  await knex.schema.alterTable('commands', (table) => {
+    table.index('moduleId');
+  });
+  await knex.schema.alterTable('events', (table) => {
+    table.index(['domain', 'createdAt']);
+  });
+  await knex.schema.alterTable('functions', (table) => {
+    table.index('moduleId');
+  });
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.index(['gameServerId', 'domain']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Re-add removed indexes (if needed)
+  await knex.schema.alterTable('events', (table) => {
+    table.index('domain', 'events_domain_index');
+  });
+  await knex.schema.alterTable('items', (table) => {
+    table.index('code', 'items_code_index');
+  });
+  await knex.schema.alterTable('players', (table) => {
+    table.index('domain', 'players_domain_index');
+  });
+
+  // Drop added indexes
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropIndex('moduleId');
+  });
+  await knex.schema.alterTable('events', (table) => {
+    table.dropIndex(['domain', 'createdAt']);
+  });
+  await knex.schema.alterTable('functions', (table) => {
+    table.dropIndex('moduleId');
+  });
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropIndex(['gameServerId', 'domain']);
+  });
+}

package/src/migrations/sql/20241020133133-make-listing-name-required.ts

@@ -0,0 +1,16 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Set all listings w/o name to 'Unnamed'
+  await knex('shopListing').whereNull('name').update({ name: 'Unnamed' });
+
+  await knex.schema.alterTable('shopListing', (table) => {
+    table.string('name').notNullable().alter();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('shopListing', (table) => {
+    table.string('name').nullable().alter();
+  });
+}

package/src/migrations/sql/20241024164331-events-fk-fix.ts

@@ -0,0 +1,16 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // When player, module, gameserver or userId is deleted, keep the event
+  await knex.schema.alterTable('events', (table) => {
+    table.dropForeign(['actingUserId']);
+    table.dropForeign(['actingModuleId']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (table) => {
+    table.foreign('actingUserId').references('id').inTable('users').onDelete('CASCADE');
+    table.foreign('actingModuleId').references('id').inTable('modules').onDelete('CASCADE');
+  });
+}

package/src/migrations/sql/20241030130613-index-for-roleId.ts

@@ -0,0 +1,31 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('permissionOnRole', (table) => {
+    table.index(['roleId']);
+  });
+
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.index(['domain', 'playerId']);
+  });
+
+  await knex.schema.alterTable('playerInventory', (table) => {
+    table.dropIndex(['playerId', 'domain']);
+    table.index(['playerId', 'domain', 'itemId']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('permissionOnRole', (table) => {
+    table.dropIndex(['roleId']);
+  });
+
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropIndex(['domain', 'playerId']);
+  });
+
+  await knex.schema.alterTable('playerInventory', (table) => {
+    table.dropIndex(['playerId', 'domain', 'itemId']);
+    table.index(['playerId', 'domain']);
+  });
+}

package/src/migrations/sql/20241205201123-gameserver-deletedAt.ts

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

package/src/migrations/sql/20241330200212-module-versions.ts

@@ -0,0 +1,384 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Create a new table for module versions
+  await knex.schema.createTable('moduleVersions', (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.index('domain');
+    table.uuid('moduleId').notNullable().references('modules.id').onDelete('CASCADE');
+    table.string('tag').notNullable().defaultTo('0.0.1');
+    table.unique(['moduleId', 'tag']);
+
+    table.text('description').nullable();
+    table.text('configSchema').nullable();
+    table.text('uiSchema').nullable();
+  });
+
+  // Copy over all existing modules
+  const modules = await knex('modules').select('id', 'domain', 'description', 'configSchema', 'uiSchema');
+  console.log(`Migrating ${modules.length} modules to moduleVersions`);
+  for (const mod of modules) {
+    await knex('moduleVersions').insert({
+      domain: mod.domain,
+      moduleId: mod.id,
+      description: mod.description,
+      configSchema: mod.configSchema,
+      uiSchema: mod.uiSchema,
+      tag: 'latest',
+    });
+  }
+
+  // Delete the old columns
+  await knex.schema.table('modules', (table) => {
+    table.dropColumn('description');
+    table.dropColumn('configSchema');
+    table.dropColumn('uiSchema');
+  });
+
+  // Rename table moduleAssignments to moduleInstallations
+  await knex.schema.renameTable('moduleAssignments', 'moduleInstallations');
+
+  // Prepare versionId column in moduleInstallations
+  await knex.schema.table('moduleInstallations', (table) => {
+    table.uuid('versionId');
+    table.dropUnique(['gameserverId', 'moduleId', 'domain'], 'moduleassignments_gameserverid_moduleid_domain_unique');
+  });
+
+  // For each module installation, find the latest version and set it as the versionId
+  // There's a lot of installs, so we'll do this in batches
+  const batchSize = 100;
+  let offset = 0;
+  let installs;
+  do {
+    installs = await knex('moduleInstallations')
+      .select('id', 'moduleId')
+      .limit(batchSize)
+      .offset(offset)
+      .orderBy('createdAt');
+    for (const install of installs) {
+      const latestVersion = await knex('moduleVersions')
+        .select('id')
+        .where('moduleId', install.moduleId)
+        .orderBy('createdAt', 'desc')
+        .first();
+      await knex('moduleInstallations').where('id', install.id).update({ versionId: latestVersion.id });
+    }
+    offset += batchSize;
+  } while (installs.length === batchSize);
+
+  await knex('moduleInstallations').whereNull('versionId').delete();
+
+  // Set versionId as not nullable and add foreign key constraint
+  await knex.schema.alterTable('moduleInstallations', (table) => {
+    table.uuid('versionId').notNullable().alter();
+    table.foreign('versionId').references('moduleVersions.id').onDelete('CASCADE');
+  });
+
+  // Now, we also need to move the commands,hooks and cronjobs to the moduleVersions table
+  // Currently, they have an FK to modules, but we need to replace them with moduleVersions
+  // Same logic here, let's just link all of them to the latest version of the module (which is the only one that should exist)
+
+  // First, let's remove the old FKs
+  // And add a new column for the versionId
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropForeign('moduleId');
+    table.uuid('versionId');
+  });
+
+  await knex.schema.alterTable('hooks', (table) => {
+    table.dropForeign('moduleId');
+    table.uuid('versionId');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.dropForeign('moduleId');
+    table.uuid('versionId');
+  });
+
+  await knex.schema.alterTable('permission', (table) => {
+    table.dropForeign('moduleId', 'modulepermission_moduleid_foreign');
+    table.uuid('moduleVersionId');
+  });
+
+  await knex.schema.alterTable('functions', (table) => {
+    table.dropForeign('moduleId');
+    table.uuid('versionId');
+  });
+
+  offset = 0;
+  let commands;
+  do {
+    commands = await knex('commands').select('id', 'moduleId').limit(batchSize).offset(offset).orderBy('createdAt');
+    for (const command of commands) {
+      const latestVersion = await knex('moduleVersions')
+        .select('id')
+        .where('moduleId', command.moduleId)
+        .orderBy('createdAt', 'desc')
+        .first();
+      await knex('commands').where('id', command.id).update({ versionId: latestVersion.id });
+    }
+    offset += batchSize;
+  } while (commands.length === batchSize);
+
+  offset = 0;
+  let hooks;
+  do {
+    hooks = await knex('hooks').select('id', 'moduleId').limit(batchSize).offset(offset).orderBy('createdAt');
+    for (const hook of hooks) {
+      const latestVersion = await knex('moduleVersions')
+        .select('id')
+        .where('moduleId', hook.moduleId)
+        .orderBy('createdAt', 'desc')
+        .first();
+      await knex('hooks').where('id', hook.id).update({ versionId: latestVersion.id });
+    }
+    offset += batchSize;
+  } while (hooks.length === batchSize);
+
+  offset = 0;
+  let cronjobs;
+  do {
+    cronjobs = await knex('cronJobs').select('id', 'moduleId').limit(batchSize).offset(offset).orderBy('createdAt');
+    for (const cronjob of cronjobs) {
+      const latestVersion = await knex('moduleVersions')
+        .select('id')
+        .where('moduleId', cronjob.moduleId)
+        .orderBy('createdAt', 'desc')
+        .first();
+      await knex('cronJobs').where('id', cronjob.id).update({ versionId: latestVersion.id });
+    }
+    offset += batchSize;
+  } while (cronjobs.length === batchSize);
+
+  offset = 0;
+  let permissions;
+  do {
+    permissions = await knex('permission')
+      .select('id', 'moduleId')
+      .limit(batchSize)
+      .offset(offset)
+      .orderBy('createdAt');
+    for (const permission of permissions) {
+      if (!permission.moduleId) {
+        // Not a module scoped permission, so skip
+        continue;
+      }
+      const latestVersion = await knex('moduleVersions')
+        .select('id')
+        .where('moduleId', permission.moduleId)
+        .orderBy('createdAt', 'desc')
+        .first();
+      await knex('permission').where('id', permission.id).update({ moduleVersionId: latestVersion.id });
+    }
+    offset += batchSize;
+  } while (permissions.length === batchSize);
+
+  offset = 0;
+  let functions;
+  do {
+    functions = await knex('functions').select('id', 'moduleId').limit(batchSize).offset(offset).orderBy('createdAt');
+    for (const func of functions) {
+      if (!func.moduleId) {
+        // Not module scoped, so skip
+        continue;
+      }
+      const latestVersion = await knex('moduleVersions')
+        .select('id')
+        .where('moduleId', func.moduleId)
+        .orderBy('createdAt', 'desc')
+        .first();
+      await knex('functions').where('id', func.id).update({ versionId: latestVersion.id });
+    }
+    offset += batchSize;
+  } while (functions.length === batchSize);
+
+  // Finally, let's drop old columns and ensure new FK is in place
+  const orphanedCommands = await knex('commands').delete().whereNull('versionId');
+  console.log(`Deleted ${orphanedCommands} orphaned commands`);
+  const orphanedHooks = await knex('hooks').delete().whereNull('versionId');
+  console.log(`Deleted ${orphanedHooks} orphaned hooks`);
+  const orphanedCronjobs = await knex('cronJobs').delete().whereNull('versionId');
+  console.log(`Deleted ${orphanedCronjobs} orphaned cronjobs`);
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropColumn('moduleId');
+    table.uuid('versionId').notNullable().alter();
+    table.foreign('versionId').references('moduleVersions.id').onDelete('CASCADE');
+  });
+
+  await knex.schema.alterTable('hooks', (table) => {
+    table.dropColumn('moduleId');
+    table.uuid('versionId').notNullable().alter();
+    table.foreign('versionId').references('moduleVersions.id').onDelete('CASCADE');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.dropColumn('moduleId');
+    table.uuid('versionId').notNullable().alter();
+    table.foreign('versionId').references('moduleVersions.id').onDelete('CASCADE');
+  });
+
+  await knex.schema.alterTable('permission', (table) => {
+    table.dropColumn('moduleId');
+    table.uuid('moduleVersionId').nullable().alter();
+    table.foreign('moduleVersionId').references('moduleVersions.id').onDelete('CASCADE');
+  });
+
+  await knex.schema.alterTable('functions', (table) => {
+    table.dropColumn('moduleId');
+    table.uuid('versionId').nullable().alter();
+    table.foreign('versionId').references('moduleVersions.id').onDelete('CASCADE');
+  });
+
+  await knex.schema.alterTable('moduleInstallations', (table) => {
+    table.unique(['moduleId', 'gameserverId', 'domain'], { indexName: 'unique_module_per_gameserver' });
+    table.index(['moduleId', 'gameserverId', 'domain'], 'idx_moduleinstallations_module_gameserver');
+  });
+
+  // Hook name must be unique inside a version
+  await knex.schema.alterTable('hooks', (table) => {
+    table.unique(['name', 'versionId']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('hooks', (table) => {
+    table.dropUnique(['name', 'versionId']);
+  });
+
+  await knex.schema.alterTable('moduleInstallations', (table) => {
+    table.dropUnique(['moduleId', 'gameserverId', 'domain'], 'unique_module_per_gameserver');
+    table.dropIndex(['moduleId', 'gameserverId', 'domain'], 'idx_moduleinstallations_module_gameserver');
+  });
+
+  // Remove the FKs from commands, hooks and cronjobs
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropForeign('versionId');
+  });
+
+  await knex.schema.alterTable('hooks', (table) => {
+    table.dropForeign('versionId');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.dropForeign('versionId');
+  });
+
+  await knex.schema.alterTable('permission', (table) => {
+    table.dropForeign('moduleVersionId');
+  });
+
+  await knex.schema.alterTable('functions', (table) => {
+    table.dropForeign('versionId');
+  });
+
+  // Drop the new columns
+  await knex.schema.alterTable('moduleInstallations', (table) => {
+    table.dropForeign('versionId');
+    table.dropColumn('versionId');
+    table.unique(['gameserverId', 'moduleId', 'domain'], {
+      indexName: 'moduleassignments_gameserverid_moduleid_domain_unique',
+    });
+  });
+
+  // Rename table moduleInstallations to moduleAssignments
+  await knex.schema.renameTable('moduleInstallations', 'moduleAssignments');
+
+  // Add back the old columns
+  await knex.schema.table('modules', (table) => {
+    table.text('description').nullable();
+    table.text('configSchema').nullable();
+    table.text('uiSchema').nullable();
+  });
+
+  // Add the old column back
+  await knex.schema.alterTable('commands', (table) => {
+    table.uuid('moduleId');
+  });
+
+  await knex.schema.alterTable('hooks', (table) => {
+    table.uuid('moduleId');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.uuid('moduleId');
+  });
+
+  await knex.schema.alterTable('permission', (table) => {
+    table.uuid('moduleId').nullable();
+  });
+
+  await knex.schema.alterTable('functions', (table) => {
+    table.uuid('moduleId').nullable();
+  });
+
+  // Copy over the latest version of each module
+  const versions = await knex('moduleVersions')
+    .select('id', 'moduleId', 'createdAt', 'description', 'configSchema', 'uiSchema')
+    .distinct('moduleId')
+    .orderBy('createdAt', 'desc');
+  for (const version of versions) {
+    await knex('modules').where('id', version.moduleId).update({
+      description: version.description,
+      configSchema: version.configSchema,
+      uiSchema: version.uiSchema,
+    });
+
+    // Copy over the commands, hooks, cronjobs and permissions
+    const commands = await knex('commands').select('id').where('versionId', version.id);
+    for (const command of commands) {
+      await knex('commands').where('id', command.id).update({ moduleId: version.moduleId });
+    }
+
+    const hooks = await knex('hooks').select('id').where('versionId', version.id);
+    for (const hook of hooks) {
+      await knex('hooks').where('id', hook.id).update({ moduleId: version.moduleId });
+    }
+
+    const cronjobs = await knex('cronJobs').select('id').where('versionId', version.id);
+    for (const cronjob of cronjobs) {
+      await knex('cronJobs').where('id', cronjob.id).update({ moduleId: version.moduleId });
+    }
+
+    const permissions = await knex('permission').select('id').where('moduleVersionId', version.id);
+    for (const permission of permissions) {
+      await knex('permission').where('id', permission.id).update({ moduleId: version.moduleId });
+    }
+
+    const functions = await knex('functions').select('id').where('versionId', version.id);
+    for (const func of functions) {
+      await knex('functions').where('id', func.id).update({ moduleId: version.moduleId });
+    }
+  }
+
+  // Enable the old FKs
+  await knex.schema.alterTable('commands', (table) => {
+    table.foreign('moduleId').references('modules.id').onDelete('CASCADE');
+    table.dropColumn('versionId');
+  });
+
+  await knex.schema.alterTable('hooks', (table) => {
+    table.foreign('moduleId').references('modules.id').onDelete('CASCADE');
+    table.dropColumn('versionId');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.foreign('moduleId').references('modules.id').onDelete('CASCADE');
+    table.dropColumn('versionId');
+  });
+
+  await knex.schema.alterTable('permission', (table) => {
+    table.foreign('moduleId', 'modulepermission_moduleid_foreign').references('modules.id').onDelete('CASCADE');
+    table.dropColumn('moduleVersionId');
+  });
+
+  await knex.schema.alterTable('functions', (table) => {
+    table.foreign('moduleId').references('modules.id').onDelete('CASCADE');
+    table.dropColumn('versionId');
+  });
+
+  // Drop the moduleVersions table
+  await knex.schema.dropTable('moduleVersions');
+}