Implemented basic flag system (#522)

no ref

- Expected flags are declared on service initialisation
- Flags are enabled via query string (i.e `GET /account?new-account-response=1`)
- Header added to response to show which flags have been enabled

Author: mike182uk

src/app.ts

@@ -83,6 +83,7 @@ import {
 } from './dispatchers';
 import { FeedUpdateService } from './feed/feed-update.service';
 import { FeedService } from './feed/feed.service';
+import { FlagService } from './flag/flag.service';
 import {
     createDerepostActionHandler,
     createFollowActionHandler,
@@ -246,6 +247,8 @@ if (process.env.MANUALLY_START_QUEUE === 'true') {
     });
 }
 
+const flagService = new FlagService([]);
+
 const events = new AsyncEvents();
 const fedifyContextFactory = new FedifyContextFactory();
 
@@ -648,6 +651,26 @@ app.use(async (ctx, next) => {
     });
 });
 
+app.use(async (ctx, next) => {
+    return flagService.runInContext(async () => {
+        const enabledFlags: string[] = [];
+
+        for (const flag of flagService.getRegistered()) {
+            if (ctx.req.query(flag)) {
+                flagService.enable(flag);
+
+                enabledFlags.push(flag);
+            }
+        }
+
+        if (enabledFlags.length > 0) {
+            ctx.res.headers.set('x-enabled-flags', enabledFlags.join(','));
+        }
+
+        return next();
+    });
+});
+
 function sleep(n: number) {
     return new Promise((resolve) => setTimeout(resolve, n));
 }

src/flag/flag.service.ts

@@ -0,0 +1,47 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+export class FlagService {
+    private flags: Set<string>;
+    private store: AsyncLocalStorage<Set<string>>;
+
+    constructor(flags: string[]) {
+        this.flags = new Set(flags);
+        this.store = new AsyncLocalStorage<Set<string>>();
+    }
+
+    public async runInContext<T>(fn: () => Promise<T>) {
+        return this.store.run(new Set<string>(), fn);
+    }
+
+    public enable(flag: string) {
+        if (!this.flags.has(flag)) {
+            return;
+        }
+
+        const store = this.store.getStore();
+
+        if (!store) {
+            return;
+        }
+
+        store.add(flag);
+    }
+
+    public isEnabled(flag: string) {
+        if (!this.flags.has(flag)) {
+            return false;
+        }
+
+        const store = this.store.getStore();
+
+        if (!store) {
+            return false;
+        }
+
+        return store.has(flag);
+    }
+
+    public getRegistered() {
+        return Array.from(this.flags);
+    }
+}

src/flag/flag.service.unit.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import { FlagService } from './flag.service';
+
+describe('FlagService', () => {
+    it('should be able to register flags', () => {
+        const flagService = new FlagService(['foo', 'bar']);
+
+        expect(flagService.getRegistered()).toEqual(['foo', 'bar']);
+    });
+
+    it('should be able to enable a flag', () => {
+        const flagService = new FlagService(['foo', 'bar']);
+
+        flagService.runInContext(async () => {
+            flagService.enable('foo');
+
+            expect(flagService.isEnabled('foo')).toBe(true);
+            expect(flagService.isEnabled('bar')).toBe(false);
+        });
+    });
+
+    it('should be able to enable multiple flags', () => {
+        const flagService = new FlagService(['foo', 'bar']);
+
+        flagService.runInContext(async () => {
+            flagService.enable('foo');
+            flagService.enable('bar');
+
+            expect(flagService.isEnabled('foo')).toBe(true);
+            expect(flagService.isEnabled('bar')).toBe(true);
+        });
+    });
+
+    it('should ignore unregistered flags', () => {
+        const flagService = new FlagService(['foo']);
+
+        flagService.runInContext(async () => {
+            flagService.enable('bar');
+
+            expect(flagService.isEnabled('bar')).toBe(false);
+        });
+    });
+
+    it('should isolate flags between different contexts', async () => {
+        const flagService = new FlagService(['foo', 'bar']);
+
+        flagService.runInContext(async () => {
+            flagService.enable('foo');
+
+            expect(flagService.isEnabled('foo')).toBe(true);
+            expect(flagService.isEnabled('bar')).toBe(false);
+        });
+
+        flagService.runInContext(async () => {
+            flagService.enable('bar');
+
+            expect(flagService.isEnabled('foo')).toBe(false);
+            expect(flagService.isEnabled('bar')).toBe(true);
+        });
+    });
+});