create-agent-rig 0.9.1 → 0.10.0

package/templates/skeleton/aws-serverless/packages/core/src/index.ts

@@ -1,15 +0,0 @@
-export {
-  NewNoteSchema,
-  NoteSchema,
-  InvalidNoteError,
-  createNote,
-  slugify,
-  type NewNote,
-  type Note,
-  type NoteIdentity,
-} from './note.js';
-export {
-  NoteCreatedEventSchema,
-  makeNoteCreatedEvent,
-  type NoteCreatedEvent,
-} from './events.js';

package/templates/skeleton/aws-serverless/packages/core/src/note.ts

@@ -1,69 +0,0 @@
-// The domain core is pure: no I/O, no clock, no randomness, no environment.
-// "Now" and "a new id" are decided by the caller (the usecase layer) and enter
-// as arguments. The guard-core-purity hook enforces this at the tool layer.
-import { z } from 'zod';
-
-export const NewNoteSchema = z.object({
-  title: z.string().trim().min(1, 'title must not be empty').max(200, 'title too long'),
-  tags: z.array(z.string().trim().min(1).max(40)).max(10).default([]),
-});
-export type NewNote = z.infer<typeof NewNoteSchema>;
-
-export const NoteSchema = z.object({
-  id: z.string().min(1),
-  title: z.string().min(1),
-  slug: z.string().min(1),
-  tags: z.array(z.string()),
-  createdAt: z.string().min(1),
-});
-export type Note = z.infer<typeof NoteSchema>;
-
-/** Thrown when input fails domain validation. The core owns its own error type. */
-export class InvalidNoteError extends Error {
-  readonly issues: readonly string[];
-
-  constructor(issues: readonly string[]) {
-    super(`invalid note: ${issues.join('; ')}`);
-    this.name = 'InvalidNoteError';
-    this.issues = issues;
-  }
-}
-
-export interface NoteIdentity {
-  /** Generated by the caller — the core never invents ids. */
-  id: string;
-  /** ISO-8601 timestamp decided by the caller — the core never reads the clock. */
-  createdAt: string;
-}
-
-/**
- * The one domain function: validate raw input and construct a Note.
- * Deterministic — identical arguments always yield an identical note.
- */
-export function createNote(input: unknown, identity: NoteIdentity): Note {
-  const parsed = NewNoteSchema.safeParse(input);
-  if (!parsed.success) {
-    throw new InvalidNoteError(
-      parsed.error.issues.map((issue) => `${issue.path.join('.') || 'input'}: ${issue.message}`),
-    );
-  }
-  const { title, tags } = parsed.data;
-  return {
-    id: identity.id,
-    title,
-    slug: slugify(title),
-    tags: [...new Set(tags)],
-    createdAt: identity.createdAt,
-  };
-}
-
-/** Lowercased, hyphen-separated, ascii-ish slug. Pure string work. */
-export function slugify(title: string): string {
-  const slug = title
-    .toLowerCase()
-    .normalize('NFKD')
-    .replace(/[\u0300-\u036f]/g, '') // strip combining marks left by NFKD
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  return slug.length > 0 ? slug : 'note';
-}

package/templates/skeleton/aws-serverless/packages/core/test/events.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { NoteCreatedEventSchema, makeNoteCreatedEvent } from '../src/events.js';
-import { createNote } from '../src/note.js';
-
-const note = createNote({ title: 'Hello' }, { id: 'n1', createdAt: '2024-01-01T00:00:00.000Z' });
-
-describe('note.created event', () => {
-  it('wraps a note and round-trips through its own schema', () => {
-    const event = makeNoteCreatedEvent(note);
-    expect(event.type).toBe('note.created');
-    expect(NoteCreatedEventSchema.parse(JSON.parse(JSON.stringify(event)))).toEqual(event);
-  });
-
-  it('rejects a payload with the wrong type tag', () => {
-    expect(NoteCreatedEventSchema.safeParse({ type: 'other', note }).success).toBe(false);
-  });
-
-  it('rejects a payload with a malformed note', () => {
-    expect(
-      NoteCreatedEventSchema.safeParse({ type: 'note.created', note: { id: '' } }).success,
-    ).toBe(false);
-  });
-});

package/templates/skeleton/aws-serverless/packages/core/test/note.test.ts

@@ -1,101 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { InvalidNoteError, createNote, slugify } from '../src/note.js';
-
-const identity = { id: 'note-1', createdAt: '2024-01-01T00:00:00.000Z' };
-
-describe('createNote', () => {
-  it('builds a note from valid input', () => {
-    const note = createNote({ title: 'Hello World', tags: ['a', 'b'] }, identity);
-    expect(note).toEqual({
-      id: 'note-1',
-      title: 'Hello World',
-      slug: 'hello-world',
-      tags: ['a', 'b'],
-      createdAt: '2024-01-01T00:00:00.000Z',
-    });
-  });
-
-  it('is deterministic: identical arguments yield an identical note', () => {
-    const a = createNote({ title: 'Same' }, identity);
-    const b = createNote({ title: 'Same' }, identity);
-    expect(a).toEqual(b);
-  });
-
-  it('defaults tags to an empty array', () => {
-    expect(createNote({ title: 'No tags' }, identity).tags).toEqual([]);
-  });
-
-  it('trims the title', () => {
-    expect(createNote({ title: '  padded  ' }, identity).title).toBe('padded');
-  });
-
-  it('deduplicates tags', () => {
-    expect(createNote({ title: 'T', tags: ['x', 'x', 'y'] }, identity).tags).toEqual(['x', 'y']);
-  });
-
-  it('refuses an empty or whitespace-only title', () => {
-    expect(() => createNote({ title: '' }, identity)).toThrow(InvalidNoteError);
-    expect(() => createNote({ title: '   ' }, identity)).toThrow(InvalidNoteError);
-  });
-
-  it('refuses a title over 200 characters', () => {
-    expect(() => createNote({ title: 'x'.repeat(201) }, identity)).toThrow(InvalidNoteError);
-    expect(() => createNote({ title: 'x'.repeat(200) }, identity)).not.toThrow();
-  });
-
-  it('refuses more than 10 tags', () => {
-    const tags = Array.from({ length: 11 }, (_, i) => `t${i}`);
-    expect(() => createNote({ title: 'T', tags }, identity)).toThrow(InvalidNoteError);
-  });
-
-  it('refuses empty or oversized tags', () => {
-    expect(() => createNote({ title: 'T', tags: [''] }, identity)).toThrow(InvalidNoteError);
-    expect(() => createNote({ title: 'T', tags: ['x'.repeat(41)] }, identity)).toThrow(
-      InvalidNoteError,
-    );
-  });
-
-  it('refuses non-object input', () => {
-    for (const bad of [null, undefined, 42, 'title', []]) {
-      expect(() => createNote(bad, identity)).toThrow(InvalidNoteError);
-    }
-  });
-
-  it('refuses wrongly-typed fields', () => {
-    expect(() => createNote({ title: 42 }, identity)).toThrow(InvalidNoteError);
-    expect(() => createNote({ title: 'T', tags: 'not-an-array' }, identity)).toThrow(
-      InvalidNoteError,
-    );
-  });
-
-  it('reports every issue with its path', () => {
-    try {
-      createNote({ title: '', tags: [''] }, identity);
-      expect.unreachable('should have thrown');
-    } catch (error) {
-      const invalid = error as InvalidNoteError;
-      expect(invalid.issues.length).toBeGreaterThanOrEqual(2);
-      expect(invalid.issues.join('\n')).toMatch(/title/);
-      expect(invalid.issues.join('\n')).toMatch(/tags/);
-    }
-  });
-});
-
-describe('slugify', () => {
-  it('lowercases and hyphenates', () => {
-    expect(slugify('Hello World')).toBe('hello-world');
-  });
-
-  it('collapses runs of non-alphanumerics and trims hyphens', () => {
-    expect(slugify('  a -- b!! c  ')).toBe('a-b-c');
-  });
-
-  it('strips diacritics', () => {
-    expect(slugify('Crème Brûlée')).toBe('creme-brulee');
-  });
-
-  it('falls back to "note" when nothing survives', () => {
-    expect(slugify('!!!')).toBe('note');
-    expect(slugify('日本語')).toBe('note');
-  });
-});

package/templates/skeleton/aws-serverless/packages/db/package.json

@@ -1,14 +0,0 @@
-{
-  "name": "@app/db",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "@app/core": "workspace:*",
-    "@app/shared": "workspace:*",
-    "@aws-sdk/client-dynamodb": "^3.1092.0",
-    "@aws-sdk/lib-dynamodb": "^3.1092.0"
-  }
-}

package/templates/skeleton/aws-serverless/packages/db/src/client.ts

@@ -1,17 +0,0 @@
-// The ONLY file in the project that constructs the storage SDK client.
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
-
-/**
- * Structural view of the document client — models depend on this, tests stub it.
- * (Method parameters are bivariant, so the real client satisfies it.)
- */
-export interface DocumentClient {
-  send(command: unknown): Promise<unknown>;
-}
-
-export function createDocumentClient(): DocumentClient {
-  return DynamoDBDocumentClient.from(new DynamoDBClient({}), {
-    marshallOptions: { removeUndefinedValues: true },
-  }) as DocumentClient;
-}

package/templates/skeleton/aws-serverless/packages/db/src/index.ts

@@ -1,2 +0,0 @@
-export { createDocumentClient, type DocumentClient } from './client.js';
-export { NoteModel } from './note-model.js';

package/templates/skeleton/aws-serverless/packages/db/src/note-model.ts

@@ -1,52 +0,0 @@
-// Single-table layout: pk = NOTE#<id>, sk = META. One model, one table, one
-// place that knows the key schema.
-import { GetCommand, PutCommand, ScanCommand } from '@aws-sdk/lib-dynamodb';
-import { NoteSchema, type Note } from '@app/core';
-import { NotFoundError } from '@app/shared';
-import type { DocumentClient } from './client.js';
-
-const noteKey = (id: string) => ({ pk: `NOTE#${id}`, sk: 'META' });
-
-export class NoteModel {
-  constructor(
-    private readonly client: DocumentClient,
-    private readonly tableName: string,
-  ) {}
-
-  async put(note: Note): Promise<void> {
-    await this.client.send(
-      new PutCommand({
-        TableName: this.tableName,
-        Item: { ...noteKey(note.id), ...note },
-        ConditionExpression: 'attribute_not_exists(pk)',
-      }),
-    );
-  }
-
-  async get(id: string): Promise<Note> {
-    const result = (await this.client.send(
-      new GetCommand({ TableName: this.tableName, Key: noteKey(id) }),
-    )) as { Item?: Record<string, unknown> };
-    if (!result.Item) {
-      throw new NotFoundError(`note ${id} not found`);
-    }
-    // Validate on the way out too: the database is an external system.
-    return NoteSchema.parse(result.Item);
-  }
-
-  async list(): Promise<Note[]> {
-    // A filtered Scan is fine at skeleton scale; swap for a GSI Query when
-    // real data volume arrives (a Tier-2 change — it touches the schema).
-    const result = (await this.client.send(
-      new ScanCommand({
-        TableName: this.tableName,
-        FilterExpression: 'sk = :meta',
-        ExpressionAttributeValues: { ':meta': 'META' },
-      }),
-    )) as { Items?: Array<Record<string, unknown>> };
-    // Validate every entry — silently skipping corruption would hide data loss.
-    return (result.Items ?? [])
-      .map((item) => NoteSchema.parse(item))
-      .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-  }
-}

package/templates/skeleton/aws-serverless/packages/db/test/note-model.test.ts

@@ -1,91 +0,0 @@
-import { GetCommand, PutCommand, ScanCommand } from '@aws-sdk/lib-dynamodb';
-import { NotFoundError } from '@app/shared';
-import { describe, expect, it } from 'vitest';
-import { NoteModel } from '../src/note-model.js';
-import type { DocumentClient } from '../src/client.js';
-
-const note = {
-  id: 'n1',
-  title: 'Hello',
-  slug: 'hello',
-  tags: ['x'],
-  createdAt: '2024-01-01T00:00:00.000Z',
-};
-
-function stubClient(response: unknown = {}) {
-  const sent: unknown[] = [];
-  const client: DocumentClient = {
-    send: (command) => {
-      sent.push(command);
-      return Promise.resolve(response);
-    },
-  };
-  return { client, sent };
-}
-
-describe('NoteModel.put', () => {
-  it('writes the note under the single-table key, refusing overwrites', async () => {
-    const { client, sent } = stubClient();
-    await new NoteModel(client, 'notes-table').put(note);
-    expect(sent).toHaveLength(1);
-    const command = sent[0] as PutCommand;
-    expect(command).toBeInstanceOf(PutCommand);
-    expect(command.input).toMatchObject({
-      TableName: 'notes-table',
-      Item: { pk: 'NOTE#n1', sk: 'META', ...note },
-      ConditionExpression: 'attribute_not_exists(pk)',
-    });
-  });
-});
-
-describe('NoteModel.get', () => {
-  it('reads by key and validates the stored shape', async () => {
-    const { client, sent } = stubClient({ Item: { pk: 'NOTE#n1', sk: 'META', ...note } });
-    const loaded = await new NoteModel(client, 'notes-table').get('n1');
-    expect(loaded).toEqual(note);
-    const command = sent[0] as GetCommand;
-    expect(command).toBeInstanceOf(GetCommand);
-    expect(command.input).toMatchObject({
-      TableName: 'notes-table',
-      Key: { pk: 'NOTE#n1', sk: 'META' },
-    });
-  });
-
-  it('throws NotFoundError on a miss', async () => {
-    const { client } = stubClient({});
-    await expect(new NoteModel(client, 'notes-table').get('nope')).rejects.toThrow(NotFoundError);
-  });
-
-  it('refuses corrupt stored data instead of returning it', async () => {
-    const { client } = stubClient({ Item: { pk: 'NOTE#n1', sk: 'META', id: 'n1' } });
-    await expect(new NoteModel(client, 'notes-table').get('n1')).rejects.toThrow();
-  });
-});
-
-describe('NoteModel.list', () => {
-  it('scans meta items, validates them, and returns newest-first', async () => {
-    const older = { ...note, id: 'a', createdAt: '2024-01-01T00:00:00.000Z' };
-    const newer = { ...note, id: 'b', createdAt: '2024-02-01T00:00:00.000Z' };
-    const { client, sent } = stubClient({
-      Items: [
-        { pk: 'NOTE#a', sk: 'META', ...older },
-        { pk: 'NOTE#b', sk: 'META', ...newer },
-      ],
-    });
-    const listed = await new NoteModel(client, 'notes-table').list();
-    expect(listed.map((n) => n.id)).toEqual(['b', 'a']);
-    const command = sent[0] as ScanCommand;
-    expect(command).toBeInstanceOf(ScanCommand);
-    expect(command.input.TableName).toBe('notes-table');
-  });
-
-  it('returns [] for an empty table', async () => {
-    const { client } = stubClient({ Items: [] });
-    expect(await new NoteModel(client, 'notes-table').list()).toEqual([]);
-  });
-
-  it('refuses corrupt stored entries instead of skipping them', async () => {
-    const { client } = stubClient({ Items: [{ pk: 'NOTE#x', sk: 'META', id: 'x' }] });
-    await expect(new NoteModel(client, 'notes-table').list()).rejects.toThrow();
-  });
-});

package/templates/skeleton/aws-serverless/packages/shared/package.json

@@ -1,11 +0,0 @@
-{
-  "name": "@app/shared",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "dependencies": {
-    "zod": "^4.4.3"
-  }
-}

package/templates/skeleton/aws-serverless/packages/shared/src/env.ts

@@ -1,17 +0,0 @@
-import type { ZodType } from 'zod';
-import { AppError } from './errors.js';
-
-/**
- * Parse the environment through a zod schema, once, at startup. Configuration
- * is invalid → the process fails loudly at boot, not deep inside a request.
- */
-export function loadEnv<T>(schema: ZodType<T>, source: Record<string, string | undefined>): T {
-  const parsed = schema.safeParse(source);
-  if (!parsed.success) {
-    const details = parsed.error.issues
-      .map((issue) => `${issue.path.join('.') || '(root)'}: ${issue.message}`)
-      .join('; ');
-    throw new AppError(`invalid environment: ${details}`, { code: 'ENV_INVALID' });
-  }
-  return parsed.data;
-}

package/templates/skeleton/aws-serverless/packages/shared/src/errors.ts

@@ -1,33 +0,0 @@
-/**
- * Typed errors. Every error that crosses a layer boundary is one of these —
- * handlers map them to transport codes without inspecting messages.
- */
-export class AppError extends Error {
-  readonly code: string;
-  readonly statusCode: number;
-
-  constructor(
-    message: string,
-    options: { code?: string; statusCode?: number; cause?: unknown } = {},
-  ) {
-    super(message, options.cause !== undefined ? { cause: options.cause } : undefined);
-    this.name = new.target.name;
-    this.code = options.code ?? 'INTERNAL';
-    this.statusCode = options.statusCode ?? 500;
-  }
-}
-
-export class ValidationError extends AppError {
-  readonly issues: readonly string[];
-
-  constructor(message: string, issues: readonly string[] = []) {
-    super(message, { code: 'VALIDATION', statusCode: 400 });
-    this.issues = issues;
-  }
-}
-
-export class NotFoundError extends AppError {
-  constructor(message: string) {
-    super(message, { code: 'NOT_FOUND', statusCode: 404 });
-  }
-}

package/templates/skeleton/aws-serverless/packages/shared/src/index.ts

@@ -1,3 +0,0 @@
-export { AppError, NotFoundError, ValidationError } from './errors.js';
-export { createLogger, type Logger } from './logger.js';
-export { loadEnv } from './env.js';

package/templates/skeleton/aws-serverless/packages/shared/src/logger.ts

@@ -1,20 +0,0 @@
-/** Minimal structured logger: one JSON object per line on stdout. */
-export interface Logger {
-  info(message: string, fields?: Record<string, unknown>): void;
-  warn(message: string, fields?: Record<string, unknown>): void;
-  error(message: string, fields?: Record<string, unknown>): void;
-}
-
-export function createLogger(
-  base: Record<string, unknown> = {},
-  write: (line: string) => void = (line) => process.stdout.write(line + '\n'),
-): Logger {
-  const emit = (level: string, message: string, fields?: Record<string, unknown>) => {
-    write(JSON.stringify({ level, message, ...base, ...fields }));
-  };
-  return {
-    info: (message, fields) => emit('info', message, fields),
-    warn: (message, fields) => emit('warn', message, fields),
-    error: (message, fields) => emit('error', message, fields),
-  };
-}

package/templates/skeleton/aws-serverless/packages/shared/test/env.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod';
-import { AppError } from '../src/errors.js';
-import { loadEnv } from '../src/env.js';
-
-const schema = z.object({
-  TABLE_NAME: z.string().min(1),
-  QUEUE_URL: z.string().min(1),
-});
-
-describe('loadEnv', () => {
-  it('returns the typed subset of the environment', () => {
-    const env = loadEnv(schema, { TABLE_NAME: 't', QUEUE_URL: 'q', UNRELATED: 'x' });
-    expect(env).toEqual({ TABLE_NAME: 't', QUEUE_URL: 'q' });
-  });
-
-  it('fails loudly, naming every missing key', () => {
-    expect(() => loadEnv(schema, {})).toThrow(AppError);
-    expect(() => loadEnv(schema, {})).toThrow(/TABLE_NAME/);
-    expect(() => loadEnv(schema, {})).toThrow(/QUEUE_URL/);
-  });
-
-  it('rejects empty values', () => {
-    expect(() => loadEnv(schema, { TABLE_NAME: '', QUEUE_URL: 'q' })).toThrow(/TABLE_NAME/);
-  });
-});

package/templates/skeleton/aws-serverless/packages/shared/test/errors.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { AppError, NotFoundError, ValidationError } from '../src/errors.js';
-
-describe('typed errors', () => {
-  it('AppError defaults to INTERNAL/500', () => {
-    const error = new AppError('boom');
-    expect(error.code).toBe('INTERNAL');
-    expect(error.statusCode).toBe(500);
-    expect(error.name).toBe('AppError');
-  });
-
-  it('preserves an explicit cause', () => {
-    const cause = new Error('root');
-    expect(new AppError('boom', { cause }).cause).toBe(cause);
-  });
-
-  it('ValidationError is 400 and carries issues', () => {
-    const error = new ValidationError('bad input', ['title: required']);
-    expect(error.statusCode).toBe(400);
-    expect(error.code).toBe('VALIDATION');
-    expect(error.issues).toEqual(['title: required']);
-    expect(error).toBeInstanceOf(AppError);
-  });
-
-  it('NotFoundError is 404', () => {
-    expect(new NotFoundError('nope').statusCode).toBe(404);
-  });
-});

package/templates/skeleton/aws-serverless/packages/shared/test/logger.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createLogger } from '../src/logger.js';
-
-describe('createLogger', () => {
-  it('emits one JSON line per call with level, message, base and call fields', () => {
-    const lines: string[] = [];
-    const log = createLogger({ service: 'api' }, (line) => lines.push(line));
-    log.info('started', { port: 3000 });
-    log.error('failed');
-    expect(lines).toHaveLength(2);
-    expect(JSON.parse(lines[0]!)).toEqual({
-      level: 'info',
-      message: 'started',
-      service: 'api',
-      port: 3000,
-    });
-    expect(JSON.parse(lines[1]!)).toMatchObject({ level: 'error', message: 'failed' });
-  });
-});