2021-07-07 10:46:50 +02:00
|
|
|
import { stateSchema } from './state-schema';
|
|
|
|
import {
|
|
|
|
DROP_FEATURE_TAGS,
|
2020-11-03 14:56:07 +01:00
|
|
|
DROP_FEATURES,
|
2021-07-07 10:46:50 +02:00
|
|
|
DROP_PROJECTS,
|
2020-11-03 14:56:07 +01:00
|
|
|
DROP_STRATEGIES,
|
2021-07-07 10:46:50 +02:00
|
|
|
DROP_TAG_TYPES,
|
2021-03-12 11:08:10 +01:00
|
|
|
DROP_TAGS,
|
2021-07-07 10:46:50 +02:00
|
|
|
FEATURE_IMPORT,
|
2021-03-12 11:08:10 +01:00
|
|
|
FEATURE_TAG_IMPORT,
|
|
|
|
PROJECT_IMPORT,
|
2021-07-07 10:46:50 +02:00
|
|
|
STRATEGY_IMPORT,
|
|
|
|
TAG_IMPORT,
|
|
|
|
TAG_TYPE_IMPORT,
|
|
|
|
} from '../types/events';
|
|
|
|
|
|
|
|
import { filterEqual, filterExisting, parseFile, readFile } from './state-util';
|
|
|
|
import FeatureToggleStore from '../db/feature-toggle-store';
|
|
|
|
import TagTypeStore, { ITagType } from '../db/tag-type-store';
|
|
|
|
import FeatureTagStore, { IFeatureTag } from '../db/feature-tag-store';
|
|
|
|
import ProjectStore, { IProject } from '../db/project-store';
|
|
|
|
import TagStore from '../db/tag-store';
|
|
|
|
import StrategyStore, { IStrategy } from '../db/strategy-store';
|
|
|
|
import { Logger } from '../logger';
|
|
|
|
import { IUnleashStores } from '../types/stores';
|
|
|
|
import { IUnleashConfig } from '../types/option';
|
|
|
|
import EventStore from '../db/event-store';
|
|
|
|
import {
|
|
|
|
FeatureToggle,
|
|
|
|
IEnvironment,
|
|
|
|
IFeatureEnvironment,
|
|
|
|
ITag,
|
|
|
|
} from '../types/model';
|
|
|
|
import FeatureStrategiesStore, {
|
|
|
|
IFeatureStrategy,
|
|
|
|
} from '../db/feature-strategy-store';
|
|
|
|
import EnvironmentStore from '../db/environment-store';
|
|
|
|
import { GLOBAL_ENV } from '../types/environment';
|
|
|
|
|
|
|
|
export interface IBackupOption {
|
|
|
|
includeFeatureToggles: boolean;
|
|
|
|
includeStrategies: boolean;
|
|
|
|
includeProjects: boolean;
|
|
|
|
includeTags: boolean;
|
|
|
|
}
|
|
|
|
|
|
|
|
interface IImportOption {
|
|
|
|
keepExising: boolean;
|
|
|
|
dropBeforeImport: boolean;
|
|
|
|
userName: string;
|
|
|
|
}
|
|
|
|
|
|
|
|
export default class StateService {
|
|
|
|
private logger: Logger;
|
|
|
|
|
|
|
|
private toggleStore: FeatureToggleStore;
|
|
|
|
|
|
|
|
private featureStrategiesStore: FeatureStrategiesStore;
|
2020-11-03 14:56:07 +01:00
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
private strategyStore: StrategyStore;
|
2020-11-03 14:56:07 +01:00
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
private eventStore: EventStore;
|
|
|
|
|
|
|
|
private tagStore: TagStore;
|
|
|
|
|
|
|
|
private tagTypeStore: TagTypeStore;
|
|
|
|
|
|
|
|
private projectStore: ProjectStore;
|
|
|
|
|
|
|
|
private featureTagStore: FeatureTagStore;
|
|
|
|
|
|
|
|
private environmentStore: EnvironmentStore;
|
|
|
|
|
|
|
|
constructor(
|
|
|
|
stores: IUnleashStores,
|
|
|
|
{ getLogger }: Pick<IUnleashConfig, 'getLogger'>,
|
|
|
|
) {
|
2020-11-03 14:56:07 +01:00
|
|
|
this.eventStore = stores.eventStore;
|
|
|
|
this.toggleStore = stores.featureToggleStore;
|
|
|
|
this.strategyStore = stores.strategyStore;
|
2021-03-12 11:08:10 +01:00
|
|
|
this.tagStore = stores.tagStore;
|
2021-07-07 10:46:50 +02:00
|
|
|
this.featureStrategiesStore = stores.featureStrategiesStore;
|
2021-03-12 11:08:10 +01:00
|
|
|
this.tagTypeStore = stores.tagTypeStore;
|
|
|
|
this.projectStore = stores.projectStore;
|
2021-07-07 10:46:50 +02:00
|
|
|
this.featureTagStore = stores.featureTagStore;
|
|
|
|
this.environmentStore = stores.environmentStore;
|
2020-11-03 14:56:07 +01:00
|
|
|
this.logger = getLogger('services/state-service.js');
|
|
|
|
}
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
async importFile({
|
|
|
|
file,
|
|
|
|
dropBeforeImport,
|
|
|
|
userName,
|
|
|
|
keepExisting,
|
|
|
|
}): Promise<void> {
|
2020-11-03 14:56:07 +01:00
|
|
|
return readFile(file)
|
|
|
|
.then(data => parseFile(file, data))
|
|
|
|
.then(data =>
|
|
|
|
this.import({ data, userName, dropBeforeImport, keepExisting }),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
async import({
|
|
|
|
data,
|
|
|
|
userName,
|
|
|
|
dropBeforeImport,
|
|
|
|
keepExisting,
|
|
|
|
}): Promise<void> {
|
2020-11-03 14:56:07 +01:00
|
|
|
const importData = await stateSchema.validateAsync(data);
|
|
|
|
|
|
|
|
if (importData.features) {
|
2021-07-07 10:46:50 +02:00
|
|
|
let projectData;
|
|
|
|
if (!importData.version || importData.version === 1) {
|
|
|
|
projectData = await this.convertLegacyFeatures(importData);
|
|
|
|
} else {
|
|
|
|
projectData = importData;
|
|
|
|
}
|
|
|
|
const {
|
|
|
|
features,
|
|
|
|
featureStrategies,
|
|
|
|
featureEnvironments,
|
|
|
|
} = projectData;
|
|
|
|
|
2020-11-03 14:56:07 +01:00
|
|
|
await this.importFeatures({
|
2021-07-07 10:46:50 +02:00
|
|
|
features,
|
|
|
|
userName,
|
|
|
|
dropBeforeImport,
|
|
|
|
keepExisting,
|
|
|
|
});
|
|
|
|
await this.importFeatureEnvironments({
|
|
|
|
featureEnvironments,
|
|
|
|
});
|
|
|
|
await this.importFeatureStrategies({
|
|
|
|
featureStrategies,
|
2020-11-03 14:56:07 +01:00
|
|
|
userName,
|
|
|
|
dropBeforeImport,
|
|
|
|
keepExisting,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
if (importData.strategies) {
|
|
|
|
await this.importStrategies({
|
|
|
|
strategies: data.strategies,
|
|
|
|
userName,
|
|
|
|
dropBeforeImport,
|
|
|
|
keepExisting,
|
|
|
|
});
|
|
|
|
}
|
2021-03-12 11:08:10 +01:00
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
if (importData.projects) {
|
|
|
|
await this.importProjects({
|
|
|
|
projects: data.projects,
|
2021-03-12 11:08:10 +01:00
|
|
|
userName,
|
|
|
|
dropBeforeImport,
|
|
|
|
keepExisting,
|
|
|
|
});
|
|
|
|
}
|
2021-07-07 10:46:50 +02:00
|
|
|
|
|
|
|
if (importData.tagTypes && importData.tags) {
|
|
|
|
await this.importTagData({
|
|
|
|
tagTypes: data.tagTypes,
|
|
|
|
tags: data.tags,
|
|
|
|
featureTags:
|
|
|
|
data.featureTags.map(t => ({
|
|
|
|
featureName: t.featureName,
|
|
|
|
tagValue: t.tagValue || t.value,
|
|
|
|
tagType: t.tagType || t.type,
|
|
|
|
})) || [],
|
2021-03-12 11:08:10 +01:00
|
|
|
userName,
|
|
|
|
dropBeforeImport,
|
|
|
|
keepExisting,
|
|
|
|
});
|
|
|
|
}
|
2020-11-03 14:56:07 +01:00
|
|
|
}
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
async importFeatureEnvironments({ featureEnvironments }): Promise<void> {
|
|
|
|
await Promise.all(
|
|
|
|
featureEnvironments.map(env =>
|
|
|
|
this.featureStrategiesStore.connectEnvironmentAndFeature(
|
|
|
|
env.featureName,
|
|
|
|
env.environment,
|
|
|
|
env.enabled,
|
|
|
|
),
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
async importFeatureStrategies({
|
|
|
|
featureStrategies,
|
|
|
|
userName,
|
|
|
|
dropBeforeImport,
|
|
|
|
keepExisting,
|
|
|
|
}): Promise<void> {
|
|
|
|
const oldFeatureStrategies = dropBeforeImport
|
|
|
|
? []
|
|
|
|
: await this.featureStrategiesStore.getAllFeatureStrategies();
|
|
|
|
if (dropBeforeImport) {
|
|
|
|
this.logger.info(
|
|
|
|
'Dropping existing strategies for feature toggles',
|
|
|
|
);
|
|
|
|
await this.featureStrategiesStore.deleteFeatureStrategies();
|
|
|
|
}
|
|
|
|
const strategiesToImport = keepExisting
|
|
|
|
? featureStrategies.filter(
|
|
|
|
s => !oldFeatureStrategies.some(o => o.id === s.id),
|
|
|
|
)
|
|
|
|
: featureStrategies;
|
|
|
|
await Promise.all(
|
|
|
|
strategiesToImport.map(featureStrategy =>
|
|
|
|
this.featureStrategiesStore.createStrategyConfig(
|
|
|
|
featureStrategy,
|
|
|
|
),
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
async convertLegacyFeatures({
|
|
|
|
features,
|
|
|
|
}): Promise<{ features; featureStrategies; featureEnvironments }> {
|
|
|
|
const strategies = features.flatMap(f =>
|
|
|
|
f.strategies.map(strategy => ({
|
|
|
|
featureName: f.name,
|
|
|
|
projectName: f.project,
|
|
|
|
constraints: strategy.constraints || [],
|
|
|
|
parameters: strategy.parameters || {},
|
|
|
|
environment: GLOBAL_ENV,
|
|
|
|
strategyName: strategy.name,
|
|
|
|
})),
|
|
|
|
);
|
|
|
|
const newFeatures = features;
|
|
|
|
const featureEnvironments = features.map(feature => ({
|
|
|
|
featureName: feature.name,
|
|
|
|
environment: GLOBAL_ENV,
|
|
|
|
enabled: feature.enabled,
|
|
|
|
}));
|
|
|
|
return {
|
|
|
|
features: newFeatures,
|
|
|
|
featureStrategies: strategies,
|
|
|
|
featureEnvironments,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2020-11-03 14:56:07 +01:00
|
|
|
async importFeatures({
|
|
|
|
features,
|
|
|
|
userName,
|
|
|
|
dropBeforeImport,
|
|
|
|
keepExisting,
|
2021-07-07 10:46:50 +02:00
|
|
|
}): Promise<void> {
|
2020-11-03 14:56:07 +01:00
|
|
|
this.logger.info(`Importing ${features.length} feature toggles`);
|
|
|
|
const oldToggles = dropBeforeImport
|
|
|
|
? []
|
|
|
|
: await this.toggleStore.getFeatures();
|
|
|
|
|
|
|
|
if (dropBeforeImport) {
|
2021-02-23 06:20:10 +01:00
|
|
|
this.logger.info('Dropping existing feature toggles');
|
2021-01-18 12:32:19 +01:00
|
|
|
await this.toggleStore.dropFeatures();
|
2020-11-03 14:56:07 +01:00
|
|
|
await this.eventStore.store({
|
|
|
|
type: DROP_FEATURES,
|
|
|
|
createdBy: userName,
|
|
|
|
data: { name: 'all-features' },
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
await Promise.all(
|
|
|
|
features
|
2021-03-12 11:08:10 +01:00
|
|
|
.filter(filterExisting(keepExisting, oldToggles))
|
2020-11-03 14:56:07 +01:00
|
|
|
.filter(filterEqual(oldToggles))
|
|
|
|
.map(feature =>
|
2021-07-07 10:46:50 +02:00
|
|
|
this.toggleStore
|
|
|
|
.createFeature(feature.project, feature)
|
|
|
|
.then(() => {
|
|
|
|
this.eventStore.store({
|
|
|
|
type: FEATURE_IMPORT,
|
|
|
|
createdBy: userName,
|
|
|
|
data: feature,
|
|
|
|
});
|
2021-01-18 12:32:19 +01:00
|
|
|
}),
|
2020-11-03 14:56:07 +01:00
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
async importStrategies({
|
|
|
|
strategies,
|
|
|
|
userName,
|
|
|
|
dropBeforeImport,
|
|
|
|
keepExisting,
|
2021-07-07 10:46:50 +02:00
|
|
|
}): Promise<void> {
|
2020-11-03 14:56:07 +01:00
|
|
|
this.logger.info(`Importing ${strategies.length} strategies`);
|
|
|
|
const oldStrategies = dropBeforeImport
|
|
|
|
? []
|
|
|
|
: await this.strategyStore.getStrategies();
|
|
|
|
|
|
|
|
if (dropBeforeImport) {
|
2021-02-23 06:20:10 +01:00
|
|
|
this.logger.info('Dropping existing strategies');
|
2021-01-18 12:32:19 +01:00
|
|
|
await this.strategyStore.dropStrategies();
|
2020-11-03 14:56:07 +01:00
|
|
|
await this.eventStore.store({
|
|
|
|
type: DROP_STRATEGIES,
|
|
|
|
createdBy: userName,
|
|
|
|
data: { name: 'all-strategies' },
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
await Promise.all(
|
|
|
|
strategies
|
2021-03-12 11:08:10 +01:00
|
|
|
.filter(filterExisting(keepExisting, oldStrategies))
|
2020-11-03 14:56:07 +01:00
|
|
|
.filter(filterEqual(oldStrategies))
|
|
|
|
.map(strategy =>
|
2021-01-18 12:32:19 +01:00
|
|
|
this.strategyStore.importStrategy(strategy).then(() => {
|
|
|
|
this.eventStore.store({
|
|
|
|
type: STRATEGY_IMPORT,
|
|
|
|
createdBy: userName,
|
|
|
|
data: strategy,
|
|
|
|
});
|
2020-11-03 14:56:07 +01:00
|
|
|
}),
|
|
|
|
),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2021-03-12 11:08:10 +01:00
|
|
|
async importProjects({
|
|
|
|
projects,
|
|
|
|
userName,
|
|
|
|
dropBeforeImport,
|
|
|
|
keepExisting,
|
2021-07-07 10:46:50 +02:00
|
|
|
}): Promise<void> {
|
2021-03-12 11:08:10 +01:00
|
|
|
this.logger.info(`Import ${projects.length} projects`);
|
|
|
|
const oldProjects = dropBeforeImport
|
|
|
|
? []
|
|
|
|
: await this.projectStore.getAll();
|
|
|
|
if (dropBeforeImport) {
|
|
|
|
this.logger.info('Dropping existing projects');
|
|
|
|
await this.projectStore.dropProjects();
|
|
|
|
await this.eventStore.store({
|
|
|
|
type: DROP_PROJECTS,
|
|
|
|
createdBy: userName,
|
|
|
|
data: { name: 'all-projects' },
|
|
|
|
});
|
|
|
|
}
|
|
|
|
const projectsToImport = projects.filter(project =>
|
|
|
|
keepExisting
|
|
|
|
? !oldProjects.some(old => old.id === project.id)
|
|
|
|
: true,
|
|
|
|
);
|
|
|
|
if (projectsToImport.length > 0) {
|
|
|
|
const importedProjects = await this.projectStore.importProjects(
|
|
|
|
projectsToImport,
|
|
|
|
);
|
2021-04-16 15:29:23 +02:00
|
|
|
const importedProjectEvents = importedProjects.map(project => ({
|
|
|
|
type: PROJECT_IMPORT,
|
|
|
|
createdBy: userName,
|
|
|
|
data: project,
|
|
|
|
}));
|
2021-03-12 11:08:10 +01:00
|
|
|
await this.eventStore.batchStore(importedProjectEvents);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
async importTagData({
|
|
|
|
tagTypes,
|
|
|
|
tags,
|
|
|
|
featureTags,
|
|
|
|
userName,
|
|
|
|
dropBeforeImport,
|
|
|
|
keepExisting,
|
2021-07-07 10:46:50 +02:00
|
|
|
}): Promise<void> {
|
2021-03-12 11:08:10 +01:00
|
|
|
this.logger.info(
|
|
|
|
`Importing ${tagTypes.length} tagtypes, ${tags.length} tags and ${featureTags.length} feature tags`,
|
|
|
|
);
|
|
|
|
const oldTagTypes = dropBeforeImport
|
|
|
|
? []
|
|
|
|
: await this.tagTypeStore.getAll();
|
|
|
|
const oldTags = dropBeforeImport ? [] : await this.tagStore.getAll();
|
|
|
|
const oldFeatureTags = dropBeforeImport
|
|
|
|
? []
|
2021-07-07 10:46:50 +02:00
|
|
|
: await this.featureTagStore.getAllFeatureTags();
|
2021-03-12 11:08:10 +01:00
|
|
|
if (dropBeforeImport) {
|
|
|
|
this.logger.info(
|
|
|
|
'Dropping all existing featuretags, tags and tagtypes',
|
|
|
|
);
|
2021-07-07 10:46:50 +02:00
|
|
|
await this.featureTagStore.dropFeatureTags();
|
2021-03-12 11:08:10 +01:00
|
|
|
await this.tagStore.dropTags();
|
|
|
|
await this.tagTypeStore.dropTagTypes();
|
|
|
|
await this.eventStore.batchStore([
|
|
|
|
{
|
|
|
|
type: DROP_FEATURE_TAGS,
|
|
|
|
createdBy: userName,
|
|
|
|
data: { name: 'all-feature-tags' },
|
|
|
|
},
|
|
|
|
{
|
|
|
|
type: DROP_TAGS,
|
|
|
|
createdBy: userName,
|
|
|
|
data: { name: 'all-tags' },
|
|
|
|
},
|
|
|
|
{
|
|
|
|
type: DROP_TAG_TYPES,
|
|
|
|
createdBy: userName,
|
|
|
|
data: { name: 'all-tag-types' },
|
|
|
|
},
|
|
|
|
]);
|
|
|
|
}
|
|
|
|
await this.importTagTypes(
|
|
|
|
tagTypes,
|
|
|
|
keepExisting,
|
|
|
|
oldTagTypes,
|
|
|
|
userName,
|
|
|
|
);
|
|
|
|
await this.importTags(tags, keepExisting, oldTags, userName);
|
|
|
|
await this.importFeatureTags(
|
|
|
|
featureTags,
|
|
|
|
keepExisting,
|
|
|
|
oldFeatureTags,
|
|
|
|
userName,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
compareFeatureTags: (old: IFeatureTag, tag: IFeatureTag) => boolean = (
|
|
|
|
old,
|
|
|
|
tag,
|
|
|
|
) =>
|
2021-03-12 11:08:10 +01:00
|
|
|
old.featureName === tag.featureName &&
|
|
|
|
old.tagValue === tag.tagValue &&
|
|
|
|
old.tagType === tag.tagType;
|
|
|
|
|
|
|
|
async importFeatureTags(
|
2021-07-07 10:46:50 +02:00
|
|
|
featureTags: IFeatureTag[],
|
|
|
|
keepExisting: boolean,
|
|
|
|
oldFeatureTags: IFeatureTag[],
|
|
|
|
userName: string,
|
|
|
|
): Promise<void> {
|
2021-03-12 11:08:10 +01:00
|
|
|
const featureTagsToInsert = featureTags.filter(tag =>
|
|
|
|
keepExisting
|
|
|
|
? !oldFeatureTags.some(old => this.compareFeatureTags(old, tag))
|
|
|
|
: true,
|
|
|
|
);
|
|
|
|
if (featureTagsToInsert.length > 0) {
|
2021-07-07 10:46:50 +02:00
|
|
|
const importedFeatureTags = await this.featureTagStore.importFeatureTags(
|
2021-03-12 11:08:10 +01:00
|
|
|
featureTagsToInsert,
|
|
|
|
);
|
2021-04-16 15:29:23 +02:00
|
|
|
const importedFeatureTagEvents = importedFeatureTags.map(tag => ({
|
|
|
|
type: FEATURE_TAG_IMPORT,
|
|
|
|
createdBy: userName,
|
|
|
|
data: tag,
|
|
|
|
}));
|
2021-03-12 11:08:10 +01:00
|
|
|
await this.eventStore.batchStore(importedFeatureTagEvents);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
compareTags = (old: ITag, tag: ITag): boolean =>
|
2021-03-12 11:08:10 +01:00
|
|
|
old.type === tag.type && old.value === tag.value;
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
async importTags(
|
|
|
|
tags: ITag[],
|
|
|
|
keepExisting: boolean,
|
|
|
|
oldTags: ITag[],
|
|
|
|
userName: string,
|
|
|
|
): Promise<void> {
|
2021-03-12 11:08:10 +01:00
|
|
|
const tagsToInsert = tags.filter(tag =>
|
|
|
|
keepExisting
|
|
|
|
? !oldTags.some(old => this.compareTags(old, tag))
|
|
|
|
: true,
|
|
|
|
);
|
|
|
|
if (tagsToInsert.length > 0) {
|
|
|
|
const importedTags = await this.tagStore.bulkImport(tagsToInsert);
|
2021-04-16 15:29:23 +02:00
|
|
|
const importedTagEvents = importedTags.map(tag => ({
|
|
|
|
type: TAG_IMPORT,
|
|
|
|
createdBy: userName,
|
|
|
|
data: tag,
|
|
|
|
}));
|
2021-03-12 11:08:10 +01:00
|
|
|
await this.eventStore.batchStore(importedTagEvents);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
async importTagTypes(
|
|
|
|
tagTypes: ITagType[],
|
|
|
|
keepExisting: boolean,
|
|
|
|
oldTagTypes: ITagType[] = [],
|
|
|
|
userName: string,
|
|
|
|
): Promise<void> {
|
2021-03-12 11:08:10 +01:00
|
|
|
const tagTypesToInsert = tagTypes.filter(tagType =>
|
|
|
|
keepExisting
|
|
|
|
? !oldTagTypes.some(t => t.name === tagType.name)
|
|
|
|
: true,
|
|
|
|
);
|
|
|
|
if (tagTypesToInsert.length > 0) {
|
|
|
|
const importedTagTypes = await this.tagTypeStore.bulkImport(
|
|
|
|
tagTypesToInsert,
|
|
|
|
);
|
2021-04-16 15:29:23 +02:00
|
|
|
const importedTagTypeEvents = importedTagTypes.map(tagType => ({
|
|
|
|
type: TAG_TYPE_IMPORT,
|
|
|
|
createdBy: userName,
|
|
|
|
data: tagType,
|
|
|
|
}));
|
2021-03-12 11:08:10 +01:00
|
|
|
await this.eventStore.batchStore(importedTagTypeEvents);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
async export({
|
|
|
|
includeFeatureToggles = true,
|
|
|
|
includeStrategies = true,
|
|
|
|
includeProjects = true,
|
|
|
|
includeTags = true,
|
2021-07-07 10:46:50 +02:00
|
|
|
includeEnvironments = true,
|
|
|
|
}): Promise<{
|
|
|
|
features: FeatureToggle[];
|
|
|
|
strategies: IStrategy[];
|
|
|
|
version: number;
|
|
|
|
projects: IProject[];
|
|
|
|
tagTypes: ITagType[];
|
|
|
|
tags: ITag[];
|
|
|
|
featureTags: IFeatureTag[];
|
|
|
|
featureStrategies: IFeatureStrategy[];
|
|
|
|
environments: IEnvironment[];
|
|
|
|
featureEnvironments: IFeatureEnvironment[];
|
|
|
|
}> {
|
2020-11-03 14:56:07 +01:00
|
|
|
return Promise.all([
|
|
|
|
includeFeatureToggles
|
|
|
|
? this.toggleStore.getFeatures()
|
2021-07-07 10:46:50 +02:00
|
|
|
: Promise.resolve([]),
|
2020-11-03 14:56:07 +01:00
|
|
|
includeStrategies
|
|
|
|
? this.strategyStore.getEditableStrategies()
|
2021-07-07 10:46:50 +02:00
|
|
|
: Promise.resolve([]),
|
2021-03-12 11:08:10 +01:00
|
|
|
this.projectStore && includeProjects
|
|
|
|
? this.projectStore.getAll()
|
2021-07-07 10:46:50 +02:00
|
|
|
: Promise.resolve([]),
|
|
|
|
includeTags ? this.tagTypeStore.getAll() : Promise.resolve([]),
|
|
|
|
includeTags ? this.tagStore.getAll() : Promise.resolve([]),
|
2021-03-12 11:08:10 +01:00
|
|
|
includeTags
|
2021-07-07 10:46:50 +02:00
|
|
|
? this.featureTagStore.getAllFeatureTags()
|
|
|
|
: Promise.resolve([]),
|
|
|
|
includeFeatureToggles
|
|
|
|
? this.featureStrategiesStore.getAll()
|
|
|
|
: Promise.resolve([]),
|
|
|
|
includeEnvironments
|
|
|
|
? this.environmentStore.getAll()
|
|
|
|
: Promise.resolve([]),
|
|
|
|
includeFeatureToggles
|
|
|
|
? this.featureStrategiesStore.getAllFeatureEnvironments()
|
|
|
|
: Promise.resolve([]),
|
2021-03-12 11:08:10 +01:00
|
|
|
]).then(
|
|
|
|
([
|
|
|
|
features,
|
|
|
|
strategies,
|
|
|
|
projects,
|
|
|
|
tagTypes,
|
|
|
|
tags,
|
|
|
|
featureTags,
|
2021-07-07 10:46:50 +02:00
|
|
|
featureStrategies,
|
|
|
|
environments,
|
|
|
|
featureEnvironments,
|
2021-03-12 11:08:10 +01:00
|
|
|
]) => ({
|
2021-07-07 10:46:50 +02:00
|
|
|
version: 2,
|
2021-03-12 11:08:10 +01:00
|
|
|
features,
|
|
|
|
strategies,
|
|
|
|
projects,
|
|
|
|
tagTypes,
|
|
|
|
tags,
|
|
|
|
featureTags,
|
2021-07-07 10:46:50 +02:00
|
|
|
featureStrategies,
|
|
|
|
environments,
|
|
|
|
featureEnvironments,
|
2021-03-12 11:08:10 +01:00
|
|
|
}),
|
|
|
|
);
|
2020-11-03 14:56:07 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
module.exports = StateService;
|