@vizzly/api-client 0.0.55 → 0.0.57

package/dist/models/VizzlyApi.d.ts

@@ -48,10 +48,14 @@ export declare class VizzlyApi extends Api {
         permissions: Array<GlobalLibraryPermissionFromAPI>;
     }>;
     buildCreateGlobalLibraryRequest(params: RequestParams<CreateGlobalLibraryParams>): Request<{}>;
-    getProjects(params?: RequestParams): Promise<{
+    getProjects(params?: RequestParams<{
+        withParentDashboards?: boolean;
+    }>): Promise<{
         projects: Array<ProjectFromAPI>;
     }>;
-    buildGetProjectsRequest(params?: RequestParams): Request<{}>;
+    buildGetProjectsRequest(params?: RequestParams<{
+        withParentDashboards?: boolean;
+    }>): Request<{}>;
     createProjectApiKey(params: RequestParams<nVizzlyApi.CreateProjectApiKeyParams>): Promise<Response<{
         api_key: string;
     }>>;

package/dist/models/VizzlyApi.js

@@ -156,8 +156,9 @@ class VizzlyApi extends Api_1.Api {
         });
     }
     buildGetProjectsRequest(params) {
+        const queryString = (params === null || params === void 0 ? void 0 : params.withParentDashboards) ? '?with_parent_dashboards=true' : '';
         return {
-            path: `/api/v2/projects`,
+            path: `/api/v2/projects${queryString}`,
             method: 'get',
             abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
         };
@@ -262,7 +263,7 @@ class VizzlyApi extends Api_1.Api {
                 dashboardIds: params.dashboardIds,
             },
             abortSignal: params.abortSignal,
-            acceptedAuthParams: ['projectApiKey']
+            acceptedAuthParams: ['projectApiKey'],
         };
     }
     /**
@@ -329,8 +330,9 @@ class VizzlyApi extends Api_1.Api {
         });
     }
     buildGetProjectRequest(params) {
+        const queryString = params.withParentDashboards ? '?with_parent_dashboards=true' : '';
         return {
-            path: `/api/v3/project/${params.projectId}`,
+            path: `/api/v3/project/${params.projectId}${queryString}`,
             method: 'get',
             abortSignal: params.abortSignal,
             acceptedAuthParams: ['projectApiKey', 'projectAccessToken', 'appSessionToken'],

package/dist/models/VizzlyQueryEngineApi.d.ts

@@ -1,6 +1,6 @@
 import { Api } from './Api';
 import { Authentication } from './Authentication';
-import { nVizzlyQueryEngine, Request, extraHeaders, CreateDashboardParams, UpdateDashboardParams, UpdateGlobalLibraryParams, GlobalLibrary, CreateGlobalLibraryParams, GlobalLibraryPermissionFromAPI, RequestParams } from '../types';
+import { nVizzlyQueryEngine, Request, extraHeaders, CreateDashboardParams, UpdateDashboardParams, UpdateGlobalLibraryParams, GlobalLibrary, CreateGlobalLibraryParams, GlobalLibraryPermissionFromAPI, RequestParams, DataOptimiser } from '../types';
 import { nSemanticLayer } from '@vizzly/semantic-layer-public';
 import { SQLSchema } from '@vizzly/sqlbuilder-public';
 export declare class VizzlyQueryEngineApi extends Api {
@@ -94,6 +94,11 @@ export declare class VizzlyQueryEngineApi extends Api {
     buildUpdateQueryEngineUserRequest(params: RequestParams<nVizzlyQueryEngine.UpdateQueryEngineUserParams>): Request<{}>;
     uploadDataToVizzlyCloud(params: RequestParams<nVizzlyQueryEngine.UploadDataToVizzlyCloudParams>): Promise<import("../types").Response<unknown>>;
     buildUploadDataToVizzlyCloudRequest(params: RequestParams<nVizzlyQueryEngine.UploadDataToVizzlyCloudParams>): Request<{}>;
+    /**
+     * Create snowflake & AWS infrastructure for a new company
+     * & return the bucket & role and snowflake connection
+     * information.
+     * */
     createCompanyInfrastructure(params: RequestParams<{
         companyId: string;
     }>): Promise<import("../types").Response<{
@@ -110,5 +115,76 @@ export declare class VizzlyQueryEngineApi extends Api {
             username: string;
         };
     }>>;
+    /** Get the status of a create company infrastructure call */
+    getCreateCompanyInfrastructureStatus(params: RequestParams<{
+        companyId: string;
+    }>): Promise<import("../types").Response<DataOptimiser.StatusResponse<{
+        create_database_action: DataOptimiser.ActionStatus<{}>;
+        create_aws_infra_action: DataOptimiser.ActionStatus<{}>;
+    }>>>;
     private buildCreateCompanyInfrastructureRequest;
+    /** Send request to ingest data */
+    ingestDatasource(params: RequestParams<{
+        dataSourceId: string;
+        ingestFields: DataOptimiser.DataSourceFields;
+        internalCompanyConnection: DataOptimiser.QueryEngineConnection;
+        externalSnowflakeConnection: DataOptimiser.QueryEngineConnection;
+    }>): Promise<import("../types").Response<DataOptimiser.ExecuteResponse<{
+        setup_export_data_integration: DataOptimiser.ActionResult<{}>;
+        ingest_to_s3: DataOptimiser.ActionResult<{
+            toBucket: string;
+            toPath: string;
+            fromSnowflakeTableAddress: string[];
+        }>;
+        ingest_s3_storage_to_snowflake: DataOptimiser.ActionResult<{
+            destinationAddress: string[];
+        }>;
+    }>>>;
+    /** Get the status of a call to ingest data for a data source. */
+    getIngestDatasourceStatus(params: RequestParams<{
+        dataSourceId: string;
+        ingestFields: DataOptimiser.DataSourceFields;
+        internalCompanyConnection: DataOptimiser.QueryEngineConnection;
+        externalSnowflakeConnection: DataOptimiser.QueryEngineConnection;
+    }>): Promise<import("../types").Response<DataOptimiser.StatusResponse<{
+        setup_export_data_integration: DataOptimiser.ActionStatus<{}>;
+        ingest_to_s3: DataOptimiser.ActionStatus<{
+            s3Bucket: {
+                path: string;
+                bucket: string;
+            };
+        }>;
+        ingest_s3_storage_to_snowflake: DataOptimiser.ActionStatus<{
+            destinationAddress: string[];
+            destinationFields: DataOptimiser.DataSourceFields;
+        }>;
+    }>>>;
+    private buildIngestDatasourceRequest;
+    /** Get the status of a call to ingest data for a data source. */
+    getCreateSnapshotStatus(params: RequestParams<{
+        ingestDataSourceId: string;
+        snapshotDataSourceId: string;
+        ingestFields: DataOptimiser.DataSourceFields;
+        cascadingInstructions: DataOptimiser.CascadingInstructions;
+        internalCompanyConnection: DataOptimiser.QueryEngineConnection;
+        primaryDateFieldId?: string | undefined;
+    }>): Promise<import("../types").Response<DataOptimiser.StatusResponse<{
+        create_snapshot: DataOptimiser.ActionStatus<{
+            snapshotDataOptimiser: DataOptimiser.DataSourceFields;
+        }>;
+    }>>>;
+    /** Send request to create a snapshot */
+    createSnapshot(params: RequestParams<{
+        ingestDataSourceId: string;
+        snapshotDataSourceId: string;
+        ingestFields: DataOptimiser.DataSourceFields;
+        cascadingInstructions: DataOptimiser.CascadingInstructions;
+        internalCompanyConnection: DataOptimiser.QueryEngineConnection;
+        primaryDateFieldId?: string | undefined;
+    }>): Promise<import("../types").Response<DataOptimiser.ExecuteResponse<{
+        create_snapshot: DataOptimiser.ActionResult<{
+            snapshotFields: DataOptimiser.DataSourceFields;
+        }>;
+    }>>>;
+    private buildCreateSnapshotRequest;
 }

package/dist/models/VizzlyQueryEngineApi.js

@@ -16,6 +16,7 @@ const FailedToResolveDataSets_1 = require("../errors/FailedToResolveDataSets");
 const FailedToSetupProject_1 = require("../errors/FailedToSetupProject");
 const errors_1 = require("../errors");
 const DashboardRepository_1 = require("./DashboardRepository");
+const Path_1 = require("./Path");
 class VizzlyQueryEngineApi extends Api_1.Api {
     constructor(auth, host, extraHeaders) {
         super(auth, host, extraHeaders);
@@ -435,20 +436,88 @@ class VizzlyQueryEngineApi extends Api_1.Api {
             },
         };
     }
+    /**
+     * Create snowflake & AWS infrastructure for a new company
+     * & return the bucket & role and snowflake connection
+     * information.
+     * */
     createCompanyInfrastructure(params) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this.execute(this.buildCreateCompanyInfrastructureRequest(params));
         });
     }
-    buildCreateCompanyInfrastructureRequest(params) {
+    /** Get the status of a create company infrastructure call */
+    getCreateCompanyInfrastructureStatus(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateCompanyInfrastructureRequest(params, { statusOnly: true }));
+        });
+    }
+    buildCreateCompanyInfrastructureRequest(params, options) {
+        const maybeStatusRoutePath = (options === null || options === void 0 ? void 0 : options.statusOnly) ? '/status' : '';
         return {
-            path: `/api/v1/data-optimiser/company`,
+            path: Path_1.Path.buildPath(`/api/v1/data-optimiser/company`, maybeStatusRoutePath),
             method: 'post',
             abortSignal: params.abortSignal,
             body: {
                 company: { id: params.companyId },
             },
-            acceptedAuthParams: ['queryEngineApiKey']
+            acceptedAuthParams: ['queryEngineApiKey'],
+        };
+    }
+    /** Send request to ingest data */
+    ingestDatasource(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildIngestDatasourceRequest(params, { statusOnly: false }));
+        });
+    }
+    /** Get the status of a call to ingest data for a data source. */
+    getIngestDatasourceStatus(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildIngestDatasourceRequest(params, { statusOnly: true }));
+        });
+    }
+    buildIngestDatasourceRequest(params, options) {
+        const maybeStatusRoutePath = (options === null || options === void 0 ? void 0 : options.statusOnly) ? '/status' : '';
+        return {
+            path: Path_1.Path.buildPath(`/api/v1/data-optimiser/ingest`, maybeStatusRoutePath),
+            method: 'post',
+            abortSignal: params.abortSignal,
+            body: {
+                dataSourceId: params.dataSourceId,
+                ingestFields: params.ingestFields,
+                internalCompanyConnection: params.internalCompanyConnection,
+                externalSnowflakeConnection: params.externalSnowflakeConnection,
+            },
+            acceptedAuthParams: ['queryEngineApiKey'],
+        };
+    }
+    /** Get the status of a call to ingest data for a data source. */
+    getCreateSnapshotStatus(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateSnapshotRequest(params, { statusOnly: true }));
+        });
+    }
+    /** Send request to create a snapshot */
+    createSnapshot(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateSnapshotRequest(params, { statusOnly: false }));
+        });
+    }
+    buildCreateSnapshotRequest(params, options) {
+        const maybeStatusRoutePath = (options === null || options === void 0 ? void 0 : options.statusOnly) ? '/status' : '';
+        return {
+            path: Path_1.Path.buildPath(`/api/v1/data-optimiser/snapshot`, maybeStatusRoutePath),
+            method: 'post',
+            abortSignal: params.abortSignal,
+            body: {
+                ingestDataSourceId: params.ingestDataSourceId,
+                snapshotDataSourceId: params.snapshotDataSourceId,
+                ingestFields: params.ingestFields,
+                cascadingInstructions: params.cascadingInstructions,
+                primaryDateFieldId: params.primaryDateFieldId,
+                internalCompanyConnection: params.internalCompanyConnection,
+            },
+            acceptedAuthParams: ['queryEngineApiKey'],
         };
     }
 }

package/dist/types/project.d.ts

@@ -8,7 +8,13 @@ export type ProjectFromAPI = {
     type: ProjectType;
     created_at: Date;
     share_links?: ShareLink[];
-    parent_dashboards: DashboardFromAPI[];
+    /**
+     * To include parent dashboards, use the withParentDashboards param.
+     * However only do this when strictly necessary as it inceases
+     * load on the Vizzly API for projects that create many parent dashboards, like
+     * the GTi next gen application.
+     * */
+    parent_dashboards: DashboardFromAPI[] | null;
     parent_global_libraries: GlobalLibrary[];
     key_pairs: RawKeyPair[];
     encrypted_encryption_secret: string | null;

package/dist/types.d.ts

@@ -9,6 +9,7 @@ export * from './types/team';
 export * from './types/user';
 import { DataAccessConfig } from '@vizzly/auth';
 import { nSemanticLayer, OriginId } from '@vizzly/semantic-layer-public';
+import { SnowflakeConnection } from '@vizzly/sqlbuilder-public';
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type UpdateDashboardResponseBody = {
     dashboard: DashboardFromAPI;
@@ -220,6 +221,7 @@ export declare namespace nVizzlyApi {
     };
     type GetProjectParams = {
         projectId: string;
+        withParentDashboards?: boolean;
     };
     type GetManagedQueryEngineKeyPairParams = {
         managedProjectId: string;
@@ -466,3 +468,75 @@ export type GlobalLibraryPermissionFromAPI = {
     token: string;
     scope: 'read' | 'read_write';
 };
+export declare namespace DataOptimiser {
+    type DataSourceFields = Array<{
+        id: string;
+        address: string[];
+        data_type: string;
+    }>;
+    type EphemeralDataSourceFields = Array<Omit<DataSourceFields[number], 'id'>>;
+    type DimensionFieldsMapping = Array<{
+        field_id: string;
+        gti_dimension_key: 'brands' | 'regions' | 'media_channels';
+        dimension_values_mappings: Array<{
+            gti_dimension_value_key: string;
+            label_override?: string;
+            data_source_original_value: string;
+        }>;
+    }>;
+    /**
+     * We can send a list of instructions to the data optimiser, which
+     * will combine them depending on their order which signifies their
+     * importance.
+     *
+     * The first set of instructions will be overridden by the next set,
+     * if it makes sense.
+     *
+     * This means that we can send the instructions for the data source &
+     * snapshot in the same request  without doing any logic, and the data
+     * optimiser will pick what it needs.
+     */
+    type CascadingInstructions = Array<{
+        datasourceDimensionFieldMapping: DimensionFieldsMapping;
+        dataStartDate: string | null;
+        dataEndDate: string | null;
+    }>;
+    type ActionResultStatus = 'success' | 'failure' | 'no_action_taken' | 'started_in_background';
+    type ActionStatus<PlannedOutcome> = {
+        name: string;
+        status: ActionResultStatus;
+        plannedOutcome: PlannedOutcome;
+    };
+    type ActionResult<Content> = {
+        status: ActionResultStatus;
+        content: Content;
+    };
+    type StatusResponse<Status extends {
+        [actionId: string]: {
+            name: string;
+            status: ActionResultStatus;
+            plannedOutcome: any;
+        };
+    }> = {
+        dataConnections: {
+            dataTeamSnowflake: boolean | null;
+            gtiCommonSnowflake: boolean | null;
+            gtiAdminSnowflake: boolean | null;
+        };
+        status: Status;
+    };
+    type ExecuteResponse<ActionResult extends {
+        [actionId: string]: {
+            status: ActionResultStatus;
+            content: any;
+        };
+    }> = {
+        actionResults: {
+            [actionId: string]: ActionResult;
+        };
+    };
+    type QueryEngineConnection = {
+        encryptedCredentials: string;
+        unencryptedCredentials?: Partial<SnowflakeConnection>;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizzly/api-client",
-  "version": "0.0.55",
+  "version": "0.0.57",
   "private": false,
   "license": "NONE",
   "source": "src/index.ts",