@takaro/db 0.0.1 → 0.0.4

package/src/__tests__/queryBuilder.integration.test.ts

@@ -183,18 +183,21 @@ describe('QueryBuilder', () => {
     const start = new Date();
     await TestUserModel.query().insert({ name: 'test1' });
     await TestUserModel.query().insert({ name: 'test2' });
-
     const end = new Date();
 
     // Quick hack to make the test pass
     // Relying on times like this with an external DB is troublesome...
     await sleep(250);
 
-    await TestUserModel.query().insert({ name: 'test3', createdAt: end.toISOString() });
+    await TestUserModel.query().insert({ name: 'test3' });
 
     const res = await new QueryBuilder<TestUserModel, TestUserModel>({
-      startDate: start.toISOString(),
-      endDate: end.toISOString(),
+      greaterThan: {
+        createdAt: start.toISOString(),
+      },
+      lessThan: {
+        createdAt: end.toISOString(),
+      },
     }).build(TestUserModel.query());
 
     expect(res.results).to.have.lengthOf(2);

package/src/config.ts

@@ -7,6 +7,8 @@ export interface IDbConfig extends IBaseConfig {
     user: string;
     password: string;
     database: string;
+    ssl: boolean;
+    ca: string;
   };
   redis: {
     host: string;
@@ -51,6 +53,18 @@ export const configSchema = {
       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: {

package/src/knex.ts

@@ -18,6 +18,7 @@ export function getKnexOptions(extra: Record<string, unknown> = {}) {
       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,
   };

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

@@ -38,7 +38,7 @@ export async function up(knex: Knex): Promise<void> {
       'MANAGE_PLAYERS',
       'MANAGE_SETTINGS',
       'READ_SETTINGS',
-    ])
+    ]),
   );
 }
 
@@ -65,6 +65,6 @@ export async function down(knex: Knex): Promise<void> {
       'MANAGE_MODULES',
       'READ_PLAYERS',
       'MANAGE_PLAYERS',
-    ])
+    ]),
   );
 }

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

@@ -25,7 +25,7 @@ export async function up(knex: Knex): Promise<void> {
       'READ_SETTINGS',
       'READ_COMMANDS',
       'MANAGE_COMMANDS',
-    ])
+    ]),
   );
 
   await knex.schema.alterTable('commands', (table) => {
@@ -61,6 +61,6 @@ export async function down(knex: Knex): Promise<void> {
       'MANAGE_PLAYERS',
       'MANAGE_SETTINGS',
       'READ_SETTINGS',
-    ])
+    ]),
   );
 }

package/src/migrations/sql/20230308183400-persistent-variables.ts

@@ -27,7 +27,7 @@ export async function up(knex: Knex): Promise<void> {
       'MANAGE_COMMANDS',
       'READ_VARIABLES',
       'MANAGE_VARIABLES',
-    ])
+    ]),
   );
 
   await knex.schema.createTable('variables', (table) => {
@@ -69,6 +69,6 @@ export async function down(knex: Knex): Promise<void> {
       'READ_SETTINGS',
       'READ_COMMANDS',
       'MANAGE_COMMANDS',
-    ])
+    ]),
   );
 }

package/src/migrations/sql/20230604130951-fix-hook-eventtypes.ts

@@ -3,7 +3,7 @@ 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'])
+    formatAlterTableEnumSql('hooks', 'eventType', ['log', 'player-connected', 'player-disconnected', 'chat-message']),
   );
 }
 

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

@@ -9,12 +9,12 @@ export async function up(knex: Knex): Promise<void> {
       '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'])
+    formatAlterTableEnumSql('hooks', 'eventType', ['log', 'player-connected', 'player-disconnected', 'chat-message']),
   );
 }

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

@@ -42,7 +42,7 @@ export async function down(knex: Knex): Promise<void> {
       'MANAGE_PLAYERS',
       'MANAGE_SETTINGS',
       'READ_SETTINGS',
-    ])
+    ]),
   );
 
   await knex.schema.dropTable('roleOnPlayer');

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

@@ -36,7 +36,7 @@ export async function up(knex: Knex): Promise<void> {
     perms.map((perm) => ({
       permission: perm,
       canHaveCount: false,
-    }))
+    })),
   );
 
   await knex.schema.createTable('temp_permissiononrole', (table) => {

package/src/migrations/sql/20240105130846-remove-some-module-perms.ts

@@ -20,14 +20,14 @@ export async function up(knex: Knex): Promise<void> {
   const readPermissionOnRole = await knex('permissionOnRole')
     .whereIn(
       'permissionId',
-      readPerms.map((p) => p.id)
+      readPerms.map((p) => p.id),
     )
     .select('id');
 
   const managePermissionOnRole = await knex('permissionOnRole')
     .whereIn(
       'permissionId',
-      managePerms.map((p) => p.id)
+      managePerms.map((p) => p.id),
     )
     .select('id');
 
@@ -35,7 +35,7 @@ export async function up(knex: Knex): Promise<void> {
   await knex('permissionOnRole')
     .whereIn(
       'id',
-      readPermissionOnRole.map((p) => p.id)
+      readPermissionOnRole.map((p) => p.id),
     )
     .update({
       permissionId: readModulePerm.id,
@@ -44,7 +44,7 @@ export async function up(knex: Knex): Promise<void> {
   await knex('permissionOnRole')
     .whereIn(
       'id',
-      managePermissionOnRole.map((p) => p.id)
+      managePermissionOnRole.map((p) => p.id),
     )
     .update({
       permissionId: manageModulePerm.id,

package/src/migrations/sql/20240119152426-remove-hook-check.ts

@@ -13,6 +13,6 @@ export async function down(knex: Knex): Promise<void> {
       'player-disconnected',
       'chat-message',
       'discord-message',
-    ])
+    ]),
   );
 }

package/src/migrations/sql/20240121142329-move-ip-history.ts

@@ -27,7 +27,7 @@ export async function up(knex: Knex): Promise<void> {
         playerId: pog.playerId,
         gameServerId: pog.gameServerId,
       };
-    })
+    }),
   );
 
   if (newRecords.length) {

package/src/migrations/sql/20240613175009-lastseen-users-pog.ts

@@ -0,0 +1,21 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('users', (table) => {
+    table.timestamp('lastSeen').defaultTo(knex.fn.now()).notNullable();
+  });
+
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.timestamp('lastSeen').defaultTo(knex.fn.now()).notNullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('users', (table) => {
+    table.dropColumn('lastSeen');
+  });
+
+  await knex.schema.alterTable('playerOnGameServer', (table) => {
+    table.dropColumn('lastSeen');
+  });
+}

package/src/migrations/sql/20240614143517-shop.ts

@@ -0,0 +1,39 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('shopListing', (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('gameServerId').references('gameservers.id').onDelete('CASCADE').notNullable();
+
+    table.uuid('itemId').references('items.id').onDelete('CASCADE');
+    table.uuid('functionId').references('functions.id').onDelete('CASCADE');
+
+    // Either an item or a function must be set
+    table.check('("itemId" IS NOT NULL) OR ("functionId" IS NOT NULL)');
+
+    table.integer('price').notNullable();
+
+    // Price must be positive and non-zero
+    table.check('"price" > 0');
+
+    table.string('name').nullable();
+  });
+
+  // Listings can only be bought by users with the role
+  await knex.schema.createTable('shopListingRole', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+
+    table.uuid('listingId').references('shopListing.id').onDelete('CASCADE').notNullable();
+    table.uuid('roleId').references('roles.id').onDelete('CASCADE').notNullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('shopListingRole');
+  await knex.schema.dropTable('shopListing');
+}

package/src/migrations/sql/20240615145045-user-player-link.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Remove users_idp_id_unique constraint
+  //idpId must be unique per domain instead
+  await knex.schema.alterTable('users', (table) => {
+    table.dropUnique(['idpid']);
+    table.unique(['idpId', 'domain']);
+
+    table.uuid('playerId').references('players.id').onDelete('SET NULL').nullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('users', (table) => {
+    table.dropUnique(['idpid', 'domain']);
+    table.unique(['idpId']);
+    table.dropColumn('playerId');
+  });
+}

package/src/migrations/sql/20240622132552-fix-ip-history-fk.ts

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

package/src/migrations/sql/20240626200803-player-inventory-idx.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerInventory', (table) => {
+    table.index(['playerId', 'domain']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('playerInventory', (table) => {
+    table.dropIndex(['playerId', 'domain']);
+  });
+}

package/src/migrations/sql/20240628174914-shop-orders.ts

@@ -0,0 +1,20 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('shopOrder', (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('listingId').references('shopListing.id').onDelete('CASCADE').notNullable();
+    table.uuid('userId').references('users.id').onDelete('CASCADE').notNullable();
+
+    table.integer('amount').defaultTo(1).notNullable();
+    table.enum('status', ['COMPLETED', 'PAID', 'CANCELED']).notNullable();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTable('shopOrder');
+}

package/src/migrations/sql/20240705140358-teleports-public-refactor.ts

@@ -0,0 +1,31 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  // Find all variables where key starts with 'tp_'
+  const variables = await knex('variables').select().where('key', 'like', 'tp_%');
+
+  // Reduce the list to only public teleports
+  const publicTeleports = variables.filter((variable) => {
+    try {
+      const value = JSON.parse(variable.value);
+      return value.public;
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.warn(`Error parsing JSON for variable ${variable.key}: ${error}. Skipping.`);
+      return false;
+    }
+  });
+
+  // Change the key for all public teleports from tp_xxx to pubtp_xxx
+  await Promise.all(
+    publicTeleports.map((teleport) => {
+      return knex('variables')
+        .update({ key: `pub${teleport.key}` })
+        .where('id', teleport.id);
+    }),
+  );
+}
+
+export async function down(_knex: Knex): Promise<void> {
+  // ... no down here, this is a one-way migration
+}

package/src/migrations/sql/20240710181429-events-name-idx.ts

@@ -0,0 +1,13 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (table) => {
+    table.index(['domain', 'eventName']);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (table) => {
+    table.dropIndex(['domain', 'eventName']);
+  });
+}

package/src/migrations/sql/20240711181423-shop-orders-multi-listing.ts

@@ -0,0 +1,34 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable('itemOnShopListing', (table) => {
+    table.timestamps(true, true, true);
+    table.uuid('id').primary().defaultTo(knex.raw('gen_random_uuid ()'));
+
+    table.uuid('listingId').references('shopListing.id').onDelete('CASCADE').notNullable();
+    table.uuid('itemId').references('items.id').onDelete('CASCADE');
+
+    table.integer('amount').defaultTo(1).notNullable();
+    // Amount must be positive and non-zero
+    table.check('"amount" > 0');
+
+    table.string('quality').nullable();
+  });
+
+  await knex.schema.alterTable('shopListing', (table) => {
+    table.dropChecks('"shopListing_check"');
+    table.dropColumn('functionId');
+    table.dropColumn('itemId');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('shopListing', (table) => {
+    table.uuid('itemId').references('items.id').onDelete('CASCADE');
+    table.uuid('functionId').references('functions.id').onDelete('CASCADE');
+
+    table.check('("itemId" IS NOT NULL) OR ("functionId" IS NOT NULL)');
+  });
+
+  await knex.schema.dropTable('itemOnShopListing');
+}

package/src/migrations/sql/20240718150807-listing-deleted-and-draft-status.ts

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

package/src/migrations/sql/20240720135010-acting-user-and-module.ts

@@ -0,0 +1,24 @@
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (table) => {
+    table.uuid('actingUserId').nullable();
+    table.foreign('actingUserId').references('id').inTable('users');
+
+    table.uuid('actingModuleId').nullable();
+    table.foreign('actingModuleId').references('id').inTable('modules');
+
+    table.index('actingUserId');
+    table.index('actingModuleId');
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('events', (table) => {
+    table.dropForeign(['actingUserId']);
+    table.dropColumn('actingUserId');
+
+    table.dropForeign(['actingModuleId']);
+    table.dropColumn('actingModuleId');
+  });
+}

package/src/migrations/sql/20240811061243-domain-rate-limit-setting.ts

@@ -0,0 +1,16 @@
+import ms from 'ms';
+import { Knex } from 'knex';
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.integer('rateLimitPoints').notNullable().defaultTo(2500);
+    table.integer('rateLimitDuration').notNullable().defaultTo(ms('15min'));
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable('domains', (table) => {
+    table.dropColumn('rateLimitPoints');
+    table.dropColumn('rateLimitDuration');
+  });
+}

package/src/migrations/util/alterEnum.ts

@@ -4,7 +4,7 @@ export function formatAlterTableEnumSql(tableName: string, columnName: string, e
   return [
     `ALTER TABLE "${tableName}" DROP CONSTRAINT IF EXISTS "${constraintName}";`,
     `ALTER TABLE "${tableName}" ADD CONSTRAINT "${constraintName}" CHECK ("${columnName}" = ANY (ARRAY['${enums.join(
-      "'::text, '"
+      "'::text, '",
     )}'::text]));`,
   ].join('\n');
 }

package/src/queryBuilder.ts

@@ -1,5 +1,12 @@
-import { IsDateString, IsEnum, IsNumber, IsOptional, IsString } from 'class-validator';
-import { QueryBuilder as ObjectionQueryBuilder, Model as ObjectionModel, Page, AnyQueryBuilder } from 'objection';
+import { IsEnum, IsNumber, IsOptional, IsString } from 'class-validator';
+import {
+  QueryBuilder as ObjectionQueryBuilder,
+  Model as ObjectionModel,
+  Page,
+  AnyQueryBuilder,
+  Expression,
+  PrimitiveValue,
+} from 'objection';
 
 export class ITakaroQuery<T> {
   @IsOptional()
@@ -12,6 +19,16 @@ export class ITakaroQuery<T> {
     [key in keyof T]?: unknown[] | unknown;
   };
 
+  @IsOptional()
+  greaterThan?: {
+    [key in keyof T]?: unknown;
+  };
+
+  @IsOptional()
+  lessThan?: {
+    [key in keyof T]?: unknown;
+  };
+
   @IsOptional()
   @IsNumber()
   page?: number;
@@ -29,14 +46,6 @@ export class ITakaroQuery<T> {
   @IsEnum(['asc', 'desc'])
   sortDirection?: SortDirection;
 
-  @IsOptional()
-  @IsDateString()
-  startDate?: string;
-
-  @IsOptional()
-  @IsDateString()
-  endDate?: string;
-
   @IsOptional()
   @IsString({ each: true })
   extend?: string[];
@@ -58,14 +67,9 @@ export class QueryBuilder<Model extends ObjectionModel, OutputDTO> {
 
     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);
+    qry = this.greaterThan(tableName, qry);
+    qry = this.lessThan(tableName, qry);
 
     if (this.query.search) {
       qry.where((builder) => {
@@ -93,15 +97,19 @@ export class QueryBuilder<Model extends ObjectionModel, OutputDTO> {
 
   private filters(
     tableName: string,
-    query: ObjectionQueryBuilder<Model, Page<Model>>
+    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) {
+          if (searchVal.includes(null) || searchVal.includes('null')) {
+            query.whereNull(`${tableName}.${filter}`);
+            continue;
+          }
+
+          if (searchVal.length) {
             query.whereIn(`${tableName}.${filter}`, searchVal.filter(Boolean) as unknown as AnyQueryBuilder);
           }
         }
@@ -111,6 +119,38 @@ export class QueryBuilder<Model extends ObjectionModel, OutputDTO> {
     return query;
   }
 
+  private greaterThan(
+    tableName: string,
+    query: ObjectionQueryBuilder<Model, Page<Model>>,
+  ): ObjectionQueryBuilder<Model, Page<Model>> {
+    for (const filter in this.query.greaterThan) {
+      if (Object.prototype.hasOwnProperty.call(this.query.greaterThan, filter)) {
+        const searchVal = this.query.greaterThan[filter];
+        if (searchVal) {
+          query.where(`${tableName}.${filter}`, '>=', searchVal as unknown as Expression<PrimitiveValue>);
+        }
+      }
+    }
+
+    return query;
+  }
+
+  private lessThan(
+    tableName: string,
+    query: ObjectionQueryBuilder<Model, Page<Model>>,
+  ): ObjectionQueryBuilder<Model, Page<Model>> {
+    for (const filter in this.query.lessThan) {
+      if (Object.prototype.hasOwnProperty.call(this.query.lessThan, filter)) {
+        const searchVal = this.query.lessThan[filter];
+        if (searchVal) {
+          query.where(`${tableName}.${filter}`, '<=', searchVal as unknown as Expression<PrimitiveValue>);
+        }
+      }
+    }
+
+    return query;
+  }
+
   private sorting(): { sortBy: string; sortDirection: SortDirection } {
     if (!this.query.sortBy) {
       return {