@takaro/db 0.0.0-next.09a7ca1

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

package/src/migrations/sql/20250112102308-generic-gameserver.ts

@@ -0,0 +1,55 @@
+import { Knex } from 'knex';
+import { formatAlterTableEnumSql } from '../util/alterEnum.js';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(`
+    CREATE OR REPLACE FUNCTION generate_registration_token()
+    RETURNS text
+    LANGUAGE sql
+    AS $$
+      SELECT encode(
+        decode(
+          replace(
+            array_to_string(
+              ARRAY[
+                gen_random_uuid()::text,
+                gen_random_uuid()::text
+              ],
+              ''
+            ),
+            '-',
+            ''
+          ),
+          'hex'
+        ),
+        'base64'
+      );
+    $$;
+  `);
+
+  // Then run the migrations
+  await knex.raw(formatAlterTableEnumSql('gameservers', 'type', ['MOCK', 'RUST', 'SEVENDAYSTODIE', 'GENERIC']));
+
+  await knex.schema.alterTable('domains', (table) => {
+    table.string('serverRegistrationToken', 128).notNullable().defaultTo(knex.raw('generate_registration_token()'));
+  });
+
+  await knex.schema.alterTable('gameservers', (table) => {
+    table.string('identityToken').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw(formatAlterTableEnumSql('gameservers', 'type', ['MOCK', 'RUST', 'SEVENDAYSTODIE']));
+
+  await knex.schema.alterTable('domains', (table) => {
+    table.dropColumn('serverRegistrationToken');
+  });
+
+  await knex.schema.alterTable('gameservers', (table) => {
+    table.dropColumn('identityToken');
+  });
+
+  // Drop the function
+  await knex.raw('DROP FUNCTION IF EXISTS generate_registration_token();');
+}

package/src/migrations/sql/20250128200529-version-fixes.ts

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

package/src/migrations/sql/20250131183251-domain-settings.ts

@@ -0,0 +1,55 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.integer('maxGameservers').defaultTo(1);
+    table.integer('maxUsers').defaultTo(1);
+    table.integer('eventRetentionDays').defaultTo(7);
+    table.integer('maxVariables').defaultTo(10000);
+    table.integer('maxModules').defaultTo(1000);
+    table.integer('maxFunctionsInModule').defaultTo(50);
+  });
+
+  await knex.schema.alterTable('users', (table) => {
+    table.boolean('isDashboardUser').defaultTo(false);
+  });
+
+  /**
+   * We need to find all the 'root' users and make them dashboard users. Root users have name === 'root'
+   * Also, we need to find any users with the "ROOT"" permission and make them dashboard users
+   */
+  await knex('users').where('name', 'root').update({ isDashboardUser: true });
+
+  // Then update users with ROOT permission
+  const usersWithRootPermission = await knex('users as u')
+    .distinct('u.id')
+    .join('roleOnUser as ru', 'u.id', 'ru.userId')
+    .join('permissionOnRole as pr', 'ru.roleId', 'pr.roleId')
+    .join('permission as p', 'pr.permissionId', 'p.id')
+    .where('p.permission', 'ROOT')
+    .select('u.id');
+
+  if (usersWithRootPermission.length > 0) {
+    await knex('users')
+      .whereIn(
+        'id',
+        usersWithRootPermission.map((user) => user.id),
+      )
+      .update({ isDashboardUser: true });
+  }
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.dropColumn('maxGameservers');
+    table.dropColumn('maxUsers');
+    table.dropColumn('eventRetentionDays');
+    table.dropColumn('maxVariables');
+    table.dropColumn('maxModules');
+    table.dropColumn('maxFunctionsInModule');
+  });
+
+  await knex.schema.alterTable('users', (table) => {
+    table.dropColumn('isDashboardUser');
+  });
+}

package/src/migrations/sql/20250221130042-variable-length.ts

@@ -0,0 +1,35 @@
+import { Knex } from 'knex';
+
+/**
+ * Alters the variables.value column from varchat to text
+ * Reason being is that users frequently want to store strings longer than 255 characters
+ * And length of this doesn't really matter for us...
+ * We still add a constraint to ensure that there's an upper bound
+ * Otherwise, users could upload 1TB of data to a single variable and crash postgres :)
+ */
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('variables', (table) => {
+    // Alter column type to text
+    table.text('value').alter();
+  });
+
+  // Add CHECK constraint to prevent extremely large values (128KB)
+  await knex.raw('ALTER TABLE variables ADD CONSTRAINT value_length_check CHECK (length(value) <= 131072)');
+}
+
+/**
+ * Reverts the variables.value column back to varchar(255)
+ * Removes the CHECK constraint
+ *
+ * @param knex Knex instance
+ */
+export async function down(knex: Knex): Promise<void> {
+  // Remove CHECK constraint first
+  await knex.raw('ALTER TABLE variables DROP CONSTRAINT value_length_check');
+
+  await knex.schema.alterTable('variables', (table) => {
+    // Revert column type to varchar(255)
+    table.string('value', 255).alter();
+  });
+}

package/src/migrations/sql/20250221193144-versions-perf-improvements.ts

@@ -0,0 +1,79 @@
+import { Knex } from 'knex';
+
+/**
+ * Adds performance optimization indices for module version querying
+ */
+export async function up(knex: Knex): Promise<void> {
+  // ModuleVersions composite index
+  await knex.schema.raw(
+    'CREATE INDEX IF NOT EXISTS idx_moduleversions_moduleid_tag ON "moduleVersions" ("moduleId", tag)',
+  );
+
+  // Add indices on versionId foreign keys
+  await knex.schema.alterTable('functions', (table) => {
+    table.index(['versionId'], 'idx_functions_versionid');
+  });
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.index(['versionId'], 'idx_commands_versionid');
+  });
+
+  await knex.schema.alterTable('hooks', (table) => {
+    table.index(['versionId'], 'idx_hooks_versionid');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.index(['versionId'], 'idx_cronjobs_versionid');
+  });
+
+  // Add indices on functionId foreign keys
+  await knex.schema.alterTable('hooks', (table) => {
+    table.index(['functionId'], 'idx_hooks_functionid');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.index(['functionId'], 'idx_cronjobs_functionid');
+  });
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.index(['functionId'], 'idx_commands_functionid');
+  });
+}
+
+/**
+ * Removes performance optimization indices
+ */
+export async function down(knex: Knex): Promise<void> {
+  // Drop ModuleVersions composite index
+  await knex.schema.raw('DROP INDEX IF EXISTS idx_moduleversions_moduleid_tag');
+
+  // Drop versionId indices
+  await knex.schema.alterTable('functions', (table) => {
+    table.dropIndex(['versionId'], 'idx_functions_versionid');
+  });
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropIndex(['versionId'], 'idx_commands_versionid');
+  });
+
+  await knex.schema.alterTable('hooks', (table) => {
+    table.dropIndex(['versionId'], 'idx_hooks_versionid');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.dropIndex(['versionId'], 'idx_cronjobs_versionid');
+  });
+
+  // Drop functionId indices
+  await knex.schema.alterTable('hooks', (table) => {
+    table.dropIndex(['functionId'], 'idx_hooks_functionid');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.dropIndex(['functionId'], 'idx_cronjobs_functionid');
+  });
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropIndex(['functionId'], 'idx_commands_functionid');
+  });
+}

package/src/migrations/sql/20250223143705-fix-ban-constraint.ts

@@ -0,0 +1,43 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // First drop the existing foreign key constraint
+  await knex.schema.table('bans', (table) => {
+    table.dropForeign(['gameServerId']);
+  });
+
+  // Make gameServerId nullable and recreate foreign key
+  await knex.schema.alterTable('bans', (table) => {
+    table.uuid('gameServerId').nullable().alter();
+    table.foreign('gameServerId').references('id').inTable('gameservers').onDelete('CASCADE');
+  });
+
+  // Add the check constraint
+  await knex.raw(`
+    ALTER TABLE bans
+    ADD CONSTRAINT bans_global_gameserver_check
+    CHECK (
+      ("isGlobal" = true AND "gameServerId" IS NULL) OR
+      ("isGlobal" = false AND "gameServerId" IS NOT NULL)
+    )
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Remove the check constraint
+  await knex.raw(`
+    ALTER TABLE bans
+    DROP CONSTRAINT bans_global_gameserver_check
+  `);
+
+  // Drop the foreign key
+  await knex.schema.table('bans', (table) => {
+    table.dropForeign(['gameServerId']);
+  });
+
+  // Make gameServerId required again and recreate original foreign key
+  await knex.schema.alterTable('bans', (table) => {
+    table.uuid('gameServerId').notNullable().alter();
+    table.foreign('gameServerId').references('id').inTable('gameservers').onDelete('CASCADE');
+  });
+}