@takaro/db 0.0.0-next.0da151e

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

package/src/migrations/sql/20250305210650-more-module-metadata.ts

@@ -0,0 +1,49 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('hooks', (table) => {
+    table.text('description').nullable();
+  });
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.text('description').nullable();
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.text('description').nullable();
+  });
+
+  await knex.schema.alterTable('functions', (table) => {
+    table.text('description').nullable();
+  });
+
+  await knex.raw('ALTER TABLE hooks ADD CONSTRAINT description_length_check CHECK (length(description) <= 131072)');
+  await knex.raw('ALTER TABLE commands ADD CONSTRAINT description_length_check CHECK (length(description) <= 131072)');
+  await knex.raw(
+    'ALTER TABLE "cronJobs" ADD CONSTRAINT description_length_check CHECK (length(description) <= 131072)',
+  );
+  await knex.raw('ALTER TABLE functions ADD CONSTRAINT description_length_check CHECK (length(description) <= 131072)');
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw('ALTER TABLE hooks DROP CONSTRAINT description_length_check');
+  await knex.raw('ALTER TABLE commands DROP CONSTRAINT description_length_check');
+  await knex.raw('ALTER TABLE "cronJobs" DROP CONSTRAINT description_length_check');
+  await knex.raw('ALTER TABLE functions DROP CONSTRAINT description_length_check');
+
+  await knex.schema.alterTable('hooks', (table) => {
+    table.dropColumn('description');
+  });
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropColumn('description');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.dropColumn('description');
+  });
+
+  await knex.schema.alterTable('functions', (table) => {
+    table.dropColumn('description');
+  });
+}

package/src/migrations/sql/20250307162855-default-systemconfig.ts

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

package/src/migrations/sql/20250312184104-unique-external-reference.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.unique(['externalReference']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.dropUnique(['externalReference']);
+  });
+}

package/src/migrations/sql/20250314185501-root-users-not-dashboard-user.ts

@@ -0,0 +1,17 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(`
+    UPDATE users
+    SET "isDashboardUser" = false
+    WHERE name = 'root'
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw(`
+    UPDATE users
+    SET "isDashboardUser" = true
+    WHERE name = 'root'
+  `);
+}

package/src/migrations/sql/20250315191707-fix-constraint-module-items.ts

@@ -0,0 +1,26 @@
+import { Knex } from 'knex';
+
+/**
+ * This migration ensures that all commands,hooks,cronjobs have a unique name inside their module version
+ * @param knex
+ */
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(
+    `ALTER TABLE "commands" ADD CONSTRAINT "commands_unique_name_versionId" UNIQUE ("name", "versionId");`,
+  );
+  await knex.raw(`ALTER TABLE "hooks" ADD CONSTRAINT "hooks_unique_name_versionId" UNIQUE ("name", "versionId");`);
+  await knex.raw(
+    `ALTER TABLE "cronJobs" ADD CONSTRAINT "cronJobs_unique_name_versionId" UNIQUE ("name", "versionId");`,
+  );
+  await knex.raw(
+    `ALTER TABLE "functions" ADD CONSTRAINT "functions_unique_name_versionId" UNIQUE ("name", "versionId");`,
+  );
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw(`ALTER TABLE "commands" DROP CONSTRAINT "commands_unique_name_versionId";`);
+  await knex.raw(`ALTER TABLE "hooks" DROP CONSTRAINT "hooks_unique_name_versionId";`);
+  await knex.raw(`ALTER TABLE "cronJobs" DROP CONSTRAINT "cronJobs_unique_name_versionId";`);
+  await knex.raw(`ALTER TABLE "functions" DROP CONSTRAINT "functions_unique_name_versionId";`);
+}

package/src/migrations/sql/20250519185149-add-item-indexes.ts

@@ -0,0 +1,42 @@
+import { Knex } from 'knex';
+
+/**
+ * These indexes singificantly improve performance of the gameserver delete operation
+ * CREATE INDEX idx_itemonshoplisting_itemid ON "itemOnShopListing" ("itemId");
+ * CREATE INDEX idx_playerinventory_itemid ON "playerInventory" ("itemId");
+ * CREATE INDEX idx_playeriphistory_gameserverid ON "playerIpHistory" ("gameServerId");
+ * CREATE INDEX idx_shoplisting_gameserverid ON "shopListing" ("gameServerId");
+ *
+ * @param knex
+ */
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema
+    .alterTable('itemOnShopListing', (table) => {
+      table.index(['itemId'], 'idx_itemonshoplisting_itemid');
+    })
+    .alterTable('playerInventory', (table) => {
+      table.index(['itemId'], 'idx_playerinventory_itemid');
+    })
+    .alterTable('playerIpHistory', (table) => {
+      table.index(['gameServerId'], 'idx_playeriphistory_gameserverid');
+    })
+    .alterTable('shopListing', (table) => {
+      table.index(['gameServerId'], 'idx_shoplisting_gameserverid');
+    });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema
+    .alterTable('itemOnShopListing', (table) => {
+      table.dropIndex([], 'idx_itemonshoplisting_itemid');
+    })
+    .alterTable('playerInventory', (table) => {
+      table.dropIndex([], 'idx_playerinventory_itemid');
+    })
+    .alterTable('playerIpHistory', (table) => {
+      table.dropIndex([], 'idx_playeriphistory_gameserverid');
+    })
+    .alterTable('shopListing', (table) => {
+      table.dropIndex([], 'idx_shoplisting_gameserverid');
+    });
+}

package/src/migrations/sql/20250524054924-tracking.ts

@@ -0,0 +1,79 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Create partitioned table using raw SQL since Knex doesn't have native partition support
+  await knex.raw(`
+    CREATE TABLE "playerLocation" (
+      id UUID DEFAULT gen_random_uuid() NOT NULL,
+      "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP NOT NULL,
+      "updatedAt" TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP NOT NULL,
+      domain VARCHAR(255) NOT NULL,
+      "playerId" UUID NOT NULL,
+      x NUMERIC(10,3) NOT NULL,
+      y NUMERIC(10,3) NOT NULL,
+      z NUMERIC(10,3) NOT NULL,
+      CONSTRAINT "playerLocation_pkey" PRIMARY KEY ("createdAt", "playerId"),
+      CONSTRAINT "playerLocation_domain_foreign" FOREIGN KEY (domain) REFERENCES domains(id) ON DELETE CASCADE,
+      CONSTRAINT "playerLocation_playerId_foreign" FOREIGN KEY ("playerId") REFERENCES "playerOnGameServer"(id) ON DELETE CASCADE
+    ) PARTITION BY RANGE ("createdAt")
+  `);
+
+  // Create function to ensure partition exists for given date
+  await knex.raw(`
+    CREATE OR REPLACE FUNCTION ensure_player_location_partition(date_param VARCHAR DEFAULT NULL)
+    RETURNS VOID AS $$
+    DECLARE
+      current_day_start DATE;
+      next_day_start DATE;
+      partition_name TEXT;
+      partition_exists BOOLEAN;
+      target_date DATE;
+    BEGIN
+      -- Parse date parameter or use current date
+      IF date_param IS NOT NULL THEN
+        target_date := DATE(date_param::TIMESTAMP);
+      ELSE
+        target_date := CURRENT_DATE;
+      END IF;
+      
+      -- Calculate day boundaries for target date
+      current_day_start := DATE_TRUNC('day', target_date);
+      next_day_start := current_day_start + INTERVAL '1 day';
+      
+      -- Generate partition name (format: playerLocation_YYYY_MM_DD)
+      partition_name := 'playerLocation_' || TO_CHAR(current_day_start, 'YYYY_MM_DD');
+      
+      -- Check if partition exists
+      SELECT EXISTS (
+        SELECT 1 FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = partition_name
+          AND n.nspname = 'public'
+      ) INTO partition_exists;
+      
+      -- Create partition if it doesn't exist
+      IF NOT partition_exists THEN
+        EXECUTE format(
+          'CREATE TABLE %I PARTITION OF "playerLocation"
+           FOR VALUES FROM (%L) TO (%L)',
+          partition_name,
+          current_day_start,
+          next_day_start
+        );
+        
+        RAISE NOTICE 'Created partition: % for date: %',
+          partition_name, current_day_start;
+      END IF;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+
+  // Create indexes
+  await knex.raw(`CREATE INDEX "playerLocation_domain_createdAt_idx" ON "playerLocation" (domain, "createdAt")`);
+  await knex.raw(`CREATE INDEX "playerLocation_playerId_idx" ON "playerLocation" ("playerId")`);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw('DROP FUNCTION IF EXISTS ensure_player_location_partition(VARCHAR)');
+  await knex.raw('DROP TABLE IF EXISTS "playerLocation" CASCADE');
+}

package/src/migrations/sql/20250525135204-ban-reason-length.ts

@@ -0,0 +1,35 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('bans', (table) => {
+    table.text('reason').alter();
+  });
+
+  await knex.raw(`
+    CREATE OR REPLACE FUNCTION truncate_reason()
+    RETURNS TRIGGER AS $$
+    BEGIN
+      IF char_length(NEW.reason) > 10000 THEN
+        NEW.reason = left(NEW.reason, 10000);
+      END IF;
+      RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+
+  await knex.raw(`
+    CREATE TRIGGER truncate_reason_trigger
+      BEFORE INSERT OR UPDATE ON "bans"
+      FOR EACH ROW
+      EXECUTE FUNCTION truncate_reason();
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw('DROP TRIGGER IF EXISTS truncate_reason_trigger ON "bans"');
+  await knex.raw('DROP FUNCTION IF EXISTS truncate_reason()');
+
+  await knex.schema.alterTable('bans', (table) => {
+    table.string('reason', 255).alter();
+  });
+}

package/src/migrations/sql/20250605201140-shop-permissions-missing.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex('permission').insert([
+    {
+      permission: 'MANAGE_SHOP_LISTINGS',
+      description: 'Manage shop listings',
+      friendlyName: 'Manage Shop Listings',
+    },
+    {
+      permission: 'MANAGE_SHOP_ORDERS',
+      description: 'Manage shop orders, allowing administrative actions on orders not belonging to the user',
+      friendlyName: 'Manage Shop Orders',
+    },
+  ]);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex('permission').whereIn('permission', ['MANAGE_SHOP_LISTINGS', 'MANAGE_SHOP_ORDERS']).del();
+}