unleash-server
Version:
Unleash is an enterprise ready feature flag service. It provides different strategies for handling feature flags.
147 lines • 5.94 kB
JavaScript
import crypto from 'node:crypto';
import ApiUser from '../../types/api-user.js';
import { InMemStorageProvider, Unleash, UnleashEvents, } from 'unleash-client';
import { ApiTokenType } from '../../types/model.js';
import { frontendSettingsKey, } from '../../types/settings/frontend-settings.js';
import { validateOrigins } from '../../util/index.js';
import { BadDataError, InvalidTokenError } from '../../error/index.js';
import { FRONTEND_API_REPOSITORY_CREATED } from '../../metric-events.js';
import { FrontendApiRepository } from './frontend-api-repository.js';
export class FrontendApiService {
constructor(config, services, globalFrontendApiCache) {
/**
* This is intentionally a Promise because we want to be able to await
* until the client (which might be being created by a different request) is ready
* Check this test that fails if we don't use a Promise: frontend-api.concurrency.e2e.test.ts
*/
this.clients = new Map();
this.config = config;
this.logger = config.getLogger('services/frontend-api-service.ts');
this.services = services;
this.flagResolver = config.flagResolver;
this.globalFrontendApiCache = globalFrontendApiCache;
}
async getFrontendApiFeatures(token, context) {
const client = await this.clientForFrontendApiToken(token);
const definitions = client.getFeatureToggleDefinitions() || [];
const sessionId = context.sessionId || crypto.randomBytes(18).toString('hex');
const resultDefinitions = definitions
.filter((feature) => {
const enabled = client.isEnabled(feature.name, {
...context,
sessionId,
});
return enabled;
})
.map((feature) => ({
name: feature.name,
enabled: Boolean(feature.enabled),
variant: client.getVariant(feature.name, {
...context,
sessionId,
}),
impressionData: Boolean(feature.impressionData),
}));
return resultDefinitions;
}
resolveProject(user) {
if (user instanceof ApiUser) {
return user.projects;
}
return ['default'];
}
async registerFrontendApiMetrics(token, metrics, ip, sdkVersion) {
FrontendApiService.assertExpectedTokenType(token);
const environment = this.services.clientMetricsServiceV2.resolveMetricsEnvironment(token, metrics);
await this.services.clientMetricsServiceV2.registerClientMetrics({
...metrics,
environment,
}, ip);
if (metrics.instanceId && typeof sdkVersion === 'string') {
const client = {
appName: metrics.appName,
instanceId: metrics.instanceId,
sdkVersion: sdkVersion,
sdkType: 'frontend',
environment: environment,
projects: this.resolveProject(token),
};
this.services.clientInstanceService.registerFrontendClient(client);
}
}
async clientForFrontendApiToken(token) {
FrontendApiService.assertExpectedTokenType(token);
let client = this.clients.get(token.secret);
if (!client) {
client = this.createClientForFrontendApiToken(token);
this.clients.set(token.secret, client);
this.config.eventBus.emit(FRONTEND_API_REPOSITORY_CREATED);
}
return client;
}
async createClientForFrontendApiToken(token) {
const repository = new FrontendApiRepository(this.config, this.globalFrontendApiCache, token);
const client = new Unleash({
appName: 'frontend-api',
url: 'unused',
storageProvider: new InMemStorageProvider(),
disableMetrics: true,
repository,
disableAutoStart: true,
skipInstanceCountWarning: true,
});
client.on(UnleashEvents.Error, (error) => {
this.logger.error('We found an event error', error);
});
await client.start();
return client;
}
async deleteClientForFrontendApiToken(secret) {
const clientPromise = this.clients.get(secret);
if (clientPromise) {
const client = await clientPromise;
client.destroy();
this.clients.delete(secret);
}
}
stopAll() {
this.clients.forEach((promise) => {
promise.then((c) => c.destroy());
});
}
refreshData() {
return this.globalFrontendApiCache.refreshData();
}
static assertExpectedTokenType({ type }) {
if (!(type === ApiTokenType.FRONTEND || type === ApiTokenType.ADMIN)) {
throw new InvalidTokenError();
}
}
async setFrontendCorsSettings(value, auditUser) {
const error = validateOrigins(value);
if (error) {
throw new BadDataError(error);
}
const settings = (await this.getFrontendSettings(false)) || {};
await this.services.settingService.insert(frontendSettingsKey, { ...settings, frontendApiOrigins: value }, auditUser, false);
}
async fetchFrontendSettings() {
try {
this.cachedFrontendSettings =
await this.services.settingService.getWithDefault(frontendSettingsKey, {
frontendApiOrigins: this.config.frontendApiOrigins,
});
}
catch (error) {
this.logger.debug('Unable to fetch frontend settings', error);
}
return this.cachedFrontendSettings;
}
async getFrontendSettings(useCache = true) {
if (useCache && this.cachedFrontendSettings) {
return this.cachedFrontendSettings;
}
return this.fetchFrontendSettings();
}
}
//# sourceMappingURL=frontend-api-service.js.map