create-agent-rig 0.9.0 → 0.10.0

package/templates/skeleton/aws-serverless/pnpm-workspace.yaml

@@ -1,14 +0,0 @@
-packages:
-  - packages/*
-  - services/*
-  - apps/*
-  - infra
-
-# esbuild's postinstall is intentionally NOT approved: skipping it keeps the JS
-# launcher in place (which resolves the platform binary itself); approving it
-# swaps in a raw binary that pnpm's node-based bin shim cannot execute.
-# sharp (via next) only matters for the image optimizer, which a static
-# export never runs — its native build stays off.
-allowBuilds:
-  esbuild: false
-  sharp: false

package/templates/skeleton/aws-serverless/services/api/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "@app/api",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "main": "src/main.ts",
-  "types": "src/main.ts",
-  "dependencies": {
-    "@app/core": "workspace:*",
-    "@app/db": "workspace:*",
-    "@app/shared": "workspace:*",
-    "@aws-sdk/client-sqs": "^3.1092.0",
-    "zod": "^4.4.3"
-  }
-}

package/templates/skeleton/aws-serverless/services/api/src/adapters/sqs-publisher.ts

@@ -1,26 +0,0 @@
-// The one place that touches the queue SDK on the sending side.
-import { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs';
-import type { NoteCreatedEvent } from '@app/core';
-import type { EventPublisher } from '../usecases/create-note.js';
-
-/** Structural view of the SQS client — tests stub it. */
-export interface QueueClient {
-  send(command: unknown): Promise<unknown>;
-}
-
-export function createQueueClient(): QueueClient {
-  return new SQSClient({}) as QueueClient;
-}
-
-export class SqsEventPublisher implements EventPublisher {
-  constructor(
-    private readonly client: QueueClient,
-    private readonly queueUrl: string,
-  ) {}
-
-  async publish(event: NoteCreatedEvent): Promise<void> {
-    await this.client.send(
-      new SendMessageCommand({ QueueUrl: this.queueUrl, MessageBody: JSON.stringify(event) }),
-    );
-  }
-}

package/templates/skeleton/aws-serverless/services/api/src/handlers/create-note.ts

@@ -1,69 +0,0 @@
-// The handler translates transport ⇄ domain and nothing else: decode the
-// payload, call the usecase, map the result (or the typed error) to HTTP.
-import type { APIGatewayProxyEventV2, APIGatewayProxyResultV2, Context } from 'aws-lambda';
-import { InvalidNoteError } from '@app/core';
-import { AppError } from '@app/shared';
-import { createNoteUsecase, type CreateNoteDeps } from '../usecases/create-note.js';
-
-/**
- * Lambda passes the context as the second argument; the handler takes the one
- * field it needs, so a log line can be tied back to the invocation that wrote
- * it. Optional because the context is Lambda's to supply, not the caller's.
- */
-type Handler = (
-  event: APIGatewayProxyEventV2,
-  context?: Pick<Context, 'awsRequestId'>,
-) => Promise<APIGatewayProxyResultV2>;
-
-const json = (statusCode: number, body: unknown): APIGatewayProxyResultV2 => ({
-  statusCode,
-  headers: { 'content-type': 'application/json' },
-  body: JSON.stringify(body),
-});
-
-export function makeCreateNoteHandler(deps: CreateNoteDeps): Handler {
-  return async (event, context) => {
-    let payload: unknown;
-    try {
-      const raw = event.isBase64Encoded
-        ? Buffer.from(event.body ?? '', 'base64').toString('utf8')
-        : (event.body ?? '');
-      payload = JSON.parse(raw);
-    } catch {
-      return json(400, { error: 'body must be valid JSON' });
-    }
-
-    try {
-      const note = await createNoteUsecase(payload, deps);
-      return json(201, { note });
-    } catch (error) {
-      if (error instanceof InvalidNoteError) {
-        return json(400, { error: 'invalid note', issues: error.issues });
-      }
-      // A 4xx message was written for the caller to read. A 5xx one was not:
-      // `AppError` defaults to 500/INTERNAL, so a table name, a host or an SDK
-      // message arrives here wearing the same type as "title is required".
-      // Typed does not mean safe to show — the status decides.
-      //
-      // The status itself is kept: 503 tells a caller to retry and 500 does
-      // not, and that distinction is transport, not disclosure. Only the
-      // message is withheld.
-      if (error instanceof AppError && error.statusCode < 500) {
-        return json(error.statusCode, { error: error.message, code: error.code });
-      }
-      // Everything past here is withheld, so it has to be kept somewhere: the
-      // message AND its frames, because a message with no stack is not
-      // something anyone can debug from a log aggregator, and the request id,
-      // because a line nobody can tie to an invocation is barely a line.
-      deps.log.error('unhandled error in create-note', {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : undefined,
-        // The one field of a withheld AppError worth keeping: it says WHICH
-        // internal failure this was, and it never reaches the caller.
-        code: error instanceof AppError ? error.code : undefined,
-        awsRequestId: context?.awsRequestId,
-      });
-      return json(error instanceof AppError ? error.statusCode : 500, { error: 'internal error' });
-    }
-  };
-}

package/templates/skeleton/aws-serverless/services/api/src/handlers/list-notes.ts

@@ -1,37 +0,0 @@
-import type { APIGatewayProxyEventV2, APIGatewayProxyResultV2, Context } from 'aws-lambda';
-import { AppError } from '@app/shared';
-import type { Logger } from '@app/shared';
-import { listNotesUsecase, type ListNotesDeps } from '../usecases/list-notes.js';
-
-const json = (statusCode: number, body: unknown): APIGatewayProxyResultV2 => ({
-  statusCode,
-  headers: { 'content-type': 'application/json' },
-  body: JSON.stringify(body),
-});
-
-export function makeListNotesHandler(deps: ListNotesDeps & { log: Logger }) {
-  return async (
-    _event?: APIGatewayProxyEventV2,
-    context?: Pick<Context, 'awsRequestId'>,
-  ): Promise<APIGatewayProxyResultV2> => {
-    try {
-      return json(200, { notes: await listNotesUsecase(deps) });
-    } catch (error) {
-      // Same contract as create-note: a 4xx message was written for the caller,
-      // a 5xx one was not. The status survives — 503 tells a caller to retry
-      // and 500 does not — and only the message is withheld.
-      if (error instanceof AppError && error.statusCode < 500) {
-        return json(error.statusCode, { error: error.message, code: error.code });
-      }
-      deps.log.error('unhandled error in list-notes', {
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : undefined,
-        // The one field of a withheld AppError worth keeping: it says WHICH
-        // internal failure this was, and it never reaches the caller.
-        code: error instanceof AppError ? error.code : undefined,
-        awsRequestId: context?.awsRequestId,
-      });
-      return json(error instanceof AppError ? error.statusCode : 500, { error: 'internal error' });
-    }
-  };
-}

package/templates/skeleton/aws-serverless/services/api/src/list-main.ts

@@ -1,12 +0,0 @@
-// Composition root for the list function — one function, one entry, one job.
-import { z } from 'zod';
-import { NoteModel, createDocumentClient } from '@app/db';
-import { createLogger, loadEnv } from '@app/shared';
-import { makeListNotesHandler } from './handlers/list-notes.js';
-
-const env = loadEnv(z.object({ TABLE_NAME: z.string().min(1) }), process.env);
-
-export const handler = makeListNotesHandler({
-  notes: new NoteModel(createDocumentClient(), env.TABLE_NAME),
-  log: createLogger({ service: 'api', handler: 'list-notes' }),
-});

package/templates/skeleton/aws-serverless/services/api/src/main.ts

@@ -1,21 +0,0 @@
-// Composition root — the ONLY file with real wiring. Tests target the factory
-// (makeCreateNoteHandler) with stub deps and never import this module.
-import { randomUUID } from 'node:crypto';
-import { z } from 'zod';
-import { NoteModel, createDocumentClient } from '@app/db';
-import { createLogger, loadEnv } from '@app/shared';
-import { SqsEventPublisher, createQueueClient } from './adapters/sqs-publisher.js';
-import { makeCreateNoteHandler } from './handlers/create-note.js';
-
-const env = loadEnv(
-  z.object({ TABLE_NAME: z.string().min(1), QUEUE_URL: z.string().min(1) }),
-  process.env,
-);
-
-export const handler = makeCreateNoteHandler({
-  notes: new NoteModel(createDocumentClient(), env.TABLE_NAME),
-  events: new SqsEventPublisher(createQueueClient(), env.QUEUE_URL),
-  newId: () => randomUUID(),
-  now: () => new Date().toISOString(),
-  log: createLogger({ service: 'api' }),
-});

package/templates/skeleton/aws-serverless/services/api/src/usecases/create-note.ts

@@ -1,41 +0,0 @@
-// The usecase layer is mandatory: every business operation lives here, and
-// handlers call nothing below it. Dependencies are consumer-owned interfaces —
-// the usecase says what it needs, adapters satisfy it.
-import { createNote, makeNoteCreatedEvent, type Note, type NoteCreatedEvent } from '@app/core';
-import type { Logger } from '@app/shared';
-
-export interface NoteStore {
-  put(note: Note): Promise<void>;
-}
-
-export interface EventPublisher {
-  publish(event: NoteCreatedEvent): Promise<void>;
-}
-
-export interface CreateNoteDeps {
-  notes: NoteStore;
-  events: EventPublisher;
-  /** Id generation and the clock are decided here, never inside the core. */
-  newId(): string;
-  now(): string;
-  log: Logger;
-}
-
-/**
- * ⚠ These are **two writes and they are not atomic** — a dual write. The put
- * can succeed and the publish then fail, which leaves a stored note whose event
- * never happened: the worker does not run, nothing downstream hears about it,
- * and nothing here compensates. The caller sees a 500 for a note that exists.
- *
- * That is a deliberate simplification for a skeleton, not a pattern to copy at
- * scale. The two ways out, when it starts to matter: an **outbox** (write the
- * event into the same transaction as the note, relay it after), or DynamoDB
- * Streams feeding the worker, which removes the second write entirely.
- */
-export async function createNoteUsecase(input: unknown, deps: CreateNoteDeps): Promise<Note> {
-  const note = createNote(input, { id: deps.newId(), createdAt: deps.now() });
-  await deps.notes.put(note);
-  await deps.events.publish(makeNoteCreatedEvent(note));
-  deps.log.info('note created', { noteId: note.id, slug: note.slug });
-  return note;
-}

package/templates/skeleton/aws-serverless/services/api/src/usecases/list-notes.ts

@@ -1,14 +0,0 @@
-// Even a trivial read goes through a usecase — the uniformity is the rule.
-import type { Note } from '@app/core';
-
-export interface NoteLister {
-  list(): Promise<Note[]>;
-}
-
-export interface ListNotesDeps {
-  notes: NoteLister;
-}
-
-export async function listNotesUsecase(deps: ListNotesDeps): Promise<Note[]> {
-  return deps.notes.list();
-}

package/templates/skeleton/aws-serverless/services/api/test/create-note.handler.test.ts

@@ -1,211 +0,0 @@
-import type {
-  APIGatewayProxyEventV2,
-  APIGatewayProxyStructuredResultV2,
-  Context,
-} from 'aws-lambda';
-import { AppError, createLogger } from '@app/shared';
-import { describe, expect, it } from 'vitest';
-import { makeCreateNoteHandler } from '../src/handlers/create-note.js';
-import type { CreateNoteDeps } from '../src/usecases/create-note.js';
-
-const event = (body: string): APIGatewayProxyEventV2 =>
-  ({ body, isBase64Encoded: false }) as APIGatewayProxyEventV2;
-
-/** Lambda always passes a context; the handler only ever needs the request id. */
-const lambdaContext = (awsRequestId: string): Context => ({ awsRequestId }) as Context;
-
-function stubDeps(overrides: Partial<CreateNoteDeps> = {}) {
-  const deps: CreateNoteDeps = {
-    notes: { put: async () => {} },
-    events: { publish: async () => {} },
-    newId: () => 'fixed-id',
-    now: () => '2024-01-01T00:00:00.000Z',
-    log: createLogger({}, () => {}),
-    ...overrides,
-  };
-  return deps;
-}
-
-const asResult = (r: unknown) => r as APIGatewayProxyStructuredResultV2;
-
-describe('POST /notes handler', () => {
-  it('returns 201 with the created note', async () => {
-    const handler = makeCreateNoteHandler(stubDeps());
-    const result = asResult(await handler(event(JSON.stringify({ title: 'Hello' }))));
-    expect(result.statusCode).toBe(201);
-    expect(JSON.parse(result.body!)).toMatchObject({
-      note: { id: 'fixed-id', slug: 'hello', createdAt: '2024-01-01T00:00:00.000Z' },
-    });
-  });
-
-  it('decodes base64-encoded bodies', async () => {
-    const handler = makeCreateNoteHandler(stubDeps());
-    const raw = Buffer.from(JSON.stringify({ title: 'Encoded' })).toString('base64');
-    const result = asResult(
-      await handler({ body: raw, isBase64Encoded: true } as APIGatewayProxyEventV2),
-    );
-    expect(result.statusCode).toBe(201);
-  });
-
-  it('returns 400 for malformed JSON without touching the store', async () => {
-    let touched = false;
-    const handler = makeCreateNoteHandler(
-      stubDeps({
-        notes: {
-          put: async () => {
-            touched = true;
-          },
-        },
-      }),
-    );
-    const result = asResult(await handler(event('{not json')));
-    expect(result.statusCode).toBe(400);
-    expect(touched).toBe(false);
-  });
-
-  it('returns 400 with issues for invalid input', async () => {
-    const handler = makeCreateNoteHandler(stubDeps());
-    const result = asResult(await handler(event(JSON.stringify({ title: '' }))));
-    expect(result.statusCode).toBe(400);
-    expect(JSON.parse(result.body!).issues.join(' ')).toMatch(/title/);
-  });
-
-  it('maps typed errors to their status code', async () => {
-    const handler = makeCreateNoteHandler(
-      stubDeps({
-        notes: {
-          put: () => Promise.reject(new AppError('conflict', { statusCode: 409, code: 'DUP' })),
-        },
-      }),
-    );
-    const result = asResult(await handler(event(JSON.stringify({ title: 'T' }))));
-    expect(result.statusCode).toBe(409);
-    expect(JSON.parse(result.body!)).toEqual({ error: 'conflict', code: 'DUP' });
-  });
-
-  it('hides unknown errors behind a 500 and logs them', async () => {
-    const logs: string[] = [];
-    const handler = makeCreateNoteHandler(
-      stubDeps({
-        notes: { put: () => Promise.reject(new Error('secret detail')) },
-        log: createLogger({}, (line) => logs.push(line)),
-      }),
-    );
-    const result = asResult(await handler(event(JSON.stringify({ title: 'T' }))));
-    expect(result.statusCode).toBe(500);
-    expect(result.body).not.toContain('secret detail');
-    expect(logs.join('\n')).toContain('secret detail');
-  });
-
-  // AppError defaults to statusCode 500 / code INTERNAL, so "typed" does not
-  // mean "safe to show": a table name, a host, an SDK message all arrive this
-  // way. Only a 4xx AppError is a message the caller was meant to read.
-  it('hides a typed error that carries the default status behind the same constant 500', async () => {
-    const handler = makeCreateNoteHandler(
-      stubDeps({
-        notes: {
-          put: () => Promise.reject(new AppError('table NotesTable-prod is not authorised')),
-        },
-      }),
-    );
-    const result = asResult(await handler(event(JSON.stringify({ title: 'T' }))));
-    expect(result.statusCode).toBe(500);
-    expect(result.body).not.toContain('NotesTable-prod');
-    expect(JSON.parse(result.body!)).toEqual({ error: 'internal error' });
-  });
-
-  // Withholding the message is not the same decision as flattening the status.
-  // 503 tells a caller to retry and 500 tells it not to bother, and that
-  // distinction is transport, not disclosure — the sibling handler pins it
-  // (`list-notes.test.ts`), and this one did not, so collapsing the status here
-  // passed the whole suite.
-  it('keeps a 5xx status the caller can act on, while still hiding the message', async () => {
-    const handler = makeCreateNoteHandler(
-      stubDeps({
-        notes: {
-          put: () =>
-            Promise.reject(
-              new AppError('table NotesTable-prod is throttling', {
-                statusCode: 503,
-                code: 'X',
-              }),
-            ),
-        },
-      }),
-    );
-    const result = asResult(await handler(event(JSON.stringify({ title: 'T' }))));
-    expect(result.statusCode).toBe(503);
-    expect(result.body).not.toContain('NotesTable-prod');
-    expect(JSON.parse(result.body!)).toEqual({ error: 'internal error' });
-  });
-
-  it('logs the typed internal error it hid, so the detail is kept and not lost', async () => {
-    const logs: string[] = [];
-    const handler = makeCreateNoteHandler(
-      stubDeps({
-        notes: {
-          put: () => Promise.reject(new AppError('table NotesTable-prod is not authorised')),
-        },
-        log: createLogger({}, (line) => logs.push(line)),
-      }),
-    );
-    await handler(event(JSON.stringify({ title: 'T' })));
-    expect(logs.join('\n')).toContain('NotesTable-prod');
-  });
-
-  it('logs the failure with its stack, not only its message', async () => {
-    const logs: string[] = [];
-    const boom = new Error('secret detail');
-    const handler = makeCreateNoteHandler(
-      stubDeps({
-        notes: { put: () => Promise.reject(boom) },
-        log: createLogger({}, (line) => logs.push(line)),
-      }),
-    );
-    await handler(event(JSON.stringify({ title: 'T' })));
-    // `String(error)` is "Error: secret detail" — a message with no frames is
-    // not something anyone can debug from CloudWatch.
-    expect(JSON.parse(logs[0]!)).toMatchObject({ stack: boom.stack });
-  });
-
-  // The response withholds everything about a 5xx AppError, so the log line is
-  // the only place left that can say WHICH internal failure it was — and `code`
-  // is the one field of that error which is safe to keep verbatim. Losing it
-  // flattens DATA_CORRUPT, INTERNAL and every future code into one shape nobody
-  // can triage. The body assertion lives here on purpose: the two halves of the
-  // contract ("kept in the log", "still absent from the response") must not
-  // drift apart.
-  it('logs the code of the internal error it withheld, and still keeps it out of the response', async () => {
-    const logs: string[] = [];
-    const handler = makeCreateNoteHandler(
-      stubDeps({
-        notes: {
-          put: () =>
-            Promise.reject(
-              new AppError('table NotesTable-prod returned a torn item', {
-                code: 'DATA_CORRUPT',
-              }),
-            ),
-        },
-        log: createLogger({}, (line) => logs.push(line)),
-      }),
-    );
-    const result = asResult(await handler(event(JSON.stringify({ title: 'T' }))));
-    expect(JSON.parse(logs[0]!)).toMatchObject({ code: 'DATA_CORRUPT' });
-    expect(result.body).not.toContain('DATA_CORRUPT');
-    expect(JSON.parse(result.body!)).toEqual({ error: 'internal error' });
-  });
-
-  it('carries the Lambda request id into the line it logs', async () => {
-    const logs: string[] = [];
-    const handler = makeCreateNoteHandler(
-      stubDeps({
-        notes: { put: () => Promise.reject(new Error('secret detail')) },
-        log: createLogger({}, (line) => logs.push(line)),
-      }),
-    );
-    // Without it a log line cannot be tied to the invocation that produced it.
-    await handler(event(JSON.stringify({ title: 'T' })), lambdaContext('req-42'));
-    expect(JSON.parse(logs[0]!)).toMatchObject({ awsRequestId: 'req-42' });
-  });
-});

package/templates/skeleton/aws-serverless/services/api/test/create-note.usecase.test.ts

@@ -1,45 +0,0 @@
-import { InvalidNoteError, type Note, type NoteCreatedEvent } from '@app/core';
-import { createLogger } from '@app/shared';
-import { describe, expect, it } from 'vitest';
-import { createNoteUsecase, type CreateNoteDeps } from '../src/usecases/create-note.js';
-
-function stubDeps() {
-  const stored: Note[] = [];
-  const published: NoteCreatedEvent[] = [];
-  const logs: string[] = [];
-  const deps: CreateNoteDeps = {
-    notes: { put: async (note) => void stored.push(note) },
-    events: { publish: async (event) => void published.push(event) },
-    newId: () => 'fixed-id',
-    now: () => '2024-01-01T00:00:00.000Z',
-    log: createLogger({}, (line) => logs.push(line)),
-  };
-  return { deps, stored, published, logs };
-}
-
-describe('createNoteUsecase', () => {
-  it('creates, stores, publishes, and logs — in that order of effects', async () => {
-    const { deps, stored, published, logs } = stubDeps();
-    const note = await createNoteUsecase({ title: 'Hello World' }, deps);
-    expect(note).toMatchObject({ id: 'fixed-id', slug: 'hello-world' });
-    expect(stored).toEqual([note]);
-    expect(published).toEqual([{ type: 'note.created', note }]);
-    expect(logs.join('\n')).toContain('fixed-id');
-  });
-
-  it('rejects invalid input before any side effect', async () => {
-    const { deps, stored, published } = stubDeps();
-    await expect(createNoteUsecase({ title: '' }, deps)).rejects.toThrow(InvalidNoteError);
-    expect(stored).toEqual([]);
-    expect(published).toEqual([]);
-  });
-
-  it('propagates store failures and does not publish', async () => {
-    const { deps, published } = stubDeps();
-    deps.notes = {
-      put: () => Promise.reject(new Error('dynamo down')),
-    };
-    await expect(createNoteUsecase({ title: 'T' }, deps)).rejects.toThrow('dynamo down');
-    expect(published).toEqual([]);
-  });
-});

package/templates/skeleton/aws-serverless/services/api/test/list-notes.test.ts

@@ -1,122 +0,0 @@
-import type {
-  APIGatewayProxyEventV2,
-  APIGatewayProxyStructuredResultV2,
-  Context,
-} from 'aws-lambda';
-import { AppError, createLogger } from '@app/shared';
-import { describe, expect, it } from 'vitest';
-import { makeListNotesHandler } from '../src/handlers/list-notes.js';
-import { listNotesUsecase } from '../src/usecases/list-notes.js';
-
-const note = {
-  id: 'n1',
-  title: 'Hello',
-  slug: 'hello',
-  tags: [],
-  createdAt: '2024-01-01T00:00:00.000Z',
-};
-
-const asResult = (r: unknown) => r as APIGatewayProxyStructuredResultV2;
-
-/** Lambda always passes the event and the context; this route needs no body. */
-const getEvent = () => ({ isBase64Encoded: false }) as APIGatewayProxyEventV2;
-const lambdaContext = (awsRequestId: string): Context => ({ awsRequestId }) as Context;
-
-describe('listNotesUsecase', () => {
-  it('returns what the model lists', async () => {
-    expect(await listNotesUsecase({ notes: { list: async () => [note] } })).toEqual([note]);
-  });
-});
-
-describe('GET /notes handler', () => {
-  it('returns 200 with the notes', async () => {
-    const handler = makeListNotesHandler({
-      notes: { list: async () => [note] },
-      log: createLogger({}, () => {}),
-    });
-    const result = asResult(await handler());
-    expect(result.statusCode).toBe(200);
-    expect(JSON.parse(result.body!)).toEqual({ notes: [note] });
-  });
-
-  it('maps typed errors and hides unknown ones', async () => {
-    const typed = makeListNotesHandler({
-      notes: { list: () => Promise.reject(new AppError('nope', { statusCode: 503, code: 'X' })) },
-      log: createLogger({}, () => {}),
-    });
-    expect(asResult(await typed()).statusCode).toBe(503);
-
-    const logs: string[] = [];
-    const unknown = makeListNotesHandler({
-      notes: { list: () => Promise.reject(new Error('secret')) },
-      log: createLogger({}, (line) => logs.push(line)),
-    });
-    const result = asResult(await unknown());
-    expect(result.statusCode).toBe(500);
-    expect(result.body).not.toContain('secret');
-    expect(logs.join('')).toContain('secret');
-  });
-});
-
-// The same leak create-note was fixed for, and this handler had it too:
-// `AppError` defaults to 500/INTERNAL, so a table name, a host or an SDK
-// message arrives wearing the same type as "title is required", and every one
-// of them used to reach the caller. Typed does not mean safe to show — the
-// status decides, and these pin that both handlers decide it the same way.
-describe('GET /notes keeps its internals to itself', () => {
-  const failWith = (error: unknown, sink: (line: string) => void = () => {}) =>
-    makeListNotesHandler({
-      notes: { list: () => Promise.reject(error) },
-      log: createLogger({}, sink),
-    });
-
-  it('hides a typed error that carries the default status behind a constant 500', async () => {
-    const handler = failWith(new AppError('table NotesTable-prod is not authorised'));
-    const result = asResult(await handler(getEvent(), lambdaContext('req-1')));
-    expect(result.statusCode).toBe(500);
-    expect(result.body).not.toContain('NotesTable-prod');
-    expect(JSON.parse(result.body!)).toEqual({ error: 'internal error' });
-  });
-
-  it('still forwards a 4xx message, which was written for the caller to read', async () => {
-    const handler = failWith(new AppError('unknown tag filter', { statusCode: 400, code: 'BAD' }));
-    const result = asResult(await handler(getEvent(), lambdaContext('req-2')));
-    expect(result.statusCode).toBe(400);
-    expect(JSON.parse(result.body!)).toEqual({ error: 'unknown tag filter', code: 'BAD' });
-  });
-
-  it('logs the internal error it hid with its stack, so the detail is kept and not lost', async () => {
-    const logs: string[] = [];
-    const boom = new AppError('table NotesTable-prod is not authorised');
-    await failWith(boom, (line) => logs.push(line))(getEvent(), lambdaContext('req-3'));
-    // `String(error)` is a message with no frames — not something anyone can
-    // debug from a log aggregator.
-    expect(JSON.parse(logs[0]!)).toMatchObject({ stack: boom.stack });
-  });
-
-  // Same contract as create-note: the response withholds everything about a 5xx
-  // AppError, so the log line is the only place that can still say WHICH
-  // internal failure it was, and `code` is the one field safe to keep verbatim.
-  // The body assertion stays beside it so the two halves cannot drift apart.
-  it('logs the code of the internal error it withheld, and still keeps it out of the response', async () => {
-    const logs: string[] = [];
-    const handler = failWith(
-      new AppError('table NotesTable-prod returned a torn item', { code: 'DATA_CORRUPT' }),
-      (line) => logs.push(line),
-    );
-    const result = asResult(await handler(getEvent(), lambdaContext('req-4')));
-    expect(JSON.parse(logs[0]!)).toMatchObject({ code: 'DATA_CORRUPT' });
-    expect(result.body).not.toContain('DATA_CORRUPT');
-    expect(JSON.parse(result.body!)).toEqual({ error: 'internal error' });
-  });
-
-  it('carries the Lambda request id into the line it logs', async () => {
-    const logs: string[] = [];
-    const handler = failWith(new AppError('table NotesTable-prod is not authorised'), (line) =>
-      logs.push(line),
-    );
-    // Without it a log line cannot be tied to the invocation that produced it.
-    await handler(getEvent(), lambdaContext('req-42'));
-    expect(JSON.parse(logs[0]!)).toMatchObject({ awsRequestId: 'req-42' });
-  });
-});

package/templates/skeleton/aws-serverless/services/api/test/sqs-publisher.test.ts

@@ -1,22 +0,0 @@
-import { SendMessageCommand } from '@aws-sdk/client-sqs';
-import { makeNoteCreatedEvent, createNote } from '@app/core';
-import { describe, expect, it } from 'vitest';
-import { SqsEventPublisher } from '../src/adapters/sqs-publisher.js';
-
-describe('SqsEventPublisher', () => {
-  it('sends the JSON-encoded event to the configured queue', async () => {
-    const sent: unknown[] = [];
-    const publisher = new SqsEventPublisher(
-      { send: (c) => (sent.push(c), Promise.resolve({})) },
-      'https://queue.example/q',
-    );
-    const note = createNote({ title: 'Hi' }, { id: 'n1', createdAt: '2024-01-01T00:00:00.000Z' });
-    const event = makeNoteCreatedEvent(note);
-    await publisher.publish(event);
-
-    const command = sent[0] as SendMessageCommand;
-    expect(command).toBeInstanceOf(SendMessageCommand);
-    expect(command.input.QueueUrl).toBe('https://queue.example/q');
-    expect(JSON.parse(command.input.MessageBody!)).toEqual(event);
-  });
-});