@takaro/db 0.0.0-next.09a7ca1

package/src/migrations/sql/20240301063505-module-functions.ts

@@ -0,0 +1,17 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('functions', (table) => {
+    table.string('name').nullable();
+    table.uuid('moduleId').nullable();
+    table.foreign('moduleId').references('id').inTable('modules');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('module_functions');
+
+  await knex.schema.alterTable('functions', (table) => {
+    table.dropColumn('name');
+  });
+}

package/src/migrations/sql/20240613175009-lastseen-users-pog.ts

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

package/src/migrations/sql/20240614143517-shop.ts

@@ -0,0 +1,39 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('shopListing', (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('itemId').references('items.id').onDelete('CASCADE');
+    table.uuid('functionId').references('functions.id').onDelete('CASCADE');
+
+    // Either an item or a function must be set
+    table.check('("itemId" IS NOT NULL) OR ("functionId" IS NOT NULL)');
+
+    table.integer('price').notNullable();
+
+    // Price must be positive and non-zero
+    table.check('"price" > 0');
+
+    table.string('name').nullable();
+  });
+
+  // Listings can only be bought by users with the role
+  await knex.schema.createTable('shopListingRole', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+
+    table.uuid('listingId').references('shopListing.id').onDelete('CASCADE').notNullable();
+    table.uuid('roleId').references('roles.id').onDelete('CASCADE').notNullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('shopListingRole');
+  await knex.schema.dropTable('shopListing');
+}

package/src/migrations/sql/20240615145045-user-player-link.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Remove users_idp_id_unique constraint
+  //idpId must be unique per domain instead
+  await knex.schema.alterTable('users', (table) => {
+    table.dropUnique(['idpid']);
+    table.unique(['idpId', 'domain']);
+
+    table.uuid('playerId').references('players.id').onDelete('SET NULL').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('users', (table) => {
+    table.dropUnique(['idpid', 'domain']);
+    table.unique(['idpId']);
+    table.dropColumn('playerId');
+  });
+}

package/src/migrations/sql/20240622132552-fix-ip-history-fk.ts

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

package/src/migrations/sql/20240626200803-player-inventory-idx.ts

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

package/src/migrations/sql/20240628174914-shop-orders.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('shopOrder', (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('listingId').references('shopListing.id').onDelete('CASCADE').notNullable();
+    table.uuid('userId').references('users.id').onDelete('CASCADE').notNullable();
+
+    table.integer('amount').defaultTo(1).notNullable();
+    table.enum('status', ['COMPLETED', 'PAID', 'CANCELED']).notNullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('shopOrder');
+}

package/src/migrations/sql/20240705140358-teleports-public-refactor.ts

@@ -0,0 +1,31 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Find all variables where key starts with 'tp_'
+  const variables = await knex('variables').select().where('key', 'like', 'tp_%');
+
+  // Reduce the list to only public teleports
+  const publicTeleports = variables.filter((variable) => {
+    try {
+      const value = JSON.parse(variable.value);
+      return value.public;
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.warn(`Error parsing JSON for variable ${variable.key}: ${error}. Skipping.`);
+      return false;
+    }
+  });
+
+  // Change the key for all public teleports from tp_xxx to pubtp_xxx
+  await Promise.all(
+    publicTeleports.map((teleport) => {
+      return knex('variables')
+        .update({ key: `pub${teleport.key}` })
+        .where('id', teleport.id);
+    }),
+  );
+}
+
+export async function down(_knex: Knex): Promise<void> {
+  // ... no down here, this is a one-way migration
+}

package/src/migrations/sql/20240710181429-events-name-idx.ts

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

package/src/migrations/sql/20240711181423-shop-orders-multi-listing.ts

@@ -0,0 +1,34 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('itemOnShopListing', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+
+    table.uuid('listingId').references('shopListing.id').onDelete('CASCADE').notNullable();
+    table.uuid('itemId').references('items.id').onDelete('CASCADE');
+
+    table.integer('amount').defaultTo(1).notNullable();
+    // Amount must be positive and non-zero
+    table.check('"amount" > 0');
+
+    table.string('quality').nullable();
+  });
+
+  await knex.schema.alterTable('shopListing', (table) => {
+    table.dropChecks('"shopListing_check"');
+    table.dropColumn('functionId');
+    table.dropColumn('itemId');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('shopListing', (table) => {
+    table.uuid('itemId').references('items.id').onDelete('CASCADE');
+    table.uuid('functionId').references('functions.id').onDelete('CASCADE');
+
+    table.check('("itemId" IS NOT NULL) OR ("functionId" IS NOT NULL)');
+  });
+
+  await knex.schema.dropTable('itemOnShopListing');
+}

package/src/migrations/sql/20240718121004-delete-read-gameservers-perm.ts

@@ -0,0 +1,9 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.table('permission').where('permission', 'READ_GAMESERVERS').delete();
+}
+
+export async function down(_knex: Knex): Promise<void> {
+  // No down migration...
+}

package/src/migrations/sql/20240718150807-listing-deleted-and-draft-status.ts

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

package/src/migrations/sql/20240720135010-acting-user-and-module.ts

@@ -0,0 +1,24 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (table) => {
+    table.uuid('actingUserId').nullable();
+    table.foreign('actingUserId').references('id').inTable('users');
+
+    table.uuid('actingModuleId').nullable();
+    table.foreign('actingModuleId').references('id').inTable('modules');
+
+    table.index('actingUserId');
+    table.index('actingModuleId');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (table) => {
+    table.dropForeign(['actingUserId']);
+    table.dropColumn('actingUserId');
+
+    table.dropForeign(['actingModuleId']);
+    table.dropColumn('actingModuleId');
+  });
+}

package/src/migrations/sql/20240811061243-domain-rate-limit-setting.ts

@@ -0,0 +1,16 @@
+import ms from 'ms';
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.integer('rateLimitPoints').notNullable().defaultTo(2500);
+    table.integer('rateLimitDuration').notNullable().defaultTo(ms('15min'));
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.dropColumn('rateLimitPoints');
+    table.dropColumn('rateLimitDuration');
+  });
+}

package/src/migrations/sql/20240814133931-domain-ext-ref.ts

@@ -0,0 +1,24 @@
+import ms from 'ms';
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.text('externalReference').nullable();
+  });
+
+  // Select all domains with name starting cus_ and set externalReference to the name
+  const domains = await knex('domains').where('name', 'like', 'cus_%');
+  await Promise.all(
+    domains.map((domain) =>
+      knex('domains').where('id', domain.id).update({
+        externalReference: domain.name,
+      }),
+    ),
+  );
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.dropColumn('externalReference');
+  });
+}

package/src/migrations/sql/20240816171220-player-steam-level.ts

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

package/src/migrations/sql/20240830081157-variable-expiry.ts

@@ -0,0 +1,14 @@
+import ms from 'ms';
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('variables', (table) => {
+    table.timestamp('expiresAt').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('variables', (table) => {
+    table.dropColumn('expiresAt');
+  });
+}

package/src/migrations/sql/20240906125101-gameserver-enable.ts

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

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