@finos/legend-application-studio 28.18.131 → 28.18.133

package/src/application/LegendIngestionConfiguration.ts

@@ -20,7 +20,7 @@ import {
   usingModelSchema,
 } from '@finos/legend-shared';
 import type { AuthProviderProps } from 'react-oidc-context';
-import { createModelSchema, primitive, raw } from 'serializr';
+import { createModelSchema, optional, primitive, raw } from 'serializr';
 
 export class IngestDeploymentOIDC {
   redirectPath!: string;
@@ -51,6 +51,7 @@ export class IngestDeploymentServerConfig {
 export class IngestionDeploymentConfiguration {
   oidcConfig!: IngestDeploymentOIDC;
   defaultServer!: IngestDeploymentServerConfig;
+  useDefaultServer: boolean | undefined;
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(IngestionDeploymentConfiguration, {
@@ -58,6 +59,7 @@ export class IngestionDeploymentConfiguration {
       defaultServer: usingModelSchema(
         IngestDeploymentServerConfig.serialization.schema,
       ),
+      useDefaultServer: optional(primitive()),
     }),
   );
 }

package/src/components/editor/Editor.tsx

@@ -161,6 +161,7 @@ export const Editor = withEditorStore(
           patchReleaseVersionId,
           workspaceId,
           workspaceType,
+          studioParams,
         ),
       ).catch(applicationStore.alertUnhandledError);
     }, [
@@ -170,6 +171,7 @@ export const Editor = withEditorStore(
       projectId,
       workspaceId,
       workspaceType,
+      studioParams,
     ]);
 
     useEffect(() => {

package/src/components/editor/editor-group/dataProduct/DataPoductEditor.tsx

@@ -18,6 +18,7 @@ import { observer } from 'mobx-react-lite';
 import { useEditorStore } from '../../EditorStoreProvider.js';
 import {
   DataProductEditorState,
+  generateUrlToDeployOnOpen,
   LakehouseAccessPointState,
 } from '../../../../stores/editor/editor-state/element-editor-state/dataProduct/DataProductEditorState.js';
 import {
@@ -34,11 +35,21 @@ import {
   TimesIcon,
   PlusIcon,
   PanelHeaderActionItem,
+  RocketIcon,
+  Modal,
+  ModalHeader,
+  ModalTitle,
+  ModalBody,
+  ModalFooter,
+  ModalFooterButton,
 } from '@finos/legend-art';
 import { useRef, useState, useEffect } from 'react';
 import { filterByType } from '@finos/legend-shared';
 import { InlineLambdaEditor } from '@finos/legend-query-builder';
 import { flowResult } from 'mobx';
+import { useAuth } from 'react-oidc-context';
+import { CODE_EDITOR_LANGUAGE } from '@finos/legend-code-editor';
+import { CodeEditor } from '@finos/legend-lego/code-editor';
 
 const NewAccessPointAccessPOint = observer(
   (props: { dataProductEditorState: DataProductEditorState }) => {
@@ -254,6 +265,83 @@ const DataProductEditorSplashScreen = observer(
   },
 );
 
+const DataproductDeploymenetModal = observer(
+  (props: { state: DataProductEditorState }) => {
+    const { state } = props;
+    const applicationStore = state.editorStore.applicationStore;
+    return (
+      <Dialog
+        open={state.deploymentState.isInProgress}
+        classes={{ container: 'search-modal__container' }}
+      >
+        <Modal
+          darkMode={
+            !applicationStore.layoutService.TEMPORARY__isLightColorThemeEnabled
+          }
+          className="database-builder"
+        >
+          <ModalHeader>
+            <ModalTitle title="Deploy Data Product" />
+          </ModalHeader>
+          <ModalBody>
+            <div>{state.deploymentState.message}</div>
+          </ModalBody>
+        </Modal>
+      </Dialog>
+    );
+  },
+);
+
+const DataProductDeploymentResponseModal = observer(
+  (props: { state: DataProductEditorState }) => {
+    const { state } = props;
+    const applicationStore = state.editorStore.applicationStore;
+    const closeModal = (): void => state.setDeployResponse(undefined);
+    return (
+      <Dialog
+        open={Boolean(state.deployResponse)}
+        classes={{
+          root: 'editor-modal__root-container',
+          container: 'editor-modal__container',
+          paper: 'editor-modal__content',
+        }}
+        onClose={closeModal}
+      >
+        <Modal
+          darkMode={
+            !applicationStore.layoutService.TEMPORARY__isLightColorThemeEnabled
+          }
+          className="editor-modal"
+        >
+          <ModalHeader>
+            <ModalTitle title="Validation Error" />
+          </ModalHeader>
+          <ModalBody>
+            <PanelContent>
+              <CodeEditor
+                inputValue={JSON.stringify(
+                  state.deployResponse?.content ?? {},
+                  null,
+                  2,
+                )}
+                isReadOnly={true}
+                language={CODE_EDITOR_LANGUAGE.JSON}
+              />
+            </PanelContent>
+          </ModalBody>
+          <ModalFooter>
+            <ModalFooterButton
+              onClick={closeModal}
+              text="Close"
+              type="secondary"
+            />
+          </ModalFooter>
+        </Modal>
+      </Dialog>
+    );
+  },
+);
+
 export const DataProductEditor = observer(() => {
   const editorStore = useEditorStore();
   const dataProductEditorState =
@@ -266,6 +354,30 @@ export const DataProductEditor = observer(() => {
   const openNewModal = () => {
     dataProductEditorState.setAccessPointModal(true);
   };
+  const auth = useAuth();
+  const deployDataProduct = (): void => {
+    // Trigger OAuth flow if not authenticated
+    if (!auth.isAuthenticated) {
+      // remove this redirect if we move to do oauth at the beginning of opening studio
+      auth
+        .signinRedirect({
+          state: generateUrlToDeployOnOpen(dataProductEditorState),
+        })
+        .catch(editorStore.applicationStore.alertUnhandledError);
+      return;
+    }
+    // Use the token for deployment
+    const token = auth.user?.access_token;
+    if (token) {
+      flowResult(dataProductEditorState.deploy(token)).catch(
+        editorStore.applicationStore.alertUnhandledError,
+      );
+    } else {
+      editorStore.applicationStore.notificationService.notifyError(
+        'Authentication failed. No token available.',
+      );
+    }
+  };
 
   useEffect(() => {
     flowResult(dataProductEditorState.convertAccessPointsFuncObjects()).catch(
@@ -273,6 +385,18 @@ export const DataProductEditor = observer(() => {
     );
   }, [dataProductEditorState]);
 
+  useEffect(() => {
+    if (dataProductEditorState.deployOnOpen) {
+      flowResult(dataProductEditorState.deploy(auth.user?.access_token)).catch(
+        editorStore.applicationStore.alertUnhandledError,
+      );
+    }
+  }, [
+    auth,
+    editorStore.applicationStore.alertUnhandledError,
+    dataProductEditorState,
+  ]);
+
   return (
     <div className="data-product-editor">
       <div className="panel">
@@ -286,6 +410,20 @@ export const DataProductEditor = observer(() => {
             <div className="panel__header__title__label">data product</div>
             <div className="panel__header__title__content">{product.name}</div>
           </div>
+          <PanelHeaderActions>
+            <div className="btn__dropdown-combo btn__dropdown-combo--primary">
+              <button
+                className="btn__dropdown-combo__label"
+                onClick={deployDataProduct}
+                title={dataProductEditorState.deployValidationMessage}
+                tabIndex={-1}
+                disabled={!dataProductEditorState.deployValidationMessage}
+              >
+                <RocketIcon className="btn__dropdown-combo__label__icon" />
+                <div className="btn__dropdown-combo__label__title">Deploy</div>
+              </button>
+            </div>
+          </PanelHeaderActions>
         </div>
         <div className="panel">
           <PanelHeader>
@@ -324,6 +462,14 @@ export const DataProductEditor = observer(() => {
               dataProductEditorState={dataProductEditorState}
             />
           )}
+          {dataProductEditorState.deploymentState.isInProgress && (
+            <DataproductDeploymenetModal state={dataProductEditorState} />
+          )}
+          {dataProductEditorState.deployResponse && (
+            <DataProductDeploymentResponseModal
+              state={dataProductEditorState}
+            />
+          )}
         </div>
       </div>
     </div>

package/src/stores/editor/EditorStore.ts

@@ -566,6 +566,34 @@ export class EditorStore implements CommandRegistrar {
     this.explorerTreeState = new ExplorerTreeState(this);
   }
 
+  deCodeStudioQueryParams(
+    studioParams: Partial<StudioQueryParams> | undefined,
+  ): void {
+    if (this.editorConfig) {
+      // If editor config is already set, we do not decode again
+      return;
+    }
+    if (!studioParams) {
+      // If studio params are not provided, we do not decode
+      return;
+    }
+    const editorConfig = studioParams[LEGEND_STUDIO_QUERY_PARAMS.EDITOR_CONFIG];
+    if (!editorConfig) {
+      return;
+    }
+    const _config = returnUndefOnError(() =>
+      EditorInitialConfiguration.serialization.fromJson(
+        JSON.parse(atob(editorConfig)),
+      ),
+    );
+    const config = guaranteeNonNullable(
+      _config,
+      `error reading and serializing config ${editorConfig}`,
+    );
+
+    this.editorConfig = config;
+  }
+
   internalizeEntityPath(
     params: Partial<WorkspaceEditorPathParams>,
     studioParams: Partial<StudioQueryParams> | undefined,
@@ -574,27 +602,14 @@ export class EditorStore implements CommandRegistrar {
     const workspaceType = params.groupWorkspaceId
       ? WorkspaceType.GROUP
       : WorkspaceType.USER;
-    const editorConfig =
-      studioParams?.[LEGEND_STUDIO_QUERY_PARAMS.EDITOR_CONFIG];
+
     const workspaceId = guaranteeNonNullable(
       params.groupWorkspaceId ?? params.workspaceId,
       `Workspace/group workspace ID is not provided`,
     );
     if (entityPath) {
       this.initialEntityPath = entityPath;
-      if (editorConfig) {
-        const _config = returnUndefOnError(() =>
-          EditorInitialConfiguration.serialization.fromJson(
-            JSON.parse(atob(editorConfig)),
-          ),
-        );
-        const config = guaranteeNonNullable(
-          _config,
-          `error reading and serializing config ${editorConfig}`,
-        );
-
-        this.editorConfig = config;
-      }
+      this.deCodeStudioQueryParams(studioParams);
       this.applicationStore.navigationService.navigator.updateCurrentLocation(
         generateEditorRoute(
           guaranteeNonNullable(projectId),
@@ -616,6 +631,7 @@ export class EditorStore implements CommandRegistrar {
     patchReleaseVersionId: string | undefined,
     workspaceId: string,
     workspaceType: WorkspaceType,
+    studioParams: Partial<StudioQueryParams> | undefined,
   ): GeneratorFn<void> {
     if (!this.initState.isInInitialState) {
       /**
@@ -647,7 +663,7 @@ export class EditorStore implements CommandRegistrar {
       return;
     }
     this.initState.inProgress();
-
+    this.deCodeStudioQueryParams(studioParams);
     // TODO: when we genericize the way to initialize an application page
     this.applicationStore.assistantService.setIsHidden(false);
 
@@ -792,8 +808,12 @@ export class EditorStore implements CommandRegistrar {
           env: this.applicationStore.config.env,
           tabSize: DEFAULT_TAB_SIZE,
           clientConfig: {
-            baseUrl: this.applicationStore.config.engineServerUrl,
-            queryBaseUrl: this.applicationStore.config.engineQueryServerUrl,
+            baseUrl:
+              this.editorConfig?.engineServerUrl ??
+              this.applicationStore.config.engineServerUrl,
+            queryBaseUrl:
+              this.editorConfig?.engineQueryServerUrl ??
+              this.applicationStore.config.engineQueryServerUrl,
             enableCompression: true,
             payloadDebugger,
           },
@@ -1068,8 +1088,6 @@ export class EditorStore implements CommandRegistrar {
             this.graphManagerState.graph.getElement(this.initialEntityPath),
             this.editorConfig,
           );
-          // we may not want to set as undefined if using it for other things
-          this.editorConfig = undefined;
         } catch {
           const elementPath = this.initialEntityPath;
           this.initialEntityPath = undefined;

package/src/stores/editor/EditorTabManagerState.ts

@@ -182,7 +182,7 @@ export class EditorTabManagerState extends TabManagerState {
     } else if (element instanceof Service) {
       return new ServiceEditorState(this.editorStore, element);
     } else if (element instanceof DataProduct) {
-      return new DataProductEditorState(this.editorStore, element);
+      return new DataProductEditorState(this.editorStore, element, config);
     } else if (element instanceof GenerationSpecification) {
       return new GenerationSpecificationEditorState(this.editorStore, element);
     } else if (element instanceof FileGenerationSpecification) {

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

@@ -48,6 +48,18 @@ export class IngestElementEditorInitialConfiguration extends ElementEditorInitia
   );
 }
 
+export class DataProductElementEditorInitialConfiguration extends ElementEditorInitialConfiguration {
+  deployOnOpen?: boolean;
+  type = PACKAGEABLE_ELEMENT_TYPE._DATA_PRODUCT;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataProductElementEditorInitialConfiguration, {
+      _type: usingConstantValueSchema(PACKAGEABLE_ELEMENT_TYPE._DATA_PRODUCT),
+      deployOnOpen: optional(primitive()),
+    }),
+  );
+}
+
 const serializeElementEditorInitialConfiguration = (
   protocol: ElementEditorInitialConfiguration,
 ): PlainObject<ElementEditorInitialConfiguration> => {
@@ -56,6 +68,11 @@ const serializeElementEditorInitialConfiguration = (
       IngestElementEditorInitialConfiguration.serialization.schema,
       protocol,
     );
+  } else if (protocol instanceof DataProductElementEditorInitialConfiguration) {
+    return serialize(
+      DataProductElementEditorInitialConfiguration.serialization.schema,
+      protocol,
+    );
   }
   throw new UnsupportedOperationError(
     `Can't serialize element config`,
@@ -72,6 +89,11 @@ const deseralizeElementEditorInitialConfiguration = (
         IngestElementEditorInitialConfiguration.serialization.schema,
         json,
       );
+    case PACKAGEABLE_ELEMENT_TYPE._DATA_PRODUCT:
+      return deserialize(
+        DataProductElementEditorInitialConfiguration.serialization.schema,
+        json,
+      );
     default: {
       throw new UnsupportedOperationError(
         `Can't deserialize element config`,
@@ -83,6 +105,8 @@ const deseralizeElementEditorInitialConfiguration = (
 
 export class EditorInitialConfiguration {
   elementEditorConfiguration?: ElementEditorInitialConfiguration;
+  engineServerUrl: string | undefined;
+  engineQueryServerUrl?: string | undefined;
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(EditorInitialConfiguration, {
@@ -92,6 +116,8 @@ export class EditorInitialConfiguration {
           deseralizeElementEditorInitialConfiguration,
         ),
       ),
+      engineServerUrl: optional(primitive()),
+      engineQueryServerUrl: optional(primitive()),
     }),
   );
 }

package/src/stores/editor/editor-state/element-editor-state/dataProduct/DataProductEditorState.ts

@@ -18,6 +18,7 @@ import {
   DataProduct,
   LakehouseAccessPoint,
   type PackageableElement,
+  type IngestDefinition,
   type AccessPoint,
   stub_RawLambda,
   LakehouseTargetEnv,
@@ -40,6 +41,9 @@ import {
   LogEvent,
   deleteEntry,
   filterByType,
+  ActionState,
+  guaranteeNonNullable,
+  assertTrue,
 } from '@finos/legend-shared';
 import {
   dataProduct_addAccessPoint,
@@ -47,6 +51,13 @@ import {
   dataProduct_deleteAccessPoint,
 } from '../../../../graph-modifier/DSL_DataProduct_GraphModifierHelper.js';
 import { LambdaEditorState } from '@finos/legend-query-builder';
+import type { IngestionManager } from '../../../../ingestion/IngestionManager.js';
+import {
+  DataProductElementEditorInitialConfiguration,
+  EditorInitialConfiguration,
+} from '../ElementEditorInitialConfiguration.js';
+import { EXTERNAL_APPLICATION_NAVIGATION__generateUrlWithEditorConfig } from '../../../../../__lib__/LegendStudioNavigation.js';
+import type { AdhocDataProductDeployResponse } from '../../../../ingestion/AdhocDataProductDeployResponse.js';
 
 export class AccessPointState {
   readonly state: AccessPointGroupState;
@@ -181,10 +192,10 @@ export class AccessPointGroupState {
 
   constructor(val: AccessPointGroup, editorState: DataProductEditorState) {
     this.value = val;
+    this.state = editorState;
     this.accessPointStates = val.accessPoints.map((e) =>
       this.buildAccessPointState(e),
     );
-    this.state = editorState;
     makeObservable(this, {
       value: observable,
       accessPointStates: observable,
@@ -213,12 +224,41 @@ export class AccessPointGroupState {
   }
 }
 
+const createEditorInitialConfiguration = (): EditorInitialConfiguration => {
+  const config = new EditorInitialConfiguration();
+  const ingest = new DataProductElementEditorInitialConfiguration();
+  ingest.deployOnOpen = true;
+  config.elementEditorConfiguration = ingest;
+  return config;
+};
+
+const editorInitialConfigToBase64 = (val: EditorInitialConfiguration): string =>
+  btoa(JSON.stringify(EditorInitialConfiguration.serialization.toJson(val)));
+
+export const generateUrlToDeployOnOpen = (
+  val: DataProductEditorState,
+): string => {
+  return val.editorStore.applicationStore.navigationService.navigator.generateAddress(
+    EXTERNAL_APPLICATION_NAVIGATION__generateUrlWithEditorConfig(
+      val.editorStore.editorMode.generateElementLink(val.product.path),
+      editorInitialConfigToBase64(createEditorInitialConfiguration()),
+    ),
+  );
+};
+
 export class DataProductEditorState extends ElementEditorState {
   accessPointModal = false;
+  deploymentState = ActionState.create();
   accessPointGroupStates: AccessPointGroupState[] = [];
   isConvertingTransformLambdaObjects = false;
+  deployOnOpen = false;
+  deployResponse: AdhocDataProductDeployResponse | undefined;
 
-  constructor(editorStore: EditorStore, element: PackageableElement) {
+  constructor(
+    editorStore: EditorStore,
+    element: PackageableElement,
+    config?: EditorInitialConfiguration,
+  ) {
     super(editorStore, element);
 
     makeObservable(this, {
@@ -226,6 +266,11 @@ export class DataProductEditorState extends ElementEditorState {
       accessPointModal: observable,
       accessPointGroupStates: observable,
       isConvertingTransformLambdaObjects: observable,
+      deploy: flow,
+      deployOnOpen: observable,
+      deployResponse: observable,
+      setDeployOnOpen: action,
+      setDeployResponse: action,
       setAccessPointModal: action,
       addAccessPoint: action,
       convertAccessPointsFuncObjects: flow,
@@ -233,6 +278,20 @@ export class DataProductEditorState extends ElementEditorState {
     this.accessPointGroupStates = this.product.accessPointGroups.map(
       (e) => new AccessPointGroupState(e, this),
     );
+    const elementConfig = config?.elementEditorConfiguration;
+    if (elementConfig instanceof DataProductElementEditorInitialConfiguration) {
+      this.deployOnOpen = elementConfig.deployOnOpen ?? false;
+    }
+  }
+
+  setDeployOnOpen(value: boolean): void {
+    this.deployOnOpen = value;
+  }
+
+  setDeployResponse(
+    response: AdhocDataProductDeployResponse | undefined,
+  ): void {
+    this.deployResponse = response;
   }
 
   *convertAccessPointsFuncObjects(): GeneratorFn<void> {
@@ -303,6 +362,38 @@ export class DataProductEditorState extends ElementEditorState {
     return new AccessPointGroupState(group, this);
   }
 
+  *deploy(token: string | undefined): GeneratorFn<void> {
+    try {
+      assertTrue(
+        this.validForDeployment,
+        'Data product definition is not valid for deployment',
+      );
+      this.deploymentState.inProgress();
+      // The grammar we provide will be for the current data product + all ingests (used for compilation)
+      const grammar =
+        (yield this.editorStore.graphManagerState.graphManager.elementsToPureCode(
+          [...this.editorStore.graphManagerState.graph.ingests, this.product],
+        )) as unknown as string;
+
+      const response = (yield guaranteeNonNullable(
+        this.ingestionManager,
+      ).deployDataProduct(
+        grammar,
+        guaranteeNonNullable(this.associatedIngest?.appDirDeployment),
+        this.deploymentState,
+        token,
+      )) as unknown as AdhocDataProductDeployResponse;
+      this.setDeployResponse(response);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(
+        `Ingest definition failed to deploy: ${error.message}`,
+      );
+    } finally {
+      this.deploymentState.complete();
+    }
+  }
+
   get product(): DataProduct {
     return guaranteeType(
       this.element,
@@ -311,10 +402,37 @@ export class DataProductEditorState extends ElementEditorState {
     );
   }
 
+  get validForDeployment(): boolean {
+    return Boolean(
+      this.associatedIngest?.appDirDeployment && this.ingestionManager,
+    );
+  }
+
   get accessPoints(): AccessPoint[] {
     return this.product.accessPointGroups.map((e) => e.accessPoints).flat();
   }
 
+  get ingestionManager(): IngestionManager | undefined {
+    return this.editorStore.ingestionManager;
+  }
+
+  get deployValidationMessage(): string {
+    if (!this.associatedIngest?.appDirDeployment) {
+      return 'No app dir deployment found';
+    } else if (!this.ingestionManager) {
+      return 'No ingestion manager found';
+    }
+    return 'Deploy';
+  }
+
+  // We need to get the associated Ingest to get the app dir deployment
+  // We could do a more in depth check on the access point lambdas to check which ingest it uses but for now
+  // we will assume all ingests have the same DID
+  // we get the last one, to prioritize the ones in the current project followed by dependency ones
+  get associatedIngest(): IngestDefinition | undefined {
+    return this.editorStore.graphManagerState.graph.ingests.slice(-1)[0];
+  }
+
   override reprocess(
     newElement: PackageableElement,
     editorStore: EditorStore,

package/src/stores/ingestion/AdhocDataProductDeployResponse.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { PlainObject } from '@finos/legend-shared';
+
+export class AdhocDataProductDeployResponse {
+  content!: PlainObject;
+}
+
+export const createAdhocDataProductDeployResponse = (
+  json: PlainObject<AdhocDataProductDeployResponse>,
+): AdhocDataProductDeployResponse => {
+  const response = new AdhocDataProductDeployResponse();
+  response.content = json;
+  return response;
+};

package/src/stores/ingestion/IngestDeploymentServerClient.ts

@@ -26,9 +26,12 @@ import type {
   IngestDefinitionValidationResponse,
 } from './IngestionDeploymentResponse.js';
 import type { IngestDeploymentServerConfig } from '../../application/LegendIngestionConfiguration.js';
+import type { AdhocDataProductDeployResponse } from './AdhocDataProductDeployResponse.js';
 
 export class IngestDeploymentServerClient extends AbstractServerClient {
   environmentClassification: string;
+
+  private DATA_PRODUCT_URL = 'data-product';
   constructor(config: IngestDeploymentServerConfig) {
     super({
       baseUrl: config.ingestServerUrl,
@@ -49,6 +52,9 @@ export class IngestDeploymentServerClient extends AbstractServerClient {
     Authorization: `Bearer ${token}`,
   });
 
+  private _dataProduct = (): string =>
+    `${this.baseUrl}/${this.DATA_PRODUCT_URL}/api/entitlements/sdlc/deploy/definitions`;
+
   private _ingest = (): string =>
     `${this.baseUrl}/api/ingest/sdlc/deploy/definitions`;
 
@@ -80,4 +86,16 @@ export class IngestDeploymentServerClient extends AbstractServerClient {
       this._tokenWithTextPlain(token),
     );
   }
+
+  deployDataProduct(
+    fullGrammar: string,
+    token: string | undefined,
+  ): Promise<PlainObject<AdhocDataProductDeployResponse>> {
+    return this.post(
+      `${this._dataProduct()}`,
+      fullGrammar,
+      undefined,
+      this._tokenWithTextPlain(token),
+    );
+  }
 }