skuba 10.0.0-node-22-20250115230358 → 10.0.0-node-22-20250213082332

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

@@ -1,84 +0,0 @@
-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/src/framework/validation.ts

@@ -1,10 +0,0 @@
-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/src/hooks.ts

@@ -1,95 +0,0 @@
-/* eslint-disable no-console */
-/* istanbul ignore file */
-
-// Use minimal dependencies to reduce the chance of crashes on module load.
-import {
-  CodeDeployClient,
-  PutLifecycleEventHookExecutionStatusCommand,
-} from '@aws-sdk/client-codedeploy';
-import { InvokeCommand, LambdaClient } from '@aws-sdk/client-lambda';
-
-const codeDeploy = new CodeDeployClient({
-  apiVersion: '2014-10-06',
-  maxAttempts: 5,
-});
-
-const lambda = new LambdaClient({
-  apiVersion: '2015-03-31',
-  maxAttempts: 5,
-});
-
-type Status = 'Succeeded' | 'Failed';
-
-/**
- * Synchronously invokes a Lambda function with a smoke test event.
- *
- * Any non-error response is treated as a success.
- */
-const smokeTestLambdaFunction = async (): Promise<Status> => {
-  const functionName = process.env.FUNCTION_NAME_TO_INVOKE;
-
-  if (!functionName) {
-    console.error('Missing process.env.FUNCTION_NAME_TO_INVOKE');
-    return 'Failed';
-  }
-
-  console.info('Function:', functionName);
-
-  const response = await lambda.send(
-    new InvokeCommand({
-      FunctionName: functionName,
-      InvocationType: 'RequestResponse',
-      // Treat an empty object as our smoke test event.
-      Payload: Buffer.from('{}'),
-    }),
-  );
-
-  console.info('Version:', response.ExecutedVersion ?? '?');
-  console.info('Status', response.StatusCode ?? '?');
-
-  if (response.FunctionError) {
-    console.error('Error:', response.FunctionError);
-    if (response.Payload) {
-      console.error(response.Payload.transformToString());
-    }
-    return 'Failed';
-  }
-
-  return response.StatusCode === 200 ? 'Succeeded' : 'Failed';
-};
-
-/**
- * The event supplied to a CodeDeploy lifecycle hook Lambda function.
- *
- * {@link https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-with-hooks-create-hooks.html}
- */
-interface CodeDeployLifecycleHookEvent {
-  DeploymentId: string;
-  LifecycleEventHookExecutionId: string;
-}
-
-/**
- * A handler to smoke test a new Lambda function version before it goes live.
- *
- * This tries to be exception safe so that a status reaches CodeDeploy. If we
- * crash or otherwise fail to report back, the deployment will hang for an hour.
- */
-export const pre = async (
-  event: CodeDeployLifecycleHookEvent,
-): Promise<void> => {
-  let status: Status;
-  try {
-    status = await smokeTestLambdaFunction();
-  } catch (err) {
-    console.error('Exception:', err);
-    status = 'Failed';
-  }
-
-  await codeDeploy.send(
-    new PutLifecycleEventHookExecutionStatusCommand({
-      deploymentId: event.DeploymentId,
-      lifecycleEventHookExecutionId: event.LifecycleEventHookExecutionId,
-      status,
-    }),
-  );
-};

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

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

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

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

@@ -1,44 +0,0 @@
-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/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"
-}