@oai-statsig/statsig-node-core 0.19.5-beta.2604230102

package/additional_types.d.ts

@@ -0,0 +1,15 @@
+import { SecondaryExposure } from './statsig-generated';
+export type StickyValues = {
+    value: boolean;
+    json_value: Record<string, unknown>;
+    rule_id: string;
+    group_name: string | null;
+    secondary_exposures: SecondaryExposure[];
+    undelegated_secondary_exposures: SecondaryExposure[];
+    config_delegate: string | null;
+    explicit_parameters: string[] | null;
+    time: number;
+    configVersion?: number | undefined;
+};
+export type UserPersistedValues = Record<string, StickyValues>;
+export type SdkEvent = '*' | 'gate_evaluated' | 'dynamic_config_evaluated' | 'experiment_evaluated' | 'layer_evaluated' | 'specs_updated';

package/additional_types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/console_captrue_utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Utility functions for console capture payload parsing and processing
+ */
+export declare function safeStringify(val: unknown, maxKeysCount: number, maxDepth: number, maxLength: number): string;
+export declare function shouldNotStringify(val: object, maxKeysCount: number, maxDepth: number): boolean;
+export declare function isPlainObject(obj: unknown): boolean;
+export declare function isObjectTooDeep(obj: unknown, maxDepth: number, seen?: WeakSet<object>): boolean;
+export declare function getStackTrace(): string | null;
+export declare function truncateString(str: string, maxLength: number): string;
+export declare function simpleStringify(val: object, maxLength: number): string;
+export declare function wrapFunctionWithRestore(targetObject: Record<string, unknown>, functionName: string, wrapperFactory: (original: (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown): () => void;

package/console_captrue_utils.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Utility functions for console capture payload parsing and processing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeStringify = safeStringify;
+exports.shouldNotStringify = shouldNotStringify;
+exports.isPlainObject = isPlainObject;
+exports.isObjectTooDeep = isObjectTooDeep;
+exports.getStackTrace = getStackTrace;
+exports.truncateString = truncateString;
+exports.simpleStringify = simpleStringify;
+exports.wrapFunctionWithRestore = wrapFunctionWithRestore;
+function safeStringify(val, maxKeysCount, maxDepth, maxLength) {
+    try {
+        if (shouldNotStringify(val, maxKeysCount, maxDepth)) {
+            return simpleStringify(val, maxLength);
+        }
+        if (typeof val === 'string') {
+            return truncateString(val, maxLength);
+        }
+        if (typeof val === 'object' && val !== null) {
+            return truncateString(JSON.stringify(val), maxLength);
+        }
+        return truncateString(String(val), maxLength);
+    }
+    catch (_a) {
+        return truncateString('[Unserializable]', maxLength);
+    }
+}
+function shouldNotStringify(val, maxKeysCount, maxDepth) {
+    if (isPlainObject(val)) {
+        if (Object.keys(val).length > maxKeysCount) {
+            return true;
+        }
+        if (isObjectTooDeep(val, maxDepth)) {
+            return true;
+        }
+        return false;
+    }
+    if (typeof val === 'function') {
+        return true;
+    }
+    return false;
+}
+function isPlainObject(obj) {
+    return Object.prototype.toString.call(obj) === '[object Object]';
+}
+function isObjectTooDeep(obj, maxDepth, seen = new WeakSet()) {
+    if (maxDepth <= 0) {
+        return true;
+    }
+    if (typeof obj !== 'object' || obj === null) {
+        return false; // primitives are never "too deep"
+    }
+    if (seen.has(obj)) {
+        return false; // cycle detected
+    }
+    seen.add(obj);
+    return Object.values(obj).some((value) => isObjectTooDeep(value, maxDepth - 1, seen));
+}
+function getStackTrace() {
+    const stack = new Error().stack;
+    return stack ? stack.split('\n').slice(2, 5).join('\n') : null;
+}
+function truncateString(str, maxLength) {
+    if (str.length <= maxLength) {
+        return str;
+    }
+    return str.slice(0, maxLength) + '...';
+}
+function simpleStringify(val, maxLength) {
+    return truncateString(val.toString(), maxLength);
+}
+function wrapFunctionWithRestore(targetObject, functionName, wrapperFactory) {
+    const originalFunction = targetObject[functionName];
+    if (typeof originalFunction !== 'function') {
+        return () => {
+            // noop
+        };
+    }
+    try {
+        const wrappedFunction = wrapperFactory(originalFunction);
+        Object.defineProperty(wrappedFunction, '__statsig_original__', {
+            enumerable: false,
+            value: originalFunction,
+        });
+        targetObject[functionName] = wrappedFunction;
+        // Restore function
+        return () => {
+            targetObject[functionName] = originalFunction;
+        };
+    }
+    catch (_a) {
+        return () => {
+            // noop
+        };
+    }
+}

package/console_capture.d.ts

@@ -0,0 +1,3 @@
+import { ConsoleCaptureOptions } from './statsig-generated';
+export declare function startStatsigConsoleCapture(sdkKey: string, options?: ConsoleCaptureOptions): void;
+export declare function stopStatsigConsoleCapture(): void;

package/console_capture.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStatsigConsoleCapture = startStatsigConsoleCapture;
+exports.stopStatsigConsoleCapture = stopStatsigConsoleCapture;
+const console_captrue_utils_1 = require("./console_captrue_utils");
+const _1 = require(".");
+const CAPTURE_LEVELS = [
+    'log',
+    'warn',
+    'error',
+    'debug',
+    'info',
+    'trace',
+];
+const originalConsoleFns = {};
+const originalConsoleErrorFn = typeof console !== 'undefined' ? console.error : undefined;
+const MAX_KEYS = 100;
+const MAX_DEPTH = 10;
+const MAX_LENGTH = 4096;
+function captureLog(level, args, sdkKey, maxKeys, maxDepth, maxLength) {
+    const message = args.map((a) => (0, console_captrue_utils_1.safeStringify)(a, maxKeys, maxDepth, maxLength));
+    if (level.toLowerCase() === 'error' &&
+        typeof args[0] === 'string' &&
+        args[0].startsWith('Trace')) {
+        level = 'trace'; // node use error for console.trace
+    }
+    const stackTrace = (0, console_captrue_utils_1.getStackTrace)();
+    (0, _1.statsigCaptureLogLine)(level, message, sdkKey, stackTrace);
+}
+function startStatsigConsoleCapture(sdkKey, options) {
+    stopStatsigConsoleCapture();
+    for (const level of CAPTURE_LEVELS) {
+        const originalFn = console[level];
+        if (!originalFn || typeof originalFn !== 'function') {
+            continue;
+        }
+        let isCapturing = false;
+        const restoreFn = (0, console_captrue_utils_1.wrapFunctionWithRestore)(console, level, (originalFn) => {
+            return (...args) => {
+                var _a, _b, _c;
+                originalFn(...args);
+                if (isCapturing)
+                    return;
+                isCapturing = true;
+                const maxKeys = Math.min((_a = options === null || options === void 0 ? void 0 : options.maxKeys) !== null && _a !== void 0 ? _a : MAX_KEYS, MAX_KEYS);
+                const maxDepth = Math.min((_b = options === null || options === void 0 ? void 0 : options.maxDepth) !== null && _b !== void 0 ? _b : MAX_DEPTH, MAX_DEPTH);
+                const maxLength = Math.min((_c = options === null || options === void 0 ? void 0 : options.maxLength) !== null && _c !== void 0 ? _c : MAX_LENGTH, MAX_LENGTH);
+                try {
+                    captureLog(level, args, sdkKey, maxKeys, maxDepth, maxLength);
+                }
+                catch (err) {
+                    if (originalConsoleErrorFn &&
+                        typeof originalConsoleErrorFn === 'function') {
+                        originalConsoleErrorFn('Statsig log capture failed:', err);
+                    }
+                }
+                finally {
+                    isCapturing = false;
+                }
+            };
+        });
+        originalConsoleFns[level] = restoreFn;
+    }
+}
+function stopStatsigConsoleCapture() {
+    for (const level of CAPTURE_LEVELS) {
+        const restoreFn = originalConsoleFns[level];
+        if (restoreFn && typeof restoreFn === 'function') {
+            restoreFn();
+            delete originalConsoleFns[level];
+        }
+    }
+    for (const key of Object.keys(originalConsoleFns)) {
+        delete originalConsoleFns[key];
+    }
+}

package/error_boundary.d.ts

@@ -0,0 +1,5 @@
+export declare class ErrorBoundary {
+    static wrap(instance: unknown): void;
+    private static _capture;
+    private static _onError;
+}

package/error_boundary.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorBoundary = void 0;
+class ErrorBoundary {
+    static wrap(instance) {
+        try {
+            const obj = instance;
+            _getAllInstanceMethodNames(obj).forEach((name) => {
+                const original = obj[name];
+                if ('$EB' in original) {
+                    return;
+                }
+                obj[name] = (...args) => {
+                    return this._capture(name, () => original.apply(instance, args));
+                };
+                obj[name].$EB = true;
+            });
+        }
+        catch (err) {
+            this._onError('eb:wrap', err);
+        }
+    }
+    static _capture(tag, task) {
+        try {
+            const res = task();
+            if (res && res instanceof Promise) {
+                return res.catch((err) => this._onError(tag, err));
+            }
+            return res;
+        }
+        catch (error) {
+            this._onError(tag, error);
+            return null;
+        }
+    }
+    static _onError(tag, error) {
+        _tryConvertInvalidArgError(error);
+        const printableTag = tag.replace('__INTERNAL_', '');
+        console.error('Statsig::' + printableTag, error);
+    }
+}
+exports.ErrorBoundary = ErrorBoundary;
+function _getAllInstanceMethodNames(instance) {
+    const names = new Set();
+    let proto = Object.getPrototypeOf(instance);
+    while (proto && proto !== Object.prototype) {
+        Object.getOwnPropertyNames(proto)
+            .filter((prop) => typeof (proto === null || proto === void 0 ? void 0 : proto[prop]) === 'function')
+            .forEach((name) => names.add(name));
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Array.from(names);
+}
+function _tryConvertInvalidArgError(error) {
+    if (typeof error !== 'object' || error === null) {
+        return;
+    }
+    if (!('code' in error) || error.code !== 'InvalidArg') {
+        return;
+    }
+    if (!('message' in error) || typeof error.message !== 'string') {
+        return;
+    }
+    if (error.message.startsWith('Failed to recover `StatsigUser` type from napi value')) {
+        error.message =
+            'Expected StatsigUser instance, plain javascript object is not supported. Please create a StatsigUser instance using `new StatsigUser(...)` instead.';
+        return;
+    }
+}

package/index.d.ts

@@ -0,0 +1,20 @@
+import { DynamicConfigEvaluationOptions, ExperimentEvaluationOptions, FeatureGateEvaluationOptions, LayerEvaluationOptions, SdkEvent, StatsigNapiInternal, StatsigOptions, StatsigResult, StatsigUser } from './statsig-generated';
+import { DynamicConfig, Experiment, FeatureGate, Layer } from './statsig_types';
+export * from './statsig-generated';
+export * from './statsig_types';
+export declare class Statsig extends StatsigNapiInternal {
+    private static _sharedInstance;
+    static shared(): Statsig;
+    static hasShared(): boolean;
+    static newShared(sdkKey: string, options?: StatsigOptions): Statsig;
+    static removeSharedInstance(): void;
+    constructor(sdkKey: string, options?: StatsigOptions);
+    stopConsoleCapture(): void;
+    shutdown(timeout_ms?: number): Promise<StatsigResult>;
+    subscribe(eventName: SdkEvent, callback: (event: any) => void): string;
+    getFeatureGate(user: StatsigUser, gateName: string, options?: FeatureGateEvaluationOptions): FeatureGate;
+    getDynamicConfig(user: StatsigUser, configName: string, options?: DynamicConfigEvaluationOptions): DynamicConfig;
+    getExperiment(user: StatsigUser, experimentName: string, options?: ExperimentEvaluationOptions): Experiment;
+    getExperimentByGroupName(experimentName: string, groupName: string): Experiment;
+    getLayer(user: StatsigUser, layerName: string, options?: LayerEvaluationOptions): Layer;
+}

package/index.js

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Statsig = void 0;
+const https_proxy_agent_1 = require("https-proxy-agent");
+const console_capture_1 = require("./console_capture");
+const error_boundary_1 = require("./error_boundary");
+const statsig_generated_1 = require("./statsig-generated");
+const statsig_types_1 = require("./statsig_types");
+__exportStar(require("./statsig-generated"), exports);
+__exportStar(require("./statsig_types"), exports);
+const inspectSym = Symbol.for('nodejs.util.inspect.custom');
+// @ts-expect-error - prototype assignment
+statsig_generated_1.StatsigUser.prototype[inspectSym] = function () {
+    return this.toJSON();
+};
+// @ts-expect-error - prototype assignment
+statsig_generated_1.ParameterStore.prototype[inspectSym] = function () {
+    return this.toJSON();
+};
+function createProxyAgent(options) {
+    const proxy = options === null || options === void 0 ? void 0 : options.proxyConfig;
+    if ((proxy === null || proxy === void 0 ? void 0 : proxy.proxyHost) && (proxy === null || proxy === void 0 ? void 0 : proxy.proxyProtocol)) {
+        const protocol = proxy.proxyProtocol;
+        const host = proxy.proxyHost;
+        const port = proxy.proxyPort ? `:${proxy.proxyPort}` : '';
+        const auth = proxy.proxyAuth ? `${proxy.proxyAuth}@` : '';
+        const proxyUrl = `${protocol}://${auth}${host}${port}`;
+        if (protocol === 'http' || protocol === 'https') {
+            return new https_proxy_agent_1.HttpsProxyAgent(proxyUrl);
+        }
+    }
+    return undefined; // node-fetch agent parameter takes in undefined type instead of null
+}
+class Statsig extends statsig_generated_1.StatsigNapiInternal {
+    static shared() {
+        if (!Statsig.hasShared()) {
+            console.warn('[Statsig] No shared instance has been created yet. Call newShared() before using it. Returning an invalid instance');
+            return _createErrorInstance();
+        }
+        return Statsig._sharedInstance;
+    }
+    static hasShared() {
+        return Statsig._sharedInstance !== null;
+    }
+    static newShared(sdkKey, options) {
+        if (Statsig.hasShared()) {
+            console.warn('[Statsig] Shared instance has been created, call removeSharedInstance() if you want to create another one. ' +
+                'Returning an invalid instance');
+            return _createErrorInstance();
+        }
+        Statsig._sharedInstance = new Statsig(sdkKey, options);
+        return Statsig._sharedInstance;
+    }
+    static removeSharedInstance() {
+        Statsig._sharedInstance = null;
+    }
+    constructor(sdkKey, options) {
+        var _a;
+        super(sdkKey, options);
+        error_boundary_1.ErrorBoundary.wrap(this);
+        if ((_a = options === null || options === void 0 ? void 0 : options.consoleCaptureOptions) === null || _a === void 0 ? void 0 : _a.enabled) {
+            (0, console_capture_1.startStatsigConsoleCapture)(sdkKey, options.consoleCaptureOptions);
+        }
+    }
+    stopConsoleCapture() {
+        (0, console_capture_1.stopStatsigConsoleCapture)();
+    }
+    shutdown(timeout_ms) {
+        const _super = Object.create(null, {
+            shutdown: { get: () => super.shutdown }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, console_capture_1.stopStatsigConsoleCapture)();
+            return _super.shutdown.call(this, timeout_ms);
+        });
+    }
+    subscribe(eventName, callback) {
+        return this.__INTERNAL_subscribe(eventName, (raw) => {
+            try {
+                callback(JSON.parse(raw));
+            }
+            catch (error) {
+                console.error(`[Statsig] Error parsing SDK Event: ${error}`);
+            }
+        });
+    }
+    getFeatureGate(user, gateName, options) {
+        const raw = this.__INTERNAL_getFeatureGate(user, gateName, options);
+        return new statsig_types_1.FeatureGate(gateName, raw);
+    }
+    getDynamicConfig(user, configName, options) {
+        const raw = this.__INTERNAL_getDynamicConfig(user, configName, options);
+        return new statsig_types_1.DynamicConfig(configName, raw);
+    }
+    getExperiment(user, experimentName, options) {
+        const raw = this.__INTERNAL_getExperiment(user, experimentName, options);
+        return new statsig_types_1.Experiment(experimentName, raw);
+    }
+    getExperimentByGroupName(experimentName, groupName) {
+        const raw = this.__INTERNAL_getExperimentByGroupName(experimentName, groupName);
+        return new statsig_types_1.Experiment(experimentName, raw);
+    }
+    getLayer(user, layerName, options) {
+        const raw = this.__INTERNAL_getLayer(user, layerName, options);
+        const exposure = raw.__exposure;
+        return new statsig_types_1.Layer((param) => {
+            if (exposure != null) {
+                this.__INTERNAL_logLayerParamExposure(exposure, param);
+            }
+        }, layerName, raw);
+    }
+}
+exports.Statsig = Statsig;
+Statsig._sharedInstance = null;
+function _createErrorInstance() {
+    let dummyInstance = new Statsig('INVALID-KEY');
+    dummyInstance.shutdown();
+    return dummyInstance;
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@oai-statsig/statsig-node-core",
+  "version": "0.19.5-beta.2604230102",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest --colors"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "repository": "https://github.com/statsig-io/statsig-server-core.git",
+  "dependencies": {
+    "@octokit/core": "^6",
+    "https-proxy-agent": "^7.0.6",
+    "node-fetch": "2.7.0"
+  },
+  "devDependencies": {
+    "@babel/helpers": "7.26.10",
+    "@napi-rs/cli": "3.0.0-alpha.65",
+    "@octokit/endpoint": "10.1.3",
+    "@octokit/plugin-paginate-rest": "11.4.1",
+    "@octokit/request": "9.2.1",
+    "@octokit/request-error": "6.1.7",
+    "@types/compression": "^1.7.5",
+    "@types/express": "^5.0.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.10",
+    "@types/node-fetch": "2.6.12",
+    "compression": "^1.7.5",
+    "express": "^4.21.2",
+    "form-data": "4.0.4",
+    "jest": "^29.7.0",
+    "jest-extended": "^7.0.0",
+    "on-headers": "1.1.0",
+    "tar-fs": "^2.1.4",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": ">= 6.14.2 < 7 || >= 8.11.2 < 9 || >= 9.11.0 < 10 || >= 10.0.0"
+  },
+  "napi": {
+    "binaryName": "statsig-node-core",
+    "targets": [
+      "aarch64-apple-darwin",
+      "aarch64-unknown-linux-gnu",
+      "aarch64-unknown-linux-musl",
+      "aarch64-pc-windows-msvc",
+      "i686-pc-windows-msvc",
+      "x86_64-apple-darwin",
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl"
+    ]
+  },
+  "pnpm": {
+    "overrides": {
+      "minimatch": "10.2.1"
+    }
+  },
+  "optionalDependencies": {
+    "@oai-statsig/statsig-node-core-linux-x64-musl": "0.19.5-beta.2604230102",
+    "@oai-statsig/statsig-node-core-linux-x64-gnu": "0.19.5-beta.2604230102",
+    "@oai-statsig/statsig-node-core-win32-x64-msvc": "0.19.5-beta.2604230102",
+    "@oai-statsig/statsig-node-core-darwin-x64": "0.19.5-beta.2604230102",
+    "@oai-statsig/statsig-node-core-win32-ia32-msvc": "0.19.5-beta.2604230102",
+    "@oai-statsig/statsig-node-core-linux-arm64-musl": "0.19.5-beta.2604230102",
+    "@oai-statsig/statsig-node-core-linux-arm64-gnu": "0.19.5-beta.2604230102",
+    "@oai-statsig/statsig-node-core-darwin-arm64": "0.19.5-beta.2604230102"
+  }
+}

package/patch-generated.js

@@ -0,0 +1,22 @@
+const fs = require('fs');
+const path = require('path');
+
+const GENERATED_FILE = 'src/lib/statsig-generated.d.ts';
+const FILES_TO_APPEND = ['src/lib/additional_types.ts'];
+const generatedFileFullPath = path.resolve(__dirname, '..', GENERATED_FILE);
+
+FILES_TO_APPEND.forEach((filePath) => {
+  const fullPath = path.resolve(__dirname, '..', filePath);
+  let header = `// ---- Manually defined typing section ----- \n`;
+  if (fs.existsSync(fullPath)) {
+    let content = fs.readFileSync(fullPath, 'utf8');
+    content = content.replace(
+      /^\s*import\s+.*?from\s+['"]\.\/statsig-generated['"];\s*$/gm,
+      '',
+    );
+    content = header + content;
+    fs.appendFileSync(generatedFileFullPath, content, 'utf8');
+  } else {
+    console.warn(`❌ File not found: ${filePath}`);
+  }
+});