refactor: new OO patterns

packages/core/package.json

@@ -28,6 +28,7 @@
 		"inversify": "^6.0.1",
 		"ioredis": "^5.3.2",
 		"kysely": "^0.26.3",
+		"murmurhash": "^2.0.1",
 		"pg": "^8.11.3",
 		"pino": "^8.15.1",
 		"pino-pretty": "^10.2.0",

packages/core/src/applicationData/IDataManager.ts

@@ -0,0 +1,11 @@
+import type { Selectable } from 'kysely';
+import type { Experiment, ExperimentOverride } from '../db.js';
+
+export type ExperimentWithOverrides = Selectable<Experiment> & { overrides: Selectable<ExperimentOverride>[] };
+
+/**
+ * Abstraction over all database interactions (things like Redis included)
+ */
+export abstract class IDataManager {
+	public abstract getExperiments(): Promise<ExperimentWithOverrides[]>;
+}

packages/core/src/applicationData/KyselyDataManager.ts

@@ -0,0 +1,34 @@
+import type { Kysely } from 'kysely';
+import { jsonArrayFrom } from 'kysely/helpers/postgres';
+import type { DB } from '../db.js';
+import { IDataManager, type ExperimentWithOverrides } from './IDataManager.js';
+
+/**
+ * Our current databse implementation, using kysely with types generated by prisma-kysely
+ */
+export class KyselyDataManager extends IDataManager {
+	readonly #database: Kysely<DB>;
+
+	// Note that we avoid using an actual dependency. This is because we don't really want to expose database
+	// into our container. An implementation over IDataHandler should always be used.
+	public constructor(database: Kysely<DB>) {
+		super();
+
+		this.#database = database;
+	}
+
+	public override async getExperiments(): Promise<ExperimentWithOverrides[]> {
+		return this.#database
+			.selectFrom('Experiment')
+			.selectAll()
+			.select((query) => [
+				jsonArrayFrom(
+					query
+						.selectFrom('ExperimentOverride')
+						.selectAll('ExperimentOverride')
+						.whereRef('Experiment.name', '=', 'ExperimentOverride.experimentName'),
+				).as('overrides'),
+			])
+			.execute();
+	}
+}

packages/core/src/binary-encoding/README.md

@@ -1,3 +1,3 @@
 # binary-encoding
 
-Custom encoding we use for storing cache.
+Custom encoding we use for storing Discord data cache.

packages/core/src/cache/CacheFactory.ts

@@ -1,11 +1,10 @@
-import { inject, injectable } from 'inversify';
+import { inject } from 'inversify';
 import { Redis } from 'ioredis';
 import { INJECTION_TOKENS } from '../container.js';
-import { Cache } from './Cache.js';
 import type { ICache } from './ICache.js';
+import { RedisCache } from './RedisCache.js';
 import type { ICacheEntity } from './entities/ICacheEntity';
 
-@injectable()
 /**
  * @remarks
  * Since this is a singleton factroy, we "cache our caches" in a WeakMap to avoid additional computation on subsequent calls.
@@ -20,7 +19,7 @@ export class CacheFactory {
 			return this.caches.get(entity)! as ICache<T>;
 		}
 
-		const cache = new Cache<T>(this.redis, entity);
+		const cache = new RedisCache<T>(this.redis, entity);
 		this.caches.set(entity, cache);
 
 		return cache;

packages/core/src/cache/README.md

@@ -1,6 +1,6 @@
 # cache
 
-This is where we deal with caching. A couple of things to note:
+This is where we deal with Discord data caching. A couple of things to note:
 
 - we use our own encoding format for cache to make encoding/decoding and space usage as efficient as possible.
   Refer to the [`binary-encoding` directory](../binary-encoding)

packages/core/src/cache/Cache.ts → packages/core/src/cache/RedisCache.ts

@@ -7,7 +7,7 @@ import type { ICacheEntity } from './entities/ICacheEntity.js';
  * This class is deliberately not an `@injectable()`, refer to the README for more information on the pattern
  * being used.
  */
-export class Cache<T> implements ICache<T> {
+export class RedisCache<T> implements ICache<T> {
 	public constructor(
 		private readonly redis: Redis,
 		private readonly entity: ICacheEntity<T>,

packages/core/src/cache/entities/GuildCacheEntity.ts

@@ -1,6 +1,7 @@
 import type { Buffer } from 'node:buffer';
 import { injectable } from 'inversify';
-import { RWFactory } from '../../binary-encoding/RWFactory.js';
+import { Reader } from '../../binary-encoding/Reader.js';
+import { Writer } from '../../binary-encoding/Writer.js';
 import type { ICacheEntity } from './ICacheEntity';
 
 export interface CachedGuild {
@@ -12,26 +13,18 @@ export interface CachedGuild {
 
 @injectable()
 export class GuildCacheEntity implements ICacheEntity<CachedGuild> {
-	public constructor(private readonly rwFactory: RWFactory) {}
-
 	public readonly TTL = 60_000;
 
 	public makeKey(id: string): string {
 		return `guild:${id}`;
 	}
 
 	public toBuffer(guild: CachedGuild): Buffer {
-		return this.rwFactory
-			.buildWriter(200)
-			.u64(guild.id)
-			.string(guild.icon)
-			.string(guild.name)
-			.u64(guild.owner_id)
-			.dumpTrimmed();
+		return new Writer(200).u64(guild.id).string(guild.icon).string(guild.name).u64(guild.owner_id).dumpTrimmed();
 	}
 
 	public toJSON(data: Buffer): CachedGuild {
-		const reader = this.rwFactory.buildReader(data);
+		const reader = new Reader(data);
 
 		const decoded: CachedGuild = {
 			id: reader.u64()!.toString(),

packages/core/src/container.ts

@@ -6,12 +6,13 @@ export const globalContainer = new Container({
 });
 
 export const INJECTION_TOKENS = {
-	redis: Symbol('redis instance'),
 	logger: Symbol('logger instance'),
+	/**
+	 * @remarks
+	 * Not to be used explicitly ever. There should always be abstraction classes for interactions with redis
+	 */
+	redis: Symbol('redis instance'),
 	cacheEntities: {
 		guild: Symbol('guild cache entity'),
 	},
-	actions: {
-		restrict: Symbol('restrict action'),
-	},
 } as const;