@takaro/db 0.0.0-next.09a7ca1

package/src/config.ts

@@ -0,0 +1,122 @@
+import { Config, IBaseConfig, baseConfigConvict } from '@takaro/config';
+
+export interface IDbConfig extends IBaseConfig {
+  postgres: {
+    connectionString: string;
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    ssl: boolean;
+    ca: string;
+  };
+  redis: {
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+  };
+  systemSchema: string;
+  baseDomainSchema: string;
+  encryptionKey: string;
+}
+
+export const configSchema = {
+  postgres: {
+    connectionString: {
+      doc: 'The Postgres connection string to use',
+      format: String,
+      default: '',
+      env: 'POSTGRES_CONNECTION_STRING',
+    },
+    host: {
+      doc: 'The Postgres host to connect to',
+      format: String,
+      default: 'localhost',
+      env: 'POSTGRES_HOST',
+    },
+    port: {
+      doc: 'The Postgres port to connect to',
+      format: Number,
+      default: 5432,
+      env: 'POSTGRES_PORT',
+    },
+    user: {
+      doc: 'The Postgres user to connect as',
+      format: String,
+      default: 'postgres',
+      env: 'POSTGRES_USER',
+    },
+    password: {
+      doc: 'The Postgres password to use',
+      format: String,
+      default: 'postgres',
+      env: 'POSTGRES_PASSWORD',
+    },
+    database: {
+      doc: 'The Postgres database to use',
+      format: String,
+      default: 'postgres',
+      env: 'POSTGRES_DB',
+    },
+    ssl: {
+      doc: 'Whether to use SSL for the connection',
+      format: Boolean,
+      default: false,
+      env: 'POSTGRES_SSL',
+    },
+    ca: {
+      doc: 'The CA certificate to use for SSL connections',
+      format: String,
+      default: '',
+      env: 'POSTGRES_CA',
+    },
+  },
+  redis: {
+    host: {
+      doc: 'The host of the redis server',
+      format: String,
+      default: 'localhost',
+      env: 'REDIS_HOST',
+    },
+    port: {
+      doc: 'The port of the redis server',
+      format: Number,
+      default: 6379,
+      env: 'REDIS_PORT',
+    },
+    username: {
+      doc: 'The username of the redis server',
+      format: String,
+      default: '',
+      env: 'REDIS_USERNAME',
+    },
+    password: {
+      doc: 'The password of the redis server',
+      format: String,
+      default: '',
+      env: 'REDIS_PASSWORD',
+    },
+  },
+  systemSchema: {
+    doc: 'The Postgres schema to use for system-related actions (like domain management)',
+    format: String,
+    default: 'takaro',
+    env: 'POSTGRES_SYSTEM_SCHEMA',
+  },
+  baseDomainSchema: {
+    doc: 'String used as base for creating name of domain-scoped schemas',
+    format: String,
+    default: 'domain_',
+    env: 'POSTGRES_BASE_DOMAIN_SCHEMA',
+  },
+  encryptionKey: {
+    doc: 'Encryption key used for encrypting sensitive data',
+    format: String,
+    default: null,
+    env: 'POSTGRES_ENCRYPTION_KEY',
+  },
+};
+
+export const config = new Config<IDbConfig>([configSchema, baseConfigConvict]);

package/src/encryption.ts

@@ -0,0 +1,26 @@
+import { config } from './config.js';
+import { getKnex } from './knex.js';
+
+export async function encrypt(value: string): Promise<string> {
+  const knex = await getKnex();
+  const res = await knex.raw('SELECT PGP_SYM_ENCRYPT(?,?) AS value', [value, config.get('encryptionKey')]);
+  return res.rows[0].value;
+}
+
+export async function decrypt(value: string): Promise<string> {
+  const knex = await getKnex();
+  const res = await knex.raw('SELECT PGP_SYM_DECRYPT(?,?) AS value', [value, config.get('encryptionKey')]);
+  return res.rows[0].value;
+}
+
+export async function hash(value: string): Promise<string> {
+  const knex = await getKnex();
+  const res = await knex.raw("SELECT crypt(?, gen_salt('bf')) as value", [value]);
+  return res.rows[0].value;
+}
+
+export async function compareHashed(value: string, hash: string): Promise<boolean> {
+  const knex = await getKnex();
+  const res = await knex.raw('SELECT crypt(?, ?) = ? as result', [value, hash, hash]);
+  return res.rows[0].result;
+}

package/src/errorTypeGuards.ts

@@ -0,0 +1,11 @@
+import { errors } from '@takaro/util';
+
+export function parseCheckViolationError(error: unknown, constraintName: string): errors.BadRequestError | null {
+  if (!(error instanceof Error)) {
+    return null;
+  }
+  if (error.name === 'CheckViolationError') {
+    return new errors.BadRequestError(`Check constraint "${constraintName}" failed`);
+  }
+  return null;
+}

package/src/knex.ts

@@ -0,0 +1,59 @@
+import knexPkg from 'knex';
+import { config } from './config.js';
+import { logger, health } from '@takaro/util';
+import { TakaroModel } from './TakaroModel.js';
+
+const log = logger('sql');
+
+const { knex: createKnex } = knexPkg;
+
+type KnexClient = knexPkg.Knex<TakaroModel, unknown[]>;
+
+export function getKnexOptions(extra: Record<string, unknown> = {}) {
+  const opts: knexPkg.Knex.Config = {
+    client: 'pg',
+    connection: {
+      connectionString: config.get('postgres.connectionString'),
+      host: config.get('postgres.host'),
+      port: config.get('postgres.port'),
+      user: config.get('postgres.user'),
+      password: config.get('postgres.password'),
+      database: config.get('postgres.database'),
+      ssl: config.get('postgres.ssl') ? { ca: config.get('postgres.ca') } : false,
+    },
+    ...extra,
+  };
+  return opts;
+}
+
+let cachedKnex: KnexClient | null = null;
+
+export async function getKnex(): Promise<KnexClient> {
+  if (cachedKnex) return cachedKnex;
+
+  log.debug('Missed knex cache, creating new client');
+  const knex = createKnex(getKnexOptions());
+  cachedKnex = knex;
+
+  health.registerHook('db', isDbAvailable);
+
+  return cachedKnex;
+}
+
+export async function isDbAvailable(): Promise<boolean> {
+  try {
+    const knex = await getKnex();
+    await knex.raw('SELECT 1');
+    return true;
+  } catch (error) {
+    log.error(error);
+    return false;
+  }
+}
+
+export async function disconnectKnex(): Promise<void> {
+  if (!cachedKnex) return;
+  await cachedKnex.destroy();
+  cachedKnex = null;
+  log.info('Disconnected knex');
+}

package/src/main.ts

@@ -0,0 +1,15 @@
+export { TakaroModel, NOT_DOMAIN_SCOPED_TakaroModel } from './TakaroModel.js';
+
+export { ITakaroQuery, QueryBuilder, SortDirection } from './queryBuilder.js';
+
+export { getKnex, disconnectKnex } from './knex.js';
+
+export { migrate, migrateUndo } from './migrations/index.js';
+
+export * from './encryption.js';
+
+export { configSchema, IDbConfig } from './config.js';
+
+export { Redis, RedisClient } from './redis.js';
+
+export * from './errorTypeGuards.js';

package/src/migrations/index.ts

@@ -0,0 +1,70 @@
+import { getKnex } from '../knex.js';
+import { readdir } from 'fs/promises';
+import { Knex } from 'knex';
+import path from 'node:path';
+import { logger } from '@takaro/util';
+import * as url from 'url';
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
+const log = logger('db:migrations');
+
+interface IMigration {
+  name: string;
+  up: (knex: Knex) => Promise<void>;
+  down: (knex: Knex) => Promise<void>;
+}
+
+class TakaroMigrationSource {
+  // Hack to get around ts compiler/monorepo/dynamic import weirdness
+  // See: https://github.com/TypeStrong/ts-node/discussions/1290
+  private dynamicImport = new Function('specifier', 'return import(specifier)');
+
+  async getMigrations() {
+    const folderPath = path.join(__dirname, 'sql');
+    const files = await readdir(folderPath);
+    const migrations = files
+      .filter((file) => file.endsWith('.js'))
+      .map((file) => {
+        return this.dynamicImport(`${folderPath}/${file}`).then((migration: IMigration) => {
+          return {
+            name: file,
+            up: migration.up,
+            down: migration.down,
+          };
+        });
+      });
+    return Promise.all(migrations);
+  }
+
+  getMigrationName(migration: IMigration) {
+    return migration.name;
+  }
+
+  async getMigration(migration: IMigration) {
+    return migration;
+  }
+}
+
+export async function migrate() {
+  const knex = await getKnex();
+  knex.on('query', (queryData) => {
+    log.debug(queryData.sql);
+  });
+  await knex.migrate.latest({
+    migrationSource: new TakaroMigrationSource(),
+  });
+  await knex.destroy();
+  log.info('Migrations complete');
+}
+
+export async function migrateUndo() {
+  const knex = await getKnex();
+  knex.on('query', (queryData) => {
+    log.debug(queryData.sql);
+  });
+  await knex.migrate.down({
+    migrationSource: new TakaroMigrationSource(),
+  });
+  await knex.destroy();
+  log.info('Migrations rollback complete');
+}

package/src/migrations/sql/20220827191938_init.ts

@@ -0,0 +1,183 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('domains', (table) => {
+    table.timestamps(true, true, true);
+    table.string('id').primary();
+    table.string('name').unique();
+  });
+
+  await knex.schema.createTable('users', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('name').notNullable();
+    table.string('email').unique();
+    table.string('password').notNullable();
+
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+  });
+
+  await knex.schema.createTable('roles', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('name');
+
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+
+    table.unique(['name', 'domain']);
+  });
+
+  await knex.schema.createTable('capabilityOnRole', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.uuid('roleId').references('id').inTable('roles').onDelete('CASCADE');
+    table
+      .enu('capability', [
+        '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',
+      ])
+      .notNullable();
+
+    table.primary(['roleId', 'capability']);
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+  });
+
+  await knex.schema.createTable('roleOnUser', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('userId').references('users.id').onDelete('CASCADE').notNullable();
+    table.uuid('roleId').references('roles.id').onDelete('CASCADE').notNullable();
+
+    table.primary(['userId', 'roleId']);
+  });
+
+  await knex.schema.createTable('gameservers', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('name');
+    table.enu('type', ['MOCK', 'SEVENDAYSTODIE', 'RUST']).notNullable();
+    table.binary('connectionInfo').notNullable();
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+
+    table.unique(['name', 'domain']);
+  });
+
+  await knex.schema.createTable('players', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('name').notNullable();
+    table.string('steamId');
+    table.string('xboxLiveId');
+    table.string('epicOnlineServicesId');
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+  });
+
+  await knex.schema.createTable('playerOnGameServer', (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('gameServerId').references('gameservers.id').onDelete('CASCADE').notNullable();
+
+    table.string('gameId').notNullable();
+
+    table.primary(['playerId', 'gameServerId']);
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+  });
+
+  await knex.schema.createTable('functions', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.text('code').notNullable();
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+  });
+
+  await knex.schema.createTable('modules', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('name');
+    table.boolean('enabled').notNullable().defaultTo(true);
+    table.json('config').defaultTo('{}');
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+
+    table.unique(['name', 'domain']);
+  });
+
+  await knex.schema.createTable('cronJobs', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('name');
+    table.boolean('enabled').notNullable().defaultTo(true);
+    table.string('temporalValue').notNullable();
+    table.uuid('moduleId').references('modules.id').onDelete('CASCADE').notNullable();
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+
+    table.unique(['name', 'moduleId']);
+  });
+
+  await knex.schema.createTable('hooks', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('name');
+    table.boolean('enabled').notNullable().defaultTo(true);
+    table.enu('eventType', ['log', 'player-connected', 'player-disconnected']).notNullable();
+    table.string('regex').notNullable();
+    table.uuid('moduleId').references('modules.id').onDelete('CASCADE').notNullable();
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+
+    table.unique(['name', 'moduleId']);
+  });
+
+  await knex.schema.createTable('commands', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('name');
+    table.boolean('enabled').notNullable().defaultTo(true);
+    table.uuid('moduleId').references('modules.id').onDelete('CASCADE').notNullable();
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+
+    table.unique(['name', 'moduleId']);
+  });
+
+  await knex.schema.createTable('functionAssignments', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.uuid('function').references('functions.id').onDelete('CASCADE').notNullable().unique();
+    table.uuid('cronJob').references('cronJobs.id').onDelete('CASCADE');
+    table.uuid('hook').references('hooks.id').onDelete('CASCADE');
+    table.uuid('command').references('commands.id').onDelete('CASCADE');
+    table.check('(?? IS NOT NULL) OR (?? IS NOT NULL) OR (?? IS NOT NULL)', ['cronJob', 'hook', 'command']);
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+  });
+
+  await knex.raw('CREATE EXTENSION IF NOT EXISTS pgcrypto');
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('domains');
+  await knex.schema.dropTable('functionAssignments');
+  await knex.schema.dropTable('commands');
+  await knex.schema.dropTable('hooks');
+  await knex.schema.dropTable('cronJobs');
+  await knex.schema.dropTable('modules');
+  await knex.schema.dropTable('functions');
+  await knex.schema.dropTable('playerOnGameServer');
+  await knex.schema.dropTable('players');
+  await knex.schema.dropTable('gameservers');
+  await knex.schema.dropTable('roleOnUser');
+  await knex.schema.dropTable('roles');
+  await knex.schema.dropTable('users');
+}

package/src/migrations/sql/20221019173729_settings.ts

@@ -0,0 +1,70 @@
+import { Knex } from 'knex';
+import { formatAlterTableEnumSql } from '../util/alterEnum.js';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('settings', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.string('commandPrefix');
+    table.string('serverChatName');
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+  });
+
+  await knex.schema.createTable('gameServerSettings', (table) => {
+    table.inherits('settings');
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.uuid('gameServerId').references('gameservers.id').onDelete('CASCADE').notNullable().unique();
+    table.string('domain').references('domains.id').onDelete('CASCADE').notNullable();
+  });
+
+  await knex.raw(
+    formatAlterTableEnumSql('capabilityOnRole', 'capability', [
+      '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',
+    ]),
+  );
+}
+
+export async function down(knex: Knex): Promise<void> {
+  knex.schema.dropTable('gameServerSettings');
+  knex.schema.dropTable('settings');
+
+  await knex.raw(
+    formatAlterTableEnumSql('capabilityOnRole', 'capability', [
+      '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',
+    ]),
+  );
+}

package/src/migrations/sql/20221029103554_refactor_function_assignments.ts

@@ -0,0 +1,41 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('hooks', (table) => {
+    table.uuid('functionId').references('functions.id').onDelete('CASCADE');
+  });
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.uuid('functionId').references('functions.id').onDelete('CASCADE');
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.uuid('functionId').references('functions.id').onDelete('CASCADE');
+  });
+
+  await knex.schema.dropTable('functionAssignments');
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.createTable('functionAssignments', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+    table.uuid('functionId').references('functions.id').onDelete('CASCADE').notNullable().unique();
+    table.uuid('cronJob').references('cronJobs.id').onDelete('CASCADE');
+    table.uuid('hook').references('hooks.id').onDelete('CASCADE');
+    table.uuid('command').references('commands.id').onDelete('CASCADE');
+    table.check('(?? IS NOT NULL) OR (?? IS NOT NULL) OR (?? IS NOT NULL)', ['cronJob', 'hook', 'command']);
+  });
+
+  await knex.schema.alterTable('cronJobs', (table) => {
+    table.dropColumn('functionId');
+  });
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropColumn('functionId');
+  });
+
+  await knex.schema.alterTable('hooks', (table) => {
+    table.dropColumn('functionId');
+  });
+}

package/src/migrations/sql/20221102190532_commands.ts

@@ -0,0 +1,66 @@
+import { Knex } from 'knex';
+import { formatAlterTableEnumSql } from '../util/alterEnum.js';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(
+    formatAlterTableEnumSql('capabilityOnRole', 'capability', [
+      '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',
+      'READ_COMMANDS',
+      'MANAGE_COMMANDS',
+    ]),
+  );
+
+  await knex.schema.alterTable('commands', (table) => {
+    table.text('trigger');
+    table.text('helpText').defaultTo('No help text available');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('commands', (table) => {
+    table.dropColumn('trigger');
+    table.dropColumn('helpText');
+  });
+
+  await knex.raw(
+    formatAlterTableEnumSql('capabilityOnRole', 'capability', [
+      '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',
+    ]),
+  );
+}