@rotorsoft/act 0.33.3 → 0.35.0

package/dist/@types/types/ports.d.ts

@@ -1,485 +0,0 @@
-/**
- * @packageDocumentation
- * @module act/types
- * @category Types
- * Types and interfaces for event store ports and disposables in the Act Framework.
- */
-import type { Committed, EventMeta, Message, Query, Schema, Schemas } from "./action.js";
-import type { BlockedLease, Lease } from "./reaction.js";
-/**
- * A function that disposes of a resource asynchronously.
- * @returns Promise that resolves when disposal is complete.
- */
-export type Disposer = () => Promise<void>;
-/**
- * An object that can be disposed of asynchronously.
- */
-export type Disposable = {
-    dispose: Disposer;
-};
-/**
- * Minimal logger port compatible with pino, winston, bunyan, and console.
- *
- * Each log method accepts either:
- * - `(msg: string)` — plain message
- * - `(obj: unknown, msg?: string)` — structured data with optional message
- *
- * Implementations should respect `level` to gate output.
- *
- * @see {@link ConsoleLogger} for the default implementation
- * @see {@link https://www.npmjs.com/package/@rotorsoft/act-pino | @rotorsoft/act-pino} for the Pino adapter
- */
-export interface Logger extends Disposable {
-    level: string;
-    fatal(obj: unknown, msg?: string): void;
-    fatal(msg: string): void;
-    error(obj: unknown, msg?: string): void;
-    error(msg: string): void;
-    warn(obj: unknown, msg?: string): void;
-    warn(msg: string): void;
-    info(obj: unknown, msg?: string): void;
-    info(msg: string): void;
-    debug(obj: unknown, msg?: string): void;
-    debug(msg: string): void;
-    trace(obj: unknown, msg?: string): void;
-    trace(msg: string): void;
-    child(bindings: Record<string, unknown>): Logger;
-}
-/**
- * Result of a {@link Store.truncate} operation, keyed by stream name.
- * Each entry contains the number of deleted events and the committed
- * seed event (snapshot or tombstone).
- */
-export type TruncateResult = Map<string, {
-    deleted: number;
-    committed: Committed<Schemas, keyof Schemas>;
-}>;
-/**
- * Subscription position for a registered stream.
- *
- * Streamed by {@link Store.query_streams} to power operational dashboards
- * (projection lag, blocked subscriptions, in-flight leases). The shape
- * mirrors what every adapter already tracks on its `streams` table.
- *
- * @property stream - The subscription target (projection or reaction stream)
- * @property source - Optional source stream filter (for reactions)
- * @property at - Last processed event id watermark (-1 for fresh streams)
- * @property retry - Current retry counter
- * @property blocked - True when the stream is blocked by a poison message
- * @property error - Last error message (empty string when none)
- * @property leased_by - Current lease holder UUID (when leased)
- * @property leased_until - Lease expiration timestamp (when leased)
- */
-export type StreamPosition = {
-    readonly stream: string;
-    readonly source?: string;
-    readonly at: number;
-    readonly retry: number;
-    readonly blocked: boolean;
-    readonly error: string;
-    readonly leased_by?: string;
-    readonly leased_until?: Date;
-};
-/**
- * Filter options for {@link Store.query_streams}.
- *
- * Mirrors the {@link Query} pattern used by {@link Store.query} — pass
- * filters server-side to keep the cost low on large tables (e.g., dynamic
- * reactions producing one subscription per aggregate).
- *
- * **What the store can filter:** the columns it actually persists —
- * `stream`, `source`, `blocked`. Higher-level classification ("is this a
- * projection vs a reaction?", "is this a static or dynamic resolver?")
- * is an orchestrator concern; the streams table doesn't store kinds.
- * Layer that on top by joining results with `Act`'s built-in registry.
- *
- * @property stream - Stream-name filter. By default treated as a regex
- *   (PG `~`, SQLite/InMemory `LIKE`-translated). Pass `stream_exact: true`
- *   for exact string equality.
- * @property stream_exact - Use exact match instead of pattern match for
- *   `stream`.
- * @property source - Source-stream filter (regex by default). Useful to
- *   isolate dynamic-reaction subscriptions tied to a particular aggregate
- *   stream. Pass `source_exact: true` for exact equality.
- * @property source_exact - Use exact match instead of pattern match for
- *   `source`.
- * @property blocked - Restrict to blocked (`true`) or unblocked (`false`)
- *   streams. Omit for all.
- * @property after - Keyset pagination cursor: returns only streams with
- *   `stream > after` (lexicographic). Pass the last seen `stream` to fetch
- *   the next page.
- * @property limit - Max rows to return (default: 100).
- */
-export type QueryStreams = {
-    readonly stream?: string;
-    readonly stream_exact?: boolean;
-    readonly source?: string;
-    readonly source_exact?: boolean;
-    readonly blocked?: boolean;
-    readonly after?: string;
-    readonly limit?: number;
-};
-/**
- * Result of a {@link Store.query_streams} call.
- *
- * @property maxEventId - Highest event id in the store (-1 when empty).
- *   UI uses this to compute lag as `maxEventId - position.at`.
- * @property count - Number of stream positions delivered to the callback.
- */
-export type QueryStreamsResult = {
-    readonly maxEventId: number;
-    readonly count: number;
-};
-/**
- * Interface for event store implementations.
- *
- * The Store interface defines the contract for persistence adapters in Act.
- * Implementations must provide event storage, querying, and distributed processing
- * capabilities through leasing and watermark tracking.
- *
- * Act includes two built-in implementations:
- * - **InMemoryStore**: For development and testing
- * - **PostgresStore**: For production use with PostgreSQL
- *
- * Custom stores can be implemented for other databases or event log systems.
- *
- * @example Using a custom store
- * ```typescript
- * import { store } from "@rotorsoft/act";
- * import { PostgresStore } from "@rotorsoft/act-pg";
- *
- * // Replace the default in-memory store
- * store(new PostgresStore({
- *   host: "localhost",
- *   port: 5432,
- *   database: "myapp",
- *   user: "postgres",
- *   password: "secret"
- * }));
- *
- * const app = act()
- *   .withState(Counter)
- *   .build();
- * ```
- *
- * @see {@link InMemoryStore} for the default implementation
- * @see {@link PostgresStore} for the PostgreSQL implementation
- */
-export interface Store extends Disposable {
-    /**
-     * Initializes or resets the store.
-     *
-     * Used primarily for testing to ensure a clean state between tests.
-     * For production stores, this might create necessary tables or indexes.
-     *
-     * @example
-     * ```typescript
-     * // Reset store between tests
-     * beforeEach(async () => {
-     *   await store().seed();
-     * });
-     * ```
-     */
-    seed: () => Promise<void>;
-    /**
-     * Drops all data from the store.
-     *
-     * Dangerous operation that deletes all events and state. Use with extreme caution,
-     * primarily for testing or development environments.
-     *
-     * @example
-     * ```typescript
-     * // Clean up after tests
-     * afterAll(async () => {
-     *   await store().drop();
-     * });
-     * ```
-     */
-    drop: () => Promise<void>;
-    /**
-     * Commits one or more events to a stream atomically.
-     *
-     * This is the core method for persisting events. It must:
-     * - Assign global sequence IDs to events
-     * - Increment the stream version
-     * - Check optimistic concurrency if expectedVersion is provided
-     * - Store events atomically (all or nothing)
-     * - Attach metadata (id, stream, version, created timestamp)
-     *
-     * @template E - Event schemas
-     * @param stream - The stream ID to commit to
-     * @param msgs - Array of messages (events) to commit
-     * @param meta - Event metadata (correlation, causation)
-     * @param expectedVersion - Expected current version for optimistic concurrency
-     * @returns Array of committed events with full metadata
-     *
-     * @throws {ConcurrencyError} If expectedVersion doesn't match current version
-     *
-     * @example
-     * ```typescript
-     * const events = await store().commit(
-     *   "user-123",
-     *   [{ name: "UserCreated", data: { email: "user@example.com" } }],
-     *   { correlation: "req-456", causation: { action: {...} } },
-     *   0 // Expect version 0 (new stream)
-     * );
-     * ```
-     */
-    commit: <E extends Schemas>(stream: string, msgs: Message<E, keyof E>[], meta: EventMeta, expectedVersion?: number) => Promise<Committed<E, keyof E>[]>;
-    /**
-     * Queries events from the store with optional filtering.
-     *
-     * Calls the callback for each matching event. The callback approach allows
-     * processing large result sets without loading everything into memory.
-     *
-     * @template E - Event schemas
-     * @param callback - Function invoked for each matching event
-     * @param query - Optional filter criteria — see {@link Query} for fields
-     *   (`stream`, `name`, `after`, `before`, `created_after`, `created_before`,
-     *   `limit`, `with_snaps`, `stream_exact`).
-     * @returns Total number of events processed
-     *
-     * @example Query all events for a stream
-     * ```typescript
-     * let count = 0;
-     * await store().query(
-     *   (event) => {
-     *     console.log(event.name, event.data);
-     *     count++;
-     *   },
-     *   { stream: "user-123" }
-     * );
-     * console.log(`Found ${count} events`);
-     * ```
-     */
-    query: <E extends Schemas>(callback: (event: Committed<E, keyof E>) => void, query?: Query) => Promise<number>;
-    /**
-     * Atomically discovers and leases streams for reaction processing.
-     *
-     * Atomically discovers a stream and acquires a lease in one round-trip,
-     * eliminating the race that exists when discovery and locking are separate
-     * calls (a competing worker can grab the stream between the two).
-     *
-     * PostgresStore uses `FOR UPDATE SKIP LOCKED` for zero-contention competing
-     * consumer semantics — workers never block each other, each grabbing different
-     * streams atomically. InMemoryStore fuses its poll+lease logic equivalently.
-     *
-     * Used by `Act.drain()` as the primary stream acquisition method.
-     *
-     * @param lagging - Max streams from the lagging frontier (ascending watermark)
-     * @param leading - Max streams from the leading frontier (descending watermark)
-     * @param by - Unique lease holder identifier (UUID)
-     * @param millis - Lease duration in milliseconds
-     * @returns Array of successfully leased streams with metadata
-     *
-     * @example
-     * ```typescript
-     * const leased = await store().claim(5, 5, randomUUID(), 10000);
-     * leased.forEach(({ stream, at, lagging }) => {
-     *   console.log(`Leased ${stream} at ${at} (lagging: ${lagging})`);
-     * });
-     * ```
-     *
-     * @see {@link subscribe} for registering new streams (used by correlate)
-     * @see {@link ack} for acknowledging completion
-     * @see {@link block} for blocking failed streams
-     */
-    claim: (lagging: number, leading: number, by: string, millis: number) => Promise<Lease[]>;
-    /**
-     * Registers streams for event processing.
-     *
-     * Upserts stream entries so they become visible to {@link claim}. Used by
-     * `correlate()` to register dynamically discovered reaction target streams.
-     *
-     * Also returns the current maximum watermark across all subscribed streams,
-     * used internally for correlation checkpoint initialization on cold start.
-     *
-     * @param streams - Streams to register with optional source hint
-     * @returns `subscribed` count of newly registered streams, `watermark` max `at` across all streams
-     *
-     * @example
-     * ```typescript
-     * const { subscribed, watermark } = await store().subscribe([
-     *   { stream: "stats-user-1", source: "user-1" },
-     *   { stream: "stats-user-2", source: "user-2" },
-     * ]);
-     * ```
-     *
-     * @see {@link claim} for discovering and leasing registered streams
-     */
-    subscribe: (streams: Array<{
-        stream: string;
-        source?: string;
-    }>) => Promise<{
-        subscribed: number;
-        watermark: number;
-    }>;
-    /**
-     * Acknowledges successful processing of leased streams.
-     *
-     * Updates the watermark to indicate events have been processed successfully.
-     * Releases the lease so other workers can process subsequent events.
-     *
-     * @param leases - Leases to acknowledge with updated watermarks
-     * @returns Acknowledged leases
-     *
-     * @example
-     * ```typescript
-     * const leased = await store().claim(5, 5, randomUUID(), 10000);
-     * // Process events up to ID 150
-     * await store().ack(leased.map(l => ({ ...l, at: 150 })));
-     * ```
-     *
-     * @see {@link claim} for acquiring leases
-     */
-    ack: (leases: Lease[]) => Promise<Lease[]>;
-    /**
-     * Blocks streams after persistent processing failures.
-     *
-     * Blocked streams won't be returned by {@link claim} until manually unblocked.
-     * This prevents poison messages from repeatedly failing and consuming resources.
-     *
-     * Streams are typically blocked when:
-     * - Max retries reached
-     * - `blockOnError` option is true
-     * - Handler throws an error
-     *
-     * @param leases - Leases to block with error messages
-     * @returns Blocked leases
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   await processEvents(lease);
-     *   await store().ack([lease]);
-     * } catch (error) {
-     *   if (lease.retry >= 3) {
-     *     await store().block([{
-     *       ...lease,
-     *       error: error.message
-     *     }]);
-     *   }
-     * }
-     * ```
-     *
-     * @see {@link claim} for lease management
-     */
-    block: (leases: BlockedLease[]) => Promise<BlockedLease[]>;
-    /**
-     * Resets watermarks for the given streams to -1, making them eligible
-     * for replay from the beginning. Also clears retry, blocked, error,
-     * and lease state so the streams can be claimed immediately.
-     *
-     * **Prefer `Act.reset()` over calling this directly.** This primitive
-     * only resets the store; it does not raise the orchestrator's internal
-     * "needs drain" flag, so a settled `Act` instance will short-circuit and
-     * skip the replay. `Act.reset()` wraps this and arms the flag.
-     *
-     * @param streams - Stream names to reset
-     * @returns Count of streams that were actually reset
-     *
-     * @example
-     * ```typescript
-     * // Recommended
-     * await app.reset(["my-projection"]);
-     *
-     * // Low-level (does NOT trigger replay on settled apps)
-     * await store().reset(["my-projection"]);
-     * ```
-     *
-     * @see {@link Act.reset} for the high-level rebuild API that wraps
-     *   this primitive and arms the orchestrator's drain flag
-     */
-    reset: (streams: string[]) => Promise<number>;
-    /**
-     * Atomically truncates streams and seeds each with a final event.
-     *
-     * For each target, in a single transaction:
-     * 1. Deletes all events for the stream
-     * 2. Removes the stream's entry from the streams table
-     * 3. Inserts a `__snapshot__` (when `snapshot` is provided) or
-     *    `__tombstone__` event as the sole event on the stream
-     *
-     * @param targets - Streams to truncate with optional snapshot state and meta
-     * @returns Map keyed by stream name, each entry with `deleted` count and `committed` event
-     *
-     * @see {@link Act.close} for the high-level close-the-books API that
-     *   orchestrates safety checks, archive callbacks, and atomic
-     *   truncate+seed
-     */
-    truncate: (targets: Array<{
-        stream: string;
-        snapshot?: Schema;
-        meta?: EventMeta;
-    }>) => Promise<TruncateResult>;
-    /**
-     * Streams registered subscription positions to a callback, plus the
-     * highest event id in the store.
-     *
-     * Read-only introspection for operational dashboards (Store /
-     * Subscriptions tab, projection lag, blocked subscriptions). Avoids
-     * forcing apps to open a second connection and run raw SQL against
-     * adapter-specific schemas.
-     *
-     * Mirrors the {@link Store.query} callback pattern: the callback is
-     * invoked once per matching position, allowing large result sets to be
-     * processed without buffering. Results are ordered by `stream` name; use
-     * `query.after` (last seen stream name) for keyset pagination on big
-     * tables (dynamic reactions can produce one subscription per aggregate).
-     *
-     * @param callback - Invoked once per matching {@link StreamPosition}.
-     * @param query - Optional {@link QueryStreams} filter (default `limit: 100`).
-     * @returns `maxEventId` and the `count` of positions emitted.
-     *
-     * @example List blocked streams with their lag
-     * ```typescript
-     * const { maxEventId } = await store().query_streams(
-     *   (s) => console.log(`${s.stream}: lag=${maxEventId - s.at} ${s.error}`),
-     *   { blocked: true, limit: 50 }
-     * );
-     * ```
-     *
-     * @example Page through all positions
-     * ```typescript
-     * let after: string | undefined;
-     * for (;;) {
-     *   const page: StreamPosition[] = [];
-     *   const { count } = await store().query_streams(
-     *     (s) => page.push(s),
-     *     { after, limit: 100 }
-     *   );
-     *   if (!count) break;
-     *   // ... use page ...
-     *   after = page.at(-1)?.stream;
-     * }
-     * ```
-     */
-    query_streams: (callback: (position: StreamPosition) => void, query?: QueryStreams) => Promise<QueryStreamsResult>;
-}
-/**
- * A cached snapshot entry for a stream.
- *
- * @template TState - The state schema type
- */
-export interface CacheEntry<TState extends Schema> {
-    readonly state: TState;
-    readonly version: number;
-    readonly event_id: number;
-    readonly patches: number;
-    readonly snaps: number;
-}
-/**
- * Cache port for storing stream snapshots in-process.
- *
- * Implementations should provide fast key-value access with bounded memory.
- * The async interface is forward-compatible with external caches (e.g., Redis).
- *
- * @template TState - The state schema type
- */
-export interface Cache extends Disposable {
-    get<TState extends Schema>(stream: string): Promise<CacheEntry<TState> | undefined>;
-    set<TState extends Schema>(stream: string, entry: CacheEntry<TState>): Promise<void>;
-    invalidate(stream: string): Promise<void>;
-    clear(): Promise<void>;
-}
-//# sourceMappingURL=ports.d.ts.map

package/dist/@types/types/ports.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../../src/types/ports.ts"],"names":[],"mappings":"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"}