archstone 1.2.0 → 1.2.1

package/dist/domain/enterprise/index.d.ts

@@ -1,267 +1,3 @@
-/**
-* Represents a unique identifier for a domain entity.
-*
-* Wraps a UUID v7 string, which is time-sortable and ideal for database
-* indexing. A new identifier is generated automatically if no value is provided.
-*
-* @example
-* ```ts
-* // auto-generated
-* const id = new UniqueEntityId()
-*
-* // from existing value (e.g. reconstructing from database)
-* const id = new UniqueEntityId("0195d810-5b3e-7000-8e3e-1a2b3c4d5e6f")
-* ```
-*/
-declare class UniqueEntityId {
-	private readonly value;
-	constructor(value?: string);
-	/**
-	* Returns the identifier as a primitive string.
-	* Useful for serialization and database persistence.
-	*/
-	toValue(): string;
-	/**
-	* Returns the string representation of the identifier.
-	*/
-	toString(): string;
-	/**
-	* Compares this identifier with another by value equality.
-	*
-	* @param id - The identifier to compare against
-	* @returns `true` if both identifiers have the same value
-	*/
-	equals(id: UniqueEntityId): boolean;
-}
-/**
-* Base contract for all domain events.
-*
-* A domain event represents something meaningful that happened in the domain.
-* Events are raised by aggregate roots and dispatched after successful persistence,
-* enabling decoupled side effects such as notifications, projections, and integrations.
-*
-* @example
-* ```ts
-* class UserCreatedEvent implements DomainEvent {
-*   occurredAt = new Date()
-*
-*   constructor(private readonly user: User) {}
-*
-*   getAggregateId(): UniqueEntityId {
-*     return this.user.id
-*   }
-* }
-* ```
-*/
-interface DomainEvent {
-	/**
-	* Returns the identifier of the aggregate root that raised this event.
-	*/
-	getAggregateId(): UniqueEntityId;
-	/**
-	* The date and time when the event occurred.
-	*/
-	occurredAt: Date;
-}
-/**
-* Callback function invoked when a domain event is dispatched.
-*/
-type DomainEventCallback = (event: DomainEvent) => void;
-/**
-* Central registry and dispatcher for domain events.
-*
-* Aggregates register themselves for dispatch after raising events.
-* The infrastructure layer is responsible for calling {@link dispatchEventsForAggregate}
-* after successfully persisting an aggregate, ensuring events are only
-* dispatched after a successful transaction.
-*
-* @example
-* ```ts
-* // register a handler
-* DomainEvents.register(
-*   (event) => sendWelcomeEmail(event as UserCreatedEvent),
-*   UserCreatedEvent.name,
-* )
-*
-* // dispatch after persistence
-* await userRepository.create(user)
-* DomainEvents.dispatchEventsForAggregate(user.id)
-* ```
-*/
-declare class DomainEventsImplementation {
-	private readonly handlersMap;
-	private readonly markedAggregates;
-	/**
-	* Marks an aggregate root to have its events dispatched.
-	* Called automatically by {@link AggregateRoot.addDomainEvent}.
-	*
-	* @param aggregate - The aggregate to mark for dispatch
-	*/
-	markAggregateForDispatch(aggregate: AggregateRoot<unknown>): void;
-	/**
-	* Dispatches all pending events for the aggregate with the given id,
-	* clears its events, and removes it from the dispatch list.
-	*
-	* Should be called by the infrastructure layer after persisting the aggregate.
-	*
-	* @param id - The identifier of the aggregate to dispatch events for
-	*/
-	dispatchEventsForAggregate(id: UniqueEntityId): void;
-	/**
-	* Registers an event handler for a given event class name.
-	*
-	* @param callback - The function to invoke when the event is dispatched
-	* @param eventClassName - The name of the event class to listen for
-	*/
-	register(callback: DomainEventCallback, eventClassName: string): void;
-	/**
-	* Removes all registered event handlers.
-	* Useful for test isolation.
-	*/
-	clearHandlers(): void;
-	/**
-	* Removes all aggregates from the dispatch list.
-	* Useful for test isolation.
-	*/
-	clearMarkedAggregates(): void;
-	private dispatchAggregateEvents;
-	private removeAggregateFromMarkedDispatchList;
-	private findMarkedAggregateByID;
-	private dispatch;
-}
-/**
-* Singleton instance of the domain events registry.
-* Use this to register handlers and dispatch events across the application.
-*/
-declare const DomainEvents: DomainEventsImplementation;
-/**
-* Base contract for all event handlers.
-*
-* An event handler is responsible for subscribing to domain events
-* and executing side effects in response — such as sending emails,
-* updating read models, or triggering external integrations.
-*
-* All handlers must implement {@link setupSubscriptions} to register
-* their callbacks in the {@link DomainEvents} registry.
-*
-* @example
-* ```ts
-* class OnUserCreated implements EventHandler {
-*   constructor(private readonly mailer: Mailer) {}
-*
-*   setupSubscriptions(): void {
-*     DomainEvents.register(
-*       (event) => this.sendWelcomeEmail(event as UserCreatedEvent),
-*       UserCreatedEvent.name,
-*     )
-*   }
-*
-*   private async sendWelcomeEmail(event: UserCreatedEvent): Promise<void> {
-*     await this.mailer.send(event.user.email)
-*   }
-* }
-* ```
-*/
-interface EventHandler {
-	/**
-	* Registers all event subscriptions for this handler.
-	* Should be called once during application bootstrap.
-	*/
-	setupSubscriptions(): void;
-}
-/**
-* Base class for all domain entities.
-*
-* An entity is an object defined by its identity rather than its attributes.
-* Two entities are considered equal if they share the same `id`, regardless
-* of their other properties.
-*
-* All entities must implement a static `create` factory method to encapsulate
-* construction logic and keep the constructor protected.
-*
-* @template Props - The shape of the entity's properties
-*
-* @example
-* ```ts
-* interface UserProps {
-*   id: UniqueEntityId
-*   name: string
-*   email: string
-*   createdAt: Date
-* }
-*
-* class User extends Entity<UserProps> {
-*   get name() { return this.props.name }
-*   get email() { return this.props.email }
-*
-*   static create(props: Optional<UserProps, "id" | "createdAt">): User {
-*     return new User(
-*       { ...props, createdAt: props.createdAt ?? new Date() },
-*       props.id ?? new UniqueEntityId(),
-*     )
-*   }
-* }
-* ```
-*/
-declare abstract class Entity<Props> {
-	private readonly _id;
-	protected props: Props;
-	get id(): UniqueEntityId;
-	protected constructor(props: Props, id?: UniqueEntityId);
-	/**
-	* Compares this entity with another by identity.
-	*
-	* @param entity - The entity to compare against
-	* @returns `true` if both entities share the same `id`
-	*/
-	equals(entity: Entity<unknown>): boolean;
-}
-/**
-* Base class for all aggregate roots in the domain.
-*
-* An aggregate root is the entry point to an aggregate — a cluster of domain
-* objects that are treated as a single unit. It is responsible for enforcing
-* invariants and coordinating domain events within its boundary.
-*
-* Domain events are collected internally and dispatched after the aggregate
-* is persisted, ensuring side effects only occur after a successful transaction.
-*
-* @template Props - The shape of the aggregate's properties
-*
-* @example
-* ```ts
-* class User extends AggregateRoot<UserProps> {
-*   static create(props: Optional<UserProps, "id" | "createdAt">): User {
-*     const user = new User(
-*       { ...props, createdAt: props.createdAt ?? new Date() },
-*       props.id ?? new UniqueEntityId(),
-*     )
-*
-*     user.addDomainEvent(new UserCreatedEvent(user))
-*
-*     return user
-*   }
-* }
-* ```
-*/
-declare abstract class AggregateRoot<Props> extends Entity<Props> {
-	private readonly _domainEvents;
-	/**
-	* Returns all domain events that have been raised by this aggregate
-	* and are pending dispatch.
-	*/
-	get domainEvents(): DomainEvent[];
-	/**
-	* Registers a domain event to be dispatched after the aggregate is persisted.
-	* Automatically marks this aggregate for dispatch in the {@link DomainEvents} registry.
-	*
-	* @param domainEvent - The domain event to register
-	*/
-	protected addDomainEvent(domainEvent: DomainEvent): void;
-	/**
-	* Clears all pending domain events from this aggregate.
-	* Should be called by the infrastructure layer after events are dispatched.
-	*/
-	clearEvents(): void;
-}
+import { AggregateRoot, DomainEvent, DomainEvents, Entity, EventHandler } from "../../shared/chunk-axgwjkjg.js";
+import "../../shared/chunk-t21213sm.js";
 export { EventHandler, Entity, DomainEvents, DomainEvent, AggregateRoot };

package/dist/domain/enterprise/index.js

@@ -1,2 +1,2 @@
 // @bun
-import{e as a,f as b,g as c}from"../../shared/chunk-mmsp4fty.js";import"../../shared/chunk-27pwj1j1.js";export{b as Entity,a as DomainEvents,c as AggregateRoot};
+import{a,b,c}from"../../shared/chunk-jw0ckhsy.js";import"../../shared/chunk-r63mxet1.js";export{b as Entity,a as DomainEvents,c as AggregateRoot};