@forge/feature-flags-node 2.1.9-next.0-experimental-44a932f → 3.0.0-next.1

package/CHANGELOG.md

@@ -1,10 +1,10 @@
 # @forge/feature-flags-node
 
-## 2.1.9-next.0-experimental-44a932f
+## 3.0.0-next.1
 
-### Patch Changes
+### Major Changes
 
-- @forge/api@7.0.1-next.0-experimental-44a932f
+- 4c1adf3: Rule evaluator implementation change
 
 ## 2.1.9-next.0
 

package/README.md

@@ -47,7 +47,6 @@ export const handler = async (payload, context) => {
     capabilitySetValue = "capabilityAdvanced";
   }
 
-
   // Initialize the feature flags SDK
   const featureFlags = new ForgeFeatureFlags();
   await featureFlags.initialize({
@@ -56,7 +55,7 @@ export const handler = async (payload, context) => {
 
   // Define a user with all possible attributes that will be used in the feature flag rules
   const user = {
-    identifiers:{
+    identifiers: {
       accountId: context?.principal?.accountId,
     },
     attributes: { 
@@ -71,11 +70,14 @@ export const handler = async (payload, context) => {
   // Check a feature flag (synchronous after initialization)
   const isEnabled = featureFlags.checkFlag(user, "new-feature");
 
-  // Get multiple flags at once (synchronous)
-  const flags = featureFlags.getFeatureFlags(user, ["feature-a", "feature-b"]);
+  // Check with a default value if flag doesn't exist
+  const isEnabledWithDefault = featureFlags.checkFlag(user, "another-feature", true);
+
+  // Get all available flag IDs
+  const allFlagIds = featureFlags.getAllFlagIds();
 
-  // Shutdown when done
-  await featureFlags.shutdown();
+  // Shutdown when done (cleans up polling and resources)
+  featureFlags.shutdown();
 }
 
 ```
@@ -99,10 +101,10 @@ export const handler = async (payload, context) => {
 
   // Define a user
   const user = {
-    identifiers:{
+    identifiers: {
       installContext: context?.installContext,
     },
-    custom: { 
+    attributes: { 
       issues: 4
     }
   };
@@ -110,8 +112,8 @@ export const handler = async (payload, context) => {
   // Use feature flags...
   const isEnabled = featureFlags.checkFlag(user, "new-feature");
 
-  // Shutdown when done
-  await featureFlags.shutdown();
+  // Shutdown when done (synchronous)
+  featureFlags.shutdown();
 }
 ```
 
@@ -161,30 +163,32 @@ interface ForgeFeatureFlagConfig {
 }
 ```
 
-#### `checkFlag(user: ForgeUser, flagName: string): boolean`
-Checks if a feature flag is enabled for the given user. **Synchronous** after initialization.
+#### `checkFlag(user: User, flagId: string, defaultValue?: boolean): boolean`
+Checks if a feature flag is enabled for the given user. Returns the `defaultValue` (defaults to `false`) if the flag doesn't exist. **Synchronous** after initialization.
+
+#### `getFlag(flagId: string): FeatureFlag | undefined`
+Gets a specific flag configuration. Useful for debugging purposes.
+
+#### `getAllFlagIds(): string[]`
+Returns an array of all available flag IDs.
 
-#### `getFeatureFlags(user: ForgeUser, flagNames: string[]): Record<string, boolean>`
-Gets multiple feature flags at once. **Synchronous** after initialization.
+#### `refresh(): Promise<void>`
+Forces a refresh of feature flag configurations from the server.
 
-#### `shutdown(): Promise<void>`
-Shuts down the feature flags service and cleans up resources.
+#### `getLastFetchTime(): number`
+Returns the timestamp of the last successful fetch from the server.
 
 #### `isInitialized(): boolean`
 Checks if the service is initialized.
 
+#### `shutdown(): void`
+Shuts down the feature flags service, stops polling, and cleans up resources. **Synchronous**.
+
 ### User Interface
 
 ```typescript
-interface FeatureFlagUser {
-  custom?: Record<string, string | number>;
-  attributes?: {
-    installContext?: string;
-    accountId?: string;
-    appVersion?: string;
-    license?: string;
-    capabilitySet?: string;
-  };
+interface User {
+  attributes?: Record<string, string | number>;
   identifiers?: {
     installContext?: string;
     accountId?: string;

package/out/evaluator.d.ts

@@ -0,0 +1,13 @@
+import { FeatureFlag, User, EvaluationResult, Environment } from './types';
+export declare class Evaluator {
+    private readonly environment;
+    constructor(options: {
+        environment: Environment;
+    });
+    evaluate(user: User, flag: FeatureFlag): EvaluationResult;
+    private evaluateOverrides;
+    private evaluateRule;
+    private evaluatePassPercentage;
+    private getUserId;
+}
+//# sourceMappingURL=evaluator.d.ts.map

package/out/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../src/evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,IAAI,EAAkB,gBAAgB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAc3F,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;gBAC9B,OAAO,EAAE;QAAE,WAAW,EAAE,WAAW,CAAA;KAAE;IAM1C,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,GAAG,gBAAgB;IA0ChE,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,CAAC,YAAY;IAkBpB,OAAO,CAAC,sBAAsB;IAqC9B,OAAO,CAAC,SAAS;CAGlB"}

package/out/evaluator.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Evaluator = void 0;
+const hash_1 = require("./utils/hash");
+const conditions_1 = require("./utils/conditions");
+const api_1 = require("@forge/api");
+const CONDITION_SEGMENT_COUNT = 10000;
+class Evaluator {
+    environment;
+    constructor(options) {
+        this.environment = options.environment;
+    }
+    evaluate(user, flag) {
+        if (!flag.isEnabled) {
+            return {
+                value: false,
+                ruleId: null,
+                reason: 'disabled'
+            };
+        }
+        const overrideResult = this.evaluateOverrides(user, flag?.overrides);
+        if (overrideResult) {
+            return overrideResult;
+        }
+        const rulesForEnv = [...flag.rules]
+            .filter((rule) => rule.env.includes(this.environment))
+            .sort((a, b) => a.order - b.order);
+        for (const rule of rulesForEnv) {
+            if (this.evaluateRule(user, rule, flag)) {
+                return {
+                    value: rule.returnValue.value,
+                    ruleId: rule.name,
+                    reason: 'rule_match'
+                };
+            }
+        }
+        return {
+            value: false,
+            ruleId: null,
+            reason: 'default'
+        };
+    }
+    evaluateOverrides(user, overrides) {
+        if (!overrides) {
+            return null;
+        }
+        const overridesForEnv = [...overrides]
+            .filter((override) => override.env.includes(this.environment))
+            .sort((a, b) => a.order - b.order);
+        for (const override of overridesForEnv) {
+            const userValue = user?.attributes?.[override.attribute];
+            if (userValue !== undefined && override.values.includes(String(userValue))) {
+                return {
+                    value: override.returnValue.value,
+                    ruleId: `override:${override.attribute}`,
+                    reason: 'override'
+                };
+            }
+        }
+        return null;
+    }
+    evaluateRule(user, rule, flag) {
+        const conditionResults = rule.conditions.map((condition) => (0, conditions_1.evaluateCondition)(user, condition));
+        const conditionsPassed = conditionResults.every((result) => result === true);
+        if (!conditionsPassed) {
+            return false;
+        }
+        return this.evaluatePassPercentage(user, rule, flag);
+    }
+    evaluatePassPercentage(user, rule, flag) {
+        if (rule.passPercentage === undefined) {
+            console.warn(`passPercentage is undefined for rule '${rule.name}' in flag '${flag.flagId}'. Defaulting to false.`);
+            return false;
+        }
+        if (rule.passPercentage === 0) {
+            return false;
+        }
+        if (rule.passPercentage === 100) {
+            return true;
+        }
+        const userId = this.getUserId(user, flag.idType);
+        if (!userId) {
+            return false;
+        }
+        const appId = (0, api_1.__getRuntime)()?.appContext?.appId || 'unknown';
+        const hashInput = `${appId}.${flag.flagId}.${rule.name}.${userId}`;
+        const hash = (0, hash_1.computeHash)(hashInput);
+        const bucket = Number(hash % BigInt(CONDITION_SEGMENT_COUNT));
+        return bucket < rule.passPercentage * 100;
+    }
+    getUserId(user, idType) {
+        return user?.identifiers?.[idType];
+    }
+}
+exports.Evaluator = Evaluator;

package/out/index.d.ts

@@ -1,46 +1,24 @@
-export interface ForgeFeatureFlagConfig {
-    environment?: 'development' | 'staging' | 'production';
-}
-export interface FeatureFlagUser {
-    userID?: string;
-    custom?: Record<string, string | number>;
-    attributes?: {
-        installContext?: string;
-        accountId?: string;
-        appVersion?: string;
-        license?: string;
-        capabilitySet?: string;
-    };
-    identifiers?: {
-        installContext?: string;
-        accountId?: string;
-    };
-}
-export interface Counter {
-    incr(): void;
-    decr(): void;
-}
-export interface TimerStop {
-    stop(): void;
-}
-export interface Timer {
-    measure(): TimerStop;
-}
-export interface Metrics {
-    counter(name: string, tags?: Record<string, string>): Counter;
-    timing(name: string, tags?: Record<string, string>): Timer;
-}
+import { FeatureFlag, User, ForgeFeatureFlagConfig } from './types';
 export declare class ForgeFeatureFlags {
+    private flags;
+    private evaluator;
     private initialized;
-    private dataAdapter;
-    private metrics;
-    private tags;
+    private readonly pollingIntervalMs?;
+    private pollingTimer?;
+    private lastFetchTime;
+    private readonly metrics;
+    private readonly tags;
     initialize(config?: ForgeFeatureFlagConfig): Promise<void>;
-    checkFlag(user: FeatureFlagUser, flagName: string): boolean;
-    getFeatureFlags(user: FeatureFlagUser, flagNames: string[]): Record<string, boolean>;
-    shutdown(): Promise<void>;
-    isInitialized(): boolean;
+    private fetchConfigurations;
+    checkFlag(user: User, flagId: string, defaultValue?: boolean): boolean;
+    getFlag(flagId: string): FeatureFlag | undefined;
+    getAllFlagIds(): string[];
+    refresh(): Promise<void>;
+    private startPolling;
+    private stopPolling;
     private ensureInitialized;
-    private convertUser;
+    isInitialized(): boolean;
+    getLastFetchTime(): number;
+    shutdown(): void;
 }
 //# sourceMappingURL=index.d.ts.map

package/out/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,sBAAsB;IACrC,WAAW,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,YAAY,CAAC;CACxD;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IACzC,UAAU,CAAC,EAAE;QACX,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,WAAW,CAAC,EAAE;QACZ,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,IAAI,IAAI,CAAC;IACb,IAAI,IAAI,IAAI,CAAC;CACd;AACD,MAAM,WAAW,SAAS;IACxB,IAAI,IAAI,IAAI,CAAC;CACd;AACD,MAAM,WAAW,KAAK;IACpB,OAAO,IAAI,SAAS,CAAC;CACtB;AACD,MAAM,WAAW,OAAO;IACtB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC;IAC9D,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;CAC5D;AAKD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAiC;IACpD,OAAO,CAAC,OAAO,CAA2C;IAC1D,OAAO,CAAC,IAAI,CAGV;IAIW,UAAU,CAAC,MAAM,GAAE,sBAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;IAwCpE,SAAS,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IAS3D,eAAe,CAAC,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAe9E,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAe/B,aAAa,IAAI,OAAO;IAI/B,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,WAAW;CAOpB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,sBAAsB,EAAW,MAAM,SAAS,CAAC;AAM7E,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAyB;IAC5D,OAAO,CAAC,YAAY,CAAC,CAAiB;IACtC,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2C;IACnE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAGnB;IAKI,UAAU,CAAC,MAAM,GAAE,sBAAuC,GAAG,OAAO,CAAC,IAAI,CAAC;YAyBlE,mBAAmB;IA6CjC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,UAAQ,GAAG,OAAO;IAgBpE,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAQhD,aAAa,IAAI,MAAM,EAAE;IAQnB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ9B,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,iBAAiB;IASzB,aAAa,IAAI,OAAO;IAOxB,gBAAgB,IAAI,MAAM;IAQ1B,QAAQ,IAAI,IAAI;CAMjB"}

package/out/index.js

@@ -1,90 +1,131 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForgeFeatureFlags = void 0;
-const tslib_1 = require("tslib");
-const statsig_node_1 = tslib_1.__importDefault(require("statsig-node"));
-const data_adapter_1 = require("./data-adapter");
 const api_1 = require("@forge/api");
+const evaluator_1 = require("./evaluator");
+const DEFAULT_CONFIG = { environment: 'development' };
 class ForgeFeatureFlags {
+    flags = new Map();
+    evaluator;
     initialized = false;
-    dataAdapter = null;
+    pollingIntervalMs = 1 * 60 * 1000;
+    pollingTimer;
+    lastFetchTime = 0;
     metrics = (0, api_1.__getRuntime)()?.metrics;
     tags = {
         forgeEnv: (0, api_1.__getRuntime)()?.appContext?.environmentType || 'unknown',
         appId: (0, api_1.__getRuntime)()?.appContext?.appId || 'unknown'
     };
-    async initialize(config = {}) {
-        if (this.initialized) {
-            return;
-        }
+    async initialize(config = DEFAULT_CONFIG) {
         this.metrics?.counter('forge.feature-flags.initialize', this.tags).incr();
         const timer = this.metrics?.timing('forge.feature-flags.initialize', this.tags).measure();
         try {
-            statsig_node_1.default.shutdown();
+            await this.fetchConfigurations();
+            this.initialized = true;
+            this.metrics?.counter('forge.feature-flags.initialize.success', this.tags).incr();
+            if (this.pollingIntervalMs && (0, api_1.__getRuntime)()?.lambdaContext?.getRemainingTimeInMillis?.() > 60000) {
+                this.startPolling();
+            }
+            this.evaluator = new evaluator_1.Evaluator({ environment: config.environment });
+        }
+        catch {
+            this.initialized = false;
+            this.metrics?.counter('forge.feature-flags.initialize.failure', this.tags).incr();
+            console.error('Failed to initialize Forge Feature Flags SDK');
+        }
+        finally {
+            timer?.stop();
+        }
+    }
+    async fetchConfigurations() {
+        try {
+            const runtime = (0, api_1.__getRuntime)();
+            if (runtime?.proxy?.tokenExpiry && runtime?.proxy?.tokenExpiry * 1000 < Date.now()) {
+                this.metrics?.counter('forge.feature-flags.fetchFromAtlassianServers.tokenExpired', this.tags).incr();
+                throw new Error('Cannot fetch feature flags: authentication token has expired');
+            }
+            const remainingTime = runtime?.lambdaContext?.getRemainingTimeInMillis?.();
+            if (remainingTime !== undefined && remainingTime < 5000) {
+                this.metrics?.counter('forge.feature-flags.fetchFromAtlassianServers.remainingTimeComplete', this.tags).incr();
+                throw new Error('Cannot fetch feature flags: insufficient remaining execution time');
+            }
+            const response = await (0, api_1.__fetchProduct)({ provider: 'app', remote: 'feature-flags', type: 'feature-flags' })('/', {
+                method: 'GET',
+                redirect: 'follow',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-b3-traceid': runtime?.tracing?.traceId,
+                    'x-b3-spanid': runtime?.tracing?.spanId
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = await response.json();
+            this.flags = new Map(data?.feature_flags?.map((flag) => [flag.flagId, flag]));
+            this.lastFetchTime = Date.now();
         }
-        catch { }
-        const remainingTime = (0, api_1.__getRuntime)()?.lambdaContext?.getRemainingTimeInMillis?.();
-        const disableRulesetsSync = remainingTime && remainingTime < 60000 ? true : false;
-        if (disableRulesetsSync) {
-            this.metrics?.counter('forge.feature-flags.disableRulesetsSync', this.tags).incr();
+        catch (error) {
+            console.error('Error fetching feature flag configurations:', error);
+            throw error;
         }
-        this.dataAdapter = new data_adapter_1.ForgeDataAdapter(60000, !disableRulesetsSync);
-        const statsigOptions = {
-            environment: { tier: config.environment || 'development' },
-            disableRulesetsSync: disableRulesetsSync,
-            rulesetsSyncIntervalMs: 60000,
-            initStrategyForIDLists: 'none',
-            disableIdListsSync: true,
-            initTimeoutMs: 3000,
-            localMode: true,
-            disableAllLogging: true,
-            disableDiagnostics: true,
-            dataAdapter: this.dataAdapter
-        };
-        await statsig_node_1.default.initialize('secret-forge-internal-key', statsigOptions);
-        this.initialized = true;
-        timer?.stop();
-        this.metrics?.counter('forge.feature-flags.initialize.success', this.tags).incr();
     }
-    checkFlag(user, flagName) {
+    checkFlag(user, flagId, defaultValue = false) {
         this.ensureInitialized();
         this.metrics?.counter('forge.feature-flags.checkFlag', this.tags).incr();
-        return statsig_node_1.default.checkGate(this.convertUser(user), flagName);
+        const flag = this.flags.get(flagId);
+        if (!flag) {
+            return defaultValue;
+        }
+        const result = this.evaluator.evaluate(user, flag);
+        return result.value;
     }
-    getFeatureFlags(user, flagNames) {
-        this.ensureInitialized();
-        this.metrics?.counter('forge.feature-flags.getFeatureFlags', this.tags).incr();
-        const results = {};
-        for (const flagName of flagNames) {
-            results[flagName] = statsig_node_1.default.checkGate(this.convertUser(user), flagName);
+    getFlag(flagId) {
+        this.metrics?.counter('forge.feature-flags.getFlag', this.tags).incr();
+        return this.flags.get(flagId);
+    }
+    getAllFlagIds() {
+        this.metrics?.counter('forge.feature-flags.getAllFlagIds', this.tags).incr();
+        return Array.from(this.flags.keys());
+    }
+    async refresh() {
+        this.metrics?.counter('forge.feature-flags.refresh', this.tags).incr();
+        await this.fetchConfigurations();
+    }
+    startPolling() {
+        this.stopPolling();
+        this.pollingTimer = setInterval(async () => {
+            try {
+                await this.fetchConfigurations();
+            }
+            catch (error) {
+                console.error('Error during polling:', error);
+            }
+        }, this.pollingIntervalMs);
+    }
+    stopPolling() {
+        if (this.pollingTimer) {
+            clearInterval(this.pollingTimer);
+            this.pollingTimer = undefined;
         }
-        return results;
     }
-    async shutdown() {
+    ensureInitialized() {
         if (!this.initialized) {
-            return;
-        }
-        statsig_node_1.default.shutdown();
-        if (this.dataAdapter) {
-            await this.dataAdapter.shutdown();
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
-        this.initialized = false;
-        this.metrics?.counter('forge.feature-flags.shutdown', this.tags).incr();
     }
     isInitialized() {
         return this.initialized;
     }
-    ensureInitialized() {
-        if (!this.initialized) {
-            throw new Error('ForgeFeatureFlags not initialized. Call initialize() first.');
-        }
+    getLastFetchTime() {
+        this.metrics?.counter('forge.feature-flags.getLastFetchTime', this.tags).incr();
+        return this.lastFetchTime;
     }
-    convertUser(user) {
-        return {
-            userID: user.userID,
-            custom: { ...(user.custom || {}), ...(user.attributes || {}) },
-            customIDs: user.identifiers || {}
-        };
+    shutdown() {
+        this.stopPolling();
+        this.flags.clear();
+        this.initialized = false;
+        this.metrics?.counter('forge.feature-flags.shutdown', this.tags).incr();
     }
 }
 exports.ForgeFeatureFlags = ForgeFeatureFlags;

package/out/types/index.d.ts

@@ -0,0 +1,94 @@
+export interface ForgeFeatureFlagConfig {
+    environment: Environment;
+}
+export interface User {
+    attributes?: Record<string, string | number>;
+    identifiers?: {
+        installContext?: string;
+        accountId?: string;
+    };
+}
+export interface Counter {
+    incr(): void;
+    decr(): void;
+}
+export interface TimerStop {
+    stop(): void;
+}
+export interface Timer {
+    measure(): TimerStop;
+}
+export interface Metrics {
+    counter(name: string, tags?: Record<string, string>): Counter;
+    timing(name: string, tags?: Record<string, string>): Timer;
+}
+export declare type Environment = 'development' | 'staging' | 'production';
+export declare type IdType = 'installContext' | 'accountId';
+export declare type FlagStatus = 'implementing' | 'enabled' | 'disabled' | 'launching' | 'tidying';
+export declare type ConditionType = 'everyone' | 'attribute' | 'segment' | 'custom';
+export declare enum FeatureFlagConditionOperator {
+    anyOf = "is any of",
+    noneOf = "is none of",
+    contains = "contains",
+    equals = "is equal to",
+    gt = "is greater than",
+    lt = "is less than",
+    version_gt = "is version greater than",
+    version_lt = "is version less than"
+}
+export declare type RuleConditionOperator = 'AND' | 'OR';
+export interface ReturnValue {
+    type: string;
+    value: boolean;
+}
+export interface Condition {
+    type: string;
+    order: number;
+    field?: string;
+    operator?: string;
+    values?: string | string[];
+}
+export interface Rule {
+    name: string;
+    order: number;
+    passPercentage?: number;
+    conditions: Condition[];
+    env: string[];
+    returnValue: ReturnValue;
+}
+export interface Override {
+    attribute: string;
+    values: string[];
+    env: string[];
+    order: number;
+    returnValue: ReturnValue;
+}
+export interface FeatureFlag {
+    flagId: string;
+    name: string;
+    description?: string;
+    status?: string;
+    isEnabled: boolean;
+    rules: Rule[];
+    idType: string;
+    createdBy: string;
+    createdAt: number;
+    updatedAt: number;
+    updatedBy?: string;
+    overrides?: Override[];
+}
+export interface EvaluationResult {
+    value: boolean;
+    ruleId: string | null;
+    reason: 'override' | 'rule_match' | 'default' | 'disabled';
+}
+export interface EvaluatedFlag {
+    value: boolean;
+    ruleId: string | null;
+}
+export interface InitializeResponse {
+    flags: Record<string, EvaluatedFlag>;
+    timestamp: number;
+    hash: string;
+}
+//# sourceMappingURL=index.d.ts.map

package/out/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/out/types/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlagConditionOperator = void 0;
+var FeatureFlagConditionOperator;
+(function (FeatureFlagConditionOperator) {
+    FeatureFlagConditionOperator["anyOf"] = "is any of";
+    FeatureFlagConditionOperator["noneOf"] = "is none of";
+    FeatureFlagConditionOperator["contains"] = "contains";
+    FeatureFlagConditionOperator["equals"] = "is equal to";
+    FeatureFlagConditionOperator["gt"] = "is greater than";
+    FeatureFlagConditionOperator["lt"] = "is less than";
+    FeatureFlagConditionOperator["version_gt"] = "is version greater than";
+    FeatureFlagConditionOperator["version_lt"] = "is version less than";
+})(FeatureFlagConditionOperator = exports.FeatureFlagConditionOperator || (exports.FeatureFlagConditionOperator = {}));

package/out/utils/conditions.d.ts

@@ -0,0 +1,3 @@
+import { Condition, User } from '../types';
+export declare function evaluateCondition(user: User, condition: Condition): boolean;
+//# sourceMappingURL=conditions.d.ts.map

package/out/utils/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../src/utils/conditions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAgC,IAAI,EAAE,MAAM,UAAU,CAAC;AAKzE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAe3E"}

package/out/utils/conditions.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateCondition = void 0;
+const types_1 = require("../types");
+function evaluateCondition(user, condition) {
+    switch (condition.type) {
+        case 'everyone':
+            return true;
+        case 'attribute':
+        case 'custom_field': {
+            if (!condition.field || !condition.operator) {
+                return false;
+            }
+            const userValue = user.attributes?.[condition.field];
+            return evaluateOperator(userValue, condition.values || [], condition.operator);
+        }
+        default:
+            return false;
+    }
+}
+exports.evaluateCondition = evaluateCondition;
+function evaluateOperator(userValue, targetValues, operator) {
+    switch (operator) {
+        case types_1.FeatureFlagConditionOperator.anyOf:
+            if (Array.isArray(targetValues)) {
+                return targetValues.some((tv) => String(tv) === String(userValue));
+            }
+            return false;
+        case types_1.FeatureFlagConditionOperator.noneOf:
+            if (Array.isArray(targetValues)) {
+                return !targetValues.some((tv) => String(tv) === String(userValue));
+            }
+            return false;
+        case types_1.FeatureFlagConditionOperator.contains:
+            if (Array.isArray(targetValues)) {
+                return targetValues.some((v) => String(userValue).includes(String(v)));
+            }
+            return false;
+        case types_1.FeatureFlagConditionOperator.equals:
+            return String(userValue) === String(targetValues);
+        case types_1.FeatureFlagConditionOperator.gt: {
+            const userNum = Number(userValue);
+            const targetNum = Number(targetValues);
+            if (Number.isNaN(userNum) || Number.isNaN(targetNum)) {
+                return false;
+            }
+            return userNum > targetNum;
+        }
+        case types_1.FeatureFlagConditionOperator.lt: {
+            const userNum = Number(userValue);
+            const targetNum = Number(targetValues);
+            if (Number.isNaN(userNum) || Number.isNaN(targetNum)) {
+                return false;
+            }
+            return userNum < targetNum;
+        }
+        case types_1.FeatureFlagConditionOperator.version_gt:
+            return compareVersions(String(userValue), String(targetValues)) > 0;
+        case types_1.FeatureFlagConditionOperator.version_lt:
+            return compareVersions(String(userValue), String(targetValues)) < 0;
+        default:
+            return false;
+    }
+}
+function compareVersions(version1, version2) {
+    const v1Parts = version1.split('.').map(Number);
+    const v2Parts = version2.split('.').map(Number);
+    const maxLength = Math.max(v1Parts.length, v2Parts.length);
+    for (let i = 0; i < maxLength; i++) {
+        const v1Part = v1Parts[i] || 0;
+        const v2Part = v2Parts[i] || 0;
+        if (v1Part > v2Part)
+            return 1;
+        if (v1Part < v2Part)
+            return -1;
+    }
+    return 0;
+}

package/out/utils/hash.d.ts

@@ -0,0 +1,2 @@
+export declare function computeHash(input: string): bigint;
+//# sourceMappingURL=hash.d.ts.map

package/out/utils/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/utils/hash.ts"],"names":[],"mappings":"AAQA,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQjD"}

package/out/utils/hash.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeHash = void 0;
+const node_crypto_1 = require("node:crypto");
+function computeHash(input) {
+    const hash = (0, node_crypto_1.createHash)('sha256').update(input).digest();
+    const hashValue = hash.readBigUInt64BE(0);
+    return hashValue;
+}
+exports.computeHash = computeHash;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forge/feature-flags-node",
-  "version": "2.1.9-next.0-experimental-44a932f",
+  "version": "3.0.0-next.1",
   "description": "Feature Flags Node SDK for Atlassian Forge apps running on Node Runtime",
   "author": "Atlassian",
   "license": "SEE LICENSE IN LICENSE.txt",
@@ -15,8 +15,7 @@
     "@types/node": "20.19.1"
   },
   "dependencies": {
-    "@forge/api": "^7.0.1-next.0-experimental-44a932f",
-    "statsig-node": "^6.4.3"
+    "@forge/api": "^7.0.1-next.0"
   },
   "publishConfig": {
     "registry": "https://packages.atlassian.com/api/npm/npm-public/"

package/out/data-adapter.d.ts

@@ -1,17 +0,0 @@
-import { IDataAdapter, AdapterResponse } from 'statsig-node';
-export declare class ForgeDataAdapter implements IDataAdapter {
-    private readonly pollingIntervalMs;
-    private readonly pollingEnabled;
-    private readonly cache;
-    private metrics;
-    private tags;
-    constructor(pollingIntervalMs?: number, pollingEnabled?: boolean);
-    get(key: string): Promise<AdapterResponse>;
-    private fetchFromAtlassianServers;
-    set(key: string, value: string): Promise<void>;
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    supportsPollingUpdatesFor(key: string): boolean;
-    getPollingIntervalMs(): number;
-}
-//# sourceMappingURL=data-adapter.d.ts.map

package/out/data-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-adapter.d.ts","sourceRoot":"","sources":["../src/data-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAM7D,qBAAa,gBAAiB,YAAW,YAAY;IASjD,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,cAAc;IATjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkC;IACxD,OAAO,CAAC,OAAO,CAAgE;IAC/E,OAAO,CAAC,IAAI,CAGV;gBAGiB,iBAAiB,GAAE,MAAc,EACjC,cAAc,GAAE,OAAc;IAM3C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;YAoDlC,yBAAyB;IAuCjC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAU9C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ/B,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IA8B/C,oBAAoB,IAAI,MAAM;CAG/B"}

package/out/data-adapter.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ForgeDataAdapter = void 0;
-const api_1 = require("@forge/api");
-class ForgeDataAdapter {
-    pollingIntervalMs;
-    pollingEnabled;
-    cache = new Map();
-    metrics = (0, api_1.__getRuntime)()?.metrics;
-    tags = {
-        forgeEnv: (0, api_1.__getRuntime)()?.appContext?.environmentType || 'unknown',
-        appId: (0, api_1.__getRuntime)()?.appContext?.appId || 'unknown'
-    };
-    constructor(pollingIntervalMs = 60000, pollingEnabled = true) {
-        this.pollingIntervalMs = pollingIntervalMs;
-        this.pollingEnabled = pollingEnabled;
-    }
-    async get(key) {
-        try {
-            this.metrics?.counter('forge.feature-flags.data-adapter.get', this.tags).incr();
-            const data = await this.fetchFromAtlassianServers();
-            if (data) {
-                const serializedData = JSON.stringify(data);
-                this.cache.set(key, serializedData);
-                this.metrics?.counter('forge.feature-flags.data-adapter.get.success', this.tags).incr();
-                return {
-                    result: serializedData,
-                    time: Date.now()
-                };
-            }
-            const cachedValue = this.cache.get(key);
-            if (cachedValue) {
-                this.metrics?.counter('forge.feature-flags.data-adapter.get.cached', this.tags).incr();
-                return {
-                    result: cachedValue,
-                    time: Date.now()
-                };
-            }
-            this.metrics?.counter('forge.feature-flags.data-adapter.get.empty', this.tags).incr();
-            return {
-                result: undefined,
-                time: Date.now()
-            };
-        }
-        catch {
-            this.metrics?.counter('forge.feature-flags.data-adapter.get.failure', this.tags).incr();
-            const cachedValue = this.cache.get(key);
-            if (cachedValue) {
-                this.metrics?.counter('forge.feature-flags.data-adapter.get.cached', this.tags).incr();
-                return {
-                    result: cachedValue,
-                    time: Date.now()
-                };
-            }
-            return {
-                result: undefined,
-                time: Date.now()
-            };
-        }
-    }
-    async fetchFromAtlassianServers() {
-        const runtime = (0, api_1.__getRuntime)();
-        if (runtime?.proxy?.tokenExpiry && runtime?.proxy?.tokenExpiry * 1000 < Date.now()) {
-            this.metrics
-                ?.counter('forge.feature-flags.data-adapter.fetchFromAtlassianServers.tokenExpired', this.tags)
-                .incr();
-            return null;
-        }
-        const remainingTime = runtime?.lambdaContext?.getRemainingTimeInMillis?.();
-        if (remainingTime !== undefined && remainingTime < 5000) {
-            this.metrics
-                ?.counter('forge.feature-flags.data-adapter.fetchFromAtlassianServers.remainingTimeComplete', this.tags)
-                .incr();
-            return null;
-        }
-        const response = await (0, api_1.__fetchProduct)({ provider: 'app', remote: 'feature-flags', type: 'feature-flags' })('/', {
-            method: 'GET',
-            redirect: 'follow',
-            headers: {
-                'Content-Type': 'application/json'
-            }
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        return response.json();
-    }
-    async set(key, value) {
-        try {
-            this.cache.set(key, value);
-        }
-        catch { }
-    }
-    async initialize() { }
-    async shutdown() {
-        this.cache.clear();
-    }
-    supportsPollingUpdatesFor(key) {
-        if (!this.pollingEnabled) {
-            return false;
-        }
-        try {
-            const runtime = (0, api_1.__getRuntime)();
-            if (runtime?.proxy?.tokenExpiry && runtime?.proxy?.tokenExpiry * 1000 < Date.now()) {
-                return false;
-            }
-            const remainingTime = runtime?.lambdaContext?.getRemainingTimeInMillis?.();
-            if (remainingTime !== undefined && remainingTime < 10000) {
-                return false;
-            }
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    getPollingIntervalMs() {
-        return this.pollingIntervalMs;
-    }
-}
-exports.ForgeDataAdapter = ForgeDataAdapter;