@finos/legend-application 3.0.2 → 4.0.1

package/src/index.ts

@@ -14,31 +14,42 @@
  * limitations under the License.
  */
 
-export * from './const';
-
-export * from './application/LegendApplicationPluginManager';
-export * from './application/LegendApplication';
-
-export * from './components/ApplicationStoreProvider';
-export * from './components/WebApplicationNavigatorProvider';
-export * from './components/LegendApplicationComponentFrameworkProvider';
-
-export * from './components/ApplicationStoreProviderTestUtils';
-export * from './components/WebApplicationNavigatorProviderTestUtils';
-
-export { AppHeader } from './components/AppHeader';
-export { DocumentationLink } from './components/DocumentationLink';
-export * from './components/TextInputEditor';
-export * from './components/LambdaEditor';
-
-export * from './stores/ApplicationStore';
-export * from './stores/ApplicationTelemetry';
-export * from './stores/ApplicationEvent';
-export * from './stores/LegendApplicationConfig';
-export { WebApplicationNavigator } from './stores/WebApplicationNavigator';
-export { LambdaEditorState } from './stores/LambdaEditorState';
-export * from './stores/PackageableElementOption';
-export * from './stores/LegendApplicationDocumentationRegistry';
-export * from './stores/LegendApplicationPlugin';
-
-export * from './stores/ApplicationStoreTestUtils';
+export * from './const.js';
+
+export * from './application/LegendApplicationPluginManager.js';
+export * from './application/LegendApplication.js';
+
+export * from './components/ApplicationStoreProvider.js';
+export * from './components/WebApplicationNavigatorProvider.js';
+export * from './components/LegendApplicationComponentFrameworkProvider.js';
+export * from './components/LegendApplicationNavigationContextServiceUtils.js';
+
+export * from './components/ApplicationStoreProviderTestUtils.js';
+export * from './components/WebApplicationNavigatorProviderTestUtils.js';
+
+// TODO: consider moving this to `LegendApplicationComponentFrameworkProvider`
+// once we think we can add virtual assistant support for all apps
+export * from './components/VirtualAssistant.js';
+
+export * from './components/DocumentationLink.js';
+export * from './components/TextInputEditor.js';
+export * from './components/LambdaEditor.js';
+export * from './components/BasicValueSpecificationEditor.js';
+export * from './components/LambdaParameterValuesEditor.js';
+
+export * from './stores/ApplicationStore.js';
+export * from './stores/ApplicationTelemetry.js';
+export * from './stores/ApplicationEvent.js';
+export * from './stores/LegendApplicationConfig.js';
+export { WebApplicationNavigator } from './stores/WebApplicationNavigator.js';
+export { LambdaEditorState } from './stores/LambdaEditorState.js';
+export * from './stores/PackageableElementOption.js';
+export * from './stores/LegendApplicationDocumentationService.js';
+export * from './stores/LegendApplicationEventService.js';
+export * from './stores/LegendApplicationAssistantService.js';
+export * from './stores/LegendApplicationNavigationContextService.js';
+export * from './stores/LegendApplicationPlugin.js';
+
+export * from './stores/ApplicationStoreTestUtils.js';
+export * from './stores/ValueSpecificationModifierHelper.js';
+export * from './stores/LambdaParameterState.js';

package/src/stores/ApplicationEvent.ts

@@ -15,13 +15,17 @@
  */
 
 export enum APPLICATION_EVENT {
-  TEXT_EDITOR_FONT_LOADED = 'TEXT_EDITOR_FONT_LOADED',
-  APPLICATION_SETUP_FAILURE = 'APPLICATION_SETUP_FAILURE',
+  TEXT_EDITOR_FONT_LOADED = 'application.load.font.success',
+  APPLICATION_SETUP_FAILURE = 'application.setup.failure',
 
-  APPLICATION_FAILURE = 'APPLICATION_FAILURE',
-  APPLICATION_CONFIGURATION_FAILURE = 'APPLICATION_CONFIGURATION_FAILURE',
-  ILLEGAL_APPLICATION_STATE_OCCURRED = 'ILLEGAL_APPLICATION_STATE_OCCURRED',
-  APPLICATION_LOADED = 'APPLICATION_LOADED',
+  ILLEGAL_APPLICATION_STATE_OCCURRED = 'application.error.illegal-state',
+  APPLICATION_CONFIGURATION_FAILURE = 'application.configuration.failure',
 
-  DEVELOPMENT_ISSUE = 'DEVELOPMENT_ISSUE',
+  APPLICATION_DOCUMTENTION_LOAD_SKIPPED = 'application.load.documentation.skipped',
+  APPLICATION_CONTEXTUAL_DOCUMTENTION_LOAD_SKIPPED = 'application.load.contextual-documentation.skipped',
+
+  APPLICATION_LOADED = 'application.load.success',
+  APPLICATION_LOAD_FAILURE = 'application.load.failure',
+
+  DEVELOPMENT_ISSUE = 'development.issue',
 }

package/src/stores/ApplicationStore.ts

@@ -16,7 +16,6 @@
 
 import {
   type SuperGenericFunction,
-  EventNotifierService,
   TracerService,
   TelemetryService,
   assertTrue,
@@ -27,11 +26,14 @@ import {
   ApplicationError,
 } from '@finos/legend-shared';
 import { makeAutoObservable, action } from 'mobx';
-import { APPLICATION_EVENT } from './ApplicationEvent';
-import type { LegendApplicationConfig } from './LegendApplicationConfig';
-import type { WebApplicationNavigator } from './WebApplicationNavigator';
-import type { LegendApplicationPluginManager } from '../application/LegendApplicationPluginManager';
-import { LegendApplicationDocumentationRegistry } from './LegendApplicationDocumentationRegistry';
+import { APPLICATION_EVENT } from './ApplicationEvent.js';
+import type { LegendApplicationConfig } from './LegendApplicationConfig.js';
+import type { WebApplicationNavigator } from './WebApplicationNavigator.js';
+import type { LegendApplicationPluginManager } from '../application/LegendApplicationPluginManager.js';
+import { LegendApplicationDocumentationService } from './LegendApplicationDocumentationService.js';
+import { LegendApplicationAssistantService } from './LegendApplicationAssistantService.js';
+import { LegendApplicationEventService } from './LegendApplicationEventService.js';
+import { LegendApplicationNavigationContextService } from './LegendApplicationNavigationContextService.js';
 
 export enum ActionAlertType {
   STANDARD = 'STANDARD',
@@ -101,17 +103,29 @@ export class Notification {
 }
 
 export class ApplicationStore<T extends LegendApplicationConfig> {
+  pluginManager: LegendApplicationPluginManager;
+  config: T;
+
+  // navigation
   navigator: WebApplicationNavigator;
+  navigationContextService: LegendApplicationNavigationContextService;
+
+  // TODO: refactor this to `NotificationService` including notifications and alerts
   notification?: Notification | undefined;
   blockingAlertInfo?: BlockingAlertInfo | undefined;
   actionAlertInfo?: ActionAlertInfo | undefined;
-  config: T;
-  docRegistry: LegendApplicationDocumentationRegistry;
 
+  // TODO: consider renaming this to `LogService`
   log: Log = new Log();
+
+  // documentation & help
+  documentationService: LegendApplicationDocumentationService;
+  assistantService: LegendApplicationAssistantService;
+
+  // communication
+  eventService = new LegendApplicationEventService();
   telemetryService = new TelemetryService();
   tracerService = new TracerService();
-  eventNotifierService = new EventNotifierService();
 
   constructor(
     config: T,
@@ -121,7 +135,7 @@ export class ApplicationStore<T extends LegendApplicationConfig> {
     makeAutoObservable(this, {
       navigator: false,
       setBlockingAlert: action,
-      setActionAltertInfo: action,
+      setActionAlertInfo: action,
       setNotification: action,
       notify: action,
       notifySuccess: action,
@@ -132,29 +146,17 @@ export class ApplicationStore<T extends LegendApplicationConfig> {
 
     this.config = config;
     this.navigator = navigator;
-
-    // Documentation
-    this.docRegistry = new LegendApplicationDocumentationRegistry();
-    [
-      ...pluginManager
-        .getApplicationPlugins()
-        .flatMap(
-          (plugin) => plugin.getExtraKeyedDocumentationEntries?.() ?? [],
-        ),
-      // entries from config will override entries specified natively
-      ...config.documentationKeyedEntries,
-    ].forEach((entry) =>
-      this.docRegistry.registerEntry(entry.key, entry.content),
-    );
-    this.docRegistry.url = this.config.documentationUrl;
-
-    // Register plugins
+    this.pluginManager = pluginManager;
+    this.navigationContextService =
+      new LegendApplicationNavigationContextService();
+    this.documentationService = new LegendApplicationDocumentationService(this);
+    this.assistantService = new LegendApplicationAssistantService(this);
     this.log.registerPlugins(pluginManager.getLoggerPlugins());
     this.telemetryService.registerPlugins(
       pluginManager.getTelemetryServicePlugins(),
     );
     this.tracerService.registerPlugins(pluginManager.getTracerServicePlugins());
-    this.eventNotifierService.registerPlugins(
+    this.eventService.registerEventNotifierPlugins(
       pluginManager.getEventNotifierPlugins(),
     );
   }
@@ -163,7 +165,7 @@ export class ApplicationStore<T extends LegendApplicationConfig> {
     this.blockingAlertInfo = alertInfo;
   }
 
-  setActionAltertInfo(alertInfo: ActionAlertInfo | undefined): void {
+  setActionAlertInfo(alertInfo: ActionAlertInfo | undefined): void {
     if (this.actionAlertInfo && alertInfo) {
       this.notifyIllegalState(
         'Action alert is stacked: new alert is invoked while another one is being displayed',

package/src/stores/ApplicationStoreTestUtils.ts

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-import { ApplicationStore } from './ApplicationStore';
+import { ApplicationStore } from './ApplicationStore.js';
 import { createBrowserHistory } from 'history';
-import { WebApplicationNavigator } from './WebApplicationNavigator';
-import type { LegendApplicationConfig } from './LegendApplicationConfig';
-import type { LegendApplicationPluginManager } from '../application/LegendApplicationPluginManager';
+import { WebApplicationNavigator } from './WebApplicationNavigator.js';
+import type { LegendApplicationConfig } from './LegendApplicationConfig.js';
+import type { LegendApplicationPluginManager } from '../application/LegendApplicationPluginManager.js';
 
 export const TEST_DATA__applicationVersion = {
   buildTime: '2001-01-01T00:00:00-0000',

package/src/stores/ApplicationTelemetry.ts

@@ -15,7 +15,7 @@
  */
 
 import type { TelemetryService } from '@finos/legend-shared';
-import { APPLICATION_EVENT } from './ApplicationEvent';
+import { APPLICATION_EVENT } from './ApplicationEvent.js';
 
 type ApplicationLoaded_TelemetryData = {
   browser: {
@@ -28,7 +28,7 @@ type ApplicationLoaded_TelemetryData = {
 };
 
 export class ApplicationTelemetry {
-  static logEvent_GraphInitialized(
+  static logEvent_AppInitialized(
     telemetryService: TelemetryService,
     data: ApplicationLoaded_TelemetryData,
   ): void {

package/src/stores/CJS__Fuse.cts

@@ -0,0 +1,28 @@
+/**
+ * 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.
+ */
+
+/**
+ * Previously, these exports rely on ES module interop to expose `default` export
+ * properly. But since we use `ESM` for Typescript resolution now, we lose this
+ * so we have to workaround by importing these and re-export them from CJS
+ *
+ * TODO: remove these when the package properly work with Typescript's nodenext
+ * module resolution
+ *
+ * @workaround ESM
+ * See https://github.com/microsoft/TypeScript/issues/49298
+ */
+export { default as Fuse } from 'fuse.js';

package/src/stores/LambdaEditorState.ts

@@ -27,7 +27,7 @@ import {
  * editing _something_ but allows user to edit via text.
  */
 export abstract class LambdaEditorState {
-  uuid = uuid();
+  readonly uuid = uuid();
   lambdaPrefix: string;
   lambdaString: string; // value shown in lambda editor which can be edited
   parserError?: ParserError | undefined;
@@ -71,8 +71,8 @@ export abstract class LambdaEditorState {
   setCompilationError(compilationError: CompilationError | undefined): void {
     // account for the lambda prefix offset in source information
     if (compilationError?.sourceInformation) {
-      compilationError.setSourceInformation(
-        this.processSourceInformation(compilationError.sourceInformation),
+      compilationError.sourceInformation = this.processSourceInformation(
+        compilationError.sourceInformation,
       );
     }
     this.compilationError = compilationError;
@@ -81,8 +81,8 @@ export abstract class LambdaEditorState {
   setParserError(parserError: ParserError | undefined): void {
     // account for the lambda prefix offset in source information
     if (parserError?.sourceInformation) {
-      parserError.setSourceInformation(
-        this.processSourceInformation(parserError.sourceInformation),
+      parserError.sourceInformation = this.processSourceInformation(
+        parserError.sourceInformation,
       );
     }
     this.parserError = parserError;

package/src/stores/LambdaParameterState.ts

@@ -0,0 +1,314 @@
+/**
+ * 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 {
+  type InstanceValue,
+  type Multiplicity,
+  type ObserverContext,
+  type Type,
+  type ValueSpecification,
+  type PureModel,
+  CollectionInstanceValue,
+  Enumeration,
+  EnumValueExplicitReference,
+  EnumValueInstanceValue,
+  GenericType,
+  GenericTypeExplicitReference,
+  getEnumValue,
+  observe_ValueSpecification,
+  observe_VariableExpression,
+  PrimitiveInstanceValue,
+  PrimitiveType,
+  PRIMITIVE_TYPE,
+  VariableExpression,
+  LambdaFunction,
+  TYPICAL_MULTIPLICITY_TYPE,
+  CORE_PURE_PATH,
+  FunctionType,
+  SimpleFunctionExpression,
+  SUPPORTED_FUNCTIONS,
+  extractElementNameFromPath,
+} from '@finos/legend-graph';
+import {
+  addUniqueEntry,
+  deleteEntry,
+  IllegalStateError,
+  isNonNullable,
+  Randomizer,
+  uuid,
+} from '@finos/legend-shared';
+import { makeObservable, observable, action } from 'mobx';
+import {
+  genericType_setRawType,
+  multiplicity_setLowerBound,
+  multiplicity_setUpperBound,
+} from './ValueSpecificationModifierHelper.js';
+import { format, addDays } from 'date-fns';
+import { DATE_FORMAT, DATE_TIME_FORMAT } from '../const.js';
+
+export enum PARAMETER_SUBMIT_ACTION {
+  EXECUTE = 'EXECUTE',
+  EXPORT = 'EXPORT',
+}
+
+export const createMockEnumerationProperty = (
+  enumeration: Enumeration,
+): string =>
+  new Randomizer().getRandomItemInCollection(enumeration.values)?.name ?? '';
+
+const createMockPrimitiveProperty = (
+  primitiveType: PrimitiveType,
+  propertyName: string,
+): string | number | boolean => {
+  const randomizer = new Randomizer();
+  switch (primitiveType.name) {
+    case PRIMITIVE_TYPE.BOOLEAN:
+      return randomizer.getRandomItemInCollection([true, false]) ?? true;
+    case PRIMITIVE_TYPE.FLOAT:
+      return randomizer.getRandomFloat();
+    case PRIMITIVE_TYPE.DECIMAL:
+      return randomizer.getRandomDouble();
+    case PRIMITIVE_TYPE.NUMBER:
+    case PRIMITIVE_TYPE.INTEGER:
+      return randomizer.getRandomWholeNumber(100);
+    // NOTE that `Date` is the umbrella type that comprises `StrictDate` and `DateTime`, but for simplicity, we will generate `Date` as `StrictDate`
+    case PRIMITIVE_TYPE.DATE:
+    case PRIMITIVE_TYPE.STRICTDATE:
+      return format(
+        randomizer.getRandomDate(
+          new Date(Date.now()),
+          addDays(Date.now(), 100),
+        ),
+        DATE_FORMAT,
+      );
+    case PRIMITIVE_TYPE.DATETIME:
+      return format(
+        randomizer.getRandomDate(
+          new Date(Date.now()),
+          addDays(Date.now(), 100),
+        ),
+        DATE_TIME_FORMAT,
+      );
+    case PRIMITIVE_TYPE.STRING:
+    default:
+      return `${propertyName} ${randomizer.getRandomWholeNumber(100)}`;
+  }
+};
+
+export const buildParametersLetLambdaFunc = (
+  graph: PureModel,
+  lambdaParametersStates: LambdaParameterState[],
+): LambdaFunction => {
+  const multiplicityOne = graph.getTypicalMultiplicity(
+    TYPICAL_MULTIPLICITY_TYPE.ONE,
+  );
+  const typeString = graph.getPrimitiveType(PRIMITIVE_TYPE.STRING);
+  const typeAny = graph.getType(CORE_PURE_PATH.ANY);
+  const letlambdaFunction = new LambdaFunction(
+    new FunctionType(typeAny, multiplicityOne),
+  );
+  letlambdaFunction.expressionSequence = lambdaParametersStates
+    .map((queryParamState) => {
+      if (queryParamState.value) {
+        const letFunc = new SimpleFunctionExpression(
+          extractElementNameFromPath(SUPPORTED_FUNCTIONS.LET),
+          multiplicityOne,
+        );
+        const letVar = new PrimitiveInstanceValue(
+          GenericTypeExplicitReference.create(new GenericType(typeString)),
+          multiplicityOne,
+        );
+        letVar.values = [queryParamState.variableName];
+        letFunc.parametersValues.push(letVar);
+        letFunc.parametersValues.push(queryParamState.value);
+        return letFunc;
+      }
+      return undefined;
+    })
+    .filter(isNonNullable);
+  return letlambdaFunction;
+};
+
+export class LambdaParameterState {
+  readonly uuid = uuid();
+  readonly parameter: VariableExpression;
+  observableContext: ObserverContext;
+  value: ValueSpecification | undefined;
+
+  constructor(
+    variableExpression: VariableExpression,
+    observableContext: ObserverContext,
+  ) {
+    makeObservable(this, {
+      value: observable,
+      setValue: action,
+      mockParameterValue: action,
+    });
+    this.observableContext = observableContext;
+    this.parameter = observe_VariableExpression(variableExpression);
+  }
+
+  mockParameterValue(): void {
+    this.setValue(
+      this.generateMockValues(
+        this.parameter.genericType?.value.rawType,
+        this.parameter.multiplicity,
+      ),
+    );
+  }
+
+  private generateMockValues(
+    varType: Type | undefined,
+    multiplicity: Multiplicity,
+  ): InstanceValue | undefined {
+    if ((!multiplicity.upperBound || multiplicity.upperBound > 1) && varType) {
+      return new CollectionInstanceValue(
+        multiplicity,
+        GenericTypeExplicitReference.create(new GenericType(varType)),
+      );
+    }
+    if (varType instanceof PrimitiveType) {
+      const primitiveInst = new PrimitiveInstanceValue(
+        GenericTypeExplicitReference.create(new GenericType(varType)),
+        multiplicity,
+      );
+      primitiveInst.values = [
+        createMockPrimitiveProperty(
+          varType,
+          this.parameter.name === '' ? 'myVar' : this.parameter.name,
+        ),
+      ];
+      return primitiveInst;
+    } else if (varType instanceof Enumeration) {
+      const enumValueInstance = new EnumValueInstanceValue(
+        GenericTypeExplicitReference.create(new GenericType(varType)),
+        multiplicity,
+      );
+      const mock = createMockEnumerationProperty(varType);
+      if (mock !== '') {
+        enumValueInstance.values = [
+          EnumValueExplicitReference.create(getEnumValue(varType, mock)),
+        ];
+      }
+      return enumValueInstance;
+    }
+    return undefined;
+  }
+
+  setValue(value: ValueSpecification | undefined): void {
+    if (value instanceof VariableExpression) {
+      throw new IllegalStateError(
+        'Can not assign a parameter to another parameter',
+      );
+    }
+    this.value = value
+      ? observe_ValueSpecification(value, this.observableContext)
+      : undefined;
+  }
+
+  changeVariableType(type: Type): void {
+    if (type !== this.variableType) {
+      const genricType = this.parameter.genericType?.value;
+      if (genricType) {
+        genericType_setRawType(genricType, type);
+      }
+      this.mockParameterValue();
+    }
+  }
+
+  changeMultiplicity(
+    lowerBound: number,
+    uppderBound: number | undefined,
+  ): void {
+    const current = this.parameter.multiplicity;
+    if (
+      current.lowerBound !== lowerBound ||
+      current.upperBound !== uppderBound
+    ) {
+      multiplicity_setLowerBound(current, lowerBound);
+      multiplicity_setUpperBound(current, uppderBound);
+      this.mockParameterValue();
+    }
+  }
+
+  get variableName(): string {
+    return this.parameter.name;
+  }
+
+  get variableType(): Type | undefined {
+    return this.parameter.genericType?.value.rawType;
+  }
+}
+
+export class ParameterInstanceValuesEditorState {
+  showModal = false;
+  submitAction:
+    | {
+        handler: () => Promise<void>;
+        label: string;
+      }
+    | undefined;
+
+  constructor() {
+    makeObservable(this, {
+      showModal: observable,
+      submitAction: observable,
+      setShowModal: action,
+      open: action,
+      setSubmitAction: action,
+    });
+  }
+
+  setShowModal(val: boolean): void {
+    this.showModal = val;
+  }
+
+  setSubmitAction(
+    val:
+      | {
+          handler: () => Promise<void>;
+          label: string;
+        }
+      | undefined,
+  ): void {
+    this.submitAction = val;
+  }
+
+  open(handler: () => Promise<void>, label: string): void {
+    this.setSubmitAction({ handler, label });
+    this.setShowModal(true);
+  }
+
+  close(): void {
+    this.setSubmitAction(undefined);
+    this.setShowModal(false);
+  }
+}
+export class LambdaParametersState {
+  parameterStates: LambdaParameterState[] = [];
+  parameterValuesEditorState = new ParameterInstanceValuesEditorState();
+
+  addParameter(val: LambdaParameterState): void {
+    addUniqueEntry(this.parameterStates, val);
+  }
+
+  removeParameter(val: LambdaParameterState): void {
+    deleteEntry(this.parameterStates, val);
+  }
+  setParameters(val: LambdaParameterState[]): void {
+    this.parameterStates = val;
+  }
+}