skuba 9.0.0-renovate-eslint-9.x-20240923103202 → 9.0.1-upgrade-cdk-template-20241002233314

package/template/lambda-sqs-worker-cdk/src/config.ts

@@ -4,8 +4,11 @@ interface Config {
   environment: Environment;
 
   logLevel: string;
+  metrics: boolean;
   name: string;
   version: string;
+
+  destinationSnsTopicArn: string;
 }
 
 type Environment = (typeof environments)[number];
@@ -18,26 +21,38 @@ const environment = Env.oneOf(environments)('ENVIRONMENT');
 const configs: Record<Environment, () => Omit<Config, 'environment'>> = {
   local: () => ({
     logLevel: 'debug',
+    metrics: false,
     name: '<%- serviceName %>',
     version: 'local',
+
+    destinationSnsTopicArn: 'arn:aws:sns:us-east-2:123456789012:destination',
   }),
 
   test: () => ({
     logLevel: Env.string('LOG_LEVEL', { default: 'silent' }),
+    metrics: false,
     name: '<%- serviceName %>',
     version: 'test',
+
+    destinationSnsTopicArn: 'arn:aws:sns:us-east-2:123456789012:destination',
   }),
 
   dev: () => ({
     logLevel: 'debug',
+    metrics: true,
     name: Env.string('SERVICE'),
     version: Env.string('VERSION'),
+
+    destinationSnsTopicArn: Env.string('DESTINATION_SNS_TOPIC_ARN'),
   }),
 
   prod: () => ({
     logLevel: 'info',
+    metrics: true,
     name: Env.string('SERVICE'),
     version: Env.string('VERSION'),
+
+    destinationSnsTopicArn: Env.string('DESTINATION_SNS_TOPIC_ARN'),
   }),
 };
 

package/template/lambda-sqs-worker-cdk/src/framework/handler.test.ts

@@ -0,0 +1,61 @@
+import { createCtx } from 'src/testing/handler';
+import { logger } from 'src/testing/logging';
+import { chance } from 'src/testing/types';
+
+import { createHandler } from './handler';
+
+describe('createHandler', () => {
+  const ctx = createCtx();
+  const input = chance.paragraph();
+
+  beforeAll(logger.spy);
+
+  afterEach(logger.clear);
+
+  it('handles happy path', async () => {
+    const output = chance.paragraph();
+
+    const handler = createHandler((event) => {
+      expect(event).toBe(input);
+
+      logger.debug('Handler invoked');
+
+      return Promise.resolve(output);
+    });
+
+    await expect(handler(input, ctx)).resolves.toBe(output);
+
+    expect(logger.error).not.toHaveBeenCalled();
+
+    expect(logger.debug.mock.calls).toEqual([
+      ['Handler invoked'],
+      ['Function succeeded'],
+    ]);
+  });
+
+  it('handles async error', async () => {
+    const err = Error(chance.sentence());
+
+    const handler = createHandler(() => Promise.reject(err));
+
+    await expect(handler(input, ctx)).rejects.toThrow('Function failed');
+
+    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
+
+    expect(logger.debug).not.toHaveBeenCalled();
+  });
+
+  it('handles sync error', async () => {
+    const err = Error(chance.sentence());
+
+    const handler = createHandler(() => {
+      throw err;
+    });
+
+    await expect(handler(input, ctx)).rejects.toThrow('Function failed');
+
+    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
+
+    expect(logger.debug).not.toHaveBeenCalled();
+  });
+});

package/template/lambda-sqs-worker-cdk/src/framework/handler.ts

@@ -0,0 +1,43 @@
+import { datadog } from 'datadog-lambda-js';
+
+import { config } from 'src/config';
+import { logger, loggerContext } from 'src/framework/logging';
+
+interface LambdaContext {
+  awsRequestId: string;
+}
+
+type Handler<Event, Output> = (
+  event: Event,
+  ctx: LambdaContext,
+) => Promise<Output>;
+
+/**
+ * Conditionally applies the Datadog wrapper to a Lambda handler.
+ *
+ * This also "fixes" its broken type definitions.
+ */
+const withDatadog = <Event, Output = unknown>(
+  fn: Handler<Event, Output>,
+): Handler<Event, Output> =>
+  // istanbul ignore next
+  config.metrics ? (datadog(fn) as Handler<Event, Output>) : fn;
+
+export const createHandler = <Event, Output = unknown>(
+  fn: (event: Event) => Promise<Output>,
+) =>
+  withDatadog<Event>((event, { awsRequestId }) =>
+    loggerContext.run({ awsRequestId }, async () => {
+      try {
+        const output = await fn(event);
+
+        logger.debug('Function succeeded');
+
+        return output;
+      } catch (err) {
+        logger.error({ err }, 'Function failed');
+
+        throw new Error('Function failed');
+      }
+    }),
+  );

package/template/lambda-sqs-worker-cdk/src/framework/logging.ts

@@ -0,0 +1,27 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+import createLogger from '@seek/logger';
+
+import { config } from 'src/config';
+
+interface LoggerContext {
+  awsRequestId: string;
+}
+
+export const loggerContext = new AsyncLocalStorage<LoggerContext>();
+
+export const logger = createLogger({
+  base: {
+    environment: config.environment,
+    version: config.version,
+  },
+
+  level: config.logLevel,
+
+  mixin: () => ({ ...loggerContext.getStore() }),
+
+  name: config.name,
+
+  transport:
+    config.environment === 'local' ? { target: 'pino-pretty' } : undefined,
+});

package/template/lambda-sqs-worker-cdk/src/framework/metrics.ts

@@ -0,0 +1,14 @@
+import { sendDistributionMetric } from 'datadog-lambda-js';
+
+import { config } from 'src/config';
+
+const prefix = `${config.name}.`;
+
+export const metricsClient = {
+  distribution: (
+    ...[name, ...rest]: Parameters<typeof sendDistributionMetric>
+  ) =>
+    config.metrics
+      ? sendDistributionMetric(`${prefix}${name}`, ...rest)
+      : undefined,
+};

package/template/lambda-sqs-worker-cdk/src/framework/validation.test.ts

@@ -0,0 +1,84 @@
+import {
+  IdDescriptionSchema,
+  chance,
+  mockIdDescription,
+} from 'src/testing/types';
+
+import { validateJson } from './validation';
+
+describe('validateJson', () => {
+  const idDescription = mockIdDescription();
+
+  it('permits valid input', () => {
+    const input = JSON.stringify(idDescription);
+
+    expect(validateJson(input, IdDescriptionSchema)).toStrictEqual(
+      idDescription,
+    );
+  });
+
+  it('filters additional properties', () => {
+    const input = JSON.stringify({ ...idDescription, hacker: chance.name() });
+
+    expect(validateJson(input, IdDescriptionSchema)).toStrictEqual(
+      idDescription,
+    );
+  });
+
+  it('blocks mistyped prop', () => {
+    const input = JSON.stringify({ ...idDescription, id: null });
+
+    expect(() => validateJson(input, IdDescriptionSchema))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "[
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "received": "null",
+          "path": [
+            "id"
+          ],
+          "message": "Expected string, received null"
+        }
+      ]"
+    `);
+  });
+
+  it('blocks missing prop', () => {
+    const input = '{}';
+
+    expect(() => validateJson(input, IdDescriptionSchema))
+      .toThrowErrorMatchingInlineSnapshot(`
+      "[
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "received": "undefined",
+          "path": [
+            "id"
+          ],
+          "message": "Required"
+        },
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "received": "undefined",
+          "path": [
+            "description"
+          ],
+          "message": "Required"
+        }
+      ]"
+    `);
+  });
+
+  it('blocks invalid JSON', () => {
+    const input = '}';
+
+    expect(() =>
+      validateJson(input, IdDescriptionSchema),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `"Unexpected token '}', "}" is not valid JSON"`,
+    );
+  });
+});

package/template/lambda-sqs-worker-cdk/src/framework/validation.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+
+export const validateJson = <
+  Output,
+  Def extends z.ZodTypeDef = z.ZodTypeDef,
+  Input = Output,
+>(
+  input: string,
+  schema: z.ZodSchema<Output, Def, Input>,
+): Output => schema.parse(JSON.parse(input));

package/template/lambda-sqs-worker-cdk/src/mapping/jobScorer.ts

@@ -0,0 +1,22 @@
+import type { JobScorerInput, JobScorerOutput } from 'src/types/jobScorer';
+import type {
+  JobPublishedEvent,
+  JobScoredEvent,
+} from 'src/types/pipelineEvents';
+
+export const jobPublishedEventToScorerInput = (
+  record: JobPublishedEvent,
+): JobScorerInput => ({
+  details: record.data.details,
+  id: record.entityId,
+});
+
+export const jobScorerOutputToScoredEvent = (
+  output: JobScorerOutput,
+): JobScoredEvent => ({
+  data: {
+    score: output.score,
+  },
+  entityId: output.id,
+  eventType: 'JobScored',
+});

package/template/lambda-sqs-worker-cdk/src/services/aws.ts

@@ -0,0 +1,5 @@
+import { SNSClient } from '@aws-sdk/client-sns';
+
+export const sns = new SNSClient({
+  apiVersion: '2010-03-31',
+});

package/template/lambda-sqs-worker-cdk/src/services/jobScorer.test.ts

@@ -0,0 +1,44 @@
+import { scoringService } from 'src/testing/services';
+import { chance, mockJobPublishedEvent } from 'src/testing/types';
+
+import * as jobScorer from './jobScorer';
+
+describe('scoreJobPublishedEvent', () => {
+  beforeAll(scoringService.spy);
+
+  afterEach(scoringService.clear);
+
+  it('scores an event', async () => {
+    const score = chance.floating({ max: 1, min: 0 });
+
+    scoringService.request.mockResolvedValue(score);
+
+    await expect(
+      jobScorer.scoreJobPublishedEvent(
+        mockJobPublishedEvent({ entityId: '1' }),
+      ),
+    ).resolves.toStrictEqual({
+      data: {
+        score,
+      },
+      entityId: '1',
+      eventType: 'JobScored',
+    });
+
+    expect(scoringService.request).toHaveBeenCalledTimes(1);
+  });
+
+  it('bubbles up scoring service error', async () => {
+    const err = Error(chance.sentence());
+
+    scoringService.request.mockRejectedValue(err);
+
+    await expect(
+      jobScorer.scoreJobPublishedEvent(
+        mockJobPublishedEvent({ entityId: '1' }),
+      ),
+    ).rejects.toThrow(err);
+
+    expect(scoringService.request).toHaveBeenCalledTimes(1);
+  });
+});

package/template/lambda-sqs-worker-cdk/src/services/jobScorer.ts

@@ -0,0 +1,59 @@
+import {
+  jobPublishedEventToScorerInput,
+  jobScorerOutputToScoredEvent,
+} from 'src/mapping/jobScorer';
+import {
+  type JobScorerInput,
+  type JobScorerOutput,
+  JobScorerOutputSchema,
+} from 'src/types/jobScorer';
+import type {
+  JobPublishedEvent,
+  JobScoredEvent,
+} from 'src/types/pipelineEvents';
+
+/* istanbul ignore next: simulation of an external service */
+export const scoringService = {
+  request: (details: string): Promise<unknown> => {
+    // Networking woes
+    if (Math.random() < 0.05) {
+      const err = Error('could not reach scoring service');
+
+      return Promise.reject(err);
+    }
+
+    // Unexpected behaviour on certain inputs
+    if (details.length % 100 === 0) {
+      return Promise.resolve(null);
+    }
+
+    return Promise.resolve(Math.random());
+  },
+
+  smokeTest: async (): Promise<void> => {
+    // A connectivity test
+    await Promise.resolve();
+  },
+};
+
+const scoreJob = async ({
+  details,
+  id,
+}: JobScorerInput): Promise<JobScorerOutput> => {
+  const score = await scoringService.request(details);
+
+  return JobScorerOutputSchema.parse({
+    id,
+    score,
+  });
+};
+
+export const scoreJobPublishedEvent = async (
+  publishedJob: JobPublishedEvent,
+): Promise<JobScoredEvent> => {
+  const scorerInput = jobPublishedEventToScorerInput(publishedJob);
+
+  const scorerOutput = await scoreJob(scorerInput);
+
+  return jobScorerOutputToScoredEvent(scorerOutput);
+};

package/template/lambda-sqs-worker-cdk/src/services/pipelineEventSender.test.ts

@@ -0,0 +1,40 @@
+import { PublishCommand } from '@aws-sdk/client-sns';
+
+import { sns } from 'src/testing/services';
+import { chance } from 'src/testing/types';
+
+import { sendPipelineEvent } from './pipelineEventSender';
+
+describe('sendPipelineEvent', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('handles happy path', async () => {
+    const messageId = chance.guid({ version: 4 });
+
+    sns.publish.resolves({ MessageId: messageId });
+
+    await expect(sendPipelineEvent({})).resolves.toBe(messageId);
+
+    expect(sns.client).toReceiveCommandTimes(PublishCommand, 1);
+  });
+
+  it('bubbles up SNS error', () => {
+    const err = Error(chance.sentence());
+
+    sns.publish.rejects(err);
+
+    return expect(sendPipelineEvent({})).rejects.toThrow(err);
+  });
+
+  it('throws on missing message ID', () => {
+    sns.publish.resolves({});
+
+    return expect(
+      sendPipelineEvent({}),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `"SNS did not return a message ID"`,
+    );
+  });
+});

package/template/lambda-sqs-worker-cdk/src/services/pipelineEventSender.ts

@@ -0,0 +1,33 @@
+import { PublishCommand } from '@aws-sdk/client-sns';
+
+import { config } from 'src/config';
+
+import { sns } from './aws';
+
+export const sendPipelineEvent = async (
+  event: unknown,
+  smokeTest: boolean = false,
+): Promise<string> => {
+  const snsResponse = await sns.send(
+    new PublishCommand({
+      Message: JSON.stringify(event),
+      ...(smokeTest && {
+        MessageAttributes: {
+          // Used for connectivity tests.
+          // Subscribers should filter out messages containing this attribute.
+          SmokeTest: {
+            DataType: 'String',
+            StringValue: 'true',
+          },
+        },
+      }),
+      TopicArn: config.destinationSnsTopicArn,
+    }),
+  );
+
+  if (snsResponse.MessageId === undefined) {
+    throw Error('SNS did not return a message ID');
+  }
+
+  return snsResponse.MessageId;
+};

package/template/lambda-sqs-worker-cdk/src/testing/handler.ts

@@ -0,0 +1,13 @@
+import type { Context, SQSEvent } from 'aws-lambda';
+
+import { chance } from './types';
+
+export const createCtx = () =>
+  ({
+    awsRequestId: chance.guid({ version: 4 }),
+  }) as Context;
+
+export const createSqsEvent = (bodies: string[]) =>
+  ({
+    Records: bodies.map((body) => ({ body })),
+  }) as SQSEvent;

package/template/lambda-sqs-worker-cdk/src/testing/logging.ts

@@ -0,0 +1,19 @@
+import * as logging from 'src/framework/logging';
+
+export const logger = {
+  error: jest.fn(),
+  info: jest.fn(),
+  debug: jest.fn(),
+
+  clear: () => {
+    logger.error.mockClear();
+    logger.info.mockClear();
+    logger.debug.mockClear();
+  },
+
+  spy: () => {
+    jest.spyOn(logging.logger, 'error').mockImplementation(logger.error);
+    jest.spyOn(logging.logger, 'info').mockImplementation(logger.info);
+    jest.spyOn(logging.logger, 'debug').mockImplementation(logger.debug);
+  },
+};

package/template/lambda-sqs-worker-cdk/src/testing/services.ts

@@ -0,0 +1,28 @@
+import 'aws-sdk-client-mock-jest';
+
+import { PublishCommand } from '@aws-sdk/client-sns';
+import { mockClient } from 'aws-sdk-client-mock';
+
+import { sns as snsClient } from 'src/services/aws';
+import * as jobScorer from 'src/services/jobScorer';
+
+export const scoringService = {
+  request: jest.fn(),
+
+  clear: () => scoringService.request.mockClear(),
+
+  spy: () =>
+    jest
+      .spyOn(jobScorer.scoringService, 'request')
+      .mockImplementation(scoringService.request),
+};
+
+const snsMock = mockClient(snsClient);
+
+export const sns = {
+  publish: snsMock.on(PublishCommand),
+
+  clear: () => snsMock.resetHistory(),
+
+  client: snsMock,
+};

package/template/lambda-sqs-worker-cdk/src/testing/types.ts

@@ -0,0 +1,33 @@
+import { Chance } from 'chance';
+import { z } from 'zod';
+
+import type { JobPublishedEvent } from 'src/types/pipelineEvents';
+
+export type IdDescription = z.infer<typeof IdDescriptionSchema>;
+
+export const IdDescriptionSchema = z.object({
+  id: z.string(),
+  description: z.string(),
+});
+
+export const chance = new Chance();
+
+export const mockIdDescription = (): IdDescription => ({
+  id: chance.guid({ version: 4 }),
+  description: chance.sentence(),
+});
+
+export const mockIdDescriptionJson = (): string =>
+  JSON.stringify(mockIdDescription());
+
+export const mockJobPublishedEvent = ({
+  entityId,
+}: {
+  entityId: string;
+}): JobPublishedEvent => ({
+  data: {
+    details: chance.paragraph(),
+  },
+  entityId,
+  eventType: 'JobPublished',
+});

package/template/lambda-sqs-worker-cdk/src/types/jobScorer.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export type JobScorerInput = z.infer<typeof JobScorerInputSchema>;
+
+export const JobScorerInputSchema = z.object({
+  id: z.string(),
+  details: z.string(),
+});
+
+export type JobScorerOutput = z.infer<typeof JobScorerOutputSchema>;
+
+export const JobScorerOutputSchema = z.object({
+  id: z.string(),
+  score: z.number(),
+});

package/template/lambda-sqs-worker-cdk/src/types/pipelineEvents.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+export type JobPublishedEvent = z.infer<typeof JobPublishedEventSchema>;
+
+export const JobPublishedEventSchema = z.object({
+  data: z.object({
+    details: z.string(),
+  }),
+  entityId: z.string(),
+  eventType: z.literal('JobPublished'),
+});
+
+export type JobScoredEvent = z.infer<typeof JobScoredEventSchema>;
+
+export const JobScoredEventSchema = z.object({
+  data: z.object({
+    score: z.number(),
+  }),
+  entityId: z.string(),
+  eventType: z.literal('JobScored'),
+});