skuba 9.0.1-upgrade-cdk-template-20241002233314 → 9.0.1

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

@@ -1,57 +1,35 @@
-import 'skuba-dive/register';
+import createLogger from '@seek/logger';
+import type { SQSEvent, SQSHandler } from 'aws-lambda';
 
-import type { SQSEvent } from 'aws-lambda';
+import { config } from './config';
 
-import { createHandler } from 'src/framework/handler';
-import { logger } from 'src/framework/logging';
-import { metricsClient } from 'src/framework/metrics';
-import { validateJson } from 'src/framework/validation';
-import { scoreJobPublishedEvent, scoringService } from 'src/services/jobScorer';
-import { sendPipelineEvent } from 'src/services/pipelineEventSender';
-import { JobPublishedEventSchema } from 'src/types/pipelineEvents';
+export const logger = createLogger({
+  base: {
+    environment: config.environment,
+    version: config.version,
+  },
+
+  level: config.logLevel,
+
+  name: config.name,
+
+  transport:
+    config.environment === 'local' ? { target: 'pino-pretty' } : undefined,
+});
 
 /**
  * Tests connectivity to ensure appropriate access and network configuration.
  */
-const smokeTest = async () => {
-  await Promise.all([scoringService.smokeTest(), sendPipelineEvent({}, true)]);
-};
+const smokeTest = async () => Promise.resolve();
 
-export const handler = createHandler<SQSEvent>(async (event) => {
+export const handler: SQSHandler = (event: SQSEvent) => {
   // Treat an empty object as our smoke test event.
   if (!Object.keys(event).length) {
     logger.debug('Received smoke test request');
     return smokeTest();
   }
 
-  const count = event.Records.length;
-
-  if (count !== 1) {
-    throw Error(`Received ${count} records`);
-  }
-
-  logger.debug({ count }, 'Received jobs');
-
-  metricsClient.distribution('job.received', event.Records.length);
-
-  const record = event.Records[0];
-  if (!record) {
-    throw new Error('Malformed SQS event with no records');
-  }
-
-  const { body } = record;
-
-  // TODO: this throws an error, which will cause the Lambda function to retry
-  // the event and eventually send it to your dead-letter queue. If you don't
-  // trust your source to provide consistently well-formed input, consider
-  // catching and handling this error in code.
-  const publishedJob = validateJson(body, JobPublishedEventSchema);
-
-  const scoredJob = await scoreJobPublishedEvent(publishedJob);
+  logger.info('Hello World!');
 
-  const snsMessageId = await sendPipelineEvent(scoredJob);
-
-  logger.debug({ snsMessageId }, 'Scored job');
-
-  metricsClient.distribution('job.scored', 1);
-});
+  return;
+};

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

@@ -4,11 +4,8 @@ interface Config {
   environment: Environment;
 
   logLevel: string;
-  metrics: boolean;
   name: string;
   version: string;
-
-  destinationSnsTopicArn: string;
 }
 
 type Environment = (typeof environments)[number];
@@ -21,38 +18,26 @@ 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/.env

@@ -1 +0,0 @@
-ENVIRONMENT=local

package/template/lambda-sqs-worker-cdk/README.md

@@ -1,145 +0,0 @@
-# <%- repoName %>
-
-[![Powered by skuba](https://img.shields.io/badge/🤿%20skuba-powered-009DC4)](https://github.com/seek-oss/skuba)
-
-Next steps:
-
-1. [ ] Finish templating if this was skipped earlier:
-
-   ```shell
-   pnpm exec skuba configure
-   ```
-
-2. [ ] Create a new repository in the appropriate GitHub organisation.
-3. [ ] Add the repository to BuildAgency;
-       see our internal [Buildkite Docs] for more information.
-4. [ ] Add Datadog extension, deployment bucket configuration and data classification tags to [infra/config.ts](infra/config.ts).
-5. [ ] Push local commits to the upstream GitHub branch.
-6. [ ] Configure [GitHub repository settings].
-7. [ ] Delete this checklist 😌.
-
-[Buildkite Docs]: https://backstage.myseek.xyz/docs/default/component/buildkite-docs
-[GitHub repository settings]: https://github.com/<%-orgName%>/<%-repoName%>/settings
-
-## Design
-
-<%-repoName %> is a Node.js [Lambda] application built in line with our [Technical Guidelines].
-It is backed by a typical SQS message + dead letter queue configuration and uses common SEEK packages.
-Workers enable fault-tolerant asynchronous processing of events.
-
-The `lambda-sqs-worker-cdk` template is modelled after a hypothetical enricher that scores job advertisements.
-It's stubbed out with in-memory [scoring service](src/services/jobScorer.ts).
-This would be replaced with internal logic or an external service in production.
-
-This project is deployed with [AWS CDK].
-The Lambda runtime provisions a single Node.js process per container.
-The supplied [infra/appStack.ts](infra/appStack.ts) starts out with a minimal `memorySize` which may require tuning based on workload.
-Under load, we autoscale horizontally in terms of container count up to `reservedConcurrency`.
-
-[@seek/aws-codedeploy-hooks] configures [CodeDeploy] for a blue-green deployment approach.
-A smoke test is run against the new version before traffic is switched over,
-providing an opportunity to test access and connectivity to online dependencies.
-This defaults to an invocation with an empty object `{}`.
-
-## Development
-
-### Test
-
-```shell
-# Run Jest tests locally
-pnpm test
-
-# Authenticate to dev account
-awsauth
-
-# Run smoke test against deployed application
-ENVIRONMENT=dev pnpm smoke
-```
-
-### Lint
-
-```shell
-# Fix issues
-pnpm format
-
-# Check for issues
-pnpm lint
-```
-
-### Start
-
-```shell
-# Start a local HTTP server
-pnpm start
-
-# Start with Node.js Inspector enabled
-pnpm start:debug
-```
-
-This serves the Lambda application over HTTP.
-For example, to invoke the handler with an empty object `{}` for smoke testing:
-
-```shell
-curl --data '[{}, {"awsRequestId": "local"}]' --include localhost:<%- port %>
-```
-
-### Deploy
-
-This project is deployed through a [Buildkite pipeline](.buildkite/pipeline.yml).
-
-- Commits to a feature branch can be deployed to the dev environment by unblocking a step in the Buildkite UI
-- Commits to the default branch are automatically deployed to the dev and prod environments in sequence
-
-To deploy locally:
-
-```shell
-# Authenticate to dev account
-awsauth
-
-ENVIRONMENT=dev pnpm run deploy
-```
-
-A hotswap deploy enables faster deployment but come with caveats such as requiring a Lambda to be rebuilt with every build.
-
-To deploy a [hotswap]:
-
-```shell
-# Authenticate to dev account
-awsauth
-
-ENVIRONMENT=dev pnpm run deploy:hotswap
-```
-
-To rapidly roll back a change,
-retry an individual deployment step from the previous build in Buildkite.
-Note that this will introduce drift between the head of the default Git branch and the live environment;
-use with caution and always follow up with a proper revert or fix in Git history.
-
-## Support
-
-### Dev
-
-TODO: add support links for the dev environment.
-
-<!--
-- CloudWatch dashboard
-- Datadog dashboard
-- Splunk logs
--->
-
-### Prod
-
-TODO: add support links for the prod environment.
-
-<!--
-- CloudWatch dashboard
-- Datadog dashboard
-- Splunk logs
--->
-
-[@seek/aws-codedeploy-hooks]: https://github.com/seek-oss/aws-codedeploy-hooks
-[AWS CDK]: https://docs.aws.amazon.com/cdk/v2/guide/home.html
-[CodeDeploy]: https://docs.aws.amazon.com/codedeploy
-[Hotswap]: https://docs.aws.amazon.com/cdk/v2/guide/ref-cli-cmd-deploy.html#ref-cli-cmd-deploy-options
-[Lambda]: https://docs.aws.amazon.com/lambda
-[Technical Guidelines]: https://myseek.atlassian.net/wiki/spaces/AA/pages/2358346017/

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

@@ -1,116 +0,0 @@
-import { PublishCommand } from '@aws-sdk/client-sns';
-
-import { metricsClient } from 'src/framework/metrics';
-import { createCtx, createSqsEvent } from 'src/testing/handler';
-import { logger } from 'src/testing/logging';
-import { scoringService, sns } from 'src/testing/services';
-import { chance, mockJobPublishedEvent } from 'src/testing/types';
-
-import * as app from './app';
-
-describe('app', () => {
-  it('exports a handler', () => expect(app).toHaveProperty('handler'));
-});
-
-describe('handler', () => {
-  const ctx = createCtx();
-
-  const jobPublished = mockJobPublishedEvent({ entityId: chance.name() });
-
-  const score = chance.floating({ max: 1, min: 0 });
-
-  const distribution = jest
-    .spyOn(metricsClient, 'distribution')
-    .mockReturnValue();
-
-  beforeAll(logger.spy);
-  beforeAll(scoringService.spy);
-
-  beforeEach(() => {
-    scoringService.request.mockResolvedValue(score);
-    sns.publish.resolves({ MessageId: chance.guid({ version: 4 }) });
-  });
-
-  afterEach(() => {
-    logger.clear();
-    distribution.mockClear();
-    scoringService.clear();
-    sns.clear();
-  });
-
-  it('handles one record', async () => {
-    const event = createSqsEvent([JSON.stringify(jobPublished)]);
-
-    await expect(app.handler(event, ctx)).resolves.toBeUndefined();
-
-    expect(scoringService.request).toHaveBeenCalledTimes(1);
-
-    expect(logger.error).not.toHaveBeenCalled();
-
-    expect(logger.debug.mock.calls).toEqual([
-      [{ count: 1 }, 'Received jobs'],
-      [{ snsMessageId: expect.any(String) }, 'Scored job'],
-      ['Function succeeded'],
-    ]);
-
-    expect(distribution.mock.calls).toEqual([
-      ['job.received', 1],
-      ['job.scored', 1],
-    ]);
-
-    expect(sns.client).toReceiveCommandTimes(PublishCommand, 1);
-  });
-
-  it('throws on invalid input', () => {
-    const event = createSqsEvent(['}']);
-
-    return expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
-  });
-
-  it('bubbles up scoring service error', async () => {
-    const err = Error(chance.sentence());
-
-    scoringService.request.mockRejectedValue(err);
-
-    const event = createSqsEvent([JSON.stringify(jobPublished)]);
-
-    await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
-
-    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
-  });
-
-  it('bubbles up SNS error', async () => {
-    const err = Error(chance.sentence());
-
-    sns.publish.rejects(err);
-
-    const event = createSqsEvent([JSON.stringify(jobPublished)]);
-
-    await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
-
-    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
-  });
-
-  it('throws on zero records', async () => {
-    const err = new Error('Received 0 records');
-
-    const event = createSqsEvent([]);
-
-    await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
-
-    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
-  });
-
-  it('throws on multiple records', async () => {
-    const err = new Error('Received 2 records');
-
-    const event = createSqsEvent([
-      JSON.stringify(jobPublished),
-      JSON.stringify(jobPublished),
-    ]);
-
-    await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
-
-    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
-  });
-});

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

@@ -1,61 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -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-cdk/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-cdk/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-cdk/src/services/aws.ts

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