@takaro/db 0.0.0-next.0da151e

package/src/migrations/sql/20240101162751-add-settings-constraint.ts

@@ -0,0 +1,39 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Delete any settings where duplicate key, same domain and null gameServerId
+  await knex.raw(`
+    DELETE FROM settings
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id, ROW_NUMBER() OVER (partition BY key, domain ORDER BY id) AS rnum
+        FROM settings
+        WHERE "gameServerId" IS NULL
+      ) t
+      WHERE t.rnum > 1
+    );
+  `);
+
+  // Drop the old constraint
+  await knex.schema.alterTable('settings', (table) => {
+    table.dropUnique(['key', 'domain', 'gameServerId'], 'new_settings_domain_key_gameserverid_unique');
+  });
+
+  await knex.raw(`
+  ALTER TABLE settings
+  ADD CONSTRAINT settings_key_domain_unique
+  UNIQUE NULLS NOT DISTINCT (key, domain, "gameServerId");
+`);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw(`
+    ALTER TABLE settings
+    DROP CONSTRAINT settings_key_domain_unique;
+  `);
+
+  await knex.schema.alterTable('settings', (table) => {
+    table.unique(['key', 'domain', 'gameServerId'], 'new_settings_domain_key_gameserverid_unique');
+  });
+}

package/src/migrations/sql/20240105130846-remove-some-module-perms.ts

@@ -0,0 +1,104 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // All perms to-be-deleted
+  const readPermissions = ['READ_FUNCTIONS', 'READ_CRONJOBS', 'READ_HOOKS', 'READ_COMMANDS'];
+
+  const managePermissions = ['MANAGE_FUNCTIONS', 'MANAGE_CRONJOBS', 'MANAGE_HOOKS', 'MANAGE_COMMANDS'];
+
+  // First, find all permissions that are to be deleted
+  const readPerms = await knex('permission').whereIn('permission', readPermissions).select('id');
+
+  const managePerms = await knex('permission').whereIn('permission', managePermissions).select('id');
+
+  // Then, find the READ_MODULES and MANAGE_MODULES permissions
+  const readModulePerm = await knex('permission').where('permission', 'READ_MODULES').select('id').first();
+
+  const manageModulePerm = await knex('permission').where('permission', 'MANAGE_MODULES').select('id').first();
+
+  // Then, find all permissionOnRole entries that reference those permissions
+  const readPermissionOnRole = await knex('permissionOnRole')
+    .whereIn(
+      'permissionId',
+      readPerms.map((p) => p.id),
+    )
+    .select('id');
+
+  const managePermissionOnRole = await knex('permissionOnRole')
+    .whereIn(
+      'permissionId',
+      managePerms.map((p) => p.id),
+    )
+    .select('id');
+
+  // Then, update the permissionOnRole entries to reference the new permissions
+  await knex('permissionOnRole')
+    .whereIn(
+      'id',
+      readPermissionOnRole.map((p) => p.id),
+    )
+    .update({
+      permissionId: readModulePerm.id,
+    });
+
+  await knex('permissionOnRole')
+    .whereIn(
+      'id',
+      managePermissionOnRole.map((p) => p.id),
+    )
+    .update({
+      permissionId: manageModulePerm.id,
+    });
+
+  // Then, delete the old perms
+  await knex('permission')
+    .whereIn('permission', [...readPermissions, ...managePermissions])
+    .del();
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Cant actually undo this, we deleted the data (:
+  // Just put back the old perms
+  await knex('permission').insert([
+    {
+      permission: 'READ_FUNCTIONS',
+      description: 'Read functions',
+      friendlyName: 'Read Functions',
+    },
+    {
+      permission: 'READ_CRONJOBS',
+      description: 'Read cronjobs',
+      friendlyName: 'Read Cronjobs',
+    },
+    {
+      permission: 'READ_HOOKS',
+      description: 'Read hooks',
+      friendlyName: 'Read Hooks',
+    },
+    {
+      permission: 'READ_COMMANDS',
+      description: 'Read commands',
+      friendlyName: 'Read Commands',
+    },
+    {
+      permission: 'MANAGE_FUNCTIONS',
+      description: 'Manage functions',
+      friendlyName: 'Manage Functions',
+    },
+    {
+      permission: 'MANAGE_CRONJOBS',
+      description: 'Manage cronjobs',
+      friendlyName: 'Manage Cronjobs',
+    },
+    {
+      permission: 'MANAGE_HOOKS',
+      description: 'Manage hooks',
+      friendlyName: 'Manage Hooks',
+    },
+    {
+      permission: 'MANAGE_COMMANDS',
+      description: 'Manage commands',
+      friendlyName: 'Manage Commands',
+    },
+  ]);
+}

package/src/migrations/sql/20240116141936-add-ui-schema-to-module.ts

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

package/src/migrations/sql/20240119152426-remove-hook-check.ts

@@ -0,0 +1,18 @@
+import { Knex } from 'knex';
+import { formatAlterTableEnumSql } from '../util/alterEnum.js';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw('ALTER TABLE hooks DROP CONSTRAINT "hooks_eventType_check";');
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw(
+    formatAlterTableEnumSql('hooks', 'eventType', [
+      'log',
+      'player-connected',
+      'player-disconnected',
+      'chat-message',
+      'discord-message',
+    ]),
+  );
+}

package/src/migrations/sql/20240121142329-move-ip-history.ts

@@ -0,0 +1,53 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('playerIpHistory', (table) => {
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.timestamps(true, true, true);
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+    table.uuid('playerId').references('players.id').onDelete('CASCADE').notNullable();
+    table.uuid('gameServerId').references('gameservers.id').onDelete('SET NULL').nullable();
+    table.specificType('ip', 'inet').notNullable();
+    table.string('country');
+    table.string('city');
+    table.string('longitude');
+    table.string('latitude');
+  });
+
+  // Transfer all the old IP history to new table
+
+  const oldIpHistory = await knex('playerOnGameServerIp').select('*');
+
+  const newRecords = await Promise.all(
+    oldIpHistory.map(async (ipHistory) => {
+      const pog = await knex('playerOnGameServer').select('*').where('id', ipHistory.pogId).first();
+      delete ipHistory.pogId;
+      return {
+        ...ipHistory,
+        playerId: pog.playerId,
+        gameServerId: pog.gameServerId,
+      };
+    }),
+  );
+
+  if (newRecords.length) {
+    await knex('playerIpHistory').insert(newRecords);
+  }
+  await knex.schema.dropTable('playerOnGameServerIp');
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('playerIpHistory');
+
+  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');
+  });
+}

package/src/migrations/sql/20240202101208-rename-economy-to-economyUtils.ts

@@ -0,0 +1,15 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex('modules').where('builtin', '=', 'economy').update({
+    builtin: 'economyUtils',
+    name: 'economyUtils',
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex('modules').where('builtin', '=', 'economyUtils').update({
+    builtin: 'economy',
+    name: 'economy',
+  });
+}

package/src/migrations/sql/20240216120143-domain-state.ts

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

package/src/migrations/sql/20240229141340-looser-fks-events.ts

@@ -0,0 +1,20 @@
+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(['playerId']);
+    table.dropForeign(['moduleId']);
+    table.dropForeign(['gameserverId']);
+    table.dropForeign(['userId']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (table) => {
+    table.foreign('playerId').references('id').inTable('players').onDelete('CASCADE');
+    table.foreign('moduleId').references('id').inTable('modules').onDelete('CASCADE');
+    table.foreign('gameserverId').references('id').inTable('gameservers').onDelete('CASCADE');
+    table.foreign('userId').references('id').inTable('users').onDelete('CASCADE');
+  });
+}

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