@rotorsoft/act-tck 0.1.0

package/dist/@types/logger-tck.d.ts

@@ -0,0 +1,47 @@
+import type { Logger } from "@rotorsoft/act/types";
+/**
+ * Options for {@link runLoggerTck}.
+ */
+export type LoggerTckOptions = {
+    /**
+     * Display name for the implementation under test.
+     */
+    readonly name: string;
+    /**
+     * Factory invoked before each test. Must return a fresh logger
+     * instance — tests do not assume any starting state.
+     */
+    readonly factory: () => Logger;
+};
+/**
+ * Runs the Logger contract test compatibility kit against the
+ * implementation produced by `options.factory`.
+ *
+ * The {@link Logger} contract is intentionally narrow: implementations
+ * are pluggable wrappers around pino, winston, bunyan, console, etc.
+ * The TCK verifies the **shape** of the contract, not the format of
+ * the output (which is adapter-specific by design):
+ * - every level method exists and is callable in both overload forms
+ *   `(msg)` and `(obj, msg?)`
+ * - `child(bindings)` returns something that satisfies the same
+ *   contract and can itself spawn children
+ * - `level` is a non-empty string
+ * - `dispose` is awaitable and idempotent
+ * - cyclic payloads must not throw (sinks may choose any fallback)
+ *
+ * Anything more (output format, level gating, color, file routing) is
+ * adapter-specific and stays in the adapter's own test suite.
+ *
+ * @example
+ * ```ts
+ * import { runLoggerTck } from "@rotorsoft/act-tck";
+ * import { ConsoleLogger } from "@rotorsoft/act";
+ *
+ * runLoggerTck({
+ *   name: "ConsoleLogger",
+ *   factory: () => new ConsoleLogger({ level: "trace" }),
+ * });
+ * ```
+ */
+export declare const runLoggerTck: (options: LoggerTckOptions) => void;
+//# sourceMappingURL=logger-tck.d.ts.map

package/dist/@types/logger-tck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-tck.d.ts","sourceRoot":"","sources":["../../src/logger-tck.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,CAAC;CAChC,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,gBAAgB,KAAG,IAuExD,CAAC"}

package/dist/@types/store-tck.d.ts

@@ -0,0 +1,75 @@
+import type { Store } from "@rotorsoft/act/types";
+/**
+ * Optional features a {@link Store} implementation may or may not
+ * support. Default to `false` — only enable a flag when the adapter
+ * exposes the corresponding surface and you want the TCK to cover it.
+ */
+export type StoreCapabilities = {
+    /**
+     * Adapter implements {@link Store.notify}. When `true`, the TCK runs
+     * a basic subscribe/dispose smoke test. Cross-process LISTEN/NOTIFY
+     * semantics are not exercised — that needs two processes and stays
+     * in the adapter's own suite.
+     */
+    readonly notify?: boolean;
+};
+/**
+ * Options for {@link runStoreTck}.
+ */
+export type StoreTckOptions = {
+    /**
+     * Display name for the implementation under test.
+     */
+    readonly name: string;
+    /**
+     * Returns the {@link Store} instance under test. Called once during
+     * `beforeAll`. The TCK does not assume a fresh store per test — each
+     * test namespaces its streams via {@link uid} so they don't collide.
+     * The TCK calls `store.seed()` once before any test runs and
+     * `store.dispose()` after all tests, with `store.drop()` in between
+     * if any test needs it.
+     */
+    readonly factory: () => Store | Promise<Store>;
+    /**
+     * Optional capabilities flags — see {@link StoreCapabilities}.
+     */
+    readonly capabilities?: StoreCapabilities;
+};
+/**
+ * Runs the Store contract test compatibility kit against the
+ * implementation produced by `options.factory`.
+ *
+ * The TCK is the executable definition of the {@link Store} contract.
+ * Every method on the interface in `libs/act/src/types/ports.ts` has
+ * matching cases here:
+ *
+ * - `commit` — single + multi-event commits, optimistic concurrency
+ * - `query` — stream, names, correlation, before, after, created_after,
+ *   created_before, limit, with_snaps, stream_exact, backward traversal
+ * - `subscribe` — idempotent re-subscribe, watermark return value
+ * - `claim` / `ack` — lease lifecycle, dual frontiers, leased streams
+ *   not double-claimed
+ * - `block` — blocked streams hidden from claim, only same-drainer can block
+ * - `reset` — restart watermarks (including blocked), no-op for missing
+ * - `prioritize` — bulk priority updates by filter
+ * - `truncate` — snapshot vs tombstone seeding, empty inputs, missing streams
+ * - `query_streams` — filters, exact-match, pagination, blocked
+ * - `notify` (capability-gated) — subscribe + dispose smoke test
+ *
+ * Tests namespace their streams with a per-test {@link uid} so the
+ * suite is parallel-safe against a shared backing store (e.g., a real
+ * Postgres instance running tests for the whole monorepo concurrently).
+ *
+ * @example
+ * ```ts
+ * import { runStoreTck } from "@rotorsoft/act-tck";
+ * import { InMemoryStore } from "@rotorsoft/act";
+ *
+ * runStoreTck({
+ *   name: "InMemoryStore",
+ *   factory: () => new InMemoryStore(),
+ * });
+ * ```
+ */
+export declare const runStoreTck: (options: StoreTckOptions) => void;
+//# sourceMappingURL=store-tck.d.ts.map

package/dist/@types/store-tck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-tck.d.ts","sourceRoot":"","sources":["../../src/store-tck.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,KAAK,EAEN,MAAM,sBAAsB,CAAC;AAc9B;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAC/C;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,iBAAiB,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,eAAe,KAAG,IA8zBtD,CAAC"}