create-agent-rig 0.1.0

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

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

@@ -0,0 +1,15 @@
+{
+  "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

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

@@ -0,0 +1,42 @@
+// 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 } from 'aws-lambda';
+import { InvalidNoteError } from '@app/core';
+import { AppError } from '@app/shared';
+import { createNoteUsecase, type CreateNoteDeps } from '../usecases/create-note.js';
+
+type Handler = (event: APIGatewayProxyEventV2) => 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) => {
+    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 });
+      }
+      if (error instanceof AppError) {
+        return json(error.statusCode, { error: error.message, code: error.code });
+      }
+      deps.log.error('unhandled error in create-note', { error: String(error) });
+      return json(500, { error: 'internal error' });
+    }
+  };
+}

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

@@ -0,0 +1,24 @@
+import type { APIGatewayProxyResultV2 } 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 (): Promise<APIGatewayProxyResultV2> => {
+    try {
+      return json(200, { notes: await listNotesUsecase(deps) });
+    } catch (error) {
+      if (error instanceof AppError) {
+        return json(error.statusCode, { error: error.message, code: error.code });
+      }
+      deps.log.error('unhandled error in list-notes', { error: String(error) });
+      return json(500, { error: 'internal error' });
+    }
+  };
+}

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

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

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

@@ -0,0 +1,30 @@
+// 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;
+}
+
+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

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

@@ -0,0 +1,92 @@
+import type { APIGatewayProxyEventV2, APIGatewayProxyStructuredResultV2 } 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;
+
+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');
+  });
+});

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

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

@@ -0,0 +1,51 @@
+import type { APIGatewayProxyStructuredResultV2 } 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;
+
+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');
+  });
+});

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

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

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

@@ -0,0 +1,12 @@
+{
+  "name": "@app/worker",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "src/main.ts",
+  "types": "src/main.ts",
+  "dependencies": {
+    "@app/core": "workspace:*",
+    "@app/shared": "workspace:*"
+  }
+}

package/templates/skeleton/aws-serverless/services/worker/src/handlers/note-created.ts

@@ -0,0 +1,15 @@
+import type { SQSEvent } from 'aws-lambda';
+import type { ProcessDeps } from '../usecases/process-note-created.js';
+import { processNoteCreated } from '../usecases/process-note-created.js';
+
+/**
+ * The event source uses batchSize 1, so a throw fails exactly this message and
+ * SQS redrives it (then the DLQ takes over). Keep the handler a thin loop.
+ */
+export function makeNoteCreatedHandler(deps: ProcessDeps) {
+  return async (event: SQSEvent): Promise<void> => {
+    for (const record of event.Records) {
+      await processNoteCreated(record.body, deps);
+    }
+  };
+}

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

@@ -0,0 +1,7 @@
+// Composition root for the worker Lambda.
+import { createLogger } from '@app/shared';
+import { makeNoteCreatedHandler } from './handlers/note-created.js';
+
+export const handler = makeNoteCreatedHandler({
+  log: createLogger({ service: 'worker' }),
+});

package/templates/skeleton/aws-serverless/services/worker/src/usecases/process-note-created.ts

@@ -0,0 +1,37 @@
+// Queue discipline: validate the message against the shared event schema; a
+// message that does not parse is poison — throw, let SQS retry it, and after
+// maxReceiveCount the DLQ (with its alarm) catches it. Never swallow poison.
+import { NoteCreatedEventSchema, type NoteCreatedEvent } from '@app/core';
+import { ValidationError, type Logger } from '@app/shared';
+
+export interface ProcessDeps {
+  log: Logger;
+}
+
+export function parseNoteCreatedEvent(raw: string): NoteCreatedEvent {
+  let candidate: unknown;
+  try {
+    candidate = JSON.parse(raw);
+  } catch {
+    throw new ValidationError('message body is not JSON');
+  }
+  const parsed = NoteCreatedEventSchema.safeParse(candidate);
+  if (!parsed.success) {
+    throw new ValidationError(
+      'message is not a note.created event',
+      parsed.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`),
+    );
+  }
+  return parsed.data;
+}
+
+export async function processNoteCreated(raw: string, deps: ProcessDeps): Promise<void> {
+  const event = parseNoteCreatedEvent(raw);
+  // The skeleton's "processing" is deliberately small: acknowledge the note.
+  // Replace this with real downstream work; keep the validate-first shape.
+  deps.log.info('note.created processed', {
+    noteId: event.note.id,
+    slug: event.note.slug,
+    tagCount: event.note.tags.length,
+  });
+}

package/templates/skeleton/aws-serverless/services/worker/test/note-created.test.ts

@@ -0,0 +1,61 @@
+import type { SQSEvent } from 'aws-lambda';
+import { createNote, makeNoteCreatedEvent } from '@app/core';
+import { ValidationError, createLogger } from '@app/shared';
+import { describe, expect, it } from 'vitest';
+import { makeNoteCreatedHandler } from '../src/handlers/note-created.js';
+import { parseNoteCreatedEvent, processNoteCreated } from '../src/usecases/process-note-created.js';
+
+const note = createNote({ title: 'Hello' }, { id: 'n1', createdAt: '2024-01-01T00:00:00.000Z' });
+const validBody = JSON.stringify(makeNoteCreatedEvent(note));
+
+const sqsEvent = (...bodies: string[]): SQSEvent =>
+  ({ Records: bodies.map((body) => ({ body })) }) as SQSEvent;
+
+function collectLogs() {
+  const lines: string[] = [];
+  return { log: createLogger({}, (line) => lines.push(line)), lines };
+}
+
+describe('parseNoteCreatedEvent', () => {
+  it('parses a valid event', () => {
+    expect(parseNoteCreatedEvent(validBody).note.id).toBe('n1');
+  });
+
+  it('throws ValidationError for non-JSON bodies', () => {
+    expect(() => parseNoteCreatedEvent('not json')).toThrow(ValidationError);
+  });
+
+  it('throws ValidationError for JSON that is not a note.created event', () => {
+    expect(() => parseNoteCreatedEvent(JSON.stringify({ type: 'other' }))).toThrow(
+      ValidationError,
+    );
+  });
+});
+
+describe('processNoteCreated', () => {
+  it('logs the processed note', async () => {
+    const { log, lines } = collectLogs();
+    await processNoteCreated(validBody, { log });
+    expect(lines.join('\n')).toContain('n1');
+  });
+
+  it('lets poison messages throw — the DLQ is the safety net, not a catch block', async () => {
+    const { log } = collectLogs();
+    await expect(processNoteCreated('poison', { log })).rejects.toThrow(ValidationError);
+  });
+});
+
+describe('makeNoteCreatedHandler', () => {
+  it('processes every record in the batch', async () => {
+    const { log, lines } = collectLogs();
+    await makeNoteCreatedHandler({ log })(sqsEvent(validBody, validBody));
+    expect(lines).toHaveLength(2);
+  });
+
+  it('propagates the failure of a poison record', async () => {
+    const { log } = collectLogs();
+    await expect(makeNoteCreatedHandler({ log })(sqsEvent('poison'))).rejects.toThrow(
+      ValidationError,
+    );
+  });
+});

package/templates/skeleton/aws-serverless/tsconfig.base.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"]
+  }
+}

package/templates/skeleton/aws-serverless/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": [
+    "packages/*/src/**/*.ts",
+    "packages/*/test/**/*.ts",
+    "services/*/src/**/*.ts",
+    "services/*/test/**/*.ts",
+    "infra/bin/**/*.ts",
+    "infra/lib/**/*.ts",
+    "infra/test/**/*.ts",
+    "vitest.config.ts"
+  ]
+}

package/templates/skeleton/aws-serverless/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: [
+      'packages/*/test/**/*.test.ts',
+      'services/*/test/**/*.test.ts',
+      'apps/*/test/**/*.test.ts',
+      'infra/test/**/*.test.ts',
+    ],
+    // CDK assertion tests bundle the Lambda entries with esbuild.
+    testTimeout: 120_000,
+  },
+});

package/templates/skeleton/node-service/.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 11
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+      - run: pnpm install --no-frozen-lockfile
+      - run: pnpm lint
+      - run: pnpm typecheck
+      - run: pnpm test