@vizzly/api-client 0.0.44 → 0.0.46

package/README.md

@@ -1 +1,25 @@
 # Vizzly API client
+
+## Create a parent dashboard
+
+```ts
+import { VizzlyApi, Authentication } from '@vizzly/api-client';
+
+export const createParentDashboard = async () => {
+  const auth = new Authentication({projectApiKey: process.env['VIZZLY_PROJECT_API_KEY']});
+  const vizzlyApi = new VizzlyApi(auth);
+
+  const response = await vizzlyApi.createParentDashboard({
+    name: 'My new parent dashboard'
+  });
+
+  if(response.status === 200) {
+    const { dashboard } = response.body;
+    // dashboard.id
+    // dashboard.name
+  } else {
+    throw "Failed to create a parent dashboard.";
+  }
+};
+
+```

package/dist/models/Authentication.d.ts

@@ -4,11 +4,13 @@ export declare class Authentication {
     constructor(authParams: AuthParams);
     updateAuthParams(authParams: Partial<AuthParams>): void;
     clearAuthParams(): void;
+    getQueryEngineApiKey(): string;
     getQueryEngineAccessToken(): string;
     getProjectAdminOverrideToken(): string | undefined;
     getDashboardAccessToken(): string;
     getAppSessionToken(): string | undefined;
-    getDataAccessToken(): string;
+    hasDataAccessToken(): boolean;
+    getDataAccessToken(): string | undefined;
     getProjectApiKey(): string;
     getProjectAccessToken(): string;
     buildAuthHeaders(acceptedAuthParams: Request<{}>['acceptedAuthParams']): {

package/dist/models/Authentication.js

@@ -13,6 +13,11 @@ class Authentication {
     clearAuthParams() {
         this.authParams = {};
     }
+    getQueryEngineApiKey() {
+        if (!this.authParams.queryEngineApiKey)
+            throw new MissingAuthParameter_1.MissingAuthParameter('queryEngineApiKey');
+        return this.authParams.queryEngineApiKey;
+    }
     getQueryEngineAccessToken() {
         if (!this.authParams.queryEngineAccessToken)
             throw new MissingAuthParameter_1.MissingAuthParameter('queryEngineAccessToken');
@@ -29,8 +34,11 @@ class Authentication {
     getAppSessionToken() {
         return this.authParams.appSessionToken;
     }
+    hasDataAccessToken() {
+        return !!this.authParams.dataAccessToken;
+    }
     getDataAccessToken() {
-        if (!this.authParams.dataAccessToken)
+        if (!this.hasDataAccessToken())
             throw new MissingAuthParameter_1.MissingAuthParameter('dataAccessToken');
         return this.authParams.dataAccessToken;
     }
@@ -51,6 +59,11 @@ class Authentication {
                 auth: `Bearer ${usableAuthParams.dashboardAccessToken}`,
             };
         }
+        if (usableAuthParams.queryEngineApiKey) {
+            return {
+                'Config-Api-Key': usableAuthParams.queryEngineApiKey,
+            };
+        }
         // If a project access token has been set on the config, use that instead
         // of fetching one. This is most likely used on the managed query-engine where we
         // pass the project access token through in a request header.

package/dist/models/VizzlyApi.d.ts

@@ -1,6 +1,6 @@
 import { Api } from './Api';
 import { Authentication } from './Authentication';
-import { CreateDashboardParams, CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermissionFromAPI, PersistedReport, QueryEngineUserFromAPI, Request, RequestParams, TeamMemberFromAPI, UpdateDashboardParams, UpdateDashboardResponseBody, UpdateGlobalLibraryParams } from '../types';
+import { CreateDashboardParams, CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermissionFromAPI, PersistedReport, QueryEngineUserFromAPI, Request, RequestParams, Response, TeamMemberFromAPI, UpdateDashboardParams, UpdateDashboardResponseBody, UpdateGlobalLibraryParams } from '../types';
 import { nVizzlyApi } from '../types';
 import { ProjectFromAPI } from '../types/project';
 export declare class VizzlyApi extends Api {
@@ -11,7 +11,7 @@ export declare class VizzlyApi extends Api {
     }>;
     fetchGlobalLibraries(params: RequestParams<{
         globalLibraryAccessTokens: string[];
-    }>): Promise<import("../types").Response<{
+    }>): Promise<Response<{
         found: GlobalLibrary[];
         not_found: string[];
     }>>;
@@ -20,7 +20,7 @@ export declare class VizzlyApi extends Api {
     }>): Request<{
         globalLibraryAccessTokens: string[];
     }>;
-    fetchGlobalLibraryAccessTokens(params?: RequestParams): Promise<import("../types").Response<{
+    fetchGlobalLibraryAccessTokens(params?: RequestParams): Promise<Response<{
         global_libraries: GlobalLibrary[];
         permissions: Array<GlobalLibraryPermissionFromAPI>;
     }>>;
@@ -34,9 +34,14 @@ export declare class VizzlyApi extends Api {
     buildFetchDashboardsRequest(params: RequestParams<{
         dashboardSessionAccessTokens: string[];
     }>): Request<{}>;
-    createParentDashboard(params: RequestParams<nVizzlyApi.CreateParentDashboardParams>): Promise<import("../types").Response<unknown>>;
+    createParentDashboard(params: RequestParams<nVizzlyApi.CreateParentDashboardParams>): Promise<Response<{
+        dashboard: {
+            id: string;
+            name: string | null;
+        };
+    }>>;
     buildCreateParentDashboardRequest(params: RequestParams<nVizzlyApi.CreateParentDashboardParams>): Request<{}>;
-    createParentGlobalLibrary(params: RequestParams<nVizzlyApi.CreateParentGlobalLibraryParams>): Promise<import("../types").Response<unknown>>;
+    createParentGlobalLibrary(params: RequestParams<nVizzlyApi.CreateParentGlobalLibraryParams>): Promise<Response<unknown>>;
     buildCreateParentGlobalLibraryRequest(params: RequestParams<nVizzlyApi.CreateParentGlobalLibraryParams>): Request<{}>;
     createGlobalLibrary(params: RequestParams<CreateGlobalLibraryParams>): Promise<{
         global_library: GlobalLibrary;
@@ -47,7 +52,7 @@ export declare class VizzlyApi extends Api {
         projects: Array<ProjectFromAPI>;
     }>;
     buildGetProjectsRequest(params?: RequestParams): Request<{}>;
-    createProjectApiKey(params: RequestParams<nVizzlyApi.CreateProjectApiKeyParams>): Promise<import("../types").Response<{
+    createProjectApiKey(params: RequestParams<nVizzlyApi.CreateProjectApiKeyParams>): Promise<Response<{
         api_key: string;
     }>>;
     buildCreateProjectApiKeyRequest(params: RequestParams<nVizzlyApi.CreateProjectApiKeyParams>): Request<{}>;
@@ -56,23 +61,23 @@ export declare class VizzlyApi extends Api {
     buildCreateSelfHostedDynamicQueryEngineProjectRequest(params?: RequestParams): Request<{}>;
     buildCreateSelfHostedInBrowserProjectRequest(params?: RequestParams): Request<{}>;
     buildCreateSelfHostedProjectRequest(params?: RequestParams): Request<{}>;
-    createManagedQueryEngineProject(params?: RequestParams): Promise<import("../types").Response<unknown>>;
+    createManagedQueryEngineProject(params?: RequestParams): Promise<Response<unknown>>;
     buildCreateManagedQueryEngineProjectRequest(params?: RequestParams): Request<{}>;
-    createVizzlyConfigVersion(params: RequestParams<nVizzlyApi.CreateVizzlyConfigVersionParams>): Promise<import("../types").Response<unknown>>;
+    createVizzlyConfigVersion(params: RequestParams<nVizzlyApi.CreateVizzlyConfigVersionParams>): Promise<Response<unknown>>;
     buildCreateVizzlyConfigVersionRequest(params: RequestParams<nVizzlyApi.CreateVizzlyConfigVersionParams>): Request<{}>;
-    duplicateParentDashboard(params: RequestParams<nVizzlyApi.DuplicateParentDashboardParams>): Promise<import("../types").Response<unknown>>;
+    duplicateParentDashboard(params: RequestParams<nVizzlyApi.DuplicateParentDashboardParams>): Promise<Response<unknown>>;
     buildDuplicateParentDashboardRequest(params: RequestParams<nVizzlyApi.DuplicateParentDashboardParams>): Request<{}>;
     getConnection(params: RequestParams<nVizzlyApi.GetConnectionParams>): Promise<{
         encryptedCredentials: string | null;
     }>;
     buildGetConnectionRequest(params: RequestParams<nVizzlyApi.GetConnectionParams>): Request<{}>;
-    getManagedQueryEngineKeyPair(params: RequestParams<nVizzlyApi.GetManagedQueryEngineKeyPairParams>): Promise<import("../types").Response<unknown>>;
+    getManagedQueryEngineKeyPair(params: RequestParams<nVizzlyApi.GetManagedQueryEngineKeyPairParams>): Promise<Response<unknown>>;
     buildGetManagedQueryEngineKeyPairRequest(params: RequestParams<nVizzlyApi.GetManagedQueryEngineKeyPairParams>): Request<{}>;
     getProject(params: RequestParams<nVizzlyApi.GetProjectParams>): Promise<{
         project: ProjectFromAPI;
     }>;
     buildGetProjectRequest(params: RequestParams<nVizzlyApi.GetProjectParams>): Request<{}>;
-    getProjectAccessToken(params: RequestParams<nVizzlyApi.GetProjectAccessTokenParams>): Promise<import("../types").Response<{
+    getProjectAccessToken(params: RequestParams<nVizzlyApi.GetProjectAccessTokenParams>): Promise<Response<{
         token: {
             max_age: number;
             token: string;
@@ -89,27 +94,27 @@ export declare class VizzlyApi extends Api {
         encryptedConfig: string | null;
     }>;
     buildGetVizzlyConfigRequest(params: RequestParams<nVizzlyApi.GetVizzlyConfigParams>): Request<{}>;
-    saveConnection(params: RequestParams<nVizzlyApi.SaveConnectionParams>): Promise<import("../types").Response<unknown>>;
+    saveConnection(params: RequestParams<nVizzlyApi.SaveConnectionParams>): Promise<Response<unknown>>;
     buildSaveConnectionRequest(params: RequestParams<nVizzlyApi.SaveConnectionParams>): Request<{}>;
     saveEncryptedProjectEncryptionSecret(params: RequestParams<nVizzlyApi.SaveEncryptedProjectEncryptionSecretParams>): Promise<boolean>;
     buildSaveEncryptedProjectEncryptionSecretRequest(params: RequestParams<nVizzlyApi.SaveEncryptedProjectEncryptionSecretParams>): Request<{}>;
-    getScheduledReports(params: RequestParams<nVizzlyApi.GetScheduledReportParams>): Promise<import("../types").Response<{
+    getScheduledReports(params: RequestParams<nVizzlyApi.GetScheduledReportParams>): Promise<Response<{
         reports: Array<PersistedReport>;
     }>>;
     buildGetScheduledReports(params: RequestParams<nVizzlyApi.GetScheduledReportParams>): Request<{}>;
-    saveScheduledReport(params: RequestParams<nVizzlyApi.SaveScheduledReportParams>): Promise<import("../types").Response<{
+    saveScheduledReport(params: RequestParams<nVizzlyApi.SaveScheduledReportParams>): Promise<Response<{
         report: PersistedReport;
     }>>;
     buildSaveScheduledReportRequest(params: RequestParams<nVizzlyApi.SaveScheduledReportParams>): Request<{}>;
-    updateDashboard(params: RequestParams<UpdateDashboardParams>): Promise<import("../types").Response<UpdateDashboardResponseBody>>;
+    updateDashboard(params: RequestParams<UpdateDashboardParams>): Promise<Response<UpdateDashboardResponseBody>>;
     buildUpdateDashboardRequest(params: RequestParams<UpdateDashboardParams>): Request<{}>;
-    updateParentGlobalLibrary(params: RequestParams<nVizzlyApi.UpdateParentGlobalLibraryParams>): Promise<import("../types").Response<unknown>>;
+    updateParentGlobalLibrary(params: RequestParams<nVizzlyApi.UpdateParentGlobalLibraryParams>): Promise<Response<unknown>>;
     buildUpdateParentGlobalLibraryRequest(params: RequestParams<nVizzlyApi.UpdateParentGlobalLibraryParams>): Request<{}>;
-    updateGlobalLibrary(params: UpdateGlobalLibraryParams): Promise<import("../types").Response<{
+    updateGlobalLibrary(params: UpdateGlobalLibraryParams): Promise<Response<{
         global_library: GlobalLibrary;
     }>>;
     buildUpdateGlobalLibraryRequest(params: RequestParams<UpdateGlobalLibraryParams>): Request<{}>;
-    updateProjectApiKey(params: RequestParams<nVizzlyApi.UpdateProjectApiKeyParams>): Promise<import("../types").Response<unknown>>;
+    updateProjectApiKey(params: RequestParams<nVizzlyApi.UpdateProjectApiKeyParams>): Promise<Response<unknown>>;
     buildUpdateProjectApiKeyRequest(params: RequestParams<nVizzlyApi.UpdateProjectApiKeyParams>): Request<{}>;
     updateQueryEngineUser(params: RequestParams<nVizzlyApi.UpdateQueryEngineUserParams>): Promise<boolean>;
     buildUpdateQueryEngineUserRequest(params: RequestParams<nVizzlyApi.UpdateQueryEngineUserParams>): Request<{}>;

package/dist/models/VizzlyQueryEngineApi.d.ts

@@ -1,6 +1,8 @@
 import { Api } from './Api';
 import { Authentication } from './Authentication';
 import { nVizzlyQueryEngine, Request, extraHeaders, CreateDashboardParams, UpdateDashboardParams, UpdateGlobalLibraryParams, GlobalLibrary, CreateGlobalLibraryParams, GlobalLibraryPermissionFromAPI, RequestParams } from '../types';
+import { nSemanticLayer } from '@vizzly/semantic-layer-public';
+import { SQLSchema } from '@vizzly/sqlbuilder-public';
 export declare class VizzlyQueryEngineApi extends Api {
     constructor(auth: Authentication, host: string, extraHeaders?: extraHeaders);
     buildCreateDashboardRequest(params: RequestParams<CreateDashboardParams>): Request<CreateDashboardParams & {
@@ -23,8 +25,19 @@ export declare class VizzlyQueryEngineApi extends Api {
     }>): Request<{}>;
     createConfigFromUpload(createConfigFromUploadParams: RequestParams<nVizzlyQueryEngine.CreateConfigFromUploadParams>): Promise<import("../types").Response<unknown>>;
     private buildCreateConfigFromUploadRequest;
-    createResults(params: RequestParams<nVizzlyQueryEngine.CreateResultsParams>): Promise<import("../types").Response<unknown>>;
+    createResults(params: RequestParams<nVizzlyQueryEngine.CreateResultsParams>, versionOverride?: 'v1' | 'v2'): Promise<import("../types").Response<{
+        results: Array<nSemanticLayer.Result>;
+    }>>;
     private buildCreateResultsRequest;
+    collectSchema(params: RequestParams<nVizzlyQueryEngine.CollectSchemaParams>): Promise<import("../types").Response<{
+        schemaByConnection: {
+            [connectionId: string]: {
+                /** ID of the connection */
+                id: string;
+            } & SQLSchema;
+        };
+    }>>;
+    private buildCollectSchemaRequest;
     createSqlPreview(params: RequestParams<nVizzlyQueryEngine.CreateSqlPreviewParams>): Promise<import("../types").Response<{
         message: string;
     }>>;

package/dist/models/VizzlyQueryEngineApi.js

@@ -88,21 +88,41 @@ class VizzlyQueryEngineApi extends Api_1.Api {
             },
         };
     }
-    createResults(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.execute(this.buildCreateResultsRequest(params));
+    createResults(params_1) {
+        return __awaiter(this, arguments, void 0, function* (params, versionOverride = 'v2') {
+            return yield this.execute(this.buildCreateResultsRequest(params, versionOverride));
         });
     }
-    buildCreateResultsRequest(params) {
+    buildCreateResultsRequest(params, versionOverride) {
         return {
-            path: `/api/v1/create-results`,
+            path: `/api/${versionOverride}/create-results`,
             method: 'post',
             abortSignal: params.abortSignal,
             body: {
                 queries: params.queries,
+                dynamicConfig: params.dynamicConfig,
+                identityConfigIntegritySignature: this.auth.hasDataAccessToken() ? this.auth.getDataAccessToken() : undefined,
+                secureFilters: params.secureFilters,
                 virtualFields: {},
-                identityConfigIntegritySignature: this.auth.getDataAccessToken(),
             },
+            acceptedAuthParams: ['queryEngineApiKey', 'dashboardAccessToken'],
+        };
+    }
+    collectSchema(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCollectSchemaRequest(params));
+        });
+    }
+    buildCollectSchemaRequest(params) {
+        return {
+            path: `/api/v1/schema`,
+            method: 'post',
+            abortSignal: params.abortSignal,
+            body: {
+                allowedConfigOrigins: params.allowedConfigOrigins,
+                dynamicConfig: params.dynamicConfig,
+            },
+            acceptedAuthParams: ['queryEngineApiKey'],
         };
     }
     createSqlPreview(params) {

package/dist/types.d.ts

@@ -7,6 +7,8 @@ export * from './types/dashboard';
 export * from './types/project';
 export * from './types/team';
 export * from './types/user';
+import { DataAccessConfig } from '@vizzly/auth';
+import { nSemanticLayer, OriginId } from '@vizzly/semantic-layer-public';
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type UpdateDashboardResponseBody = {
     dashboard: DashboardFromAPI;
@@ -86,6 +88,7 @@ export type AuthParams = {
     dataAccessToken?: string;
     projectApiKey?: string;
     appSessionToken?: string;
+    queryEngineApiKey?: string;
 };
 export declare namespace nVizzlyQueryEngine {
     type CreateConfigFromUploadParams = {
@@ -94,6 +97,12 @@ export declare namespace nVizzlyQueryEngine {
     };
     type CreateResultsParams = {
         queries: any;
+        dynamicConfig?: nSemanticLayer.Config;
+        secureFilters?: DataAccessConfig['secureFilters'];
+    };
+    type CollectSchemaParams = {
+        allowedConfigOrigins: OriginId[];
+        dynamicConfig?: nSemanticLayer.Config;
     };
     type CreateSqlPreviewParams = {
         sql: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizzly/api-client",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "private": false,
   "license": "NONE",
   "source": "src/index.ts",
@@ -14,7 +14,7 @@
     "@types/jest": "^29.5.12",
     "@types/lodash": "^4.17.0",
     "@types/uuid": "^9.0.8",
-    "@vizzly/auth": "^0.2.8",
+    "@vizzly/auth": "^0.2.16",
     "jest": "^29.6.0",
     "lodash": "^4.17.21",
     "nock": "^13.5.4",
@@ -33,6 +33,8 @@
     "prepublish": "yarn build"
   },
   "dependencies": {
+    "@vizzly/semantic-layer-public": "^0.0.228",
+    "@vizzly/sqlbuilder-public": "^0.1.33",
     "cross-fetch": "^4.0.0"
   }
 }