feat: add engagement ads support to boot

Author: capJavert

__tests__/boot.ts

@@ -112,6 +112,7 @@ const BASE_BODY = {
   },
   exp: { f: 'enc', e: [], a: {} },
   geo: {},
+  engagementCreatives: [],
 };
 
 const LOGGED_IN_BODY = {
@@ -2236,3 +2237,124 @@ describe('boot profile completion', () => {
     });
   });
 });
+
+describe('engagement creatives', () => {
+  const GENERATION_ID = 'test-generation-id';
+
+  const skadiEngagementPayload = {
+    promoted_name: 'Test Brand',
+    promoted_body: 'Test body',
+    promoted_cta: 'Try now',
+    promoted_url: 'https://example.com',
+    promoted_logo_img: {
+      dark: 'https://example.com/logo-dark.png',
+      light: 'https://example.com/logo-light.png',
+    },
+    promoted_icon_img: {
+      dark: 'https://example.com/icon-dark.png',
+      light: 'https://example.com/icon-light.png',
+    },
+    promoted_gradient_start: { dark: '#FF0000', light: '#CC0000' },
+    promoted_gradient_end: { dark: '#0000FF', light: '#0000CC' },
+    tools: ['tool1', 'tool2'],
+    keywords: ['keyword1', 'keyword2'],
+    tags: ['tag1', 'tag2'],
+  };
+
+  const skadiResponse = {
+    generation_id: GENERATION_ID,
+    value: { engagement: skadiEngagementPayload },
+  };
+
+  const expectedCreative = {
+    ...skadiEngagementPayload,
+    gen_id: GENERATION_ID,
+  };
+
+  afterEach(() => {
+    nock.cleanAll();
+  });
+
+  it('should not fetch engagement creatives when ega param is missing', async () => {
+    const scope = nock(process.env.SKADI_ORIGIN)
+      .post('/private')
+      .reply(200, skadiResponse);
+
+    const res = await request(app.server)
+      .get(BASE_PATH)
+      .set('User-Agent', TEST_UA)
+      .set('Cookie', await mockLoggedInCookie())
+      .expect(200);
+
+    expect(res.body.engagementCreatives).toEqual([]);
+    expect(scope.isDone()).toBe(false);
+  });
+
+  it('should return engagement creatives when ega=1 for logged in user', async () => {
+    nock(process.env.SKADI_ORIGIN)
+      .post('/private', {
+        placement: 'default_engagement',
+        metadata: { USERID: '1' },
+      })
+      .reply(200, skadiResponse);
+
+    const res = await request(app.server)
+      .get(`${BASE_PATH}?ega=1`)
+      .set('User-Agent', TEST_UA)
+      .set('Cookie', await mockLoggedInCookie())
+      .expect(200);
+
+    expect(res.body.engagementCreatives).toEqual([expectedCreative]);
+  });
+
+  it('should return engagement creatives when ega=1 for anonymous user', async () => {
+    nock(process.env.SKADI_ORIGIN).post('/private').reply(200, skadiResponse);
+
+    const res = await request(app.server)
+      .get(`${BASE_PATH}?ega=1`)
+      .set('User-Agent', TEST_UA)
+      .expect(200);
+
+    expect(res.body.engagementCreatives).toEqual([expectedCreative]);
+  });
+
+  it('should return empty array when skadi returns no generation_id', async () => {
+    nock(process.env.SKADI_ORIGIN)
+      .post('/private')
+      .reply(200, { value: { engagement: skadiEngagementPayload } });
+
+    const res = await request(app.server)
+      .get(`${BASE_PATH}?ega=1`)
+      .set('User-Agent', TEST_UA)
+      .set('Cookie', await mockLoggedInCookie())
+      .expect(200);
+
+    expect(res.body.engagementCreatives).toEqual([]);
+  });
+
+  it('should return empty array when skadi returns empty response', async () => {
+    nock(process.env.SKADI_ORIGIN).post('/private').reply(200, {});
+
+    const res = await request(app.server)
+      .get(`${BASE_PATH}?ega=1`)
+      .set('User-Agent', TEST_UA)
+      .set('Cookie', await mockLoggedInCookie())
+      .expect(200);
+
+    expect(res.body.engagementCreatives).toEqual([]);
+  });
+
+  it('should return empty array when skadi returns error', async () => {
+    nock(process.env.SKADI_ORIGIN)
+      .post('/private')
+      .reply(500, 'Internal Server Error');
+
+    const res = await request(app.server)
+      .get(`${BASE_PATH}?ega=1`)
+      .set('User-Agent', TEST_UA)
+      .set('Cookie', await mockLoggedInCookie())
+      .expect(200);
+
+    expect(res.body.engagementCreatives).toEqual([]);
+  });
+});

src/integrations/garmr.ts

@@ -10,6 +10,8 @@ import {
   Policy,
   retry,
   SamplingBreaker,
+  timeout,
+  TimeoutStrategy,
   wrap,
 } from 'cockatiel';
 import { logger } from '../logger';
@@ -55,6 +57,7 @@ export class GarmrService implements IGarmrService {
     breakerOpts,
     retryOpts,
     limits,
+    timeoutMs,
     events,
   }: {
     service: string;
@@ -73,6 +76,7 @@ export class GarmrService implements IGarmrService {
       maxRequests: number;
       queuedRequests?: number;
     };
+    timeoutMs?: number;
     events?: Partial<{
       onBreak?: (props: {
         event: FailureReason<Error>;
@@ -151,7 +155,17 @@ export class GarmrService implements IGarmrService {
       events?.onReset?.({ meta: instanceMeta });
     });
 
-    this.instance = wrap(retryPolicy, circuitBreakerPolicy, bulkheadPolicy);
+    const policies: IPolicy[] = [
+      retryPolicy,
+      circuitBreakerPolicy,
+      bulkheadPolicy,
+    ];
+
+    if (timeoutMs && timeoutMs > 0) {
+      policies.push(timeout(timeoutMs, TimeoutStrategy.Cooperative));
+    }
+
+    this.instance = wrap(...policies);
   }
 
   execute<T>(

src/integrations/skadi/clients.ts

@@ -1,11 +1,16 @@
 import { RequestInit } from 'node-fetch';
-import { ISkadiClient, SkadiResponse } from './types';
+import {
+  ISkadiClient,
+  SkadiResponse,
+  type EngagementCreative,
+  type SkadiAd,
+} from './types';
 import { GarmrNoopService, IGarmrService, GarmrService } from '../garmr';
 import { fetchOptions as globalFetchOptions } from '../../http';
 import { fetchParse } from '../retry';
 import { counters } from '../../telemetry';
 
-export class SkadiClient implements ISkadiClient {
+export class SkadiClient<TValue> implements ISkadiClient<TValue> {
   private readonly fetchOptions: RequestInit;
   private readonly garmr: IGarmrService;
 
@@ -30,8 +35,8 @@ export class SkadiClient implements ISkadiClient {
     metadata: {
       USERID: string;
     },
-  ): Promise<SkadiResponse> {
-    return this.garmr.execute(() => {
+  ): Promise<SkadiResponse<TValue>> {
+    return this.garmr.execute(({ signal }) => {
       return fetchParse(`${this.url}/private`, {
         ...this.fetchOptions,
         method: 'POST',
@@ -42,6 +47,7 @@ export class SkadiClient implements ISkadiClient {
           placement,
           metadata,
         }),
+        signal,
       });
     });
   }
@@ -86,9 +92,27 @@ const garmrSkadiPersonalizedDigestService = new GarmrService({
   },
 });
 
-export const skadiPersonalizedDigestClient = new SkadiClient(
-  process.env.SKADI_ORIGIN,
-  {
-    garmr: garmrSkadiPersonalizedDigestService,
+export const skadiPersonalizedDigestClient = new SkadiClient<{
+  digest: SkadiAd;
+}>(process.env.SKADI_ORIGIN, {
+  garmr: garmrSkadiPersonalizedDigestService,
+});
+
+const garmrSkadiEngagementService = new GarmrService({
+  service: `${SkadiClient.name}Engagement`,
+  breakerOpts: {
+    halfOpenAfter: 5 * 1000,
+    threshold: 0.1,
+    duration: 10 * 1000,
   },
-);
+  retryOpts: {
+    maxAttempts: 0,
+  },
+  timeoutMs: 600,
+});
+
+export const skadiEngagementClient = new SkadiClient<{
+  engagement: EngagementCreative;
+}>(process.env.SKADI_ORIGIN, {
+  garmr: garmrSkadiEngagementService,
+});

src/integrations/skadi/index.ts

@@ -1,4 +1,8 @@
 export * from './types';
-export { SkadiClient, skadiPersonalizedDigestClient } from './clients';
+export {
+  SkadiClient,
+  skadiPersonalizedDigestClient,
+  skadiEngagementClient,
+} from './clients';
 export * from './api/v2';
 export * from './api/common';

src/integrations/skadi/types.ts

@@ -7,19 +7,38 @@ export type SkadiAd = {
   company_logo: string;
   call_to_action: string;
 };
-export type SkadiResponse = Partial<{
+export type SkadiResponse<TValue> = Partial<{
   type: string;
-  value: {
-    digest: SkadiAd;
-  };
+  value: TValue;
   pixels: string[];
+  generation_id: string;
 }>;
 
-export interface ISkadiClient {
+export type ThemedValue = {
+  dark: string;
+  light: string;
+};
+
+export type EngagementCreative = {
+  gen_id: string;
+  promoted_name: string;
+  promoted_body: string;
+  promoted_cta: string;
+  promoted_url: string;
+  promoted_logo_img: ThemedValue;
+  promoted_icon_img: ThemedValue;
+  promoted_gradient_start: ThemedValue;
+  promoted_gradient_end: ThemedValue;
+  tools: string[];
+  keywords: string[];
+  tags: string[];
+};
+
+export interface ISkadiClient<TValue> {
   getAd(
     placement: string,
     metadata: {
       USERID: string;
     },
-  ): Promise<SkadiResponse>;
+  ): Promise<SkadiResponse<TValue>>;
 }