feat(reputation): add ReputationService, rank resolver integration, and GET /api/reputation

apps/api/src/reputation/reputation.service.spec.ts

@@ -0,0 +1,233 @@
+import { DataSource, EntityManager, EntityTarget } from 'typeorm';
+import { CharacterReputation } from './entities/character-reputation.entity';
+import { ReputationFaction } from './entities/reputation-faction.entity';
+import { ReputationDomainError } from './reputation.errors';
+import { ReputationService } from './reputation.service';
+
+const FACTION_ID = '80000000-0000-4000-8000-000000000001';
+const CHARACTER_ID = '10000000-0000-4000-8000-000000000001';
+
+interface State {
+  factions: ReputationFaction[];
+  characterReputation: CharacterReputation[];
+}
+
+class FakeRepository<T extends { id: string }> {
+  constructor(
+    private readonly rows: T[],
+    private readonly prefix: string,
+    private readonly inTransaction: boolean,
+  ) {}
+
+  findOne(options: { where: Partial<T>; lock?: { mode: string } }): Promise<T | null> {
+    if (options.lock && !this.inTransaction) {
+      throw new Error('Pessimistic locks require a transaction');
+    }
+    return Promise.resolve(this.rows.find((row) => this.matches(row, options.where)) ?? null);
+  }
+
+  findOneBy(where: Partial<T>): Promise<T | null> {
+    return Promise.resolve(this.rows.find((row) => this.matches(row, where)) ?? null);
+  }
+
+  find(options: { where?: Partial<T> } = {}): Promise<T[]> {
+    return Promise.resolve(
+      options.where ? this.rows.filter((row) => this.matches(row, options.where!)) : [...this.rows],
+    );
+  }
+
+  create(values: Partial<T>): T {
+    return { ...values } as T;
+  }
+
+  save(entity: T): Promise<T> {
+    if (!entity.id) {
+      entity.id = `${this.prefix}-${this.rows.length + 1}`;
+    }
+    const index = this.rows.findIndex((row) => row.id === entity.id);
+    if (index === -1) {
+      this.rows.push(entity);
+    } else {
+      this.rows[index] = entity;
+    }
+    return Promise.resolve(entity);
+  }
+
+  private matches(row: T, where: Partial<T>): boolean {
+    return Object.entries(where).every(([key, value]) => row[key as keyof T] === value);
+  }
+}
+
+class FakeDataSource {
+  constructor(public state: State) {}
+
+  getRepository<T extends { id: string }>(target: EntityTarget<T>) {
+    return this.repoFor(target, false);
+  }
+
+  async transaction<T>(work: (manager: EntityManager) => Promise<T>): Promise<T> {
+    return work({
+      getRepository: <U extends { id: string }>(target: EntityTarget<U>) => this.repoFor(target, true),
+    } as unknown as EntityManager);
+  }
+
+  private repoFor<T extends { id: string }>(target: EntityTarget<T>, inTransaction: boolean) {
+    if (target === ReputationFaction)
+      return new FakeRepository(this.state.factions, 'faction', inTransaction) as never;
+    if (target === CharacterReputation)
+      return new FakeRepository(this.state.characterReputation, 'char-rep', inTransaction) as never;
+    throw new Error('Unsupported repository');
+  }
+}
+
+function faction(overrides: Partial<ReputationFaction> = {}): ReputationFaction {
+  return {
+    id: FACTION_ID,
+    key: 'border-guard',
+    name: 'Grenzwacht',
+    description: '',
+    regionKey: 'ashen-fields',
+    enabled: true,
+    ...overrides,
+  } as ReputationFaction;
+}
+
+function createState(overrides: Partial<State> = {}): State {
+  return { factions: [faction()], characterReputation: [], ...overrides };
+}
+
+function createService(state: State) {
+  const dataSource = new FakeDataSource(state);
+  return { service: new ReputationService(dataSource as unknown as DataSource), state };
+}
+
+async function expectReputationDomainError(promise: Promise<unknown>, code: string): Promise<void> {
+  let error: unknown;
+  try {
+    await promise;
+  } catch (cause) {
+    error = cause;
+  }
+  expect(error).toBeInstanceOf(ReputationDomainError);
+  if (!(error instanceof ReputationDomainError)) {
+    throw new Error('Expected ReputationDomainError');
+  }
+  expect(error.code).toBe(code);
+}
+
+describe('ReputationService', () => {
+  describe('grantReputation', () => {
+    it('creates a reputation row starting from 0 on the first grant', async () => {
+      const { service, state } = createService(createState());
+
+      const result = await service.grantReputation(CHARACTER_ID, 'border-guard', 40);
+
+      expect(result).toEqual({
+        factionKey: 'border-guard',
+        previousReputation: 0,
+        newReputation: 40,
+        previousRank: 'STRANGER',
+        newRank: 'STRANGER',
+        rankChanged: false,
+      });
+      expect(state.characterReputation).toHaveLength(1);
+      expect(state.characterReputation[0].reputation).toBe(40);
+    });
+
+    it('accumulates onto an existing reputation row', async () => {
+      const state = createState({
+        characterReputation: [
+          { id: 'existing', characterId: CHARACTER_ID, factionId: FACTION_ID, reputation: 90 } as CharacterReputation,
+        ],
+      });
+      const { service } = createService(state);
+
+      const result = await service.grantReputation(CHARACTER_ID, 'border-guard', 20);
+
+      expect(result.previousReputation).toBe(90);
+      expect(result.newReputation).toBe(110);
+    });
+
+    it('reports rankChanged when a grant crosses a threshold', async () => {
+      const state = createState({
+        characterReputation: [
+          { id: 'existing', characterId: CHARACTER_ID, factionId: FACTION_ID, reputation: 90 } as CharacterReputation,
+        ],
+      });
+      const { service } = createService(state);
+
+      const result = await service.grantReputation(CHARACTER_ID, 'border-guard', 20);
+
+      expect(result.previousRank).toBe('STRANGER');
+      expect(result.newRank).toBe('TOLERATED');
+      expect(result.rankChanged).toBe(true);
+    });
+
+    it('reports rankChanged: false when a grant stays within the same rank', async () => {
+      const state = createState({
+        characterReputation: [
+          { id: 'existing', characterId: CHARACTER_ID, factionId: FACTION_ID, reputation: 120 } as CharacterReputation,
+        ],
+      });
+      const { service } = createService(state);
+
+      const result = await service.grantReputation(CHARACTER_ID, 'border-guard', 10);
+
+      expect(result.rankChanged).toBe(false);
+    });
+
+    it('rejects an unknown faction key', async () => {
+      const { service } = createService(createState());
+
+      await expectReputationDomainError(
+        service.grantReputation(CHARACTER_ID, 'unknown-faction', 10),
+        'REPUTATION_FACTION_NOT_FOUND',
+      );
+    });
+  });
+
+  describe('getCharacterReputation', () => {
+    it('returns 0 Reputation / Stranger for a faction the character has never interacted with', async () => {
+      const { service } = createService(createState());
+
+      const result = await service.getCharacterReputation(CHARACTER_ID);
+
+      expect(result).toEqual([
+        {
+          factionKey: 'border-guard',
+          factionName: 'Grenzwacht',
+          reputation: 0,
+          rank: 'STRANGER',
+          rankLabel: 'Fremder',
+          nextThreshold: 100,
+        },
+      ]);
+    });
+
+    it('reflects a persisted grant', async () => {
+      const state = createState();
+      const { service } = createService(state);
+      await service.grantReputation(CHARACTER_ID, 'border-guard', 300);
+
+      const result = await service.getCharacterReputation(CHARACTER_ID);
+
+      expect(result[0]).toEqual({
+        factionKey: 'border-guard',
+        factionName: 'Grenzwacht',
+        reputation: 300,
+        rank: 'KNOWN',
+        rankLabel: 'Bekannt',
+        nextThreshold: 500,
+      });
+    });
+
+    it('omits a disabled faction', async () => {
+      const state = createState({ factions: [faction({ enabled: false })] });
+      const { service } = createService(state);
+
+      const result = await service.getCharacterReputation(CHARACTER_ID);
+
+      expect(result).toEqual([]);
+    });
+  });
+});