@takaro/db 0.0.0-next.0da151e

package/src/migrations/sql/20230618053611-discord-funtionality.ts

@@ -0,0 +1,34 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('discordGuilds', (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.string('discordId').notNullable();
+    table.string('name').notNullable();
+    table.string('icon');
+    table.boolean('takaroEnabled').defaultTo(false);
+
+    table.unique(['discordId', 'domain']);
+  });
+
+  await knex.schema.createTable('userOnDiscordGuild', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.uuid('userId').references('id').inTable('users').onDelete('CASCADE');
+    table.uuid('discordGuildId').references('id').inTable('discordGuilds').onDelete('CASCADE');
+
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+
+    table.unique(['userId', 'discordGuildId']);
+
+    table.boolean('hasManageServer').defaultTo(false);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('userOnDiscordGuild');
+  await knex.schema.dropTable('discordGuilds');
+}

package/src/migrations/sql/20230622192402-discord-hooks.ts

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

package/src/migrations/sql/20230707081218-playerOnGameServerExtension.ts

@@ -0,0 +1,21 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.integer('positionX').nullable();
+    table.integer('positionY').nullable();
+    table.integer('positionZ').nullable();
+    table.integer('ping').nullable();
+    table.specificType('ip', 'inet').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropColumn('positionX');
+    table.dropColumn('positionY');
+    table.dropColumn('positionZ');
+    table.dropColumn('ping');
+    table.dropColumn('ip');
+  });
+}

package/src/migrations/sql/20230710174340-events.ts

@@ -0,0 +1,21 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('events', (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.string('eventName').notNullable();
+
+    table.uuid('playerId').nullable().references('id').inTable('players').onDelete('CASCADE');
+    table.uuid('gameserverId').nullable().references('id').inTable('gameservers').onDelete('CASCADE');
+    table.uuid('moduleId').nullable().references('id').inTable('modules').onDelete('CASCADE');
+
+    table.json('meta').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('events');
+}

package/src/migrations/sql/20230712061220-roles-permissions-extension.ts

@@ -0,0 +1,50 @@
+import { Knex } from 'knex';
+import { formatAlterTableEnumSql } from '../util/alterEnum.js';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw('ALTER TABLE "permissionOnRole" DROP CONSTRAINT IF EXISTS "capabilityOnRole_capability_check";');
+
+  await knex.schema.createTable('roleOnPlayer', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.uuid('playerId').references('players.id').onDelete('CASCADE').notNullable();
+    table.uuid('roleId').references('roles.id').onDelete('CASCADE').notNullable();
+    table.uuid('gameServerId').references('gameservers.id').onDelete('CASCADE').nullable();
+  });
+
+  await knex.schema.createTable('modulePermission', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.uuid('moduleId').references('modules.id').onDelete('CASCADE').notNullable();
+    table.string('permission').notNullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.raw(
+    formatAlterTableEnumSql('permissionOnRole', 'permission', [
+      'ROOT',
+      'MANAGE_USERS',
+      'READ_USERS',
+      'MANAGE_ROLES',
+      'READ_ROLES',
+      'MANAGE_GAMESERVERS',
+      'READ_GAMESERVERS',
+      'READ_FUNCTIONS',
+      'MANAGE_FUNCTIONS',
+      'READ_CRONJOBS',
+      'MANAGE_CRONJOBS',
+      'READ_HOOKS',
+      'MANAGE_HOOKS',
+      'READ_MODULES',
+      'MANAGE_MODULES',
+      'READ_PLAYERS',
+      'MANAGE_PLAYERS',
+      'MANAGE_SETTINGS',
+      'READ_SETTINGS',
+    ]),
+  );
+
+  await knex.schema.dropTable('roleOnPlayer');
+  await knex.schema.dropTable('modulePermission');
+}

package/src/migrations/sql/20230713184927-variables-modulescoped.ts

@@ -0,0 +1,32 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // drop the old 'variables_key_domain_gameServerId_playerId_unique' constraint
+  await knex.raw(`
+    ALTER TABLE variables
+    DROP CONSTRAINT variables_key_domain_gameServerId_playerId_unique;
+  `);
+
+  await knex.schema.alterTable('variables', (table) => {
+    table.uuid('moduleId').references('modules.id').onDelete('CASCADE').nullable();
+  });
+
+  await knex.raw(`
+  ALTER TABLE variables
+  ADD CONSTRAINT variables_key_domain_gameServerId_moduleId_playerId_unique
+  UNIQUE NULLS NOT DISTINCT (key, domain, "gameServerId", "playerId", "moduleId");
+`);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('variables', (table) => {
+    table.dropForeign(['moduleId']);
+    table.dropUnique(['key', 'domain', 'gameServerId', 'playerId', 'moduleId']);
+  });
+
+  await knex.raw(`
+    ALTER TABLE variables
+    ADD CONSTRAINT variables_key_domain_gameServerId_playerId_unique
+    UNIQUE NULLS NOT DISTINCT (key, domain, "gameServerId", "playerId");
+  `);
+}

package/src/migrations/sql/20230714045136-domain-index.ts

@@ -0,0 +1,40 @@
+import { Knex } from 'knex';
+
+const tablesToIndex = [
+  'roles',
+  'gameservers',
+  'players',
+  'playerOnGameServer',
+  'functions',
+  'settings',
+  'gameServerSettings',
+  'cronJobs',
+  'hooks',
+  'commands',
+  'commandArguments',
+  'modules',
+  'moduleAssignments',
+  'variables',
+  'users',
+  'discordGuilds',
+  'userOnDiscordGuild',
+  'events',
+];
+
+export async function up(knex: Knex): Promise<void> {
+  // Add index for domain in all tables
+  for (const table of tablesToIndex) {
+    await knex.schema.alterTable(table, (t) => {
+      t.index('domain');
+    });
+  }
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Remove index for domain in all tables
+  for (const table of tablesToIndex) {
+    await knex.schema.alterTable(table, (t) => {
+      t.dropIndex('domain');
+    });
+  }
+}

package/src/migrations/sql/20230714045727-events-index.ts

@@ -0,0 +1,19 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (t) => {
+    t.index('createdAt');
+    t.index('playerId');
+    t.index('gameserverId');
+    t.index('moduleId');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (t) => {
+    t.dropIndex('createdAt');
+    t.dropIndex('playerId');
+    t.dropIndex('gameserverId');
+    t.dropIndex('moduleId');
+  });
+}

package/src/migrations/sql/20230715102519-module-permissions-extra-fields.ts

@@ -0,0 +1,38 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('modulePermission', (table) => {
+    table.string('description').defaultTo('No description provided');
+    table.string('friendlyName');
+  });
+
+  await knex.raw(`
+    CREATE OR REPLACE FUNCTION set_friendly_name() 
+    RETURNS TRIGGER AS $$
+    BEGIN
+      IF NEW."friendlyName" IS NULL THEN
+        NEW."friendlyName" := NEW.permission;
+      END IF;
+      RETURN NEW;
+    END;
+    $$ LANGUAGE plpgsql;
+  `);
+
+  await knex.raw(`
+    CREATE TRIGGER check_friendly_name 
+    BEFORE INSERT OR UPDATE ON "modulePermission"
+    FOR EACH ROW EXECUTE PROCEDURE set_friendly_name();
+  `);
+
+  await knex.raw('ALTER TABLE "permissionOnRole" DROP CONSTRAINT IF EXISTS "capabilityOnRole_capability_check";');
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('modulePermission', (table) => {
+    table.dropColumn('description');
+    table.dropColumn('friendlyName');
+  });
+
+  await knex.raw('DROP TRIGGER IF EXISTS check_friendly_name ON "modulePermission";');
+  await knex.raw('DROP FUNCTION IF EXISTS set_friendly_name();');
+}

package/src/migrations/sql/20230724062109-roles-constraints.ts

@@ -0,0 +1,16 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(`
+    ALTER TABLE "roleOnPlayer"
+    ADD CONSTRAINT role_on_player_unique_idx
+    UNIQUE NULLS NOT DISTINCT ("gameServerId", "playerId", "roleId");
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Removing the unique constraint
+  await knex.raw(`
+    DROP INDEX role_on_player_unique_idx;
+  `);
+}

package/src/migrations/sql/20230811095701-userId-on-events.ts

@@ -0,0 +1,14 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (table) => {
+    table.uuid('userId').references('id').inTable('users').onDelete('CASCADE');
+    table.index('userId');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (table) => {
+    table.dropColumn('userId');
+  });
+}

package/src/migrations/sql/20230921123717-count-for-permissions.ts

@@ -0,0 +1,101 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('modulePermission', (table) => {
+    table.boolean('canHaveCount').defaultTo(false);
+    // drop not null constraint
+    table.uuid('moduleId').nullable().alter();
+  });
+
+  await knex.schema.renameTable('modulePermission', 'permission');
+
+  // Create default permissions
+  const perms = [
+    'ROOT',
+    'MANAGE_USERS',
+    'READ_USERS',
+    'MANAGE_ROLES',
+    'READ_ROLES',
+    'MANAGE_GAMESERVERS',
+    'READ_GAMESERVERS',
+    'READ_FUNCTIONS',
+    'MANAGE_FUNCTIONS',
+    'READ_CRONJOBS',
+    'MANAGE_CRONJOBS',
+    'READ_HOOKS',
+    'MANAGE_HOOKS',
+    'READ_MODULES',
+    'MANAGE_MODULES',
+    'READ_PLAYERS',
+    'MANAGE_PLAYERS',
+    'MANAGE_SETTINGS',
+    'READ_SETTINGS',
+  ];
+
+  await knex('permission').insert(
+    perms.map((perm) => ({
+      permission: perm,
+      canHaveCount: false,
+    })),
+  );
+
+  await knex.schema.createTable('temp_permissiononrole', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary();
+    table.uuid('roleId');
+    table.string('permission');
+    table.string('domain');
+  });
+
+  await knex.raw('INSERT INTO temp_permissiononrole SELECT * FROM "permissionOnRole"');
+
+  await knex.schema.alterTable('permissionOnRole', (table) => {
+    table.integer('count').defaultTo(0);
+    table.uuid('permissionId').references('permission.id').onDelete('CASCADE').nullable();
+  });
+
+  await knex.raw(`
+    UPDATE "permissionOnRole" AS por
+    SET "permissionId" = p.id
+    FROM "temp_permissiononrole" AS temp, "permission" AS p
+    WHERE temp.id = por.id AND temp.permission = p.permission
+  `);
+
+  await knex.schema.alterTable('permissionOnRole', (table) => {
+    table.dropColumn('permission');
+    // make permissionId not nullable
+    table.uuid('permissionId').notNullable().alter();
+  });
+
+  await knex.schema.dropTable('temp_permissiononrole');
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // Step 1: Re-create the original 'permission' column in 'permissionOnRole'
+  await knex.schema.alterTable('permissionOnRole', (table) => {
+    table.string('permission').nullable();
+  });
+
+  // Populate the original 'permission' based on 'permissionId'
+  await knex.raw(`
+    UPDATE "permissionOnRole" AS por
+    SET "permission" = p.permission
+    FROM "permission" AS p
+    WHERE por."permissionId" = p.id
+  `);
+
+  // Step 2: Drop the new columns and constraints in 'permissionOnRole'
+  await knex.schema.alterTable('permissionOnRole', (table) => {
+    table.dropColumn('count');
+    table.dropColumn('permissionId');
+  });
+
+  // Step 3: Rename the 'permission' table back to 'modulePermission'
+  await knex.schema.renameTable('permission', 'modulePermission');
+
+  // Step 4: Restore the original columns and constraints in 'modulePermission'
+  await knex.schema.alterTable('modulePermission', (table) => {
+    table.dropColumn('canHaveCount');
+    table.uuid('moduleId').notNullable().alter(); // Re-add the NOT NULL constraint
+  });
+}

package/src/migrations/sql/20231111102812-details-system-permissions.ts

@@ -0,0 +1,192 @@
+import { Knex } from 'knex';
+
+export enum PERMISSIONS {
+  'ROOT' = 'ROOT',
+  'MANAGE_USERS' = 'MANAGE_USERS',
+  'READ_USERS' = 'READ_USERS',
+  'MANAGE_ROLES' = 'MANAGE_ROLES',
+  'READ_ROLES' = 'READ_ROLES',
+  'MANAGE_GAMESERVERS' = 'MANAGE_GAMESERVERS',
+  'READ_GAMESERVERS' = 'READ_GAMESERVERS',
+  'READ_FUNCTIONS' = 'READ_FUNCTIONS',
+  'MANAGE_FUNCTIONS' = 'MANAGE_FUNCTIONS',
+  'READ_CRONJOBS' = 'READ_CRONJOBS',
+  'MANAGE_CRONJOBS' = 'MANAGE_CRONJOBS',
+  'READ_HOOKS' = 'READ_HOOKS',
+  'MANAGE_HOOKS' = 'MANAGE_HOOKS',
+  'READ_COMMANDS' = 'READ_COMMANDS',
+  'MANAGE_COMMANDS' = 'MANAGE_COMMANDS',
+  'READ_MODULES' = 'READ_MODULES',
+  'MANAGE_MODULES' = 'MANAGE_MODULES',
+  'READ_PLAYERS' = 'READ_PLAYERS',
+  'MANAGE_PLAYERS' = 'MANAGE_PLAYERS',
+  'MANAGE_SETTINGS' = 'MANAGE_SETTINGS',
+  'READ_SETTINGS' = 'READ_SETTINGS',
+  'READ_VARIABLES' = 'READ_VARIABLES',
+  'MANAGE_VARIABLES' = 'MANAGE_VARIABLES',
+  'READ_EVENTS' = 'READ_EVENTS',
+  'MANAGE_EVENTS' = 'MANAGE_EVENTS',
+}
+
+export interface IPermissionDetails {
+  permission: string;
+  friendlyName: string;
+  description: string;
+}
+
+export const PERMISSION_DETAILS: Record<PERMISSIONS, IPermissionDetails> = {
+  [PERMISSIONS.ROOT]: {
+    permission: PERMISSIONS.ROOT,
+    friendlyName: 'Root Access',
+    description: 'Full access to all systems and resources',
+  },
+  [PERMISSIONS.MANAGE_USERS]: {
+    permission: PERMISSIONS.MANAGE_USERS,
+    friendlyName: 'Manage Users',
+    description: 'Can create, update, and delete users',
+  },
+  [PERMISSIONS.READ_USERS]: {
+    permission: PERMISSIONS.READ_USERS,
+    friendlyName: 'Read Users',
+    description: 'Can view user details',
+  },
+  [PERMISSIONS.MANAGE_ROLES]: {
+    permission: PERMISSIONS.MANAGE_ROLES,
+    friendlyName: 'Manage Roles',
+    description: 'Can create, update, and delete roles',
+  },
+  [PERMISSIONS.READ_ROLES]: {
+    permission: PERMISSIONS.READ_ROLES,
+    friendlyName: 'Read Roles',
+    description: 'Can view role details',
+  },
+  [PERMISSIONS.MANAGE_GAMESERVERS]: {
+    permission: PERMISSIONS.MANAGE_GAMESERVERS,
+    friendlyName: 'Manage Game Servers',
+    description: 'Can create, update, and delete game servers',
+  },
+  [PERMISSIONS.READ_GAMESERVERS]: {
+    permission: PERMISSIONS.READ_GAMESERVERS,
+    friendlyName: 'Read Game Servers',
+    description: 'Can view game server details',
+  },
+  [PERMISSIONS.READ_FUNCTIONS]: {
+    permission: PERMISSIONS.READ_FUNCTIONS,
+    friendlyName: 'Read Functions',
+    description: 'Can view function details',
+  },
+  [PERMISSIONS.MANAGE_FUNCTIONS]: {
+    permission: PERMISSIONS.MANAGE_FUNCTIONS,
+    friendlyName: 'Manage Functions',
+    description: 'Can create, update, and delete functions',
+  },
+  [PERMISSIONS.READ_CRONJOBS]: {
+    permission: PERMISSIONS.READ_CRONJOBS,
+    friendlyName: 'Read Cron Jobs',
+    description: 'Can view cron job details',
+  },
+  [PERMISSIONS.MANAGE_CRONJOBS]: {
+    permission: PERMISSIONS.MANAGE_CRONJOBS,
+    friendlyName: 'Manage Cron Jobs',
+    description: 'Can create, update, and delete cron jobs',
+  },
+  [PERMISSIONS.READ_HOOKS]: {
+    permission: PERMISSIONS.READ_HOOKS,
+    friendlyName: 'Read Hooks',
+    description: 'Can view hook details',
+  },
+  [PERMISSIONS.MANAGE_HOOKS]: {
+    permission: PERMISSIONS.MANAGE_HOOKS,
+    friendlyName: 'Manage Hooks',
+    description: 'Can create, update, and delete hooks',
+  },
+  [PERMISSIONS.READ_COMMANDS]: {
+    permission: PERMISSIONS.READ_COMMANDS,
+    friendlyName: 'Read Commands',
+    description: 'Can view command details',
+  },
+  [PERMISSIONS.MANAGE_COMMANDS]: {
+    permission: PERMISSIONS.MANAGE_COMMANDS,
+    friendlyName: 'Manage Commands',
+    description: 'Can create, update, and delete commands',
+  },
+  [PERMISSIONS.READ_MODULES]: {
+    permission: PERMISSIONS.READ_MODULES,
+    friendlyName: 'Read Modules',
+    description: 'Can view module details',
+  },
+  [PERMISSIONS.MANAGE_MODULES]: {
+    permission: PERMISSIONS.MANAGE_MODULES,
+    friendlyName: 'Manage Modules',
+    description: 'Can create, update, and delete modules',
+  },
+  [PERMISSIONS.READ_PLAYERS]: {
+    permission: PERMISSIONS.READ_PLAYERS,
+    friendlyName: 'Read Players',
+    description: 'Can view player details',
+  },
+  [PERMISSIONS.MANAGE_PLAYERS]: {
+    permission: PERMISSIONS.MANAGE_PLAYERS,
+    friendlyName: 'Manage Players',
+    description: 'Can create, update, and delete players',
+  },
+  [PERMISSIONS.MANAGE_SETTINGS]: {
+    permission: PERMISSIONS.MANAGE_SETTINGS,
+    friendlyName: 'Manage Settings',
+    description: 'Can modify settings',
+  },
+  [PERMISSIONS.READ_SETTINGS]: {
+    permission: PERMISSIONS.READ_SETTINGS,
+    friendlyName: 'Read Settings',
+    description: 'Can view settings',
+  },
+  [PERMISSIONS.READ_VARIABLES]: {
+    permission: PERMISSIONS.READ_VARIABLES,
+    friendlyName: 'Read Variables',
+    description: 'Can view variables',
+  },
+  [PERMISSIONS.MANAGE_VARIABLES]: {
+    permission: PERMISSIONS.MANAGE_VARIABLES,
+    friendlyName: 'Manage Variables',
+    description: 'Can create, update, and delete variables',
+  },
+  [PERMISSIONS.READ_EVENTS]: {
+    permission: PERMISSIONS.READ_EVENTS,
+    friendlyName: 'Read Events',
+    description: 'Can view event details',
+  },
+  [PERMISSIONS.MANAGE_EVENTS]: {
+    permission: PERMISSIONS.MANAGE_EVENTS,
+    friendlyName: 'Manage Events',
+    description: 'Can create, update, and delete events',
+  },
+};
+
+export async function up(knex: Knex): Promise<void> {
+  // For all system permissions, find the record in the DB
+  // And update the description and friendly name
+
+  const permissions = Object.values(PERMISSIONS);
+
+  for (const permission of permissions) {
+    const details = PERMISSION_DETAILS[permission];
+    await knex('permission').where({ permission }).update({
+      description: details.description,
+      friendlyName: details.friendlyName,
+    });
+  }
+}
+
+export async function down(knex: Knex): Promise<void> {
+  // For all system permissions, find the record in the DB
+  // And update the description and friendly name
+
+  const permissions = Object.values(PERMISSIONS);
+
+  for (const permission of permissions) {
+    await knex('permission').where({ permission }).update({
+      description: 'No description provided',
+      friendlyName: permission,
+    });
+  }
+}

package/src/migrations/sql/20231114151343-system-roles.ts

@@ -0,0 +1,46 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Ensure for each domainId, a role 'User' and a role 'Player' exists
+  await knex.raw(`
+    INSERT INTO roles (name, domain)
+    SELECT 'User', id
+    FROM domains
+    WHERE NOT EXISTS (
+      SELECT id
+      FROM roles
+      WHERE name = 'User'
+      AND domain = domains.id
+    );
+  `);
+
+  await knex.raw(`
+    INSERT INTO roles (name, domain)
+    SELECT 'Player', id
+    FROM domains
+    WHERE NOT EXISTS (
+      SELECT id
+      FROM roles
+      WHERE name = 'Player'
+      AND domain = domains.id
+    );
+  `);
+
+  // Add a 'system' flag to the role table
+  await knex.schema.alterTable('roles', (table) => {
+    table.boolean('system').defaultTo(false);
+  });
+
+  // Set system=true for the 'user', 'player' and 'root' roles
+  await knex.raw(`
+    UPDATE roles
+    SET system = true
+    WHERE name IN ('User', 'Player', 'root');
+  `);
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('roles', (table) => {
+    table.dropColumn('system');
+  });
+}