td-feature-node 0.0.0-stage → 0.0.2

package/dist/report/thinking-data-adapter.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThinkingDataAdapter = void 0;
+exports.createThinkingDataAdapter = createThinkingDataAdapter;
+/** Converts SDK-owned exposure fields to the official Node track({ ... }) API. */
+class ThinkingDataAdapter {
+    constructor(analytics) {
+        this.analytics = analytics;
+        if (!analytics ||
+            typeof analytics.track !== 'function' ||
+            typeof analytics.flush !== 'function' ||
+            typeof analytics.close !== 'function') {
+            throw new Error('A ThinkingData track/flush/close instance is required');
+        }
+    }
+    track(event, onFailure) {
+        let calling = true;
+        let localError;
+        const params = {
+            event: event.event,
+            properties: event.properties,
+            callback(error) {
+                if (!error)
+                    return;
+                if (calling)
+                    localError = error;
+                else if (onFailure)
+                    onFailure(error);
+            },
+        };
+        if (event.accountId !== null)
+            params.accountId = event.accountId;
+        if (event.distinctId !== null)
+            params.distinctId = event.distinctId;
+        // Native track returns after buffering. Batch callbacks are not per-event
+        // acknowledgements, so waiting for one here would prevent batching.
+        const result = this.analytics.track(params);
+        calling = false;
+        if (localError)
+            throw localError;
+        return result;
+    }
+    flush() {
+        return this.analytics.flush();
+    }
+    close() {
+        return this.analytics.close();
+    }
+}
+exports.ThinkingDataAdapter = ThinkingDataAdapter;
+/** Adapt an existing collection SDK instance; its lifecycle stays caller-owned. */
+function createThinkingDataAdapter(analytics) {
+    return new ThinkingDataAdapter(analytics);
+}

package/dist/types.d.ts

@@ -0,0 +1,134 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | JsonObject;
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export interface FeatureRequest {
+    readonly accountId?: string | null;
+    readonly distinctId?: string | null;
+    readonly featureKeys?: ReadonlyArray<string> | null;
+    readonly customParams?: JsonObject | null;
+}
+export interface ExperimentInfo {
+    readonly experimentId: string | null;
+    readonly experimentGroupId: string | null;
+    readonly isControlGroup: boolean;
+    readonly bucketId: Readonly<{
+        [key: string]: string | null;
+    }> | null;
+    readonly featureList: ReadonlyArray<string | null> | null;
+    /** Optional metadata, emitted only when present; remote parsing does not invent it. */
+    readonly featureKey?: string | null;
+    readonly featureVersion?: string | null;
+    readonly splitMode?: string | null;
+    readonly assignmentSource?: string | null;
+}
+/** Structural subset of the native AbortSignal. */
+export interface AbortSignalLike {
+    readonly aborted: boolean;
+    addEventListener(type: 'abort', listener: () => void): void;
+    removeEventListener(type: 'abort', listener: () => void): void;
+}
+export interface FetchOptions {
+    readonly signal?: AbortSignalLike;
+}
+export type ExposureValue = null | boolean | number | string | Date | ExposureValue[] | ExposureProperties;
+export interface ExposureProperties {
+    [key: string]: ExposureValue;
+}
+export interface ExposureEvent {
+    readonly accountId: string | null;
+    readonly distinctId: string | null;
+    readonly event: 'te_experiment_exposure';
+    readonly properties: ExposureProperties;
+}
+export type ExposureSubmission = void | boolean | PromiseLike<void | boolean>;
+/** Injected adapters remain caller-owned. Promise completion means submission, not ingestion. */
+export interface ExposureAdapter {
+    track(event: ExposureEvent, onFailure?: (error: Error) => void): ExposureSubmission;
+    flush(): void | PromiseLike<void>;
+    close?(): void | PromiseLike<void>;
+}
+export interface ThinkingDataTrackEvent {
+    accountId?: string;
+    distinctId?: string;
+    event: string;
+    properties: ExposureProperties;
+    callback?: (error?: Error | null) => void;
+}
+/** Structural API of the official Node collection SDK. */
+export interface ThinkingDataAnalytics {
+    track(event: ThinkingDataTrackEvent): ExposureSubmission;
+    flush(callback?: (error?: Error | null) => void): void | PromiseLike<void>;
+    close(): void | PromiseLike<void>;
+}
+/** Evaluation mode identifiers. LOCAL is reserved for a later implementation. */
+export declare const SplitMode: Readonly<{
+    readonly REMOTE: "REMOTE";
+    /** Reserved; selecting LOCAL currently fails during initialization. */
+    readonly LOCAL: "LOCAL";
+}>;
+export type SplitMode = (typeof SplitMode)[keyof typeof SplitMode];
+/** Client options. Durations are in milliseconds; sizes are bytes. */
+export interface ClientOptions {
+    readonly appId: string;
+    /** Shared HTTP(S) base URL for RCC and SDK-owned collection. RCC preserves path prefixes. */
+    readonly serverUrl: string;
+    /** Evaluation mode selected at initialization. Defaults to REMOTE; LOCAL is not implemented. */
+    readonly splitMode?: SplitMode;
+    readonly timeout?: number;
+    readonly maxHttpConnections?: number;
+    readonly maxDecompressedResponseBytes?: number;
+    /** Extra HTTP attempts; defaults to zero (automatic retries disabled). */
+    readonly retryTimes?: number;
+    readonly retryInterval?: number;
+    readonly retryStrategy?: 'FIXED_INTERVAL' | 'EXPONENTIAL_BACKOFF';
+    readonly retryJitter?: boolean;
+    /** Retry wait limit in milliseconds; a longer Retry-After stops retries. */
+    readonly maxRetryInterval?: number;
+    /** Active fetch pipelines, including retry backoff and RCC decoding. */
+    readonly maxConcurrentRequests?: number;
+    /** Waiting fetch capacity; defaults to zero. Unavailable slots reject QUEUE_FULL. */
+    readonly maxQueueSize?: number;
+    readonly enableCache?: boolean;
+    /** Fallback TTL in seconds when RCC returns a non-positive TTL, as in Java. */
+    readonly cacheExpireTime?: number;
+    readonly maxCacheSize?: number;
+    readonly autoExposure?: boolean;
+    readonly exposureDedupMaxSize?: number;
+    readonly exposureDedupExpireSeconds?: number;
+    readonly exposureQueueCapacity?: number;
+    /** SDK-owned collector batch threshold; caller-owned instances keep their own settings. */
+    readonly exposureBatchSize?: number;
+    /** Maximum buffering time for a partial SDK-owned batch, in milliseconds. */
+    readonly exposureFlushIntervalMillis?: number;
+    readonly exposureFlushTimeoutMillis?: number;
+    /** Caller-owned adapter; mutually exclusive with tdAnalytics. */
+    readonly exposureAdapter?: ExposureAdapter;
+    /** Caller-owned official Batch/AsyncBatch/Debug instance. */
+    readonly tdAnalytics?: ThinkingDataAnalytics;
+    /** Explicit PEM CA trust list for RCC/owned collection HTTPS; replaces default roots. */
+    readonly tlsCa?: string | ReadonlyArray<string>;
+}
+export interface ResolvedClientOptions extends ClientOptions {
+    readonly splitMode: SplitMode;
+    readonly timeout: number;
+    readonly maxHttpConnections: number;
+    readonly maxDecompressedResponseBytes: number;
+    readonly retryTimes: number;
+    readonly retryInterval: number;
+    readonly retryStrategy: 'FIXED_INTERVAL' | 'EXPONENTIAL_BACKOFF';
+    readonly retryJitter: boolean;
+    readonly maxRetryInterval: number;
+    readonly maxConcurrentRequests: number;
+    readonly maxQueueSize: number;
+    readonly enableCache: boolean;
+    readonly cacheExpireTime: number;
+    readonly maxCacheSize: number;
+    readonly autoExposure: boolean;
+    readonly exposureDedupMaxSize: number;
+    readonly exposureDedupExpireSeconds: number;
+    readonly exposureQueueCapacity: number;
+    readonly exposureBatchSize: number;
+    readonly exposureFlushIntervalMillis: number;
+    readonly exposureFlushTimeoutMillis: number;
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SplitMode = void 0;
+/** Evaluation mode identifiers. LOCAL is reserved for a later implementation. */
+exports.SplitMode = Object.freeze({
+    REMOTE: 'REMOTE',
+    /** Reserved; selecting LOCAL currently fails during initialization. */
+    LOCAL: 'LOCAL',
+});