@finos/legend-application-studio
Version:
Legend Studio application core
171 lines • 7.73 kB
JavaScript
/**
* Copyright (c) 2020-present, Goldman Sachs
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { createModelSchema, list, object, optional, primitive, } from 'serializr';
import { assertNonNullable, guaranteeNonEmptyString, SerializationFactory, usingModelSchema, } from '@finos/legend-shared';
import { LegendApplicationConfig, } from '@finos/legend-application';
import { QueryBuilderConfig } from '@finos/legend-query-builder';
import { DataProductConfig } from '@finos/legend-extension-dsl-data-product';
import { LegendIngestionConfiguration, validateIngestionDeploymentConfiguration, } from './LegendIngestionConfiguration.js';
export class ServiceRegistrationEnvironmentConfig {
env;
executionUrl;
modes = [];
managementUrl;
static serialization = new SerializationFactory(createModelSchema(ServiceRegistrationEnvironmentConfig, {
env: primitive(),
executionUrl: primitive(),
managementUrl: primitive(),
modes: list(primitive()),
}));
}
export class UserSearchConfig {
applicationDirectoryUrl;
userProfileImageUrl;
static serialization = new SerializationFactory(createModelSchema(UserSearchConfig, {
applicationDirectoryUrl: primitive(),
userProfileImageUrl: primitive(),
}));
}
class LegendStudioApplicationCoreOptions {
/**
* Indicates if we should enable strict-mode for graph builder
*
* Default to `false`
*/
enableGraphBuilderStrictMode = false;
/**
* Indicates whether we enable type ahead in all editors.
*
* Default to `false` because of performance reasons for large models.
*/
typeAheadEnabled = false;
projectCreationGroupIdSuggestion = 'org.finos.legend.*';
/**
* This flag is for any feature that is not production ready.
* Used to iterate over features until they are ready for production.
*/
NonProductionFeatureFlag = false;
/**
* Indicates if we should keep section index and do not rewrite/flatten the paths shortened by section
* imports.
*
* This flag will be kept until we have full support for section index
* See https://github.com/finos/legend-studio/issues/1067
*/
TEMPORARY__preserveSectionIndex = false;
/**
* This flag can be removed when the support for local connection is official
* Right now it's done to support the SnowflakeApp creation demo
* See https://github.com/finos/legend-engine/pull/1819
*/
TEMPORARY__enableLocalConnectionBuilder = false;
/**
* This flag enables creating a sandbox project via engine.
* Remove this flag once workflow is finalized.
*/
TEMPORARY__enableCreationOfSandboxProjects = false;
/**
* Provides service registration environment configs.
*
* TODO: when we modularize service, we can move this config to DSL Service preset. Then, we can remove
* the TEMPORARY__ prefix.
*
* @modularize
* See https://github.com/finos/legend-studio/issues/65
*/
TEMPORARY__serviceRegistrationConfig = [];
/**
* Config specific to query builder
*/
queryBuilderConfig;
ingestDeploymentConfig;
dataProductConfig;
userSearchConfig;
/**
* Indicates if we should enable oauth flow
*
* Default to `false`
*/
enableOauthFlow = false;
static serialization = new SerializationFactory(createModelSchema(LegendStudioApplicationCoreOptions, {
enableGraphBuilderStrictMode: optional(primitive()),
typeAheadEnabled: optional(primitive()),
projectCreationGroupIdSuggestion: optional(primitive()),
TEMPORARY__preserveSectionIndex: optional(primitive()),
TEMPORARY__enableCreationOfSandboxProjects: optional(primitive()),
TEMPORARY__enableLocalConnectionBuilder: optional(primitive()),
NonProductionFeatureFlag: optional(primitive()),
TEMPORARY__serviceRegistrationConfig: list(object(ServiceRegistrationEnvironmentConfig)),
queryBuilderConfig: optional(usingModelSchema(QueryBuilderConfig.serialization.schema)),
ingestDeploymentConfig: optional(usingModelSchema(LegendIngestionConfiguration.serialization.schema)),
dataProductConfig: optional(usingModelSchema(DataProductConfig.serialization.schema)),
userSearchConfig: optional(usingModelSchema(UserSearchConfig.serialization.schema)),
enableOauthFlow: optional(primitive()),
}));
static create(configData) {
return LegendStudioApplicationCoreOptions.serialization.fromJson(configData);
}
}
export class LegendStudioApplicationConfig extends LegendApplicationConfig {
options = new LegendStudioApplicationCoreOptions();
engineServerUrl;
engineQueryServerUrl;
depotServerUrl;
sdlcServerUrl;
sdlcServerBaseHeaders;
sdlcServerClient;
queryApplicationUrl;
showcaseServerUrl;
pctReportUrl;
constructor(input) {
super(input);
// engine
assertNonNullable(input.configData.engine, `Can't configure application: 'engine' field is missing`);
this.engineServerUrl = LegendApplicationConfig.resolveAbsoluteUrl(guaranteeNonEmptyString(input.configData.engine.url, `Can't configure application: 'engine.url' field is missing or empty`));
if (input.configData.engine.queryUrl) {
this.engineQueryServerUrl = LegendApplicationConfig.resolveAbsoluteUrl(input.configData.engine.queryUrl);
}
// depot
assertNonNullable(input.configData.depot, `Can't configure application: 'depot' field is missing`);
this.depotServerUrl = LegendApplicationConfig.resolveAbsoluteUrl(guaranteeNonEmptyString(input.configData.depot.url, `Can't configure application: 'depot.url' field is missing or empty`));
// sdlc
assertNonNullable(input.configData.sdlc, `Can't configure application: 'sdlc' field is missing`);
this.sdlcServerUrl = LegendApplicationConfig.resolveAbsoluteUrl(guaranteeNonEmptyString(input.configData.sdlc.url, `Can't configure application: 'sdlc.url' field is missing or empty`));
this.sdlcServerBaseHeaders = input.configData.sdlc.baseHeaders;
this.sdlcServerClient = input.configData.sdlc.client;
// query
if (input.configData.query?.url) {
this.queryApplicationUrl = LegendApplicationConfig.resolveAbsoluteUrl(input.configData.query.url);
}
// showcase
if (input.configData.showcase?.url) {
this.showcaseServerUrl = LegendApplicationConfig.resolveAbsoluteUrl(input.configData.showcase.url);
}
// pct
if (input.configData.pct?.reportUrl) {
this.pctReportUrl = LegendApplicationConfig.resolveAbsoluteUrl(input.configData.pct.reportUrl);
}
// options
this.options = LegendStudioApplicationCoreOptions.create(input.configData.extensions?.core ?? {});
if (this.options.ingestDeploymentConfig) {
validateIngestionDeploymentConfiguration(this.options.ingestDeploymentConfig);
}
}
getDefaultApplicationStorageKey() {
return 'legend-studio';
}
}
//# sourceMappingURL=LegendStudioApplicationConfig.js.map