@vizzly/api-client 0.0.1

package/dist/models/VizzlyQueryEngineApi.js

@@ -0,0 +1,311 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VizzlyQueryEngineApi = void 0;
+const Api_1 = require("./Api");
+const SQLPreviewError_1 = require("../errors/SQLPreviewError");
+const FailedToResolveDataSets_1 = require("../errors/FailedToResolveDataSets");
+const FailedToSetupProject_1 = require("../errors/FailedToSetupProject");
+class VizzlyQueryEngineApi extends Api_1.Api {
+    constructor(auth, host, extraHeaders) {
+        super(auth, host, extraHeaders);
+    }
+    buildCreateDashboardRequest(params) {
+        return {
+            path: '/api/v1/dashboard',
+            method: 'post',
+            body: {
+                dashboardAccessToken: this.auth.getDashboardAccessToken(),
+                definition: params.definition,
+                meta: params.metadata,
+                parentDashboardId: params.parentDashboardId,
+                permissions: params.permissions,
+            },
+        };
+    }
+    buildFetchDashboardsRequest(dashboardSessionAccessTokens) {
+        return {
+            path: '/api/v1/get-dashboards',
+            method: 'post',
+            body: {
+                dashboardAccessTokens: dashboardSessionAccessTokens,
+            },
+        };
+    }
+    createConfigFromUpload(createConfigFromUploadParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateConfigFromUploadRequest(createConfigFromUploadParams));
+        });
+    }
+    buildCreateConfigFromUploadRequest(params) {
+        return {
+            path: `/api/v1/create-config-from-upload`,
+            method: 'post',
+            body: {
+                queryEngineAccessToken: this.auth.getQueryEngineAccessToken(),
+                table: params.table,
+                fieldPublicNames: params.fieldPublicNames,
+            },
+        };
+    }
+    createResults(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateResultsRequest(params));
+        });
+    }
+    buildCreateResultsRequest(params) {
+        return {
+            path: `/api/v1/create-results`,
+            method: 'post',
+            body: {
+                queries: params.queries,
+                virtualFields: {},
+                identityConfigIntegritySignature: this.auth.getDataAccessToken(),
+            },
+        };
+    }
+    createSqlPreview(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const response = yield this.execute(this.buildCreateSqlPreviewRequest(params));
+            if (response.status === 200)
+                return response;
+            throw new SQLPreviewError_1.SQLPreviewError(((_a = response === null || response === void 0 ? void 0 : response.body) === null || _a === void 0 ? void 0 : _a.message) || 'Unknown SQL error');
+        });
+    }
+    buildCreateSqlPreviewRequest(params) {
+        return {
+            path: `/api/v1/create-sql-preview`,
+            method: 'post',
+            body: {
+                sql: params.sql,
+                parameters: params.parameters,
+                limit: params.limit,
+            },
+        };
+    }
+    createQueryEngineUser(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateQueryEngineUserRequest(params));
+        });
+    }
+    buildCreateQueryEngineUserRequest(params) {
+        return {
+            path: `/api/v1/query-engine-user`,
+            method: 'post',
+            body: {
+                email: params.email,
+                password: params.password,
+            },
+        };
+    }
+    fetchDataSets() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = this.buildFetchDataSetsRequest();
+            const result = yield this.execute(request);
+            if (result.status === 200)
+                return result;
+            throw new FailedToResolveDataSets_1.FailedToResolveDataSets(`Failed to resolve data sets from ${request.path}. Received status ${result.status}`);
+        });
+    }
+    buildFetchDataSetsRequest() {
+        return {
+            path: `/api/v1/resolve-data-sets`,
+            method: 'post',
+            body: {
+                integritySignature: this.auth.getDataAccessToken(),
+            },
+        };
+    }
+    fetchSelfHostedQueryEngineConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute(this.buildFetchSelfHostedQueryEngineConfigRequest());
+        });
+    }
+    buildFetchSelfHostedQueryEngineConfigRequest() {
+        return {
+            path: `/api/v1/support`,
+            method: 'post',
+            body: {},
+        };
+    }
+    fetchProject() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute(this.buildFetchProjectRequest());
+        });
+    }
+    buildFetchProjectRequest() {
+        return {
+            path: `/api/v1/project`,
+            method: 'get',
+            body: {},
+        };
+    }
+    getStarted(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.execute(this.buildGetStartedRequest(params));
+            if (response.status != 200) {
+                throw new FailedToSetupProject_1.FailedToSetupProject(typeof response.body === 'object' && response.body.reason && 'reason' in response.body
+                    ? response.body.reason
+                    : 'Failed to create the first user.');
+            }
+            return response;
+        });
+    }
+    buildGetStartedRequest(params) {
+        return {
+            path: `/api/v2/get-started`,
+            method: 'post',
+            body: {
+                email: params.email,
+                password: params.password,
+            },
+        };
+    }
+    getTeamMembers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute(this.buildGetTeamMembersRequest());
+        });
+    }
+    buildGetTeamMembersRequest() {
+        return {
+            path: `/api/v1/team-members`,
+            method: 'get',
+        };
+    }
+    isVizzly() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute(this.buildIsVizzlyRequest());
+        });
+    }
+    buildIsVizzlyRequest() {
+        return {
+            path: `/api/is-vizzly`,
+            method: 'get',
+        };
+    }
+    saveConfig(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildSaveConfigRequest(params));
+        });
+    }
+    buildSaveConfigRequest(params) {
+        return {
+            path: `/api/v1/save-config`,
+            method: 'post',
+            body: {
+                config: params.config,
+            },
+        };
+    }
+    saveConnection(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildSaveConnectionRequest(params));
+        });
+    }
+    buildSaveConnectionRequest(params) {
+        return {
+            path: `/api/v1/save-connection`,
+            method: 'post',
+            body: {
+                connection: params.connection,
+                client: params.client,
+            },
+        };
+    }
+    signInWithQueryEngineAccessToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute(this.buildSignInWithQueryEngineAccessTokenRequest());
+        });
+    }
+    buildSignInWithQueryEngineAccessTokenRequest() {
+        return {
+            path: `/api/v1/sign-in`,
+            method: 'post',
+            body: {},
+        };
+    }
+    signInWithEmailAndPassword(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildSignInWithEmailAndPasswordRequest(params));
+        });
+    }
+    buildSignInWithEmailAndPasswordRequest(params) {
+        return {
+            path: `/api/v1/sign-in`,
+            method: 'post',
+            body: {
+                email: params.email,
+                password: params.password,
+            },
+        };
+    }
+    status() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute(this.buildStatusRequest());
+        });
+    }
+    buildStatusRequest() {
+        return {
+            path: `/api/status`,
+            method: 'post',
+            body: {},
+        };
+    }
+    updateDashboard(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildUpdateDashboardRequest(params));
+        });
+    }
+    buildUpdateDashboardRequest(params) {
+        return {
+            path: `/api/v1/dashboard`,
+            method: 'put',
+            body: {
+                dashboardSessionToken: params.dashboardSessionToken,
+                definition: params.definition,
+                meta: params.meta,
+                deleted: params.deleted,
+            },
+        };
+    }
+    updateQueryEngineUser(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildUpdateQueryEngineUserRequest(params));
+        });
+    }
+    buildUpdateQueryEngineUserRequest(params) {
+        return {
+            path: `/api/v1/query-engine-user`,
+            method: 'put',
+            body: {
+                queryEngineUserId: params.queryEngineUserId,
+                password: params.password,
+            },
+        };
+    }
+    uploadDataToVizzlyCloud(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildUploadDataToVizzlyCloudRequest(params));
+        });
+    }
+    buildUploadDataToVizzlyCloudRequest(params) {
+        return {
+            path: `/api/v1/ingest`,
+            method: 'post',
+            body: {
+                queryEngineAccessToken: this.auth.getQueryEngineAccessToken(),
+                ingest: params.ingest,
+            },
+        };
+    }
+}
+exports.VizzlyQueryEngineApi = VizzlyQueryEngineApi;

package/dist/types/dashboard.d.ts

@@ -0,0 +1,23 @@
+export type Dashboard = {
+    definition: DashboardDefinition;
+    created_at: string;
+    id: string;
+    metadata: Object;
+    organisation_id: string;
+    parent_dashboard_id: string | null;
+    updated_at: string;
+    webhook_id: string | null;
+};
+export type DashboardDefinition = {
+    display: any;
+    componentLibrary: Array<{
+        attributes: {
+            viewId: string;
+            protectedByOrganisation?: boolean;
+        };
+    }>;
+    globalFilters: Array<any>;
+    customFields: {
+        [dataSetId: string]: Array<any>;
+    };
+};

package/dist/types/dashboard.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });