@finos/legend-application-studio 26.1.1 → 26.1.3

package/src/components/editor/side-bar/Explorer.tsx

@@ -100,6 +100,7 @@ import {
   type PackageableElement,
   PackageableConnection,
   RelationalDatabaseConnection,
+  guaranteeRelationalDatabaseConnection,
 } from '@finos/legend-graph';
 import { useApplicationStore } from '@finos/legend-application';
 import {
@@ -122,7 +123,6 @@ import {
   CODE_EDITOR_LANGUAGE,
   CodeEditor,
 } from '@finos/legend-lego/code-editor';
-import { guaranteeRelationalDatabaseConnection } from '../../../stores/editor/editor-state/element-editor-state/connection/DatabaseBuilderState.js';
 import { DatabaseBuilder } from '../editor-group/connection-editor/DatabaseBuilder.js';
 
 const ElementRenamer = observer(() => {
@@ -684,7 +684,7 @@ const ExplorerContextMenu = observer(
           {elementTypes.map((type) => (
             <MenuContentItem key={type} onClick={createNewElement(type)}>
               <MenuContentItemIcon>
-                {getElementTypeIcon(editorStore, type)}
+                {getElementTypeIcon(type, editorStore)}
               </MenuContentItemIcon>
               <MenuContentItemLabel>
                 New {toTitleCase(getElementTypeLabel(editorStore, type))}...
@@ -844,7 +844,7 @@ const PackageTreeNodeContainer = observer(
         </div>
       )
     ) : (
-      getElementIcon(editorStore, node.packageableElement)
+      getElementIcon(node.packageableElement, editorStore)
     );
     const selectNode = (): void => onNodeSelect?.(node);
     const onContextMenuOpen = (): void => setIsSelectedFromContextMenu(true);
@@ -925,7 +925,7 @@ const ExplorerDropdownMenu = observer(() => {
       {elementTypes.map((type) => (
         <MenuContentItem key={type} onClick={createNewElement(type)}>
           <MenuContentItemIcon>
-            {getElementTypeIcon(editorStore, type)}
+            {getElementTypeIcon(type, editorStore)}
           </MenuContentItemIcon>
           <MenuContentItemLabel>
             New {toTitleCase(getElementTypeLabel(editorStore, type))}...
@@ -1146,7 +1146,7 @@ const ProjectExplorerActionPanel = observer((props: { disabled: boolean }) => {
   const isInGrammarMode =
     editorStore.graphEditorMode.mode === GRAPH_EDITOR_MODE.GRAMMAR_TEXT;
   const showSearchModal = (): void =>
-    editorStore.searchElementCommandState.open();
+    editorStore.setShowSearchElementCommand(true);
   // Explorer tree
   const selectedTreeNode = editorStore.explorerTreeState.selectedNode;
   const collapseTree = (): void => {

package/src/components/editor/side-bar/testable/GlobalTestRunner.tsx

@@ -317,10 +317,10 @@ const TestableTreeNodeContainer: React.FC<
     node instanceof TestableTreeNodeData
       ? node.testableMetadata.testable instanceof PackageableElement
         ? getElementTypeIcon(
-            editorStore,
             editorStore.graphState.getPackageableElementType(
               node.testableMetadata.testable,
             ),
+            editorStore,
           )
         : null
       : null;

package/src/components/extensions/Core_LegendStudioApplicationPlugin.tsx

@@ -39,6 +39,7 @@ import {
   configureCodeEditorComponent,
   setupPureLanguageService,
 } from '@finos/legend-lego/code-editor';
+import { STO_RELATIONAL_LEGEND_STUDIO_COMMAND_CONFIG } from '../../__lib__/STO_Relational_LegendStudioCommand.js';
 
 export class Core_LegendStudioApplicationPlugin extends LegendStudioApplicationPlugin {
   static NAME = packageJson.extensions.applicationStudioPlugin;
@@ -66,9 +67,14 @@ export class Core_LegendStudioApplicationPlugin extends LegendStudioApplicationP
   }
 
   override getExtraKeyedCommandConfigEntries(): KeyedCommandConfigEntry[] {
-    return collectKeyedCommandConfigEntriesFromConfig(
-      LEGEND_STUDIO_COMMAND_CONFIG,
-    );
+    return [
+      ...collectKeyedCommandConfigEntriesFromConfig(
+        LEGEND_STUDIO_COMMAND_CONFIG,
+      ),
+      ...collectKeyedCommandConfigEntriesFromConfig(
+        STO_RELATIONAL_LEGEND_STUDIO_COMMAND_CONFIG,
+      ),
+    ];
   }
 
   override getExtraRequiredDocumentationKeys(): string[] {

package/src/stores/editor/EditorConfig.ts

@@ -43,6 +43,7 @@ export enum PANEL_MODE {
   CONSOLE = 'COMPILE',
   DEV_TOOL = 'DEV_TOOL',
   PROBLEMS = 'PROBLEMS',
+  SQL_PLAYGROUND = 'SQL_PLAYGROUND',
 }
 
 export enum ELEMENT_NATIVE_VIEW_MODE {

package/src/stores/editor/EditorStore.ts

@@ -68,7 +68,7 @@ import {
   generateViewProjectRoute,
   type WorkspaceEditorPathParams,
 } from '../../__lib__/LegendStudioNavigation.js';
-import { NonBlockingDialogState, PanelDisplayState } from '@finos/legend-art';
+import { PanelDisplayState } from '@finos/legend-art';
 import type { DSL_LegendStudioApplicationPlugin_Extension } from '../LegendStudioApplicationPlugin.js';
 import type { Entity } from '@finos/legend-storage';
 import {
@@ -101,6 +101,8 @@ import { GraphEditFormModeState } from './GraphEditFormModeState.js';
 import type { GraphEditorMode } from './GraphEditorMode.js';
 import { GraphEditGrammarModeState } from './GraphEditGrammarModeState.js';
 import { GlobalBulkServiceRegistrationState } from './sidebar-state/BulkServiceRegistrationState.js';
+import { SQLPlaygroundPanelState } from './panel-group/SQLPlaygroundPanelState.js';
+import type { QuickInputState } from './QuickInputState.js';
 
 export abstract class EditorExtensionState {
   /**
@@ -149,6 +151,7 @@ export class EditorStore implements CommandRegistrar {
   conflictResolutionState: WorkspaceUpdateConflictResolutionState;
   globalBulkServiceRegistrationState: GlobalBulkServiceRegistrationState;
   devToolState: DevToolPanelState;
+  sqlPlaygroundState: SQLPlaygroundPanelState;
 
   modelImporterState: ModelImporterState;
   projectConfigurationEditorState: ProjectConfigurationEditorState;
@@ -159,7 +162,8 @@ export class EditorStore implements CommandRegistrar {
    * per file generation configuration type.
    */
   elementGenerationStates: ElementFileGenerationState[] = [];
-  searchElementCommandState = new NonBlockingDialogState();
+  showSearchElementCommand = false;
+  quickInputState?: QuickInputState<unknown> | undefined;
 
   activePanelMode: PANEL_MODE = PANEL_MODE.CONSOLE;
   readonly panelGroupDisplayState = new PanelDisplayState({
@@ -189,6 +193,8 @@ export class EditorStore implements CommandRegistrar {
       activePanelMode: observable,
       activeActivity: observable,
       graphEditorMode: observable,
+      showSearchElementCommand: observable,
+      quickInputState: observable,
 
       isInViewerMode: computed,
       isInConflictResolutionMode: computed,
@@ -201,6 +207,8 @@ export class EditorStore implements CommandRegistrar {
       cleanUp: action,
       reset: action,
       setActiveActivity: action,
+      setShowSearchElementCommand: action,
+      setQuickInputState: action,
 
       initialize: flow,
       initMode: flow,
@@ -227,6 +235,7 @@ export class EditorStore implements CommandRegistrar {
     this.graphEditorMode = new GraphEditFormModeState(this);
     this.changeDetectionState = new ChangeDetectionState(this, this.graphState);
     this.devToolState = new DevToolPanelState(this);
+    this.sqlPlaygroundState = new SQLPlaygroundPanelState(this);
     this.embeddedQueryBuilderState = new EmbeddedQueryBuilderState(this);
     // side bar panels
     this.explorerTreeState = new ExplorerTreeState(this);
@@ -308,6 +317,14 @@ export class EditorStore implements CommandRegistrar {
     this.mode = val;
   }
 
+  setShowSearchElementCommand(val: boolean): void {
+    this.showSearchElementCommand = val;
+  }
+
+  setQuickInputState<T>(val: QuickInputState<T> | undefined): void {
+    this.quickInputState = val as QuickInputState<unknown> | undefined;
+  }
+
   cleanUp(): void {
     // dismiss all the alerts as these are parts of application, if we don't do this, we might
     // end up blocking other parts of the app
@@ -370,7 +387,8 @@ export class EditorStore implements CommandRegistrar {
     this.applicationStore.commandService.registerCommand({
       key: LEGEND_STUDIO_COMMAND_KEY.SEARCH_ELEMENT,
       trigger: this.createEditorCommandTrigger(),
-      action: () => this.searchElementCommandState.open(),
+      action: () =>
+        this.setShowSearchElementCommand(!this.showSearchElementCommand),
     });
     this.applicationStore.commandService.registerCommand({
       key: LEGEND_STUDIO_COMMAND_KEY.TOGGLE_TEXT_MODE,
@@ -637,7 +655,6 @@ export class EditorStore implements CommandRegistrar {
         projectId,
         this.sdlcState.activeWorkspace,
       ),
-      this.graphManagerState.initializeSystem(), // this can be moved inside of `setupEngine`
       this.graphManagerState.graphManager.initialize(
         {
           env: this.applicationStore.config.env,
@@ -653,6 +670,7 @@ export class EditorStore implements CommandRegistrar {
         },
       ),
     ]);
+    yield this.graphManagerState.initializeSystem();
     yield flowResult(this.initMode());
 
     onLeave(true);
@@ -937,6 +955,7 @@ export class EditorStore implements CommandRegistrar {
       case GRAPH_EDITOR_MODE.GRAMMAR_TEXT: {
         const graphEditorMode = new GraphEditGrammarModeState(this);
         try {
+          yield flowResult(this.graphEditorMode.onLeave(fallbackOptions));
           yield flowResult(
             graphEditorMode.cleanupBeforeEntering(fallbackOptions),
           );

package/src/stores/editor/GraphEditFormModeState.ts

@@ -577,6 +577,7 @@ export class GraphEditFormModeState extends GraphEditorMode {
   }
 
   *onLeave(): GeneratorFn<void> {
+    this.editorStore.sqlPlaygroundState.setConnection(undefined);
     return;
   }
 

package/src/stores/editor/QuickInputState.ts

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+
+export type QuickInputOption<T> = { label: React.ReactNode; value: T };
+export type QuickInputState<T> = {
+  title?: string | undefined;
+  placeholder?: string | undefined;
+  options: QuickInputOption<T>[];
+  getSearchValue: (option: QuickInputOption<T>) => string;
+  onSelect: (option: QuickInputOption<T>) => void;
+};

package/src/stores/editor/editor-state/element-editor-state/FunctionEditorState.ts

@@ -14,7 +14,14 @@
  * limitations under the License.
  */
 
-import { computed, observable, action, makeObservable } from 'mobx';
+import {
+  computed,
+  observable,
+  action,
+  makeObservable,
+  flow,
+  flowResult,
+} from 'mobx';
 import type { EditorStore } from '../../EditorStore.js';
 import {
   type GeneratorFn,
@@ -22,6 +29,9 @@ import {
   LogEvent,
   guaranteeType,
   assertType,
+  StopWatch,
+  stringifyLosslessJSON,
+  filterByType,
 } from '@finos/legend-shared';
 import { ElementEditorState } from './ElementEditorState.js';
 import {
@@ -34,9 +44,26 @@ import {
   RawLambda,
   buildSourceInformationSourceId,
   isStubbed_PackageableElement,
+  type ExecutionResult,
+  type RawExecutionPlan,
+  reportGraphAnalytics,
+  buildLambdaVariableExpressions,
+  VariableExpression,
+  observe_ValueSpecification,
 } from '@finos/legend-graph';
-import { LambdaEditorState } from '@finos/legend-query-builder';
+import {
+  ExecutionPlanState,
+  LambdaEditorState,
+  LambdaParameterState,
+  LambdaParametersState,
+  PARAMETER_SUBMIT_ACTION,
+  QUERY_BUILDER_EVENT,
+  QueryBuilderTelemetryHelper,
+  buildExecutionParameterValues,
+  getExecutionQueryFromRawLambda,
+} from '@finos/legend-query-builder';
 import { FunctionActivatorBuilderState } from './FunctionActivatorBuilderState.js';
+import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
 
 export enum FUNCTION_EDITOR_TAB {
   DEFINITION = 'DEFINITION',
@@ -105,7 +132,7 @@ export class FunctionDefinitionEditorState extends LambdaEditorState {
         const lambdas = new Map<string, RawLambda>();
         const functionLamba = new RawLambda(
           [],
-          this.functionElement.expressionSequence as object,
+          this.functionElement.expressionSequence,
         );
         lambdas.set(this.lambdaId, functionLamba);
         const isolatedLambdas =
@@ -154,12 +181,74 @@ export class FunctionDefinitionEditorState extends LambdaEditorState {
   }
 }
 
+export class FunctionParametersState extends LambdaParametersState {
+  readonly functionEditorState: FunctionEditorState;
+
+  constructor(functionEditorState: FunctionEditorState) {
+    super();
+    makeObservable(this, {
+      parameterValuesEditorState: observable,
+      parameterStates: observable,
+      addParameter: action,
+      removeParameter: action,
+      openModal: action,
+      build: action,
+      setParameters: action,
+    });
+    this.functionEditorState = functionEditorState;
+  }
+
+  openModal(query: RawLambda): void {
+    this.parameterStates = this.build(query);
+    this.parameterValuesEditorState.open(
+      (): Promise<void> =>
+        flowResult(this.functionEditorState.runQuery()).catch(
+          this.functionEditorState.editorStore.applicationStore
+            .alertUnhandledError,
+        ),
+      PARAMETER_SUBMIT_ACTION.RUN,
+    );
+  }
+
+  build(query: RawLambda): LambdaParameterState[] {
+    const parameters = buildLambdaVariableExpressions(
+      query,
+      this.functionEditorState.editorStore.graphManagerState,
+    )
+      .map((parameter) =>
+        observe_ValueSpecification(
+          parameter,
+          this.functionEditorState.editorStore.changeDetectionState
+            .observerContext,
+        ),
+      )
+      .filter(filterByType(VariableExpression));
+    const states = parameters.map((variable) => {
+      const parmeterState = new LambdaParameterState(
+        variable,
+        this.functionEditorState.editorStore.changeDetectionState.observerContext,
+        this.functionEditorState.editorStore.graphManagerState.graph,
+      );
+      parmeterState.mockParameterValue();
+      return parmeterState;
+    });
+    return states;
+  }
+}
+
 export class FunctionEditorState extends ElementEditorState {
   readonly functionDefinitionEditorState: FunctionDefinitionEditorState;
   readonly activatorBuilderState: FunctionActivatorBuilderState;
 
   selectedTab: FUNCTION_EDITOR_TAB;
 
+  isRunningQuery = false;
+  isGeneratingPlan = false;
+  executionResultText?: string | undefined; // NOTE: stored as lossless JSON string
+  executionPlanState: ExecutionPlanState;
+  parametersState: FunctionParametersState;
+  queryRunPromise: Promise<ExecutionResult> | undefined = undefined;
+
   constructor(editorStore: EditorStore, element: PackageableElement) {
     super(editorStore, element);
 
@@ -168,6 +257,16 @@ export class FunctionEditorState extends ElementEditorState {
       functionElement: computed,
       setSelectedTab: action,
       reprocess: action,
+      isRunningQuery: observable,
+      isGeneratingPlan: observable,
+      executionResultText: observable,
+      executionPlanState: observable,
+      setExecutionResultText: action,
+      setIsRunningQuery: action,
+      runQuery: flow,
+      generatePlan: flow,
+      handleRunQuery: flow,
+      cancelQuery: flow,
     });
 
     assertType(
@@ -181,6 +280,11 @@ export class FunctionEditorState extends ElementEditorState {
       this.editorStore,
     );
     this.activatorBuilderState = new FunctionActivatorBuilderState(this);
+    this.executionPlanState = new ExecutionPlanState(
+      this.editorStore.applicationStore,
+      this.editorStore.graphManagerState,
+    );
+    this.parametersState = new FunctionParametersState(this);
   }
 
   get functionElement(): ConcreteFunctionDefinition {
@@ -231,4 +335,214 @@ export class FunctionEditorState extends ElementEditorState {
     functionEditorState.selectedTab = this.selectedTab;
     return functionEditorState;
   }
+
+  setIsRunningQuery(val: boolean): void {
+    this.isRunningQuery = val;
+  }
+
+  setExecutionResultText = (executionResult: string | undefined): void => {
+    this.executionResultText = executionResult;
+  };
+
+  setQueryRunPromise = (
+    promise: Promise<ExecutionResult> | undefined,
+  ): void => {
+    this.queryRunPromise = promise;
+  };
+
+  get query(): RawLambda {
+    return new RawLambda(
+      this.functionElement.parameters.map((parameter) =>
+        this.editorStore.graphManagerState.graphManager.serializeRawValueSpecification(
+          parameter,
+        ),
+      ),
+      this.functionElement.expressionSequence,
+    );
+  }
+
+  *generatePlan(debug: boolean): GeneratorFn<void> {
+    if (this.isGeneratingPlan) {
+      return;
+    }
+    try {
+      const query = this.query;
+      this.isGeneratingPlan = true;
+      let rawPlan: RawExecutionPlan;
+
+      const stopWatch = new StopWatch();
+      const report = reportGraphAnalytics(
+        this.editorStore.graphManagerState.graph,
+      );
+
+      if (debug) {
+        QueryBuilderTelemetryHelper.logEvent_ExecutionPlanDebugLaunched(
+          this.editorStore.applicationStore.telemetryService,
+        );
+        const debugResult =
+          (yield this.editorStore.graphManagerState.graphManager.debugExecutionPlanGeneration(
+            query,
+            undefined,
+            undefined,
+            this.editorStore.graphManagerState.graph,
+            report,
+          )) as { plan: RawExecutionPlan; debug: string };
+        rawPlan = debugResult.plan;
+        this.executionPlanState.setDebugText(debugResult.debug);
+      } else {
+        QueryBuilderTelemetryHelper.logEvent_ExecutionPlanGenerationLaunched(
+          this.editorStore.applicationStore.telemetryService,
+        );
+        rawPlan =
+          (yield this.editorStore.graphManagerState.graphManager.generateExecutionPlan(
+            query,
+            undefined,
+            undefined,
+            this.editorStore.graphManagerState.graph,
+            report,
+          )) as object;
+      }
+
+      stopWatch.record();
+      try {
+        this.executionPlanState.setRawPlan(rawPlan);
+        const plan =
+          this.editorStore.graphManagerState.graphManager.buildExecutionPlan(
+            rawPlan,
+            this.editorStore.graphManagerState.graph,
+          );
+        this.executionPlanState.setPlan(plan);
+      } catch {
+        // do nothing
+      }
+      stopWatch.record(QUERY_BUILDER_EVENT.BUILD_EXECUTION_PLAN__SUCCESS);
+
+      // report
+      report.timings =
+        this.editorStore.applicationStore.timeService.finalizeTimingsRecord(
+          stopWatch,
+          report.timings,
+        );
+      if (debug) {
+        QueryBuilderTelemetryHelper.logEvent_ExecutionPlanDebugSucceeded(
+          this.editorStore.applicationStore.telemetryService,
+          report,
+        );
+      } else {
+        QueryBuilderTelemetryHelper.logEvent_ExecutionPlanGenerationSucceeded(
+          this.editorStore.applicationStore.telemetryService,
+          report,
+        );
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.isGeneratingPlan = false;
+    }
+  }
+
+  *handleRunQuery(): GeneratorFn<void> {
+    if (this.isRunningQuery) {
+      return;
+    }
+    const query = this.query;
+    const parameters = (query.parameters ?? []) as object[];
+    if (parameters.length) {
+      this.parametersState.openModal(query);
+    } else {
+      this.runQuery();
+    }
+  }
+
+  *runQuery(): GeneratorFn<void> {
+    if (this.isRunningQuery) {
+      return;
+    }
+
+    QueryBuilderTelemetryHelper.logEvent_QueryRunLaunched(
+      this.editorStore.applicationStore.telemetryService,
+    );
+
+    let promise;
+    try {
+      this.isRunningQuery = true;
+      const stopWatch = new StopWatch();
+      const report = reportGraphAnalytics(
+        this.editorStore.graphManagerState.graph,
+      );
+      promise = this.editorStore.graphManagerState.graphManager.runQuery(
+        getExecutionQueryFromRawLambda(
+          this.query,
+          this.parametersState.parameterStates,
+          this.editorStore.graphManagerState,
+        ),
+        undefined,
+        undefined,
+        this.editorStore.graphManagerState.graph,
+        {
+          useLosslessParse: true,
+          parameterValues: buildExecutionParameterValues(
+            this.parametersState.parameterStates,
+            this.editorStore.graphManagerState,
+          ),
+        },
+        report,
+      );
+      this.setQueryRunPromise(promise);
+      const result = (yield promise) as ExecutionResult;
+      if (this.queryRunPromise === promise) {
+        this.setExecutionResultText(
+          stringifyLosslessJSON(result, undefined, DEFAULT_TAB_SIZE),
+        );
+        this.parametersState.setParameters([]);
+        // report
+        report.timings =
+          this.editorStore.applicationStore.timeService.finalizeTimingsRecord(
+            stopWatch,
+            report.timings,
+          );
+        QueryBuilderTelemetryHelper.logEvent_QueryRunSucceeded(
+          this.editorStore.applicationStore.telemetryService,
+          report,
+        );
+      }
+    } catch (error) {
+      // When user cancels the query by calling the cancelQuery api, it will throw an exeuction failure error.
+      // For now, we don't want to notify users about this failure. Therefore we check to ensure the promise is still the same one.
+      // When cancelled the query, we set the queryRunPromise as undefined.
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
+        error,
+      );
+      if (this.queryRunPromise === promise) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.notificationService.notifyError(
+          error,
+        );
+      }
+    } finally {
+      this.isRunningQuery = false;
+    }
+  }
+
+  *cancelQuery(): GeneratorFn<void> {
+    this.setIsRunningQuery(false);
+    this.setQueryRunPromise(undefined);
+    try {
+      yield this.editorStore.graphManagerState.graphManager.cancelUserExecutions(
+        true,
+      );
+    } catch (error) {
+      // Don't notify users about success or failure
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
+        error,
+      );
+    }
+  }
 }

package/src/stores/editor/editor-state/element-editor-state/ProtocolValueBuilderState.ts

@@ -25,7 +25,12 @@ import {
   type Property,
   classHasCycle,
 } from '@finos/legend-graph';
-import { isString, uuid, type PlainObject } from '@finos/legend-shared';
+import {
+  isString,
+  uuid,
+  type PlainObject,
+  prettyCONSTName,
+} from '@finos/legend-shared';
 import type { TreeData, TreeNodeData } from '@finos/legend-art';
 
 export abstract class ProtocolValueFieldNode implements TreeNodeData {
@@ -331,7 +336,11 @@ export class ProtocolValueBuilderState {
               break;
             }
             case PRIMITIVE_TYPE.STRING: {
-              value[property.name] = '';
+              // NOTE: this just provides some default value, and they are not necessarily sensible
+              // perhaps, we can create a mechanism for this class where we can inject value to fields
+              // but that might violate the generic usage principle of this builder as this builder's
+              // user should be relatively agnostic to the extension they are picking
+              value[property.name] = prettyCONSTName(property.name);
               break;
             }
             case PRIMITIVE_TYPE.DATE: