archstone（archstone 搜索）

Critical: Follow Archstone Conventions

Everything you know about DDD patterns may differ from how Archstone implements them. Always follow the rules below — do not apply generic DDD patterns that contradict them.

When working with Archstone:

1. Check node_modules/archstone/ for the installed version
2. All entities must extend Entity<Props> or AggregateRoot<Props> — never use plain classes
3. All value objects must extend ValueObject<Props>
4. Use cases must implement UseCase<Input, Output> and never throw — always return Either
5. Repository contracts are interfaces only — implementations belong in infrastructure
6. Domain events are raised inside aggregates and dispatched after persistence — never before
7. Use UniqueEntityId for all entity identifiers — never a plain string
8. The left side of Either must implement UseCaseError — not extend Error

If you are unsure about a pattern, check Conventions Reference before writing code.

Layer Boundaries

Always respect the layer rules. Never place infrastructure code in domain/, and never import concrete implementations into use cases.

See Layer Rules for details.

Entities & Aggregates

Use a static create() factory. Pass id as the second constructor argument. Use Optional<T, K> for auto-generated fields. See Entity Patterns.

Value Objects

Use a static create() factory with validation. Value object create() may throw — wrap calls inside use cases with try/catch and return left(). See Value Object Patterns.

Use Cases

Implement UseCase<Input, Output>. Return left() for errors, right() for success. Error classes must implement UseCaseError. See Use Case Patterns.

Repository Contracts

Define as interfaces only. Use Repository<T> or compose Findable, Creatable, Saveable, Deletable. Note: findById takes string — pass entity.id.toValue(). See Repository Patterns.

Domain Events

Raise inside the aggregate via addDomainEvent(). Dispatch after persistence via DomainEvents.dispatchEventsForAggregate(aggregate.id). Define handlers as classes implementing EventHandler<T>. See Domain Event Patterns.

Testing

Use bun:test. Co-locate test files as *.spec.ts. Use in-memory repository implementations. See Testing Patterns.

References

• Conventions — quick rules summary
• Imports — import paths for all exports
• Layers — layer boundary rules
• Entity Patterns — Entity and AggregateRoot examples
• Value Object Patterns — ValueObject examples
• Use Case Patterns — UseCase and Either examples
• Repository Patterns — repository interface and in-memory examples
• Domain Event Patterns — EventHandler and dispatch examples
• Testing Patterns — bun:test and in-memory repo examples