td-feature-node 0.0.0-stage → 0.0.2

package/dist/common/json.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = isObject;
+exports.stringValue = stringValue;
+exports.freezeJson = freezeJson;
+exports.snapshotJson = snapshotJson;
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function stringValue(value) {
+    if (value === null || value === undefined)
+        return null;
+    return typeof value === 'object' ? JSON.stringify(value) : String(value);
+}
+// Only values recursively copied and frozen here may be reused. Object.isFrozen
+// alone cannot prove that an externally supplied object's children are immutable.
+const frozenJson = new WeakSet();
+/** Freeze a detached JSON copy once, then reuse SDK-owned immutable values. */
+function freezeJson(value) {
+    if (value !== null && typeof value === 'object' && frozenJson.has(value))
+        return value;
+    if (Array.isArray(value)) {
+        const result = Object.freeze(value.map(freezeJson));
+        frozenJson.add(result);
+        return result;
+    }
+    if (isObject(value)) {
+        const result = {};
+        Object.keys(value).forEach(function (key) {
+            Object.defineProperty(result, key, { value: freezeJson(value[key]), enumerable: true });
+        });
+        Object.freeze(result);
+        frozenJson.add(result);
+        return result;
+    }
+    return value;
+}
+/** Snapshot a caller's JSON data without invoking toJSON hooks or losing reserved keys. */
+function snapshotJson(value, ancestors = []) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number' && isFinite(value))
+        return value;
+    if (typeof value !== 'object' || ancestors.indexOf(value) >= 0)
+        throw new Error('Expected acyclic JSON values');
+    const next = ancestors.concat([value]);
+    if (Array.isArray(value))
+        return value.map(function (item) {
+            return snapshotJson(item, next);
+        });
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== null && prototype !== Object.prototype)
+        throw new Error('Expected a JSON object');
+    const result = Object.create(null);
+    Object.keys(value).forEach(function (key) {
+        result[key] = snapshotJson(value[key], next);
+    });
+    return result;
+}

package/dist/core/config-snapshot.d.ts

@@ -0,0 +1,15 @@
+import { Evaluation } from '../evaluation';
+import { Feature } from '../feature';
+import type { ExperimentInfo, JsonValue } from '../types';
+export interface FeatureSnapshot {
+    readonly key: string;
+    readonly value: JsonValue;
+    readonly experimentInfo: ExperimentInfo | null;
+}
+export interface ConfigSnapshot {
+    readonly features: ReadonlyArray<FeatureSnapshot>;
+    readonly expirationPeriod: number;
+}
+export declare function makeSnapshot(features: FeatureSnapshot[], expirationPeriod: number): ConfigSnapshot;
+/** Fresh results/context on every call; experiment copies are shared within one result. */
+export declare function bindSnapshot(snapshot: ConfigSnapshot, accountId: string | null, distinctId: string | null, automaticExposure?: (feature: Feature) => void): Evaluation;

package/dist/core/config-snapshot.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSnapshot = makeSnapshot;
+exports.bindSnapshot = bindSnapshot;
+const evaluation_1 = require("../evaluation");
+const feature_1 = require("../feature");
+const json_1 = require("../common/json");
+function makeSnapshot(features, expirationPeriod) {
+    const entries = features.map(function (feature) {
+        return Object.freeze({ ...feature, value: (0, json_1.freezeJson)(feature.value) });
+    });
+    return Object.freeze({ features: Object.freeze(entries), expirationPeriod });
+}
+function copyInfo(info) {
+    const bucket = info.bucketId
+        ? Object.create(null)
+        : null;
+    if (bucket)
+        Object.keys(info.bucketId).forEach(function (key) {
+            bucket[key] = info.bucketId[key];
+        });
+    return Object.freeze({
+        experimentId: info.experimentId,
+        experimentGroupId: info.experimentGroupId,
+        isControlGroup: info.isControlGroup,
+        bucketId: bucket ? Object.freeze(bucket) : null,
+        featureList: info.featureList ? Object.freeze(info.featureList.slice()) : null,
+        featureKey: info.featureKey,
+        featureVersion: info.featureVersion,
+        splitMode: info.splitMode,
+        assignmentSource: info.assignmentSource,
+    });
+}
+/** Fresh results/context on every call; experiment copies are shared within one result. */
+function bindSnapshot(snapshot, accountId, distinctId, automaticExposure) {
+    // An experiment may cover many features. Copy its full feature list only once
+    // per evaluation, without retaining metadata or read state across fetches.
+    const experiments = new Map();
+    return (0, evaluation_1.createEvaluation)(snapshot.features.map(function (feature) {
+        const source = feature.experimentInfo;
+        let experiment = null;
+        if (source) {
+            experiment = experiments.get(source) || null;
+            if (!experiment) {
+                experiment = copyInfo(source);
+                experiments.set(source, experiment);
+            }
+        }
+        return (0, feature_1.createFeature)({
+            key: feature.key,
+            value: feature.value,
+            accountId,
+            distinctId,
+            experiment: experiment,
+            onRead: automaticExposure,
+        });
+    }), snapshot.expirationPeriod);
+}

package/dist/core/http-transport.d.ts

@@ -0,0 +1,13 @@
+import type { ResolvedClientOptions } from '../types';
+import { BuiltRequest } from './request';
+import { Operation } from './request-operation';
+export declare class HttpTransport {
+    private readonly config;
+    private readonly httpAgent;
+    private readonly httpsAgent;
+    private readonly active;
+    private closed;
+    constructor(config: Readonly<ResolvedClientOptions>);
+    send(built: BuiltRequest, operation: Operation): Promise<string>;
+    close(): void;
+}

package/dist/core/http-transport.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpTransport = void 0;
+const http = require("http");
+const https = require("https");
+const zlib = require("zlib");
+const errors_1 = require("../errors");
+const config_1 = require("../common/config");
+const request_1 = require("./request");
+const retry_1 = require("./retry");
+const stream_decoder_1 = require("./stream-decoder");
+class HttpTransport {
+    constructor(config) {
+        this.config = config;
+        this.active = new Set();
+        this.closed = false;
+        const options = {
+            keepAlive: true,
+            maxSockets: config.maxHttpConnections,
+            maxFreeSockets: config.maxHttpConnections,
+        };
+        this.httpAgent = new http.Agent(options);
+        this.httpsAgent = new https.Agent(Object.assign({}, options, { ca: config.tlsCa }));
+    }
+    send(built, operation) {
+        if (this.closed)
+            return Promise.reject(new errors_1.FeatureError('Client is closed', 'CLIENT_CLOSED'));
+        return new Promise((resolve, reject) => {
+            let request;
+            let response;
+            let decoder;
+            let settled = false;
+            let unsubscribe = function () { };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                // Already-closing native resources must not prevent promise settlement.
+                try {
+                    if (request)
+                        request.abort();
+                }
+                catch (_) { }
+                try {
+                    if (response)
+                        response.destroy();
+                }
+                catch (_) { }
+                try {
+                    if (decoder)
+                        decoder.stop();
+                }
+                catch (_) { }
+                reject(error);
+            };
+            operation.check();
+            const timer = setTimeout(() => fail(new errors_1.FeatureError('Remote request timed out', 'TIMEOUT')), this.config.timeout);
+            const cleanup = () => {
+                clearTimeout(timer);
+                unsubscribe();
+                this.active.delete(fail);
+            };
+            this.active.add(fail);
+            unsubscribe = operation.onCancel(fail);
+            if (settled)
+                return;
+            try {
+                const location = (0, config_1.requestLocation)(this.config.serverUrl);
+                const secure = location.protocol === 'https:';
+                const timestamp = Date.now();
+                request = (secure ? https : http).request({
+                    hostname: location.hostname,
+                    port: location.port || (secure ? 443 : 80),
+                    path: location.path,
+                    method: 'POST',
+                    agent: secure ? this.httpsAgent : this.httpAgent,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.byteLength(built.body, 'utf8'),
+                        appid: headerValue(this.config.appId),
+                        template_code: 'ta_feature',
+                        timestamp: String(timestamp),
+                        sign: (0, request_1.calculateSign)(timestamp, built.body),
+                        device_id: headerValue(built.deviceId),
+                    },
+                }, (incoming) => {
+                    response = incoming;
+                    let rawEnded = false;
+                    let decodedBytes = 0;
+                    const chunks = [];
+                    incoming.on('error', (error) => fail(new errors_1.FeatureError('Response stream failed', 'NETWORK_ERROR', { cause: error })));
+                    incoming.on('aborted', () => fail(new errors_1.FeatureError('Remote response was aborted', 'NETWORK_ERROR')));
+                    incoming.on('end', () => {
+                        rawEnded = true;
+                    });
+                    incoming.on('close', () => {
+                        if (!rawEnded)
+                            fail(new errors_1.FeatureError('Remote response ended prematurely', 'NETWORK_ERROR'));
+                    });
+                    const encoding = String(incoming.headers['content-encoding'] || 'identity').toLowerCase();
+                    let stream = incoming;
+                    if (encoding === 'gzip' || encoding === 'deflate') {
+                        decoder = new stream_decoder_1.Decoder(encoding === 'gzip' ? zlib.createGunzip() : zlib.createInflate());
+                        decoder.stream.on('error', (error) => fail(new errors_1.FeatureError('Invalid HTTP compression', 'INVALID_RESPONSE', { cause: error })));
+                        stream = decoder.stream;
+                        incoming.on('data', (chunk) => {
+                            if (settled)
+                                return;
+                            incoming.pause();
+                            decoder.feed(chunk, () => {
+                                if (!settled)
+                                    incoming.resume();
+                            });
+                        });
+                        incoming.on('end', () => {
+                            if (!settled)
+                                decoder.end();
+                        });
+                    }
+                    else if (encoding !== 'identity') {
+                        fail(new errors_1.FeatureError('Unsupported HTTP content encoding: ' + encoding, 'INVALID_RESPONSE'));
+                        return;
+                    }
+                    stream.on('data', (chunk) => {
+                        if (settled)
+                            return;
+                        decodedBytes += chunk.length;
+                        chunks.push(chunk);
+                    });
+                    stream.on('end', () => {
+                        if (settled)
+                            return;
+                        const status = incoming.statusCode || 0;
+                        if (status < 200 || status >= 300) {
+                            fail(new errors_1.FeatureError('Remote Config Center returned HTTP ' + status, 'HTTP_ERROR', {
+                                httpStatus: status,
+                                retryAfterMillis: (0, retry_1.parseRetryAfter)(incoming.headers['retry-after']),
+                            }));
+                            return;
+                        }
+                        try {
+                            const body = Buffer.concat(chunks, decodedBytes).toString('utf8');
+                            settled = true;
+                            cleanup();
+                            resolve(body);
+                        }
+                        catch (error) {
+                            fail(new errors_1.FeatureError('Failed to read remote response', 'INVALID_RESPONSE', {
+                                cause: error,
+                            }));
+                        }
+                    });
+                });
+                request.on('error', (error) => fail(new errors_1.FeatureError('Failed to call Remote Config Center', 'NETWORK_ERROR', {
+                    cause: error,
+                })));
+                // A Buffer keeps UTF-8 body bytes separate from Node's Latin-1 header encoding.
+                request.end(Buffer.from(built.body, 'utf8'));
+            }
+            catch (error) {
+                fail(new errors_1.FeatureError('Failed to create remote request', 'INVALID_REQUEST', {
+                    cause: error,
+                }));
+            }
+        });
+    }
+    close() {
+        this.closed = true;
+        Array.from(this.active).forEach(function (fail) {
+            fail(new errors_1.FeatureError('Client is closed', 'CLIENT_CLOSED'));
+        });
+        this.httpAgent.destroy();
+        this.httpsAgent.destroy();
+    }
+}
+exports.HttpTransport = HttpTransport;
+/** Apache's default header encoder is ISO-8859-1; verified by Java wire fixtures. */
+function headerValue(value) {
+    return value.replace(/[^\x00-\xff]/g, '?');
+}

package/dist/core/request-operation.d.ts

@@ -0,0 +1,16 @@
+import type { AbortSignalLike } from '../types';
+import { FeatureError } from '../errors';
+export declare function monotonicNow(): number;
+/** One caller's cancellation scope, shared by every stage of its fetch. */
+export declare class Operation {
+    private readonly signal?;
+    private readonly listeners;
+    private readonly abortListener;
+    private reason;
+    constructor(signal?: AbortSignalLike | undefined);
+    check(): void;
+    cancel(error: FeatureError): void;
+    onCancel(listener: (error: FeatureError) => void): () => void;
+    sleep(milliseconds: number): Promise<void>;
+    dispose(): void;
+}

package/dist/core/request-operation.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operation = void 0;
+exports.monotonicNow = monotonicNow;
+const errors_1 = require("../errors");
+function monotonicNow() {
+    const time = process.hrtime();
+    return time[0] * 1000 + time[1] / 1000000;
+}
+/** One caller's cancellation scope, shared by every stage of its fetch. */
+class Operation {
+    constructor(signal) {
+        this.signal = signal;
+        this.listeners = new Set();
+        this.abortListener = () => this.cancel(new errors_1.FeatureError('Fetch was aborted by its caller', 'ABORTED'));
+        if (signal) {
+            signal.addEventListener('abort', this.abortListener);
+            if (signal.aborted)
+                this.abortListener();
+        }
+    }
+    check() {
+        if (this.reason)
+            throw this.reason;
+    }
+    cancel(error) {
+        if (this.reason)
+            return;
+        this.reason = error;
+        const callbacks = Array.from(this.listeners);
+        this.listeners.clear();
+        callbacks.forEach(function (callback) {
+            callback(error);
+        });
+    }
+    onCancel(listener) {
+        if (this.reason) {
+            listener(this.reason);
+            return function () { };
+        }
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    sleep(milliseconds) {
+        return new Promise((resolve, reject) => {
+            this.check();
+            let unsubscribe = function () { };
+            const timer = setTimeout(() => {
+                unsubscribe();
+                try {
+                    this.check();
+                    resolve();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }, Math.max(0, Math.ceil(milliseconds)));
+            unsubscribe = this.onCancel((error) => {
+                clearTimeout(timer);
+                unsubscribe();
+                reject(error);
+            });
+        });
+    }
+    dispose() {
+        if (this.signal)
+            this.signal.removeEventListener('abort', this.abortListener);
+        this.listeners.clear();
+    }
+}
+exports.Operation = Operation;

package/dist/core/request-scheduler.d.ts

@@ -0,0 +1,16 @@
+import { Operation } from './request-operation';
+/** FIFO admission; an active job keeps its slot through decoding and retry backoff. */
+export declare class Scheduler {
+    private readonly concurrency;
+    private readonly capacity;
+    private active;
+    private waiting;
+    private head;
+    private tail;
+    private closed;
+    constructor(concurrency: number, capacity: number);
+    submit<T>(operation: Operation, run: () => Promise<T>): Promise<T>;
+    private remove;
+    private pump;
+    close(): void;
+}

package/dist/core/request-scheduler.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+const errors_1 = require("../errors");
+/** FIFO admission; an active job keeps its slot through decoding and retry backoff. */
+class Scheduler {
+    constructor(concurrency, capacity) {
+        this.concurrency = concurrency;
+        this.capacity = capacity;
+        this.active = 0;
+        this.waiting = 0;
+        this.head = null;
+        this.tail = null;
+        this.closed = false;
+    }
+    submit(operation, run) {
+        operation.check();
+        if (this.closed)
+            throw new errors_1.FeatureError('Client is closed', 'CLIENT_CLOSED');
+        if ((this.active >= this.concurrency || this.head) && this.waiting >= this.capacity) {
+            throw new errors_1.FeatureError('Fetch waiting queue is full', 'QUEUE_FULL');
+        }
+        return new Promise((resolve, reject) => {
+            const job = {
+                operation: operation,
+                reject: reject,
+                queued: false,
+                previous: null,
+                next: null,
+                unsubscribe: function () { },
+                start: () => {
+                    job.unsubscribe();
+                    this.active++;
+                    Promise.resolve()
+                        .then(() => {
+                        operation.check();
+                        return run();
+                    })
+                        .then((value) => {
+                        this.active--;
+                        resolve(value);
+                        this.pump();
+                    }, (error) => {
+                        this.active--;
+                        reject(error);
+                        this.pump();
+                    });
+                },
+            };
+            if (this.active < this.concurrency && !this.head) {
+                job.start();
+                return;
+            }
+            job.queued = true;
+            job.previous = this.tail;
+            if (this.tail)
+                this.tail.next = job;
+            else
+                this.head = job;
+            this.tail = job;
+            this.waiting++;
+            job.unsubscribe = operation.onCancel((error) => {
+                if (!job.queued)
+                    return;
+                this.remove(job);
+                job.unsubscribe();
+                reject(error);
+                this.pump();
+            });
+            this.pump();
+        });
+    }
+    remove(job) {
+        if (job.previous)
+            job.previous.next = job.next;
+        else
+            this.head = job.next;
+        if (job.next)
+            job.next.previous = job.previous;
+        else
+            this.tail = job.previous;
+        job.previous = null;
+        job.next = null;
+        job.queued = false;
+        this.waiting--;
+    }
+    pump() {
+        while (!this.closed && this.active < this.concurrency && this.head) {
+            const job = this.head;
+            this.remove(job);
+            job.unsubscribe();
+            try {
+                job.operation.check();
+                job.start();
+            }
+            catch (error) {
+                job.reject(error);
+            }
+        }
+    }
+    close() {
+        this.closed = true;
+        while (this.head) {
+            const job = this.head;
+            this.remove(job);
+            job.unsubscribe();
+            job.reject(new errors_1.FeatureError('Client is closed', 'CLIENT_CLOSED'));
+        }
+    }
+}
+exports.Scheduler = Scheduler;

package/dist/core/request.d.ts

@@ -0,0 +1,10 @@
+import type { FeatureRequest } from '../types';
+export declare const RCC_SIGN_KEY = "thinkingdata-remote-config";
+export interface BuiltRequest {
+    body: string;
+    accountId: string | null;
+    distinctId: string | null;
+    deviceId: string;
+}
+export declare function calculateSign(timestamp: number | string, body: string): string;
+export declare function buildRequest(appId: string, request: FeatureRequest): BuiltRequest;

package/dist/core/request.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RCC_SIGN_KEY = void 0;
+exports.calculateSign = calculateSign;
+exports.buildRequest = buildRequest;
+const crypto_1 = require("crypto");
+const json_1 = require("../common/json");
+const errors_1 = require("../errors");
+exports.RCC_SIGN_KEY = 'thinkingdata-remote-config';
+function calculateSign(timestamp, body) {
+    return (0, crypto_1.createHash)('sha256')
+        .update(String(timestamp) + body + exports.RCC_SIGN_KEY, 'utf8')
+        .digest('base64');
+}
+function buildRequest(appId, request) {
+    try {
+        if (!request || typeof request !== 'object' || Array.isArray(request))
+            throw new Error('FeatureRequest is required');
+        const accountId = request.accountId === undefined ? null : request.accountId;
+        const distinctId = request.distinctId === undefined ? null : request.distinctId;
+        [accountId, distinctId].forEach(function (id) {
+            if (id !== null && typeof id !== 'string')
+                throw new Error('Identifiers must be strings');
+            if (id !== null && /[\x00-\x1f\x7f]/.test(id))
+                throw new Error('Identifiers cannot contain control characters');
+        });
+        if (!accountId && !distinctId)
+            throw new Error('accountId or distinctId is required');
+        const custom = request.customParams;
+        if (custom !== undefined &&
+            custom !== null &&
+            (typeof custom !== 'object' || Array.isArray(custom))) {
+            throw new Error('customParams must be a JSON object');
+        }
+        const params = custom == null ? Object.create(null) : (0, json_1.snapshotJson)(custom);
+        params['#account_id'] = accountId;
+        params['#distinct_id'] = distinctId;
+        if (accountId === null)
+            delete params['#account_id'];
+        if (distinctId === null)
+            delete params['#distinct_id'];
+        params['#lib'] = 'node';
+        if (request.featureKeys !== undefined &&
+            request.featureKeys !== null &&
+            !Array.isArray(request.featureKeys)) {
+            throw new Error('featureKeys must be an array');
+        }
+        if (request.featureKeys && request.featureKeys.length) {
+            params['#feature_key'] = request.featureKeys.map(function (key) {
+                if (typeof key !== 'string')
+                    throw new Error('Feature keys must be strings');
+                return key;
+            });
+        }
+        else
+            delete params['#feature_key'];
+        const body = JSON.stringify({
+            appid: appId,
+            template_code: 'ta_feature',
+            request_params: params,
+        });
+        return {
+            body: body,
+            accountId: accountId,
+            distinctId: distinctId,
+            deviceId: accountId || distinctId,
+        };
+    }
+    catch (error) {
+        throw new errors_1.FeatureError(error.message, 'INVALID_REQUEST', { cause: error });
+    }
+}

package/dist/core/response.d.ts

@@ -0,0 +1,5 @@
+import { Evaluation } from '../evaluation';
+import { ConfigSnapshot } from './config-snapshot';
+import { Operation } from './request-operation';
+export declare function parseResponse(text: string, limit: number, accountId: string | null, distinctId: string | null): Promise<Evaluation>;
+export declare function parseSnapshot(text: string, limit: number, operation?: Operation): Promise<ConfigSnapshot>;