skuba 9.2.0-main-20250114234022 → 9.2.0-main-20250217113038

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

@@ -1,59 +0,0 @@
-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/src/services/pipelineEventSender.test.ts

@@ -1,40 +0,0 @@
-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/src/services/pipelineEventSender.ts

@@ -1,33 +0,0 @@
-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/src/testing/handler.ts

@@ -1,13 +0,0 @@
-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/src/testing/logging.ts

@@ -1,19 +0,0 @@
-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/src/testing/services.ts

@@ -1,28 +0,0 @@
-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/src/testing/types.ts

@@ -1,33 +0,0 @@
-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/src/types/jobScorer.ts

@@ -1,15 +0,0 @@
-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/src/types/pipelineEvents.ts

@@ -1,21 +0,0 @@
-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'),
-});

package/template/lambda-sqs-worker/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "lib": ["ES2022"],
-    "outDir": "lib",
-    "paths": {
-      "src": ["src"]
-    },
-    "target": "ES2022"
-  },
-  "exclude": ["lib*/**/*"],
-  "extends": "skuba/config/tsconfig.json"
-}