Free, Open Source, Self-Hosted WhatsApp API Gateway
TypeScript apibotgatewayself-hostedwhatsappwhatsapp-apiwhatsapp-automationwhatsapp-botwhatsapp-gatewaywhatsapp-gateway-apiwhatsapp-webwhatsapp-web-api
fix(auth): keep usage counted while a shutdown flush awaits a write
Yudhi Armyndharis2fd2661d90f1
diff --git a/src/modules/auth/api-key-usage-tracker.service.ts b/src/modules/auth/api-key-usage-tracker.service.tsindex 8ba372fe6..dfebb3cd7 100644--- a/src/modules/auth/api-key-usage-tracker.service.ts+++ b/src/modules/auth/api-key-usage-tracker.service.ts@@ -106,19 +106,22 @@ export class ApiKeyUsageTracker {}}- /** Persist every accumulated delta with an atomic increment; entries that fail stay pending. */+ /**+ * Persist every accumulated delta with an atomic increment; entries that fail go back to pending. The batch+ * is taken out of the map before the first write: a use recorded while a write is awaited then starts a+ * fresh count, instead of being deleted along with the one just written or written a second time.+ */private async flushPending(): Promise<void> {- for (const [keyId, delta] of [...this.pending.entries()]) {- if (delta <= 0) {- this.pending.delete(keyId);- continue;- }+ const batch = [...this.pending.entries()];+ this.pending.clear();+ for (const [keyId, delta] of batch) {+ if (delta <= 0) continue;try {// Atomic UPDATE ... SET usageCount = usageCount + delta — no read-modify-write race with a// concurrent windowed save, unlike reloading the row and saving it back.await this.apiKeyRepository.increment({ id: keyId }, 'usageCount', delta);- this.pending.delete(keyId);} catch (error) {+ this.pending.set(keyId, (this.pending.get(keyId) ?? 0) + delta);this.logger.warn('Usage-stat flush failed for a key; delta kept pending', {keyId,error: error instanceof Error ? error.message : String(error),diff --git a/src/modules/auth/api-key-usage-tracker.spec.ts b/src/modules/auth/api-key-usage-tracker.spec.tsnew file mode 100644index 000000000..397cf3b3b--- /dev/null+++ b/src/modules/auth/api-key-usage-tracker.spec.ts@@ -0,0 +1,130 @@+import { ApiKeyUsageTracker } from './api-key-usage-tracker.service';+import { ApiKey, ApiKeyRole } from './entities/api-key.entity';++const key = (overrides: Partial<ApiKey> = {}): ApiKey =>+ ({+ id: 'key-1',+ role: ApiKeyRole.OPERATOR,+ lastUsedAt: new Date(),+ usageCount: 0,+ ...overrides,+ }) as ApiKey;++/**+ * A repository that only counts what reaches the database: `increment` can be held open, and the+ * windowed `update` is read back from its `"usageCount" + N` expression.+ */+function makeRepository() {+ const written: number[] = [];+ let gate: Promise<void> = Promise.resolve();+ let failNext = false;+ const repository = {+ increment: jest.fn(async (_criteria: unknown, _column: string, delta: number) => {+ await gate;+ if (failNext) {+ failNext = false;+ throw new Error('database write failed');+ }+ written.push(delta);+ }),+ update: jest.fn((_criteria: unknown, patch: { usageCount: () => string }) => {+ written.push(Number(/\+ (\d+)$/.exec(patch.usageCount())?.[1]));+ return Promise.resolve();+ }),+ };+ return {+ repository,+ total: () => written.reduce((sum, delta) => sum + delta, 0),+ hold: () => {+ let release!: () => void;+ gate = new Promise<void>(resolve => (release = resolve));+ return release;+ },+ failNextIncrement: () => {+ failNext = true;+ },+ };+}++describe('ApiKeyUsageTracker shutdown flush', () => {+ it('keeps a use recorded while the flush awaits its write', async () => {+ const db = makeRepository();+ const tracker = new ApiKeyUsageTracker(db.repository as never);+ await tracker.record(key());+ await tracker.record(key());++ const release = db.hold();+ const flush = tracker.flushOnShutdown();+ await tracker.record(key());+ release();+ await flush;+ await tracker.flushOnShutdown();++ expect(db.total()).toBe(3);+ });++ it('does not write a use twice when the window closes while the flush awaits', async () => {+ const db = makeRepository();+ const tracker = new ApiKeyUsageTracker(db.repository as never);+ await tracker.record(key());+ await tracker.record(key());++ const release = db.hold();+ const flush = tracker.flushOnShutdown();+ await tracker.record(key({ lastUsedAt: new Date(Date.now() - 120_000) }));+ release();+ await flush;+ await tracker.flushOnShutdown();++ expect(db.total()).toBe(3);+ });++ it('keeps the failed batch and a use recorded meanwhile for the next flush', async () => {+ const db = makeRepository();+ const tracker = new ApiKeyUsageTracker(db.repository as never);+ await tracker.record(key());+ await tracker.record(key());++ const release = db.hold();+ db.failNextIncrement();+ const flush = tracker.flushOnShutdown();+ await tracker.record(key());+ release();+ await flush;+ await tracker.flushOnShutdown();++ expect(db.total()).toBe(3);+ });++ it('writes a batch once when two shutdown flushes overlap', async () => {+ const db = makeRepository();+ const tracker = new ApiKeyUsageTracker(db.repository as never);+ await tracker.record(key());+ await tracker.record(key());++ const release = db.hold();+ const first = tracker.flushOnShutdown();+ const second = tracker.flushOnShutdown();+ release();+ await Promise.all([first, second]);++ expect(db.total()).toBe(2);+ expect(db.repository.increment).toHaveBeenCalledTimes(1);+ });++ it('keeps a later key use while an earlier key of the batch awaits its write', async () => {+ const db = makeRepository();+ const tracker = new ApiKeyUsageTracker(db.repository as never);+ await tracker.record(key({ id: 'first' }));+ await tracker.record(key({ id: 'second' }));++ const release = db.hold();+ const flush = tracker.flushOnShutdown();+ await tracker.record(key({ id: 'second' }));+ release();+ await flush;+ await tracker.flushOnShutdown();++ expect(db.total()).toBe(3);+ });+});