featurehub-javascript-client-sdk
Version:
FeatureHub client/browser SDK
263 lines • 7.92 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.featurehubMiddleware = void 0;
const models_1 = require("./models");
class BaggageHolder {
constructor(existing, value) {
this.existing = existing;
this.baggageValue = value;
}
get featureProperties() {
return undefined;
}
isEnabled() {
return this.getBoolean() === true;
}
withContext(param) {
return new BaggageHolder(this.existing.withContext(param), this.baggageValue);
}
addListener(_) {
return 0;
}
removeListener(_) {
}
getBoolean() {
if (this.existing.isLocked()) {
return this.existing.getBoolean();
}
return this.existing.getType() === models_1.FeatureValueType.Boolean ? ('true' === this.baggageValue) : undefined;
}
getFlag() {
return this.getBoolean();
}
getKey() {
return this.existing.getKey();
}
getNumber() {
if (this.existing.isLocked()) {
return this.existing.getNumber();
}
if (this.existing.getType() === models_1.FeatureValueType.Number && this.baggageValue !== undefined) {
if (this.baggageValue.includes('.')) {
return parseFloat(this.baggageValue);
}
else {
return parseInt(this.baggageValue);
}
}
return undefined;
}
getRawJson() {
return undefined;
}
getString() {
if (this.existing.isLocked()) {
return this.existing.getString();
}
if (this.existing.getType() === models_1.FeatureValueType.String) {
return this.baggageValue;
}
return undefined;
}
getType() {
return this.existing.getType();
}
getVersion() {
return this.existing.getVersion();
}
isLocked() {
return this.existing.isLocked();
}
isSet() {
return this.value != null;
}
triggerListeners(feature) {
this.existing.triggerListeners(feature);
}
get enabled() {
return this.isEnabled();
}
get exists() {
return this.existing.exists;
}
get flag() {
return this.getBoolean();
}
get key() {
return this.getKey();
}
get locked() {
return this.isLocked();
}
get num() {
return this.getNumber();
}
get rawJson() {
return this.getRawJson();
}
get str() {
return this.getString();
}
get type() {
return this.getType();
}
get version() {
return this.getVersion();
}
_valueParseJson() {
const json = this.getRawJson();
if (!json)
return {};
try {
return JSON.parse(json);
}
catch (_) {
return {};
}
}
get value() {
if (this.type) {
const v = {
[models_1.FeatureValueType.Boolean]: this.getBoolean(),
[models_1.FeatureValueType.String]: this.getString(),
[models_1.FeatureValueType.Number]: this.getNumber(),
[models_1.FeatureValueType.Json]: this._valueParseJson(),
}[this.type];
return v;
}
return undefined;
}
}
class BaggageRepository {
constructor(repo, baggage) {
this.mappedBaggage = new Map();
this.repo = repo;
this.baggage = baggage;
}
apply(strategies, key, featureValueId, context) {
return this.repo.apply(strategies, key, featureValueId, context);
}
getFlag(key) {
return this.feature(key).getFlag();
}
getString(key) {
return this.feature(key).getString();
}
getJson(key) {
return this.feature(key).getRawJson();
}
getNumber(key) {
return this.feature(key).getNumber();
}
isSet(key) {
return this.feature(key).isSet();
}
get readyness() {
return this.repo.readyness;
}
hasFeature(key) {
return this.feature(key);
}
feature(key) {
const realFeature = this.repo.hasFeature(key);
if (realFeature !== undefined && realFeature.getType() !== undefined) {
if (this.baggage.has(key)) {
let fh = this.mappedBaggage.get(key);
if (fh === undefined && realFeature.getType() !== models_1.FeatureValueType.Json) {
fh = new BaggageHolder(realFeature, this.baggage.get(key));
this.mappedBaggage.set(key, fh);
}
if (fh !== undefined) {
return fh;
}
}
}
return this.repo.feature(key);
}
logAnalyticsEvent(action, other) {
const otherCopy = other ? other : new Map();
const baggageCopy = new Map([...this.baggage.entries(), ...otherCopy.entries()]);
this.repo.logAnalyticsEvent(action, baggageCopy);
}
simpleFeatures() {
const features = this.repo.simpleFeatures();
this.baggage.forEach((value, key) => features.set(key, value));
return features;
}
notReady() {
this.repo.notReady();
}
notify(state, data) {
this.repo.notify(state, data);
}
addValueInterceptor(interceptor) {
this.repo.addValueInterceptor(interceptor);
}
valueInterceptorMatched(key) {
return this.repo.valueInterceptorMatched(key);
}
addReadynessListener(listener) {
return this.repo.addReadinessListener(listener);
}
addReadinessListener(listener, ignoreNotReadyOnRegister) {
return this.repo.addReadinessListener(listener, ignoreNotReadyOnRegister);
}
removeReadinessListener(listener) {
this.repo.removeReadinessListener(listener);
}
addAnalyticCollector(collector) {
this.repo.addAnalyticCollector(collector);
}
get catchAndReleaseMode() {
return this.repo.catchAndReleaseMode;
}
set catchAndReleaseMode(value) {
this.repo.catchAndReleaseMode = value;
}
addPostLoadNewFeatureStateAvailableListener(listener) {
return this.repo.addPostLoadNewFeatureStateAvailableListener(listener);
}
removePostLoadNewFeatureStateAvailableListener(listener) {
this.repo.removePostLoadNewFeatureStateAvailableListener(listener);
}
getFeatureState(key) {
return this.feature(key);
}
release(disableCatchAndRelease) {
return this.repo.release(disableCatchAndRelease);
}
}
function featurehubMiddleware(repo) {
return (req, res, next) => {
let reqRepo = repo;
if (process.env.FEATUREHUB_ACCEPT_BAGGAGE !== undefined) {
const baggage = req.header('baggage');
if (baggage != null) {
const baggageMap = new Map();
baggage.split(',')
.map(b => b.trim())
.filter(b => b.startsWith('fhub='))
.forEach(b => {
const fhub = decodeURIComponent(b.substring(5));
fhub.split(',')
.forEach(feature => {
const parts = feature.split('=');
if (parts.length === 2) {
baggageMap.set(parts[0], decodeURIComponent(parts[1]));
}
else if (parts.length === 1) {
baggageMap.set(parts[0], '');
}
});
});
if (baggageMap.size > 0) {
reqRepo = new BaggageRepository(repo, baggageMap);
}
}
}
req.featureHub = reqRepo;
next();
};
}
exports.featurehubMiddleware = featurehubMiddleware;
//# sourceMappingURL=middleware.js.map