flagsmith-nodejs/build/cjs/sdk/models.js

Flagsmith lets you manage features flags and remote config across web, mobile and server side applications. Deliver true Continuous Integration. Get builds out faster. Control who has access to new features.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Flags = exports.Flag = exports.DefaultFlag = exports.BaseFlag = void 0;
/**
 * A Flagsmith feature. It has an enabled/disabled state, and an optional {@link FlagValue}.
 */
class BaseFlag {
    /**
     * Indicates whether this feature is enabled.
     */
    enabled;
    /**
     * An optional {@link FlagValue} for this feature.
     */
    value;
    /**
     * If true, the state for this feature was determined by a default flag handler. See {@link DefaultFlag}.
     */
    isDefault;
    constructor(value, enabled, isDefault) {
        this.value = value;
        this.enabled = enabled;
        this.isDefault = isDefault;
    }
}
exports.BaseFlag = BaseFlag;
/**
 * A {@link BaseFlag} returned by a default flag handler when flag evaluation fails.
 * @see FlagsmithConfig#defaultFlagHandler
 */
class DefaultFlag extends BaseFlag {
    constructor(value, enabled) {
        super(value, enabled, true);
    }
}
exports.DefaultFlag = DefaultFlag;
/**
 * A Flagsmith feature retrieved from a successful flag evaluation.
 */
class Flag extends BaseFlag {
    /**
     * An identifier for this feature, unique in a single Flagsmith installation.
     */
    featureId;
    /**
     * The programmatic name for this feature, unique per Flagsmith project.
     */
    featureName;
    /**
     * The reason for this feature, unique per Flagsmith project.
     */
    reason;
    constructor(params) {
        super(params.value, params.enabled, !!params.isDefault);
        this.featureId = params.featureId;
        this.featureName = params.featureName;
        this.reason = params.reason;
    }
    static fromFeatureStateModel(fsm, identityId) {
        return new Flag({
            value: fsm.getValue(identityId),
            enabled: fsm.enabled,
            featureId: fsm.feature.id,
            featureName: fsm.feature.name
        });
    }
    static fromAPIFlag(flagData) {
        return new Flag({
            enabled: flagData['enabled'],
            value: flagData['feature_state_value'] ?? flagData['value'],
            featureId: flagData['feature']['id'],
            featureName: flagData['feature']['name'],
            reason: flagData['feature']['reason']
        });
    }
}
exports.Flag = Flag;
class Flags {
    flags = {};
    defaultFlagHandler;
    analyticsProcessor;
    constructor(data) {
        this.flags = data.flags;
        this.defaultFlagHandler = data.defaultFlagHandler;
        this.analyticsProcessor = data.analyticsProcessor;
    }
    static fromEvaluationResult(evaluationResult, defaultFlagHandler, analyticsProcessor) {
        const flags = {};
        for (const flag of Object.values(evaluationResult.flags)) {
            const flagMetadataId = flag.metadata?.id;
            if (!flagMetadataId) {
                throw new Error(`FlagResult metadata.id is missing for feature "${flag.name}". ` +
                    `This indicates a bug in the SDK, please report it.`);
            }
            flags[flag.name] = new Flag({
                enabled: flag.enabled,
                value: flag.value ?? null,
                featureId: flagMetadataId,
                featureName: flag.name,
                reason: flag.reason
            });
        }
        return new Flags({
            flags: flags,
            defaultFlagHandler: defaultFlagHandler,
            analyticsProcessor: analyticsProcessor
        });
    }
    static fromFeatureStateModels(data) {
        const flags = {};
        for (const fs of data.featureStates) {
            flags[fs.feature.name] = Flag.fromFeatureStateModel(fs, data.identityID);
        }
        return new Flags({
            flags: flags,
            defaultFlagHandler: data.defaultFlagHandler,
            analyticsProcessor: data.analyticsProcessor
        });
    }
    static fromAPIFlags(data) {
        const flags = {};
        for (const flagData of data.apiFlags) {
            flags[flagData['feature']['name']] = Flag.fromAPIFlag(flagData);
        }
        return new Flags({
            flags: flags,
            defaultFlagHandler: data.defaultFlagHandler,
            analyticsProcessor: data.analyticsProcessor
        });
    }
    allFlags() {
        return Object.values(this.flags);
    }
    getFlag(featureName) {
        const flag = this.flags[featureName];
        if (!flag) {
            if (this.defaultFlagHandler) {
                return this.defaultFlagHandler(featureName);
            }
            return { enabled: false, isDefault: true, value: undefined };
        }
        if (this.analyticsProcessor && flag.featureId) {
            this.analyticsProcessor.trackFeature(flag.featureName);
        }
        return flag;
    }
    getFeatureValue(featureName) {
        return this.getFlag(featureName).value;
    }
    isFeatureEnabled(featureName) {
        return this.getFlag(featureName).enabled;
    }
}
exports.Flags = Flags;