@forge/feature-flags 0.0.0-experimental-e2ec7ba

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# @forge/feature-flags
+
+## 0.0.0-experimental-e2ec7ba
+
+### Major Changes
+
+- e2ec7ba: Feature Flags SDK for Forge runtime
+
+### Patch Changes
+
+- @forge/api@7.0.2-next.0-experimental-e2ec7ba

package/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2026 Atlassian
+Permission is hereby granted to use this software in accordance with the terms 
+and conditions outlined in the Atlassian Developer Terms, which can be found 
+at the following URL:
+https://developer.atlassian.com/platform/marketplace/atlassian-developer-terms/
+By using this software, you agree to comply with these terms and conditions. 
+If you do not agree with these terms, you are not permitted to use this software.

package/README.md

@@ -0,0 +1,204 @@
+# @forge/feature-flags
+
+A feature flag SDK for Atlassian Forge apps running on Forge Node Runtime. This package provides a simple interface for evaluating feature flags.
+
+## Installation
+
+```bash
+yarn add @forge/feature-flags
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { getAppContext } from "@forge/api";
+import { FeatureFlags } from "@forge/feature-flags";
+
+export const handler = async (payload, context) => {
+  // Get app context values
+  const {
+    appVersion,
+    license: appLicense,
+    environmentType,
+  } = getAppContext();
+
+  // Determine license value based on trialEndDate and isActive
+  let licenseValue = "INACTIVE";
+  const trialEndDate = appLicense?.trialEndDate;
+  const isActive = appLicense?.isActive;
+
+  if (trialEndDate) {
+    const now = new Date();
+    const trialEnd = new Date(trialEndDate);
+    if (trialEnd > now) {
+      licenseValue = "TRIAL";
+    } else if (isActive) {
+      licenseValue = "ACTIVE";
+    }
+  } else if (isActive) {
+    licenseValue = "ACTIVE";
+  }
+
+  // Determine capabilitySet value (enum)
+  let capabilitySetValue = "capabilityStandard";
+  if (appLicense?.capabilitySet === "capabilityAdvanced") {
+    capabilitySetValue = "capabilityAdvanced";
+  }
+
+  // Initialize the feature flags SDK
+  const featureFlags = new FeatureFlags();
+  await featureFlags.initialize({
+    environment: environmentType?.toLowerCase() || "development" 
+  });
+
+  // Define a user with all possible attributes that will be used in the feature flag rules
+  const user = {
+    identifiers: {
+      accountId: context?.principal?.accountId,
+    },
+    attributes: { 
+      installContext: context?.installContext,
+      accountId: context?.principal?.accountId,
+      appVersion: appVersion,
+      license: licenseValue, // "ACTIVE", "INACTIVE", "TRIAL"
+      capabilitySet: capabilitySetValue // "capabilityAdvanced", "capabilityStandard"
+    }
+  };
+
+  // Check a feature flag (synchronous after initialization)
+  const isEnabled = featureFlags.checkFlag(user, "new-feature");
+
+  // 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 (cleans up polling and resources)
+  featureFlags.shutdown();
+}
+
+```
+
+## ⚠️ Important: Initialization Best Practices
+
+**ALWAYS initialize the FeatureFlags SDK inside your handler function, NEVER initialize globally as it will use the stale feature flags**
+
+### ✅ Correct Pattern - Initialize Inside Handler
+
+```typescript
+import { getAppContext } from "@forge/api";
+import { FeatureFlags } from "@forge/feature-flags";
+
+export const handler = async (payload, context) => {
+  // ✅ Initialize inside the handler function
+  const featureFlags = new FeatureFlags();
+  await featureFlags.initialize({
+    environment: getAppContext().environmentType?.toLowerCase() || "development"
+  });
+
+  // Define a user
+  const user = {
+    identifiers: {
+      installContext: context?.installContext,
+    },
+    attributes: { 
+      issues: 4
+    }
+  };
+
+  // Use feature flags...
+  const isEnabled = featureFlags.checkFlag(user, "new-feature");
+
+  // Shutdown when done (synchronous)
+  featureFlags.shutdown();
+}
+```
+
+### ❌ Incorrect Pattern - Global Initialization
+
+```typescript
+// ❌ NEVER do this - Global initialization
+const featureFlags = new FeatureFlags();
+await featureFlags.initialize(); // This will cause problems!
+
+export const handler = async (payload, context) => {
+  // This will fail if token expires or network issues occur
+  const isEnabled = featureFlags.checkFlag(user, "new-feature");
+}
+```
+
+## Polling Behavior
+
+The package automatically polls for feature flag updates every 60 seconds:
+
+1. **Cache Updates**: New data is cached for fallback purposes
+2. **Error Resilience**: If a fetch fails, the package falls back to cached data
+3. **Immediate Updates**: Feature flag changes are reflected within 60 seconds
+
+```typescript
+// Polling happens automatically in the background
+const featureFlags = new FeatureFlags();
+await featureFlags.initialize();
+
+// Feature flags are automatically updated every 60 seconds
+// No manual intervention required
+```
+
+## API Reference
+
+### `FeatureFlags`
+
+#### `constructor()`
+Creates a new instance of the FeatureFlags class.
+
+#### `initialize(config?: ForgeFeatureFlagConfig): Promise<void>`
+Initializes the feature flags service with the provided configuration.
+
+```typescript
+interface ForgeFeatureFlagConfig {
+  environment?: 'development' | 'staging' | 'production';
+}
+```
+
+#### `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.
+
+#### `refresh(): Promise<void>`
+Forces a refresh of feature flag configurations from the server.
+
+#### `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 User {
+  attributes?: Record<string, string | number>;
+  identifiers?: {
+    installContext?: string;
+    accountId?: string;
+  };
+}
+```
+
+## Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `environment` | `'development' \| 'staging' \| 'production'` | `'development'` | Environment tier for feature flag evaluation |
+

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;IA4ChE,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,YAAY;IAwBpB,OAAO,CAAC,sBAAsB;IAqC9B,OAAO,CAAC,SAAS;CAGlB"}

package/out/evaluator.js

@@ -0,0 +1,97 @@
+"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) {
+            const ruleResult = this.evaluateRule(user, rule, flag);
+            if (ruleResult !== null) {
+                return {
+                    value: ruleResult,
+                    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 null;
+        }
+        const passesPercentageCheck = this.evaluatePassPercentage(user, rule, flag);
+        return passesPercentageCheck ? rule.returnValue.value : false;
+    }
+    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/featureFlags.d.ts

@@ -0,0 +1,24 @@
+import { FeatureFlag, User, ForgeFeatureFlagConfig } from './types';
+export declare class FeatureFlags {
+    private flags;
+    private evaluator;
+    private initialized;
+    private readonly pollingIntervalMs?;
+    private pollingTimer?;
+    private lastFetchTime;
+    private readonly metrics;
+    private readonly tags;
+    initialize(config?: ForgeFeatureFlagConfig): Promise<void>;
+    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;
+    isInitialized(): boolean;
+    getLastFetchTime(): number;
+    shutdown(): void;
+}
+//# sourceMappingURL=featureFlags.d.ts.map

package/out/featureFlags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"featureFlags.d.ts","sourceRoot":"","sources":["../src/featureFlags.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,sBAAsB,EAAW,MAAM,SAAS,CAAC;AAM7E,qBAAa,YAAY;IACvB,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;IAoDjC,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/featureFlags.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlags = void 0;
+const api_1 = require("@forge/api");
+const evaluator_1 = require("./evaluator");
+const DEFAULT_CONFIG = { environment: 'development' };
+class FeatureFlags {
+    flags = new Map();
+    evaluator;
+    initialized = false;
+    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 = 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 {
+            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 controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
+            const response = await (0, api_1.__fetchProduct)({ provider: 'app', remote: 'feature-flags', type: 'feature-flags' })('/', {
+                method: 'GET',
+                redirect: 'follow',
+                signal: controller.signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-b3-traceid': runtime?.tracing?.traceId,
+                    'x-b3-spanid': runtime?.tracing?.spanId
+                }
+            });
+            clearTimeout(timeoutId);
+            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 (error) {
+            console.error('Error fetching feature flag configurations:', error);
+            throw error;
+        }
+    }
+    checkFlag(user, flagId, defaultValue = false) {
+        this.ensureInitialized();
+        this.metrics?.counter('forge.feature-flags.checkFlag', this.tags).incr();
+        const flag = this.flags.get(flagId);
+        if (!flag) {
+            return defaultValue;
+        }
+        const result = this.evaluator.evaluate(user, flag);
+        return result.value;
+    }
+    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;
+        }
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    getLastFetchTime() {
+        this.metrics?.counter('forge.feature-flags.getLastFetchTime', this.tags).incr();
+        return this.lastFetchTime;
+    }
+    shutdown() {
+        this.stopPolling();
+        this.flags.clear();
+        this.initialized = false;
+        this.metrics?.counter('forge.feature-flags.shutdown', this.tags).incr();
+    }
+}
+exports.FeatureFlags = FeatureFlags;

package/out/index.d.ts

@@ -0,0 +1,3 @@
+export { FeatureFlags } from './featureFlags';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/out/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,cAAc,SAAS,CAAC"}

package/out/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFlags = void 0;
+const tslib_1 = require("tslib");
+var featureFlags_1 = require("./featureFlags");
+Object.defineProperty(exports, "FeatureFlags", { enumerable: true, get: function () { return featureFlags_1.FeatureFlags; } });
+tslib_1.__exportStar(require("./types"), exports);

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

@@ -0,0 +1,23 @@
+{
+  "name": "@forge/feature-flags",
+  "version": "0.0.0-experimental-e2ec7ba",
+  "description": "Feature Flags Node SDK for Atlassian Forge apps running on Node Runtime",
+  "author": "Atlassian",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "main": "out/index.js",
+  "types": "out/index.d.ts",
+  "scripts": {
+    "build": "yarn run clean && yarn run compile",
+    "clean": "rm -rf ./out && rm -f tsconfig.tsbuildinfo",
+    "compile": "tsc -b -v"
+  },
+  "devDependencies": {
+    "@types/node": "20.19.1"
+  },
+  "dependencies": {
+    "@forge/api": "^7.0.2-next.0-experimental-e2ec7ba"
+  },
+  "publishConfig": {
+    "registry": "https://packages.atlassian.com/api/npm/npm-public/"
+  }
+}