@takaro/db 0.0.1

package/src/migrations/sql/20231222180438-steam-data.ts

@@ -0,0 +1,27 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('players', (table) => {
+    table.string('steamAvatar').nullable();
+    table.timestamp('steamLastFetch').nullable();
+    table.timestamp('steamAccountCreated').nullable();
+    table.boolean('steamCommunityBanned').nullable();
+    table.string('steamEconomyBan').nullable();
+    table.boolean('steamVacBanned').nullable();
+    table.string('steamsDaysSinceLastBan').nullable();
+    table.string('steamNumberOfVACBans').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('players', (table) => {
+    table.dropColumn('steamAvatar');
+    table.dropColumn('steamLastFetch');
+    table.dropColumn('steamAccountCreated');
+    table.dropColumn('steamCommunityBanned');
+    table.dropColumn('steamEconomyBan');
+    table.dropColumn('steamVacBanned');
+    table.dropColumn('steamsDaysSinceLastBan');
+    table.dropColumn('steamNumberOfVACBans');
+  });
+}

package/src/migrations/sql/20231223132631-pog-online.ts

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

package/src/migrations/sql/20231223212031-unique-index-item-def.ts

@@ -0,0 +1,27 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Delete duplicates while keeping the first occurrence
+  await knex.raw(`
+    DELETE FROM items
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id,
+               ROW_NUMBER() OVER (PARTITION BY code, "gameserverId", domain ORDER BY id) as rnk
+        FROM items
+      ) t
+      WHERE t.rnk > 1
+    )
+  `);
+
+  await knex.schema.alterTable('items', (table) => {
+    table.unique(['code', 'gameserverId', 'domain']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('items', (table) => {
+    table.dropUnique(['code', 'gameserverId', 'domain']);
+  });
+}

package/src/migrations/sql/20231224135126-gameserver-online-status.ts

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

package/src/migrations/sql/20231224155226-unique-pog.ts

@@ -0,0 +1,27 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Delete duplicate rows first
+  await knex.raw(`
+    DELETE FROM "playerOnGameServer"
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id,
+               ROW_NUMBER() OVER (PARTITION BY "gameId", "gameServerId" ORDER BY id) as rnk
+        FROM "playerOnGameServer"
+      ) t
+      WHERE t.rnk > 1
+    )
+  `);
+
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.unique(['gameId', 'gameServerId']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropUnique(['gameId', 'gameServerId']);
+  });
+}

package/src/migrations/sql/20231225140650-extra-ip-info.ts

@@ -0,0 +1,27 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropColumn('ip');
+  });
+
+  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');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('playerOnGameServerIp');
+
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.specificType('ip', 'inet').nullable();
+  });
+}

package/src/migrations/sql/20231227144315-unique-constraints-player.ts

@@ -0,0 +1,74 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Delete any duplicate rows first
+  // Retain the record where createdAt is the oldest
+  await knex.raw(`
+    DELETE FROM "players"
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id,
+               ROW_NUMBER() OVER (PARTITION BY domain, "steamId" ORDER BY "createdAt") as rnk
+        FROM "players"
+        WHERE "steamId" IS NOT NULL
+      ) t
+      WHERE t.rnk > 1
+    )
+  `);
+
+  // Also for epicOnlineServicesId
+  await knex.raw(`
+    DELETE FROM "players"
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id,
+               ROW_NUMBER() OVER (PARTITION BY domain, "epicOnlineServicesId" ORDER BY "createdAt") as rnk
+        FROM "players"
+        WHERE "epicOnlineServicesId" IS NOT NULL
+      ) t
+      WHERE t.rnk > 1
+    )
+  `);
+
+  // And xbox
+  await knex.raw(`
+    DELETE FROM "players"
+    WHERE id IN (
+      SELECT id
+      FROM (
+        SELECT id,
+               ROW_NUMBER() OVER (PARTITION BY domain, "xboxLiveId" ORDER BY "createdAt") as rnk
+        FROM "players"
+        WHERE "xboxLiveId" IS NOT NULL
+      ) t
+      WHERE t.rnk > 1
+    )
+  `);
+
+  await knex.schema.alterTable('players', (table) => {
+    table.unique(['domain', 'steamId']);
+    table.unique(['domain', 'epicOnlineServicesId']);
+    table.unique(['domain', 'xboxLiveId']);
+  });
+
+  await knex.raw(`
+  ALTER TABLE players
+  ADD CONSTRAINT players_domain_steam_xbox_eos_unique
+  UNIQUE NULLS NOT DISTINCT (domain, "steamId", "xboxLiveId", "epicOnlineServicesId");
+`);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('players', (table) => {
+    table.dropUnique(['domain', 'steamId']);
+    table.dropUnique(['domain', 'epicOnlineServicesId']);
+    table.dropUnique(['domain', 'xboxLiveId']);
+  });
+
+  await knex.raw(`
+    ALTER TABLE players
+    DROP CONSTRAINT players_domain_steam_xbox_eos_unique;
+  `);
+}

package/src/migrations/sql/20231229144707-more-player-constraints.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Find all players that have epicOnlineServicesId starting with EOS_ and delete them
+  await knex.raw(`
+    DELETE FROM "players"
+    WHERE "epicOnlineServicesId" LIKE 'EOS_%'
+  `);
+
+  await knex.schema.alterTable('players', (table) => {
+    // epicOnlineServicesId is always 32 chars
+    table.string('epicOnlineServicesId', 32).alter();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('players', (table) => {
+    table.string('epicOnlineServicesId', 255).alter();
+  });
+}

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/util/alterEnum.ts

@@ -0,0 +1,10 @@
+/* eslint-disable quotes */
+export function formatAlterTableEnumSql(tableName: string, columnName: string, enums: string[]) {
+  const constraintName = `${tableName}_${columnName}_check`;
+  return [
+    `ALTER TABLE "${tableName}" DROP CONSTRAINT IF EXISTS "${constraintName}";`,
+    `ALTER TABLE "${tableName}" ADD CONSTRAINT "${constraintName}" CHECK ("${columnName}" = ANY (ARRAY['${enums.join(
+      "'::text, '"
+    )}'::text]));`,
+  ].join('\n');
+}

package/src/queryBuilder.ts

@@ -0,0 +1,133 @@
+import { IsDateString, IsEnum, IsNumber, IsOptional, IsString } from 'class-validator';
+import { QueryBuilder as ObjectionQueryBuilder, Model as ObjectionModel, Page, AnyQueryBuilder } from 'objection';
+
+export class ITakaroQuery<T> {
+  @IsOptional()
+  filters?: {
+    [key in keyof T]?: unknown[] | unknown;
+  };
+
+  @IsOptional()
+  search?: {
+    [key in keyof T]?: unknown[] | unknown;
+  };
+
+  @IsOptional()
+  @IsNumber()
+  page?: number;
+
+  @IsOptional()
+  @IsNumber()
+  limit?: number;
+
+  @IsOptional()
+  @IsString()
+  sortBy?: Extract<keyof T, string>;
+
+  @IsOptional()
+  @IsString()
+  @IsEnum(['asc', 'desc'])
+  sortDirection?: SortDirection;
+
+  @IsOptional()
+  @IsDateString()
+  startDate?: string;
+
+  @IsOptional()
+  @IsDateString()
+  endDate?: string;
+
+  @IsOptional()
+  @IsString({ each: true })
+  extend?: string[];
+}
+
+export enum SortDirection {
+  asc = 'asc',
+  desc = 'desc',
+}
+
+export class QueryBuilder<Model extends ObjectionModel, OutputDTO> {
+  constructor(private readonly query: ITakaroQuery<OutputDTO> = new ITakaroQuery()) {}
+
+  build(query: ObjectionQueryBuilder<Model, Model[]>): ObjectionQueryBuilder<Model, Page<Model>> {
+    const tableName = query.modelClass().tableName;
+
+    const pagination = this.pagination();
+    const sorting = this.sorting();
+
+    let qry = query.page(pagination.page, pagination.limit).orderBy(sorting.sortBy, sorting.sortDirection);
+
+    if (this.query.startDate) {
+      qry = qry.where(`${tableName}.createdAt`, '>=', this.query.startDate);
+    }
+    if (this.query.endDate) {
+      qry = qry.where(`${tableName}.createdAt`, '<=', this.query.endDate);
+    }
+
+    qry = this.filters(tableName, qry);
+
+    if (this.query.search) {
+      qry.where((builder) => {
+        for (const search in this.query.search) {
+          if (Object.prototype.hasOwnProperty.call(this.query.search, search)) {
+            const searchVal = this.query.search[search];
+            if (Array.isArray(searchVal)) {
+              searchVal.forEach((val) => {
+                if (val) {
+                  builder.orWhere(`${tableName}.${search}`, 'ilike', `%${val}%`);
+                }
+              });
+            }
+          }
+        }
+      });
+    }
+
+    for (const extend of this.query.extend ?? []) {
+      qry.withGraphFetched(extend);
+    }
+
+    return qry;
+  }
+
+  private filters(
+    tableName: string,
+    query: ObjectionQueryBuilder<Model, Page<Model>>
+  ): ObjectionQueryBuilder<Model, Page<Model>> {
+    for (const filter in this.query.filters) {
+      if (Object.prototype.hasOwnProperty.call(this.query.filters, filter)) {
+        const searchVal = this.query.filters[filter];
+
+        if (searchVal && Array.isArray(searchVal)) {
+          const filtered = searchVal.filter(Boolean);
+          if (filtered.length) {
+            query.whereIn(`${tableName}.${filter}`, searchVal.filter(Boolean) as unknown as AnyQueryBuilder);
+          }
+        }
+      }
+    }
+
+    return query;
+  }
+
+  private sorting(): { sortBy: string; sortDirection: SortDirection } {
+    if (!this.query.sortBy) {
+      return {
+        sortBy: 'id',
+        sortDirection: SortDirection.asc,
+      };
+    }
+    return {
+      sortBy: this.query.sortBy,
+      sortDirection: this.query.sortDirection ?? SortDirection.asc,
+    };
+  }
+
+  private pagination() {
+    return {
+      page: this.query.page ?? 0,
+      limit: this.query.limit ?? 100,
+    };
+  }
+}