@finos/legend-server-lakehouse 0.0.2

package/lib/models/AdhocDataProductDeployResponse.js

@@ -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 class AdhocDataProductDeployResponse {
+    content;
+}
+export const createAdhocDataProductDeployResponse = (json) => {
+    const response = new AdhocDataProductDeployResponse();
+    response.content = json;
+    return response;
+};
+//# sourceMappingURL=AdhocDataProductDeployResponse.js.map

package/lib/models/AdhocDataProductDeployResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdhocDataProductDeployResponse.js","sourceRoot":"","sources":["../../src/models/AdhocDataProductDeployResponse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,MAAM,OAAO,8BAA8B;IACzC,OAAO,CAAe;CACvB;AAED,MAAM,CAAC,MAAM,oCAAoC,GAAG,CAClD,IAAiD,EACjB,EAAE;IAClC,MAAM,QAAQ,GAAG,IAAI,8BAA8B,EAAE,CAAC;IACtD,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC;IACxB,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC"}

package/lib/models/IngestDeploymentServerConfig.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { SerializationFactory } from '@finos/legend-shared';
+export declare class IngestDeploymentServerConfig {
+    environmentClassification: string;
+    ingestServerUrl: string;
+    static readonly serialization: SerializationFactory<IngestDeploymentServerConfig>;
+}
+//# sourceMappingURL=IngestDeploymentServerConfig.d.ts.map

package/lib/models/IngestDeploymentServerConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IngestDeploymentServerConfig.d.ts","sourceRoot":"","sources":["../../src/models/IngestDeploymentServerConfig.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5D,qBAAa,4BAA4B;IACvC,yBAAyB,EAAG,MAAM,CAAC;IACnC,eAAe,EAAG,MAAM,CAAC;IAEzB,MAAM,CAAC,QAAQ,CAAC,aAAa,qDAK3B;CACH"}

package/lib/models/IngestDeploymentServerConfig.js

@@ -0,0 +1,26 @@
+/**
+ * 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 { SerializationFactory } from '@finos/legend-shared';
+import { createModelSchema, primitive } from 'serializr';
+export class IngestDeploymentServerConfig {
+    environmentClassification;
+    ingestServerUrl;
+    static serialization = new SerializationFactory(createModelSchema(IngestDeploymentServerConfig, {
+        environmentClassification: primitive(),
+        ingestServerUrl: primitive(),
+    }));
+}
+//# sourceMappingURL=IngestDeploymentServerConfig.js.map

package/lib/models/IngestDeploymentServerConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IngestDeploymentServerConfig.js","sourceRoot":"","sources":["../../src/models/IngestDeploymentServerConfig.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEzD,MAAM,OAAO,4BAA4B;IACvC,yBAAyB,CAAU;IACnC,eAAe,CAAU;IAEzB,MAAM,CAAU,aAAa,GAAG,IAAI,oBAAoB,CACtD,iBAAiB,CAAC,4BAA4B,EAAE;QAC9C,yBAAyB,EAAE,SAAS,EAAE;QACtC,eAAe,EAAE,SAAS,EAAE;KAC7B,CAAC,CACH,CAAC"}

package/lib/models/LakehouseIngestionDeploymentResponse.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { SerializationFactory, type PlainObject } from '@finos/legend-shared';
+export declare enum IngestDefinitionValidationResponseStatus {
+    NOT_CHECKED = "NOT_CHECKED",
+    SUCCESS = "SUCCESS",
+    FAILURE = "FAILURE"
+}
+export declare class IngestDefinitionValidationOutput {
+    status: IngestDefinitionValidationResponseStatus;
+}
+export declare class IngestDefinitionValidationResponse {
+    status: IngestDefinitionValidationResponseStatus;
+    content: PlainObject;
+    static readonly serialization: SerializationFactory<IngestDefinitionValidationResponse>;
+}
+export declare const createIngestDefinitionValidationResponse: (json: PlainObject<IngestDefinitionValidationResponse>) => IngestDefinitionValidationResponse;
+export declare class IngestDefinitionDeploymentResponse {
+    ingestDefinitionUrn: string;
+    write_location: PlainObject | undefined;
+    static readonly serialization: SerializationFactory<IngestDefinitionDeploymentResponse>;
+}
+export declare class ValidateAndDeploymentResponse {
+    validationResponse: IngestDefinitionValidationResponse;
+    deploymentResponse: IngestDefinitionDeploymentResponse | undefined;
+    constructor(validationResponse: IngestDefinitionValidationResponse, deploymentResponse: IngestDefinitionDeploymentResponse | undefined);
+}
+//# sourceMappingURL=LakehouseIngestionDeploymentResponse.d.ts.map

package/lib/models/LakehouseIngestionDeploymentResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LakehouseIngestionDeploymentResponse.d.ts","sourceRoot":"","sources":["../../src/models/LakehouseIngestionDeploymentResponse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAG9E,oBAAY,wCAAwC;IAClD,WAAW,gBAAgB;IAC3B,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAED,qBAAa,gCAAgC;IAC3C,MAAM,EAAG,wCAAwC,CAAC;CACnD;AAED,qBAAa,kCAAkC;IAC7C,MAAM,EAAG,wCAAwC,CAAC;IAClD,OAAO,EAAG,WAAW,CAAC;IAEtB,MAAM,CAAC,QAAQ,CAAC,aAAa,2DAI3B;CACH;AAED,eAAO,MAAM,wCAAwC,GACnD,MAAM,WAAW,CAAC,kCAAkC,CAAC,KACpD,kCAOF,CAAC;AAEF,qBAAa,kCAAkC;IAC7C,mBAAmB,EAAG,MAAM,CAAC;IAC7B,cAAc,EAAE,WAAW,GAAG,SAAS,CAAC;IAExC,MAAM,CAAC,QAAQ,CAAC,aAAa,2DAI3B;CACH;AAED,qBAAa,6BAA6B;IACxC,kBAAkB,EAAE,kCAAkC,CAAC;IACvD,kBAAkB,EAAE,kCAAkC,GAAG,SAAS,CAAC;gBAGjE,kBAAkB,EAAE,kCAAkC,EACtD,kBAAkB,EAAE,kCAAkC,GAAG,SAAS;CAKrE"}

package/lib/models/LakehouseIngestionDeploymentResponse.js

@@ -0,0 +1,56 @@
+/**
+ * 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 { SerializationFactory } from '@finos/legend-shared';
+import { createModelSchema, primitive } from 'serializr';
+export var IngestDefinitionValidationResponseStatus;
+(function (IngestDefinitionValidationResponseStatus) {
+    IngestDefinitionValidationResponseStatus["NOT_CHECKED"] = "NOT_CHECKED";
+    IngestDefinitionValidationResponseStatus["SUCCESS"] = "SUCCESS";
+    IngestDefinitionValidationResponseStatus["FAILURE"] = "FAILURE";
+})(IngestDefinitionValidationResponseStatus || (IngestDefinitionValidationResponseStatus = {}));
+export class IngestDefinitionValidationOutput {
+    status;
+}
+export class IngestDefinitionValidationResponse {
+    status;
+    content;
+    static serialization = new SerializationFactory(createModelSchema(IngestDefinitionValidationResponse, {
+        status: primitive(),
+    }));
+}
+export const createIngestDefinitionValidationResponse = (json) => {
+    const ingestDefinitionValidationResponse = new IngestDefinitionValidationResponse();
+    ingestDefinitionValidationResponse.status =
+        json.status;
+    ingestDefinitionValidationResponse.content = json;
+    return ingestDefinitionValidationResponse;
+};
+export class IngestDefinitionDeploymentResponse {
+    ingestDefinitionUrn;
+    write_location;
+    static serialization = new SerializationFactory(createModelSchema(IngestDefinitionDeploymentResponse, {
+        ingestDefinitionUrn: primitive(),
+    }));
+}
+export class ValidateAndDeploymentResponse {
+    validationResponse;
+    deploymentResponse;
+    constructor(validationResponse, deploymentResponse) {
+        this.validationResponse = validationResponse;
+        this.deploymentResponse = deploymentResponse;
+    }
+}
+//# sourceMappingURL=LakehouseIngestionDeploymentResponse.js.map

package/lib/models/LakehouseIngestionDeploymentResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LakehouseIngestionDeploymentResponse.js","sourceRoot":"","sources":["../../src/models/LakehouseIngestionDeploymentResponse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,oBAAoB,EAAoB,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEzD,MAAM,CAAN,IAAY,wCAIX;AAJD,WAAY,wCAAwC;IAClD,uEAA2B,CAAA;IAC3B,+DAAmB,CAAA;IACnB,+DAAmB,CAAA;AACrB,CAAC,EAJW,wCAAwC,KAAxC,wCAAwC,QAInD;AAED,MAAM,OAAO,gCAAgC;IAC3C,MAAM,CAA4C;CACnD;AAED,MAAM,OAAO,kCAAkC;IAC7C,MAAM,CAA4C;IAClD,OAAO,CAAe;IAEtB,MAAM,CAAU,aAAa,GAAG,IAAI,oBAAoB,CACtD,iBAAiB,CAAC,kCAAkC,EAAE;QACpD,MAAM,EAAE,SAAS,EAAE;KACpB,CAAC,CACH,CAAC;;AAGJ,MAAM,CAAC,MAAM,wCAAwC,GAAG,CACtD,IAAqD,EACjB,EAAE;IACtC,MAAM,kCAAkC,GACtC,IAAI,kCAAkC,EAAE,CAAC;IAC3C,kCAAkC,CAAC,MAAM;QACvC,IAAI,CAAC,MAAkD,CAAC;IAC1D,kCAAkC,CAAC,OAAO,GAAG,IAAI,CAAC;IAClD,OAAO,kCAAkC,CAAC;AAC5C,CAAC,CAAC;AAEF,MAAM,OAAO,kCAAkC;IAC7C,mBAAmB,CAAU;IAC7B,cAAc,CAA0B;IAExC,MAAM,CAAU,aAAa,GAAG,IAAI,oBAAoB,CACtD,iBAAiB,CAAC,kCAAkC,EAAE;QACpD,mBAAmB,EAAE,SAAS,EAAE;KACjC,CAAC,CACH,CAAC;;AAGJ,MAAM,OAAO,6BAA6B;IACxC,kBAAkB,CAAqC;IACvD,kBAAkB,CAAiD;IAEnE,YACE,kBAAsD,EACtD,kBAAkE;QAElE,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;QAC7C,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;IAC/C,CAAC;CACF"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@finos/legend-server-lakehouse",
+  "version": "0.0.2",
+  "description": "Legend Lakehouse Server Client",
+  "keywords": [
+    "legend",
+    "legend-server",
+    "legend-server-lakehouse",
+    "storage",
+    "package-registry"
+  ],
+  "homepage": "https://github.com/finos/legend-studio/tree/master/packages/legend-server-lakehouse",
+  "bugs": {
+    "url": "https://github.com/finos/legend-studio/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/finos/legend-studio.git",
+    "directory": "packages/legend-server-lakehouse"
+  },
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./lib/index.js",
+  "module": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "yarn clean && yarn build:ts",
+    "build:ts": "tsc --project ./tsconfig.build.json",
+    "clean": "npm-run-all clean:cache clean:lib",
+    "clean:cache": "rimraf \"build\"",
+    "clean:lib": "rimraf \"lib\"",
+    "dev": "yarn dev:ts",
+    "dev:ts": "tsc --watch --preserveWatchOutput",
+    "lint:js": "cross-env NODE_ENV=production eslint --cache --cache-location ./build/.eslintcache --report-unused-disable-directives --parser-options=project:\"./tsconfig.json\" \"./src/**/*.{js,ts,tsx}\"",
+    "publish:prepare": "node ../../scripts/release/preparePublishContent.js",
+    "publish:snapshot": "node ../../scripts/release/publishDevSnapshot.js",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "@finos/legend-graph": "32.1.43",
+    "@finos/legend-shared": "11.0.13",
+    "serializr": "3.0.3"
+  },
+  "devDependencies": {
+    "@finos/legend-dev-utils": "2.2.4",
+    "@jest/globals": "29.7.0",
+    "cross-env": "7.0.3",
+    "eslint": "9.22.0",
+    "jest": "29.7.0",
+    "npm-run-all": "4.1.5",
+    "rimraf": "6.0.1",
+    "typescript": "5.8.2"
+  },
+  "publishConfig": {
+    "directory": "build/publishContent"
+  }
+}

package/src/LakehouseIngestServerClient.ts

@@ -0,0 +1,129 @@
+/**
+ * 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 {
+  AbstractServerClient,
+  ContentType,
+  HttpHeader,
+  type PlainObject,
+} from '@finos/legend-shared';
+import type {
+  IngestDefinitionDeploymentResponse,
+  IngestDefinitionValidationResponse,
+} from './models/LakehouseIngestionDeploymentResponse.js';
+import type { IngestDeploymentServerConfig } from './models/IngestDeploymentServerConfig.js';
+import type { AdhocDataProductDeployResponse } from './models/AdhocDataProductDeployResponse.js';
+import type {
+  V1_IngestEnvironment,
+  V1_SandboxDataProductDeploymentResponse,
+} from '@finos/legend-graph';
+
+export class LakehouseIngestServerClient extends AbstractServerClient {
+  environmentClassification: string | undefined;
+
+  private DATA_PRODUCT_URL = 'data-product';
+  constructor(config: IngestDeploymentServerConfig | undefined) {
+    super({});
+    if (config) {
+      this.baseUrl = config.ingestServerUrl;
+      this.environmentClassification = config.environmentClassification;
+    }
+  }
+
+  private _token = (token?: string) => ({
+    Authorization: `Bearer ${token}`,
+  });
+
+  private _tokenWithTextPlain = (token?: string) => ({
+    [HttpHeader.CONTENT_TYPE]: ContentType.TEXT_PLAIN,
+    Authorization: `Bearer ${token}`,
+  });
+
+  private _dataProduct = (serverUrl?: string | undefined): string =>
+    `${serverUrl ?? this.baseUrl}/${this.DATA_PRODUCT_URL}/api/entitlements/sdlc/deploy/definitions`;
+
+  private _ingestDefinitions = (): string =>
+    `${this.baseUrl}/api/ingest/sdlc/deploy/definitions`;
+
+  private _ingest = (serverUrl?: string | undefined): string =>
+    `${serverUrl ?? this.baseUrl}/api/ingest`;
+
+  changeServer(serverConfig: IngestDeploymentServerConfig): void {
+    this.baseUrl = serverConfig.ingestServerUrl;
+    this.environmentClassification = serverConfig.environmentClassification;
+  }
+
+  validate(
+    validateGrammar: string,
+    token: string | undefined,
+  ): Promise<PlainObject<IngestDefinitionValidationResponse>> {
+    return this.post(
+      `${this._ingestDefinitions()}/validate`,
+      validateGrammar,
+      undefined,
+      this._tokenWithTextPlain(token),
+    );
+  }
+
+  deploy(
+    deployGrammar: string,
+    token: string | undefined,
+  ): Promise<IngestDefinitionDeploymentResponse> {
+    return this.post(
+      `${this._ingestDefinitions()}`,
+      deployGrammar,
+      undefined,
+      this._tokenWithTextPlain(token),
+    );
+  }
+
+  write_location(urn: string, token: string | undefined): Promise<PlainObject> {
+    return this.post(
+      `${this._ingest()}/${encodeURIComponent(urn)}/write-location`,
+      undefined,
+      undefined,
+      this._token(token),
+    );
+  }
+
+  deployDataProduct(
+    fullGrammar: string,
+    token: string | undefined,
+  ): Promise<PlainObject<AdhocDataProductDeployResponse>> {
+    return this.post(
+      `${this._dataProduct()}`,
+      fullGrammar,
+      undefined,
+      this._token(token),
+    );
+  }
+
+  getIngestEnvironment = (
+    ingestServerUrl: string | undefined,
+    token: string | undefined,
+  ): Promise<PlainObject<V1_IngestEnvironment>> =>
+    this.get(
+      `${this._ingest(ingestServerUrl)}/catalog-state/environment`,
+      {},
+      this._token(token),
+    );
+
+  getDeployedIngestDefinitions = (
+    ingestServerUrl: string | undefined,
+    token: string | undefined,
+  ): Promise<PlainObject<V1_SandboxDataProductDeploymentResponse>> =>
+    this.get(`${this._dataProduct(ingestServerUrl)}`, {}, this._token(token));
+}

package/src/LakehouseIngestionManager.ts

@@ -0,0 +1,216 @@
+/**
+ * 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 { AppDirNode } from '@finos/legend-graph';
+import {
+  NetworkClientError,
+  type PlainObject,
+  type TracerService,
+  assertErrorThrown,
+} from '@finos/legend-shared';
+import { IngestDeploymentServerConfig } from './models/IngestDeploymentServerConfig.js';
+import { LakehousePlatformServerClient } from './LakehousePlatformServerClient.js';
+import { LakehouseIngestServerClient } from './LakehouseIngestServerClient.js';
+import {
+  createIngestDefinitionValidationResponse,
+  IngestDefinitionDeploymentResponse,
+  type IngestDefinitionValidationResponse,
+  IngestDefinitionValidationResponseStatus,
+  ValidateAndDeploymentResponse,
+} from './models/LakehouseIngestionDeploymentResponse.js';
+import {
+  createAdhocDataProductDeployResponse,
+  type AdhocDataProductDeployResponse,
+} from './models/AdhocDataProductDeployResponse.js';
+
+export class LakehouseIngestionManager {
+  private ingestDiscoveryServerClient: LakehousePlatformServerClient;
+  private ingestDeploymentServerClient: LakehouseIngestServerClient;
+  private _currentAppID: number | undefined;
+  private _currentLevel: string | undefined;
+  private useDefaultServer = false;
+
+  constructor(
+    discoveryUrl: string,
+    defaultServer: IngestDeploymentServerConfig,
+    useDefaultServer: boolean | undefined,
+    tracerService: TracerService,
+  ) {
+    this.ingestDiscoveryServerClient = new LakehousePlatformServerClient(
+      discoveryUrl,
+    );
+    this.ingestDeploymentServerClient = new LakehouseIngestServerClient(
+      defaultServer,
+    );
+    this.setTracerService(tracerService);
+    this.useDefaultServer = Boolean(useDefaultServer);
+  }
+
+  setTracerService(tracerService: TracerService): void {
+    this.ingestDiscoveryServerClient.setTracerService(tracerService);
+    this.ingestDeploymentServerClient.setTracerService(tracerService);
+  }
+
+  isCurrentAppDirNode(appDirNode: AppDirNode): boolean {
+    return (
+      this._currentAppID === appDirNode.appDirId &&
+      this._currentLevel === appDirNode.level
+    );
+  }
+
+  setCurrentAppDirNode(appDirNode: AppDirNode): void {
+    this._currentAppID = appDirNode.appDirId;
+    this._currentLevel = appDirNode.level;
+  }
+
+  async deploy(
+    ingestDefinition: string,
+    appDirNode: AppDirNode,
+    messageCallBack: (message: string) => void,
+    token: string | undefined,
+  ): Promise<ValidateAndDeploymentResponse> {
+    messageCallBack(
+      `Discovering associated ingest environment for DID ${appDirNode.appDirId}...`,
+    );
+    await this.identifyIngestDeploymentServer(appDirNode, token);
+    messageCallBack(
+      `Validating ingest with server ${this.ingestDeploymentServerClient.baseUrl ?? ''} for realm ${this.ingestDeploymentServerClient.environmentClassification}...`,
+    );
+    const validateResonse = await this._validate(
+      ingestDefinition,
+      undefined,
+      token,
+    );
+    const fullResponse = new ValidateAndDeploymentResponse(
+      validateResonse,
+      undefined,
+    );
+    if (
+      validateResonse.status !==
+      IngestDefinitionValidationResponseStatus.SUCCESS
+    ) {
+      return fullResponse;
+    }
+    messageCallBack(
+      `Validation Success. Deploying ingest with server ${this.ingestDeploymentServerClient.baseUrl ?? ''} for realm ${this.ingestDeploymentServerClient.environmentClassification}...`,
+    );
+    const deployResponse = await this._deploy(
+      ingestDefinition,
+      undefined,
+      token,
+    );
+    try {
+      messageCallBack(`Deployment Success. Fetching write location...`);
+      await this._fetchDeployLocations(deployResponse, token);
+    } catch (error) {
+      assertErrorThrown(error);
+    }
+
+    return fullResponse;
+  }
+
+  async deployDataProduct(
+    grammarText: string,
+    appDirNode: AppDirNode,
+    messageCallBack: (message: string) => void,
+    token: string | undefined,
+  ): Promise<AdhocDataProductDeployResponse> {
+    messageCallBack(
+      `Discovering associated data product environment for DID ${appDirNode.appDirId}...`,
+    );
+    await this.identifyIngestDeploymentServer(appDirNode, token);
+    messageCallBack(
+      `Deploying data product with server ${this.ingestDeploymentServerClient.baseUrl ?? ''} for realm ${this.ingestDeploymentServerClient.environmentClassification}...`,
+    );
+    const deployResponse =
+      await this.ingestDeploymentServerClient.deployDataProduct(
+        grammarText,
+        token,
+      );
+    return createAdhocDataProductDeployResponse(deployResponse);
+  }
+
+  private async _validate(
+    ingestDefinition: string,
+    appDirNode: AppDirNode | undefined,
+    token: string | undefined,
+  ): Promise<IngestDefinitionValidationResponse> {
+    if (appDirNode) {
+      await this.identifyIngestDeploymentServer(appDirNode, token);
+    }
+    try {
+      const response = await this.ingestDeploymentServerClient.validate(
+        ingestDefinition,
+        token,
+      );
+      return createIngestDefinitionValidationResponse(response);
+    } catch (error) {
+      assertErrorThrown(error);
+      if (error instanceof NetworkClientError) {
+        return createIngestDefinitionValidationResponse(
+          error.payload as PlainObject<IngestDefinitionValidationResponse>,
+        );
+      }
+      throw error;
+    }
+  }
+
+  private async _deploy(
+    ingestDefinition: string,
+    appDirNode: AppDirNode | undefined,
+    token: string | undefined,
+  ): Promise<IngestDefinitionDeploymentResponse> {
+    if (appDirNode) {
+      await this.identifyIngestDeploymentServer(appDirNode, token);
+    }
+    // validate
+    const response = (await this.ingestDeploymentServerClient.deploy(
+      ingestDefinition,
+      token,
+    )) as unknown as PlainObject<IngestDefinitionDeploymentResponse>;
+    return IngestDefinitionDeploymentResponse.serialization.fromJson(response);
+  }
+
+  private async _fetchDeployLocations(
+    depploymentResponse: IngestDefinitionDeploymentResponse,
+    token: string | undefined,
+  ): Promise<void> {
+    const response = (await this.ingestDeploymentServerClient.write_location(
+      depploymentResponse.ingestDefinitionUrn,
+      token,
+    )) as unknown as PlainObject;
+    depploymentResponse.write_location = response;
+  }
+
+  private async identifyIngestDeploymentServer(
+    appDirNode: AppDirNode,
+    token: string | undefined,
+  ): Promise<void> {
+    // we do not change if current appDirNode is the same as the one we are trying to set
+    if (this.useDefaultServer || this.isCurrentAppDirNode(appDirNode)) {
+      return;
+    }
+    const serverConfig = IngestDeploymentServerConfig.serialization.fromJson(
+      await this.ingestDiscoveryServerClient.findProducerServer(
+        appDirNode.appDirId,
+        appDirNode.level,
+        token,
+      ),
+    );
+    this.ingestDeploymentServerClient.changeServer(serverConfig);
+    this.setCurrentAppDirNode(appDirNode);
+  }
+}

package/src/LakehousePlatformServerClient.ts

@@ -0,0 +1,65 @@
+/**
+ * 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 V1_LakehouseDiscoveryEnvironmentResponse } from '@finos/legend-graph';
+import { AbstractServerClient, type PlainObject } from '@finos/legend-shared';
+import type { IngestDeploymentServerConfig } from './models/IngestDeploymentServerConfig.js';
+
+export class LakehousePlatformServerClient extends AbstractServerClient {
+  constructor(url: string) {
+    super({
+      baseUrl: url,
+    });
+  }
+  private _ingest = (): string =>
+    `${this.baseUrl}/ingest/discovery/environments/producers`;
+
+  private _discovery = (): string => `${this.baseUrl}/ingest/discovery`;
+
+  private _env = (): string => `${this._discovery()}/environments`;
+
+  private _token = (token?: string) => ({
+    Authorization: `Bearer ${token}`,
+  });
+
+  getIngestEnvironmentSummaries(
+    token?: string | undefined,
+  ): Promise<PlainObject<IngestDeploymentServerConfig>[]> {
+    return this.get(`${this._env()}`, {}, this._token(token));
+  }
+
+  findProducerServer(
+    id: number,
+    level: string,
+    token?: string | undefined,
+  ): Promise<PlainObject<IngestDeploymentServerConfig>> {
+    return this.get(
+      `${this._ingest()}/${id}/${level}/search`,
+      {},
+      this._token(token),
+    );
+  }
+
+  getIngestEnvironmentSummary = (
+    ingestEnvironmentUrn: string,
+    token: string | undefined,
+  ): Promise<PlainObject<V1_LakehouseDiscoveryEnvironmentResponse>> =>
+    this.get(
+      `${this._discovery()}/environments/${ingestEnvironmentUrn}`,
+      {},
+      this._token(token),
+    );
+}