@shipeasy/sdk 4.5.0 → 5.1.0

package/dist/server/index.d.ts

@@ -10,15 +10,13 @@ interface Consequence {
 }
 /**
  * Non-exception problem, built by `violation(name)`. A plain branded object
- * (not an Error subclass) so `.message()` can be a builder method without
- * colliding with `Error.prototype.message`.
+ * (not an Error subclass). The name is the whole identity — there is no
+ * separate message; any variable/context data belongs in `.extras()` on the
+ * see chain, never on the violation itself.
  */
 interface Violation {
     readonly __seViolation: true;
     readonly violationName: string;
-    readonly violationMessage?: string;
-    /** Attach free-form detail. Variable data goes HERE (or in extras), never in the name. */
-    message(msg: string): Violation;
 }
 /**
  * Identity of a problem that see() already reported, carried on the wire as
@@ -87,12 +85,33 @@ interface SeeChain {
     /** camelCase alias of {@link SeeChain.causes_the}. */
     causesThe(subject: string): SeeOutcomeStep;
 }
-interface SeeViolationChain extends SeeChain {
-    /** Free-form detail. Variable data goes here (or extras), never in the name. */
-    message(msg: string): SeeViolationChain;
+/**
+ * Violations share the exception consequence grammar exactly — there is no
+ * separate `.message()`. Put any variable/context data in `.extras()`.
+ */
+type SeeViolationChain = SeeChain;
+interface SeeControlFlowTail {
+    /**
+     * Optional debugging context for the expected exception. Kept on the mark for
+     * local debugging only (expected exceptions are never reported). Callable
+     * repeatedly — keys merge, later wins.
+     */
+    extras(extras: SeeExtras): SeeControlFlowTail;
+}
+interface SeeControlFlowChain {
+    /** Document why the exception is expected. The reason should start with "because". */
+    because(reason: string): SeeControlFlowTail;
 }
 
 declare const version = "4.0.0";
+/**
+ * @internal Exported ONLY so the cross-language eval-parity golden-vector test
+ * (src/__tests__/eval-vectors.test.ts) can assert the raw unsigned-32-bit hash
+ * against the canonical fixture. Not part of the public SDK surface — do not
+ * rely on it in product code; the bucketing contract lives behind getFlag /
+ * getExperiment. Name-prefixed with `_` to signal "test seam, not API".
+ */
+declare function _murmur3ForTests(key: string): number;
 interface User {
     user_id?: string;
     anonymous_id?: string;
@@ -103,6 +122,30 @@ interface ExperimentResult<P> {
     group: string;
     params: P;
 }
+/**
+ * Why a flag evaluated the way it did (LaunchDarkly variationDetail parity).
+ * Computed at the client boundary, never inside the canonical eval:
+ *   - CLIENT_NOT_READY — no rules blob loaded yet (init()/initOnce() pending)
+ *   - FLAG_NOT_FOUND   — the gate name isn't present in the loaded blob
+ *   - OFF              — the gate exists but is disabled / killed
+ *   - OVERRIDE         — a local override (overrideFlag) decided the value
+ *   - RULE_MATCH       — the gate evaluated true (rules + rollout passed)
+ *   - DEFAULT          — the gate evaluated false (a rule or the rollout denied)
+ */
+declare const FLAG_REASONS: readonly ["CLIENT_NOT_READY", "FLAG_NOT_FOUND", "OFF", "OVERRIDE", "RULE_MATCH", "DEFAULT"];
+type FlagReason = (typeof FLAG_REASONS)[number];
+interface FlagDetail {
+    value: boolean;
+    reason: FlagReason;
+}
+/** Options object form of `getConfig` — keeps the legacy `decode` callback and
+ *  adds a `defaultValue` returned when the config key is absent. */
+interface GetConfigOptions<T = unknown> {
+    /** Decode the raw stored value into the typed shape callers want. */
+    decode?: (raw: unknown) => T;
+    /** Returned when the config key is absent (not overridden, not in the blob). */
+    defaultValue?: T;
+}
 interface GateRule {
     attr: string;
     op: "eq" | "neq" | "in" | "not_in" | "gt" | "gte" | "lt" | "lte" | "contains" | "regex";
@@ -115,10 +158,27 @@ interface Gate {
     enabled: 0 | 1 | boolean;
     killswitch?: 0 | 1 | boolean;
 }
+interface ExperimentGroup {
+    name: string;
+    weight: number;
+    params: Record<string, unknown>;
+}
+interface Experiment {
+    universe: string;
+    targetingGate?: string | null;
+    allocationPct: number;
+    salt: string;
+    groups: ExperimentGroup[];
+    status: "draft" | "running" | "stopped" | "archived";
+}
+interface Universe {
+    holdout_range: [number, number] | null;
+}
 interface Killswitch {
     killed: 0 | 1 | boolean;
     switches?: Record<string, 0 | 1 | boolean>;
 }
+/** Body of `GET /sdk/flags` — the snapshot's `flags` field. See {@link FlagsClient.fromSnapshot}. */
 interface FlagsBlob {
     version: string;
     plan: string;
@@ -128,6 +188,12 @@ interface FlagsBlob {
     }>;
     killswitches: Record<string, Killswitch>;
 }
+/** Body of `GET /sdk/experiments` — the snapshot's `experiments` field. See {@link FlagsClient.fromSnapshot}. */
+interface ExpsBlob {
+    version: string;
+    universes: Record<string, Universe>;
+    experiments: Record<string, Experiment>;
+}
 interface BootstrapPayload {
     flags: Record<string, boolean>;
     configs: Record<string, unknown>;
@@ -157,6 +223,13 @@ interface FlagsClientOptions {
     disableTelemetry?: boolean;
     /** Override the telemetry beacon host. Defaults to {@link DEFAULT_TELEMETRY_URL}. */
     telemetryUrl?: string;
+    /**
+     * Test mode — no network at all. init()/initOnce() are no-ops (never fetch),
+     * track() is a no-op, telemetry is forced off, and the client starts
+     * "initialized" with an empty blob. Prefer the {@link FlagsClient.forTesting}
+     * factory over passing this directly.
+     */
+    testMode?: boolean;
 }
 declare class FlagsClient {
     private readonly apiKey;
@@ -171,16 +244,89 @@ declare class FlagsClient {
     private pollInterval;
     private timer;
     private initialized;
+    private readonly testMode;
+    private readonly flagOverrides;
+    private readonly configOverrides;
+    private readonly experimentOverrides;
+    private readonly changeListeners;
     constructor(opts: FlagsClientOptions);
+    /**
+     * Build a no-network, immediately-usable client for tests (Statsig-style).
+     * init()/initOnce() are no-ops (never fetch), track() is a no-op, telemetry
+     * is disabled, and the client is already "initialized" — seed every entity
+     * with overrideFlag/overrideConfig/overrideExperiment. No SDK key required.
+     *
+     * ```ts
+     * const client = FlagsClient.forTesting();
+     * client.overrideFlag("new_checkout", true);
+     * client.getFlag("new_checkout", { user_id: "u1" }); // true
+     * ```
+     */
+    static forTesting(opts?: Partial<FlagsClientOptions>): FlagsClient;
+    /**
+     * Build a fully OFFLINE client from a pre-captured snapshot — no network ever.
+     * Reuses the test-mode plumbing (init()/initOnce()/track() are no-ops,
+     * telemetry off) but, unlike forTesting(), seeds the REAL flags + experiments
+     * blobs so evaluations run the canonical eval against the snapshot. Local
+     * overrides still apply on top.
+     *
+     * Snapshot shape mirrors the wire bodies:
+     * `{ flags: <GET /sdk/flags body>, experiments: <GET /sdk/experiments body> }`.
+     */
+    static fromSnapshot(snapshot: {
+        flags: FlagsBlob;
+        experiments: ExpsBlob;
+    }): FlagsClient;
+    /**
+     * Build a fully OFFLINE client from a snapshot JSON file on disk (Node only —
+     * not available in the browser entrypoint). The file must contain
+     * `{ "flags": <GET /sdk/flags body>, "experiments": <GET /sdk/experiments body> }`.
+     * See {@link FlagsClient.fromSnapshot}.
+     */
+    static fromFile(path: string): FlagsClient;
     init(): Promise<void>;
     initOnce(): Promise<void>;
+    /** Force `getFlag(name, …)` to return `value`, ignoring the fetched gate. */
+    overrideFlag(name: string, value: boolean): void;
+    /** Force `getConfig(name)` to return `value`, ignoring the fetched config. */
+    overrideConfig(name: string, value: unknown): void;
+    /**
+     * Force `getExperiment(name, …)` to return `{ inExperiment: true, group, params }`,
+     * ignoring allocation, holdouts, and targeting.
+     */
+    overrideExperiment(name: string, group: string, params: Record<string, unknown>): void;
+    /** Remove every programmatic override set via the override* methods. */
+    clearOverrides(): void;
     destroy(): void;
+    /**
+     * Subscribe to data-change notifications. The listener fires after a
+     * background poll fetch returns NEW data (200, not 304) — i.e. after the
+     * cached blob is updated. Never fires in testMode/offline (no polling).
+     * Returns an unsubscribe function.
+     */
+    onChange(listener: () => void): () => void;
+    private notifyChange;
     private startPoll;
     private fetchAll;
     private fetchFlags;
     private fetchExps;
-    getFlag(name: string, user: User): boolean;
+    /**
+     * Evaluate a gate and report WHY (LaunchDarkly variationDetail parity). The
+     * reason is computed entirely at this boundary — the canonical eval
+     * (evalGateInternal) is untouched. A local override short-circuits BEFORE
+     * telemetry, exactly like getFlag's override path; otherwise exactly one
+     * "gate" beacon is emitted.
+     */
+    getFlagDetail(name: string, user: User): FlagDetail;
+    /**
+     * Read a feature gate. Returns `defaultValue` ONLY when the gate cannot be
+     * evaluated (client not initialized or flag not found) — never for a gate that
+     * legitimately evaluates to false. Plain `getFlag(name, user)` keeps returning
+     * false for a missing flag.
+     */
+    getFlag(name: string, user: User, defaultValue?: boolean): boolean;
     getConfig<T = unknown>(name: string, decode?: (raw: unknown) => T): T | undefined;
+    getConfig<T = unknown>(name: string, opts: GetConfigOptions<T>): T;
     getExperiment<P extends Record<string, unknown>>(name: string, user: User, defaultParams: P, decode?: (raw: unknown) => P): ExperimentResult<P>;
     track(userId: string, eventName: string, props?: Record<string, unknown>): void;
     /**
@@ -327,8 +473,10 @@ declare const flags: {
     initOnce(): Promise<void>;
     /** Stop background timers. Safe to call repeatedly. */
     destroy(): void;
-    get(name: string, user: User): boolean;
-    getConfig<T = unknown>(name: string, decode?: (raw: unknown) => T): T | undefined;
+    get(name: string, user: User, defaultValue?: boolean): boolean;
+    /** Evaluate a gate and report why (value + reason). See {@link FlagDetail}. */
+    getDetail(name: string, user: User): FlagDetail;
+    getConfig<T = unknown>(name: string, decodeOrOpts?: ((raw: unknown) => T) | GetConfigOptions<T>): T | undefined;
     getExperiment<P extends Record<string, unknown>>(name: string, user: User, defaultParams: P, decode?: (raw: unknown) => P): ExperimentResult<P>;
     /**
      * Read a killswitch. Without `switchKey`, returns true when the whole
@@ -367,20 +515,26 @@ interface SeeApi {
     /**
      * Report a non-exception problem. Prefer passing a caught Error to `see()`
      * when one exists. The name is a stable identifier (it participates in the
-     * issue fingerprint) — variable data goes in `.message()` or `.extras()`.
+     * issue fingerprint) — variable data goes in `.extras()`, never the name.
      *
      * ```ts
      * if (results.length > LIMIT) {
-     *   see.Violation("large query").causes_the("search results").to("be trimmed");
+     *   see.Violation("large query")
+     *      .causes_the("search results").to("be trimmed").extras({ rows: results.length });
      * }
      * ```
      */
     Violation(name: string): SeeViolationChain;
     /**
      * Mark an exception as expected control flow — documents the expectation and
-     * reports nothing. The reason must start with "because".
+     * reports nothing. Say why with `.because()` (reason should start with
+     * "because"); attach optional debug context with `.extras()`.
+     *
+     * ```ts
+     * see.ControlFlowException(e).because("because the metric may not exist yet");
+     * ```
      */
-    ControlFlowException(err: unknown, because: string): void;
+    ControlFlowException(err: unknown): SeeControlFlowChain;
 }
 /**
  * Structured error reporter — the whole grammar hangs off this one import.
@@ -389,4 +543,4 @@ interface SeeApi {
  */
 declare const see: SeeApi;
 
-export { ANON_ID_COOKIE, type BootstrapHtmlOptions, type BootstrapPayload, type Consequence, type ExperimentResult, type FetchLabelsOptions, FlagsClient, type FlagsClientEnv, type FlagsClientOptions, type I18nForRequest, type LabelFile, type SeeApi, type SeeChain, type SeeErrorEvent, type SeeExtras, type SeeKind, type SeeViolationChain, type ShipeasyServerConfig, type ShipeasyServerHandle, type User, type Violation, _resetShipeasyServerForTests, configureShipeasyServer, fetchLabelsForSSR, flags, getBootstrapHtml, getShipeasyServerClient, i18n, isExpected, see, seeContext, shipeasy, version };
+export { ANON_ID_COOKIE, type BootstrapHtmlOptions, type BootstrapPayload, type Consequence, type ExperimentResult, type ExpsBlob, FLAG_REASONS, type FetchLabelsOptions, type FlagDetail, type FlagReason, type FlagsBlob, FlagsClient, type FlagsClientEnv, type FlagsClientOptions, type GetConfigOptions, type I18nForRequest, type LabelFile, type SeeApi, type SeeChain, type SeeControlFlowChain, type SeeErrorEvent, type SeeExtras, type SeeKind, type SeeViolationChain, type ShipeasyServerConfig, type ShipeasyServerHandle, type User, type Violation, _murmur3ForTests, _resetShipeasyServerForTests, configureShipeasyServer, fetchLabelsForSSR, flags, getBootstrapHtml, getShipeasyServerClient, i18n, isExpected, see, seeContext, shipeasy, version };