skuba 11.1.0-jest30-20250620003740 → 11.1.0

package/template/koa-rest-api/src/framework/validation.test.ts

@@ -43,15 +43,15 @@ describe('validate', () => {
       .expect(422)
       .expect(({ body }) =>
         expect(body).toMatchInlineSnapshot(`
-{
-  "invalidFields": {
-    "~union0/id": "Expected string, received null",
-    "~union1/id": "Expected number, received null",
-    "~union1/summary": "Required",
-  },
-  "message": "Input validation failed",
-}
-`),
+          {
+            "invalidFields": {
+              "~union0/id": "Invalid input: expected string, received null",
+              "~union1/id": "Invalid input: expected number, received null",
+              "~union1/summary": "Invalid input: expected string, received undefined",
+            },
+            "message": "Input validation failed",
+          }
+        `),
       );
   });
 
@@ -62,17 +62,17 @@ describe('validate', () => {
       .expect(422)
       .expect(({ body }) =>
         expect(body).toMatchInlineSnapshot(`
-{
-  "invalidFields": {
-    "~union0/description~union0": "Required",
-    "~union0/description~union1": "Required",
-    "~union0/id": "Required",
-    "~union1/id": "Required",
-    "~union1/summary": "Required",
-  },
-  "message": "Input validation failed",
-}
-`),
+          {
+            "invalidFields": {
+              "~union0/description~union0": "Invalid input: expected string, received undefined",
+              "~union0/description~union1": "Invalid input: expected object, received undefined",
+              "~union0/id": "Invalid input: expected string, received undefined",
+              "~union1/id": "Invalid input: expected number, received undefined",
+              "~union1/summary": "Invalid input: expected string, received undefined",
+            },
+            "message": "Input validation failed",
+          }
+        `),
       ));
 
   it('blocks invalid nested union prop', () => {
@@ -89,17 +89,17 @@ describe('validate', () => {
       .expect(422)
       .expect(({ body }) =>
         expect(body).toMatchInlineSnapshot(`
-{
-  "invalidFields": {
-    "~union0/description~union0": "Expected string, received object",
-    "~union0/description~union1/content": "Required",
-    "~union0/id": "Expected string, received null",
-    "~union1/id": "Expected number, received null",
-    "~union1/summary": "Required",
-  },
-  "message": "Input validation failed",
-}
-`),
+          {
+            "invalidFields": {
+              "~union0/description~union0": "Invalid input: expected string, received object",
+              "~union0/description~union1/content": "Invalid input: expected string, received undefined",
+              "~union0/id": "Invalid input: expected string, received null",
+              "~union1/id": "Invalid input: expected number, received null",
+              "~union1/summary": "Invalid input: expected string, received undefined",
+            },
+            "message": "Input validation failed",
+          }
+        `),
       );
   });
 });

package/template/koa-rest-api/src/framework/validation.ts

@@ -1,5 +1,5 @@
 import { ErrorMiddleware } from 'seek-koala';
-import { ZodIssueCode, type z } from 'zod';
+import type { core, z } from 'zod/v4';
 
 import type { Context } from 'src/types/koa';
 
@@ -35,41 +35,38 @@ type InvalidFields = Record<string, string>;
  * @see [union error example](./validation.test.ts)
  */
 const parseInvalidFieldsFromError = (err: z.ZodError): InvalidFields =>
-  Object.fromEntries(parseTuples(err, {}));
+  Object.fromEntries(parseTuples(err.issues));
 
 const parseTuples = (
-  { errors }: z.ZodError,
-  unions: Record<number, number[]>,
+  errors: core.$ZodIssue[],
+  basePath: Array<string | number | symbol> = [],
+  unions: Record<number, number[]> = {},
 ): Array<readonly [string, string]> =>
   errors.flatMap((issue) => {
-    if (issue.code === ZodIssueCode.invalid_union) {
-      return issue.unionErrors.flatMap((err, idx) =>
-        parseTuples(err, {
+    if (issue.code === 'invalid_union') {
+      return issue.errors.flatMap((err, idx) =>
+        parseTuples(err, issue.path, {
           ...unions,
           [issue.path.length]: [...(unions[issue.path.length] ?? []), idx],
         }),
       );
     }
 
-    const path = ['', ...issue.path]
+    const path = ['', ...basePath, ...issue.path]
       .map((prop, idx) => [prop, ...(unions[idx] ?? [])].join('~union'))
       .join('/');
 
     return [[path, issue.message]] as const;
   });
 
-export const validate = <
-  Output,
-  Def extends z.ZodTypeDef = z.ZodTypeDef,
-  Input = Output,
->({
+export const validate = <Output, Input = Output>({
   ctx,
   input,
   schema,
 }: {
   ctx: Context;
   input: unknown;
-  schema: z.ZodSchema<Output, Def, Input>;
+  schema: z.ZodSchema<Output, Input>;
 }): Output => {
   const parseResult = schema.safeParse(input);
   if (parseResult.success === false) {
@@ -85,15 +82,11 @@ export const validate = <
   return parseResult.data;
 };
 
-export const validateRequestBody = <
-  Output,
-  Def extends z.ZodTypeDef = z.ZodTypeDef,
-  Input = Output,
->(
+export const validateRequestBody = <Output, Input = Output>(
   ctx: Context,
-  schema: z.ZodSchema<Output, Def, Input>,
+  schema: z.ZodSchema<Output, Input>,
 ): Output =>
-  validate<Output, Def, Input>({
+  validate<Output, Input>({
     ctx,
     input: ctx.request.body as unknown,
     schema,

package/template/koa-rest-api/src/testing/types.ts

@@ -1,5 +1,5 @@
 import { Chance } from 'chance';
-import { z } from 'zod';
+import { z } from 'zod/v4';
 
 import type { JobInput } from 'src/types/jobs';
 

package/template/koa-rest-api/src/types/jobs.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v4';
 
 export interface Job {
   id: string;

package/template/lambda-sqs-worker-cdk/.buildkite/pipeline.yml

@@ -23,7 +23,7 @@ configs:
       concurrency: 1
       plugins:
         - *docker-ecr-cache
-        - docker-compose#v5.9.0:
+        - docker-compose#v5.10.0:
             dependencies: false
             run: app
             environment:
@@ -52,7 +52,7 @@ steps:
       GET_NPM_TOKEN: please
     plugins:
       - *docker-ecr-cache
-      - docker-compose#v5.9.0:
+      - docker-compose#v5.10.0:
           run: app
           environment:
             - GITHUB_API_TOKEN

package/template/lambda-sqs-worker-cdk/Dockerfile

@@ -1,4 +1,4 @@
-# syntax=docker/dockerfile:1.16
+# syntax=docker/dockerfile:1.17
 
 FROM public.ecr.aws/docker/library/node:22-alpine AS dev-deps
 

package/template/lambda-sqs-worker-cdk/infra/__snapshots__/appStack.test.ts.snap

@@ -369,6 +369,9 @@ exports[`returns expected CloudFormation stack for dev 1`] = `
       "Type": "AWS::Lambda::EventSourceMapping",
     },
     "workerCurrentVersionxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx": {
+      "Metadata": {
+        "aws:cdk:do-not-refactor": true,
+      },
       "Properties": {
         "FunctionName": {
           "Ref": "worker28EA3E30",
@@ -1099,6 +1102,9 @@ exports[`returns expected CloudFormation stack for prod 1`] = `
       "Type": "AWS::Lambda::EventSourceMapping",
     },
     "workerCurrentVersionxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx": {
+      "Metadata": {
+        "aws:cdk:do-not-refactor": true,
+      },
       "Properties": {
         "FunctionName": {
           "Ref": "worker28EA3E30",

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

@@ -17,15 +17,15 @@
     "@aws-sdk/client-codedeploy": "^3.363.0",
     "@aws-sdk/client-lambda": "^3.363.0",
     "@aws-sdk/client-sns": "^3.363.0",
-    "@seek/aws-codedeploy-hooks": "^1.2.0",
+    "@seek/aws-codedeploy-hooks": "^2.0.0",
     "@seek/logger": "^10.0.0",
     "datadog-lambda-js": "^10.0.0",
     "dd-trace": "^5.0.0",
     "skuba-dive": "^2.0.0",
-    "zod": "^3.19.1"
+    "zod": "^3.25.67"
   },
   "devDependencies": {
-    "@seek/aws-codedeploy-infra": "^2.1.0",
+    "@seek/aws-codedeploy-infra": "^3.0.0",
     "@types/aws-lambda": "^8.10.82",
     "@types/chance": "^1.1.3",
     "@types/node": "^22.13.10",
@@ -37,9 +37,9 @@
     "constructs": "^10.0.17",
     "datadog-cdk-constructs-v2": "^2.0.0",
     "pino-pretty": "^13.0.0",
-    "skuba": "11.1.0-jest30-20250620003740"
+    "skuba": "*"
   },
-  "packageManager": "pnpm@10.12.1",
+  "packageManager": "pnpm@10.12.4",
   "engines": {
     "node": ">=22"
   }

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

@@ -2,11 +2,11 @@ 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';
+import { stdoutMock } from './framework/logging';
 
 describe('app', () => {
   it('exports a handler', () => expect(app).toHaveProperty('handler'));
@@ -23,7 +23,6 @@ describe('handler', () => {
     .spyOn(metricsClient, 'distribution')
     .mockReturnValue();
 
-  beforeAll(logger.spy);
   beforeAll(scoringService.spy);
 
   beforeEach(() => {
@@ -32,7 +31,7 @@ describe('handler', () => {
   });
 
   afterEach(() => {
-    logger.clear();
+    stdoutMock.clear();
     distribution.mockClear();
     scoringService.clear();
     sns.clear();
@@ -45,12 +44,24 @@ describe('handler', () => {
 
     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(stdoutMock.calls).toMatchObject([
+      {
+        awsRequestId: '-',
+        count: 1,
+        level: 20,
+        msg: 'Received jobs',
+      },
+      {
+        awsRequestId: '-',
+        level: 20,
+        msg: 'Scored job',
+        snsMessageId: expect.any(String),
+      },
+      {
+        awsRequestId: '-',
+        level: 20,
+        msg: 'Function succeeded',
+      },
     ]);
 
     expect(distribution.mock.calls).toEqual([
@@ -76,7 +87,23 @@ describe('handler', () => {
 
     await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
 
-    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
+    expect(stdoutMock.calls).toMatchObject([
+      {
+        awsRequestId: '-',
+        count: 1,
+        level: 20,
+        msg: 'Received jobs',
+      },
+      {
+        awsRequestId: '-',
+        err: {
+          message: err.message,
+          type: 'Error',
+        },
+        level: 50,
+        msg: 'Function failed',
+      },
+    ]);
   });
 
   it('bubbles up SNS error', async () => {
@@ -88,22 +115,44 @@ describe('handler', () => {
 
     await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
 
-    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
+    expect(stdoutMock.calls).toMatchObject([
+      {
+        awsRequestId: '-',
+        count: 1,
+        level: 20,
+        msg: 'Received jobs',
+      },
+      {
+        awsRequestId: '-',
+        err: {
+          message: err.message,
+          type: 'Error',
+        },
+        level: 50,
+        msg: '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');
+    expect(stdoutMock.calls).toMatchObject([
+      {
+        awsRequestId: '-',
+        err: {
+          message: 'Received 0 records',
+          type: 'Error',
+        },
+        level: 50,
+        msg: 'Function failed',
+      },
+    ]);
   });
 
   it('throws on multiple records', async () => {
-    const err = new Error('Received 2 records');
-
     const event = createSqsEvent([
       JSON.stringify(jobPublished),
       JSON.stringify(jobPublished),
@@ -111,6 +160,16 @@ describe('handler', () => {
 
     await expect(app.handler(event, ctx)).rejects.toThrow('Function failed');
 
-    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
+    expect(stdoutMock.calls).toMatchObject([
+      {
+        awsRequestId: '-',
+        err: {
+          message: 'Received 2 records',
+          type: 'Error',
+        },
+        level: 50,
+        msg: 'Function failed',
+      },
+    ]);
   });
 });

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

@@ -29,7 +29,7 @@ const configs: Record<Environment, () => Omit<Config, 'environment'>> = {
   }),
 
   test: () => ({
-    logLevel: Env.string('LOG_LEVEL', { default: 'silent' }),
+    logLevel: Env.string('LOG_LEVEL', { default: 'debug' }),
     metrics: false,
     name: '<%- serviceName %>',
     version: 'test',

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

@@ -1,16 +1,14 @@
 import { createCtx } from 'src/testing/handler';
-import { logger } from 'src/testing/logging';
 import { chance } from 'src/testing/types';
 
 import { createHandler } from './handler';
+import { logger, stdoutMock } from './logging';
 
 describe('createHandler', () => {
   const ctx = createCtx();
   const input = chance.paragraph();
 
-  beforeAll(logger.spy);
-
-  afterEach(logger.clear);
+  afterEach(stdoutMock.clear);
 
   it('handles happy path', async () => {
     const output = chance.paragraph();
@@ -25,11 +23,17 @@ describe('createHandler', () => {
 
     await expect(handler(input, ctx)).resolves.toBe(output);
 
-    expect(logger.error).not.toHaveBeenCalled();
-
-    expect(logger.debug.mock.calls).toEqual([
-      ['Handler invoked'],
-      ['Function succeeded'],
+    expect(stdoutMock.calls).toMatchObject([
+      {
+        awsRequestId: '-',
+        level: 20,
+        msg: 'Handler invoked',
+      },
+      {
+        awsRequestId: '-',
+        level: 20,
+        msg: 'Function succeeded',
+      },
     ]);
   });
 
@@ -40,9 +44,17 @@ describe('createHandler', () => {
 
     await expect(handler(input, ctx)).rejects.toThrow('Function failed');
 
-    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
-
-    expect(logger.debug).not.toHaveBeenCalled();
+    expect(stdoutMock.calls).toMatchObject([
+      {
+        awsRequestId: '-',
+        err: {
+          message: err.message,
+          type: 'Error',
+        },
+        level: 50,
+        msg: 'Function failed',
+      },
+    ]);
   });
 
   it('handles sync error', async () => {
@@ -54,8 +66,16 @@ describe('createHandler', () => {
 
     await expect(handler(input, ctx)).rejects.toThrow('Function failed');
 
-    expect(logger.error).toHaveBeenCalledWith({ err }, 'Function failed');
-
-    expect(logger.debug).not.toHaveBeenCalled();
+    expect(stdoutMock.calls).toMatchObject([
+      {
+        awsRequestId: '-',
+        err: {
+          message: err.message,
+          type: 'Error',
+        },
+        level: 50,
+        msg: 'Function failed',
+      },
+    ]);
   });
 });

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

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'async_hooks';
 
-import createLogger from '@seek/logger';
+import createLogger, { createDestination } from '@seek/logger';
 
 import { config } from 'src/config';
 
@@ -10,18 +10,29 @@ interface LoggerContext {
 
 export const loggerContext = new AsyncLocalStorage<LoggerContext>();
 
-export const logger = createLogger({
-  base: {
-    environment: config.environment,
-    version: config.version,
+const { destination, stdoutMock } = createDestination({
+  mock: config.environment === 'test' && {
+    redact: ['awsRequestId'],
   },
+});
 
-  level: config.logLevel,
+export { stdoutMock };
 
-  mixin: () => ({ ...loggerContext.getStore() }),
+export const logger = createLogger(
+  {
+    base: {
+      environment: config.environment,
+      version: config.version,
+    },
 
-  name: config.name,
+    level: config.logLevel,
 
-  transport:
-    config.environment === 'local' ? { target: 'pino-pretty' } : undefined,
-});
+    mixin: () => ({ ...loggerContext.getStore() }),
+
+    name: config.name,
+
+    transport:
+      config.environment === 'local' ? { target: 'pino-pretty' } : undefined,
+  },
+  destination,
+);

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

@@ -32,13 +32,12 @@ describe('validateJson', () => {
       .toThrowErrorMatchingInlineSnapshot(`
       "[
         {
-          "code": "invalid_type",
           "expected": "string",
-          "received": "null",
+          "code": "invalid_type",
           "path": [
             "id"
           ],
-          "message": "Expected string, received null"
+          "message": "Invalid input: expected string, received null"
         }
       ]"
     `);
@@ -51,22 +50,20 @@ describe('validateJson', () => {
       .toThrowErrorMatchingInlineSnapshot(`
       "[
         {
-          "code": "invalid_type",
           "expected": "string",
-          "received": "undefined",
+          "code": "invalid_type",
           "path": [
             "id"
           ],
-          "message": "Required"
+          "message": "Invalid input: expected string, received undefined"
         },
         {
-          "code": "invalid_type",
           "expected": "string",
-          "received": "undefined",
+          "code": "invalid_type",
           "path": [
             "description"
           ],
-          "message": "Required"
+          "message": "Invalid input: expected string, received undefined"
         }
       ]"
     `);

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

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

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

@@ -1,5 +1,5 @@
 import { Chance } from 'chance';
-import { z } from 'zod';
+import { z } from 'zod/v4';
 
 import type { JobPublishedEvent } from 'src/types/pipelineEvents';
 

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v4';
 
 export type JobScorerInput = z.infer<typeof JobScorerInputSchema>;
 

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v4';
 
 export type JobPublishedEvent = z.infer<typeof JobPublishedEventSchema>;
 

package/template/koa-rest-api/src/testing/logging.ts

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

package/template/lambda-sqs-worker-cdk/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);
-  },
-};