@sisense/sdk-cli 0.11.3

package/LICENSE.md

@@ -0,0 +1,35 @@
+# SISENSE COMPOSE SDK
+
+# END USER LICENSE AGREEMENT
+
+THIS END USER LICENSE AGREEMENT (“EULA”) FORMS A BINDING AGREEMENT BETWEEN YOU INDIVIDUALLY OR THE ENTITY ON WHOSE BEHALF YOU ARE ACCEPTING THIS AGREEMENT (“YOU”) AND DESCRIBES THE TERMS AND CONDITIONS GOVERNING THE USE OF ANY APPLICATION PROGRAMMING INTERFACE, SOFTWARE DEVELOPMENT KIT, CODE SNIPPET, SAMPLE CODE, USER INTERFACE COMPONENT, VISUALIZATION, CLI TOOLS, OR SAMPLE DATA, AND THE CORRESPONDING DOCUMENTATION FOR EACH, ANY UPDATES AND UPGRADES THERETO, AND ANY MODIFICATIONS, ENHANCEMENTS, OR IMPROVEMENTS, OF ANY OF THE FOREGOING (EACH, A “TOOL” AND COLLECTIVELY, THE “TOOLS”), MADE AVAILABLE BY SISENSE LTD. OR ITS AFFILIATES (“SISENSE”).
+
+1. ACCEPTANCE. By downloading, importing, installing and/or using any Tool (or any portion thereof), You represent and warrant that: (a) You have read, understand and accept all of the provisions of this EULA; and (b) if You are accepting on behalf of an entity, You are an employee, contractor or agent of such entity and have the authority and all legal power to accept on behalf of such entity.
+
+2. LICENSE SCOPE. Subject to the terms and conditions of this EULA, Sisense hereby grants You a royalty-free, non-exclusive, non-transferrable, limited license to access, download and use the Tools (in the manner described in the documentation for such Tool) solely for utilization with Your use of the applicable Sisense subscription product (the “Product”), to which You must have purchased the necessary license and use rights pursuant to a separate written agreement with Sisense (the “Master Subscription Agreement”).
+
+3. RESTRICTIONS. You agree that You will not (and have no license to) and will not permit any third party to: (i) use the Tools except as permitted under this EULA; (ii) sell, resell, license, sublicense, rent, lease, encumber, lend, distribute, transfer, or provide a third party with access to the Tools; (iii) modify or create derivative works of the Tools; (iv) circumvent or remove by any means any copy protection used by Sisense in connection with the Tools; (v) use the Tools to develop a competitive product offering; (vi) use the Tool to access Sisense products in a manner not authorized by the Master Subscription Agreement or this EULA; or (vii) use the Tools in any manner that violates the Master Subscription Agreement or any applicable laws or regulations;
+
+4. SISENSE OWNERSHIP. Except for those portions licensed to Sisense by third parties, Sisense retains all right, title and interest in and to the Tools, including without limitation all copyrights and other intellectual property or other proprietary rights worldwide therein (including but not limited to all patent, trademark, service mark, copyright, trade secret, know-how, moral right, and any other intellectual and intangible property rights, including all continuations, continuations in part, applications, renewals, and extensions of any of the foregoing, whether registered or unregistered). All rights not expressly granted herein are reserved. You may not remove, delete or modify any of the Sisense copyright statements in the Tools.
+
+5. OPEN SOURCE COMPONENTS. To the extent any open source software components are provided with or used by the Tools, such components are licensed to You under the terms of the applicable license agreements included with such open source software components.
+
+6. THIRD-PARTY COMPONENTS. To the extent that any Tool includes one or more components licensed by a third-party (a “Component”), and such third-party’s license requirements apply to such Component in a Tool, such additional license terms will be provided in the open source disclosure file provided with or within a Tool download. Third-party license terms shall take precedence over this EULA to the extent that they impose additional restrictions or limitations on You than the license provided herein for download and use of a Component. You agree that: (a) to the extent that the terms between You and the third party for use of a third-party technology accessed by the Component are more restrictive, such terms shall apply to Your use of the Component; (b) Sisense, and not the third party, is responsible for the Component including, without limitation, for any warranties, maintenance, and support thereof, and the third party does not warrant the Component’s accuracy, reliability, completeness, usefulness, non-infringement, or quality of the Component, and will not be liable for any losses or damages of any kind, including lost profits or other indirect or consequential damages, relating to use of or reliance on the Component; and (c) the third party owns all right, title, and interest in and to the Component, including all intellectual property rights therein.
+
+7. TERM, TERMINATION, AND CHANGES. This EULA shall continue as long as You are in compliance with the terms specified herein or until otherwise terminated. This EULA shall automatically terminate upon the expiration or termination of the Master Subscription Agreement. You agree, upon termination, to destroy all copies of the Tools within Your possession or control. The Disclaimer of Warranties, Limitation of Liability and Indemnification sections set out in this EULA shall survive any termination or expiration of this EULA. Sisense may, in its sole discretion, update this EULA from time to time.
+
+8. NO DUTY TO SUPPORT. You expressly acknowledge that Sisense has no duty or obligation to support the Tools, or to provide updates or bug fixes to the Tools.
+
+9. DISCLAIMER OF WARRANTIES. THE TOOLS ARE PROVIDED “AS IS” WITHOUT ANY WARRANTIES OF ANY KIND. TO THE MAXIMUM EXTENT PERMITTED BY LAW, SISENSE DISCLAIMS RESPONSIBILITY FOR ANY HARM RESULTING FROM YOUR USE OF ANY TOOL. SISENSE DISCLAIMS TO THE FULLEST EXTENT PERMITTED, ALL GUARANTEES AND EXPRESS, IMPLIED AND STATUTORY WARRANTIES, INCLUDING WITHOUT LIMITATION THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT OF PROPRIETARY RIGHTS, AND ANY WARRANTIES REGARDING THE AVAILABILITY, SECURITY, RELIABILITY, TIMELINESS AND PERFORMANCE OF ANY TOOL. YOU ACKNOWLEDGE THAT YOU DOWNLOAD AND USE THE TOOLS AT YOUR OWN DISCRETION AND RISK, AND YOU ARE SOLELY RESPONSIBLE FOR ANY DAMAGES TO HARDWARE DEVICES OR LOSS OF DATA THAT RESULT FROM THE DOWNLOAD OR USE OF ANY TOOL.
+
+10. LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT WILL SISENSE BE LIABLE FOR ANY LOST PROFITS OR BUSINESS OPPORTUNITIES, LOSS OF USE, BUSINESS INTERRUPTION, LOSS OF DATA, OR ANY OTHER INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR FROM LIBRARY OR YOUR USE OF THE TOOLS, UNDER ANY THEORY OF LIABILITY, WHETHER BASED IN CONTRACT, TORT, NEGLIGENCE, PRODUCT LIABILITY, OR OTHERWISE. TO THE EXTENT THE PRECEDING LIMITATION DOES NOT APPLY UNDER APPLICABLE LAW, SISENSE’S LIABILITY ARISING OUT OF THE TOOLS PROVIDED HEREUNDER SHALL NOT, IN ANY EVENT, EXCEED USD $100.00.
+
+THE FOREGOING LIMITATIONS SHALL APPLY TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, REGARDLESS OF WHETHER A PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND REGARDLESS OF WHETHER ANY REMEDY FAILS OF ITS ESSENTIAL PURPOSE.
+
+11. INDEMNIFICATION. You agree to defend, indemnify and hold harmless Sisense, and any of its directors, officers, employees, affiliates, subsidiaries or agents, from and against any and all claims, losses, damages, liabilities and other expenses (including reasonable attorneys' fees), arising from or related to: (i) Your use of the Tools; (ii) any derivative works You create using the Tools; and (iii) Your breach of this EULA.
+
+12. EXPORT CONTROL. The Tools are provided subject to the U.S. Export Administration Regulations and the regulations of other jurisdictions (e.g., the European Union). Diversion contrary to applicable law is prohibited. Without limiting the foregoing, You agree that (i) You are not acting on behalf of any person who is a citizen, national, or resident of, or who is controlled by the government of any country to which the United States or other applicable government body has prohibited export transactions; (ii) You are not acting on behalf of, any person or entity listed on a relevant list of persons to whom export is prohibited (e.g., the U.S. Treasury Department list of Specially Designated Nationals and Blocked Persons, the U.S. Commerce Department Denied Persons List or Entity List, etc.); and (iii) You will not use the Tools for any purpose prohibited by applicable law.
+
+13. GOVERNMENT USE. If a Tool provided under the Master Subscription Agreement is software, then it is commercial computer software developed exclusively at private expense. Unless otherwise set forth in the Master Subscription Agreement, use, duplication, and disclosure by civilian agencies of the U.S. Government will not exceed those minimum rights set forth in FAR 52.227-19(c) or successor regulations. Use, duplication, and disclosure by U.S. Department of Defense agencies is subject solely to the license terms contained in this EULA, as stated in DFARS 227.7202 or successor regulations. U.S. Government rights will apply only to the specific agency and program for which the Product is obtained.
+
+14. GOVERNING LAW; ENTIRE AGREEMENT. This EULA shall be governed by the laws of the State of New York and the United States of America without regard to conflict of laws principles. You may not assign any part of this EULA without the prior written consent of Sisense. Any attempted assignment without consent shall be void. This EULA represents the entire agreement between You and Sisense with respect to the Tools and supersedes all prior written or oral communications, understandings and agreements containing the subject matter contained herein. Any waiver of these terms must be in writing to be effective. If any provision of these terms is found to be invalid or unenforceable, the remaining terms will continue to be valid and enforceable to the fullest extent permitted by law. In the event of a conflict between this EULA and the Master Subscription Agreement, the terms of this EULA will prevail to the extent applicable to the license and use of the Tools.

package/README.md

@@ -0,0 +1,70 @@
+This library, which is a part of Sisense Compose SDK,
+provides a set of command line utilities.
+One of which is to generate TypeScript representation of a Sisense data model.
+
+## Installation
+
+Install the package as a dev dependency in your project.
+
+With npm:
+
+```sh
+npm i @sisense/sdk-cli --save-dev
+```
+
+With Yarn:
+
+```sh
+yarn add @sisense/sdk-cli --dev
+```
+
+## Usage
+
+Run the following command to create a `my-data-source.ts` file that contains a TypeScript representation of your data model.
+Substitute `<username>`, `<instance url>`, `<data source name>` with the values for your instance.
+
+With npm:
+
+```sh
+npx sdk-cli get-data-model --username "<username>" --output my-data-source.ts --dataSource "<data source name>" --url <instance url>
+```
+
+With Yarn:
+
+```sh
+yarn run sdk-cli get-data-model --username "<username>" --output my-data-source.ts --dataSource "<data source name>" --url <instance url>
+```
+
+You will be prompted for the password.
+
+The resulting file is created in the current directory.
+
+Instead of `--username "<username>"`, you can also use `--token <token>` to authenticate with [an API token](https://sisense.dev/guides/restApi/using-rest-api.html).
+Substitute `<token>`, `<instance url>`, `<data source name>` with the values for your instance.
+
+With npm:
+
+```sh
+npx sdk-cli get-data-model --token <token> --output my-data-source.ts --dataSource "<data source name>" --url <instance url>
+```
+
+With Yarn:
+
+```sh
+yarn run sdk-cli get-data-model --token <token> --output my-data-source.ts --dataSource "<data source name>" --url <instance url>
+```
+
+Or use `--wat <wat>` to authenticate with a [Web Access Token (WAT)](https://docs.sisense.com/main/SisenseLinux/using-web-access-token.htm).
+Substitute `<token>`, `<instance url>`, `<data source name>` with the values for your instance.
+
+With npm:
+
+```sh
+npx sdk-cli get-data-model --wat <wat> --output my-data-source.ts --dataSource "<data source name>" --url <instance url>
+```
+
+With Yarn:
+
+```sh
+yarn run sdk-cli get-data-model --wat <wat> --output my-data-source.ts --dataSource "<data source name>" --url <instance url>
+```

package/dist/commands/get-api-token.d.ts

@@ -0,0 +1,3 @@
+import { CommandModule } from 'yargs';
+import { GetApiTokenOptions } from '../types.js';
+export declare const getApiTokenCommand: CommandModule<unknown, GetApiTokenOptions>;

package/dist/commands/get-api-token.js

@@ -0,0 +1,51 @@
+import { getHttpClient, handleHttpClientLogin } from './helpers.js';
+import { promptPasswordInteractive } from './prompts.js';
+import { trackExecution } from '../tracking.js';
+const command = 'get-api-token';
+const describe = 'Get an API token from the given Sisense URL using the provided credentials.';
+const builder = (yargs) => yargs
+    .options({
+    username: {
+        type: 'string',
+        describe: 'Specify the username for username/password authentication',
+        alias: ['u'],
+        demandOption: true,
+    },
+    password: {
+        type: 'string',
+        describe: 'Specify the password for username/password authentication. If not provided, the program will prompt for it interactively.',
+        alias: ['p'],
+    },
+    url: {
+        type: 'string',
+        describe: 'Specify the Sisense URL to connect to',
+        demandOption: true,
+    },
+})
+    .example([['$0 get-api-token --url https://domain.sisense.com -u user@domain.com']]);
+const handler = async (options) => {
+    const { url, username } = options;
+    let { password } = options;
+    if (username && !password) {
+        ({ maskedPassword: password } = await promptPasswordInteractive(username));
+    }
+    const httpClient = getHttpClient(url, username, password);
+    try {
+        await handleHttpClientLogin(httpClient);
+        trackExecution(httpClient, command, options);
+        const response = await httpClient.get('/api/v1/authentication/tokens/api');
+        console.log(response);
+    }
+    catch (err) {
+        if (err)
+            console.log(err);
+        // exit code 1: One or more generic errors encountered upon exit
+        process.exit(1);
+    }
+};
+export const getApiTokenCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};

package/dist/commands/get-data-model.d.ts

@@ -0,0 +1,4 @@
+import { Arguments, CommandModule } from 'yargs';
+import { Command, GetDataModelOptions } from '../types.js';
+export declare const getDataModel: (options: Arguments<GetDataModelOptions>, commandName: Command) => Promise<void>;
+export declare const getDataModelCommand: CommandModule<unknown, GetDataModelOptions>;

package/dist/commands/get-data-model.js

@@ -0,0 +1,94 @@
+import { getHttpClient, createDataModel, writeFile, handleHttpClientLogin, getFilePathInfo, isSupportedOutputFile, } from './helpers.js';
+import { promptPasswordInteractive } from './prompts.js';
+import { trackExecution } from '../tracking.js';
+const command = 'get-data-model';
+const describe = 'Write the TypeScript or JavaScript representation of a data model from the given Sisense URL and data source';
+const builder = (yargs) => yargs
+    .options({
+    username: {
+        type: 'string',
+        describe: 'Specify the username for username/password authentication',
+        alias: ['u'],
+    },
+    password: {
+        type: 'string',
+        describe: 'Specify the password for username/password authentication. If not provided, the program will prompt for it interactively.',
+        alias: ['p'],
+    },
+    token: {
+        type: 'string',
+        describe: 'Specify bearer token for token based authentication',
+    },
+    wat: {
+        type: 'string',
+        describe: 'Specify web access token for token based authentication',
+    },
+    output: {
+        type: 'string',
+        describe: 'Specify the output TypeScript (.ts) or JavaScript (.js) filename',
+        alias: ['o'],
+    },
+    url: {
+        type: 'string',
+        describe: 'Specify the Sisense URL to connect to',
+        demandOption: true,
+    },
+    dataSource: {
+        type: 'string',
+        alias: ['d'],
+        describe: 'Specify the data source name',
+        demandOption: true,
+    },
+})
+    .example([
+    [
+        '$0 get-data-model --url https://domain.sisense.com -u user@domain.com -d "Sample ECommerce" -o MySampleEComm.ts',
+    ],
+]);
+export const getDataModel = async (options, commandName) => {
+    const { url, dataSource, username, token, wat, output } = options;
+    let { password } = options;
+    // validate url
+    if (!/^(http|https):\/\//.test(url)) {
+        console.log(`Error connecting to ${url}`);
+        console.log('ValidationError: URL must start with http:// or https://');
+        // exit code 2: Incorrect usage, such as invalid options or missing arguments
+        process.exit(2);
+    }
+    //validate output file path
+    const outputInfo = getFilePathInfo({
+        filePath: output,
+        defaultBaseName: dataSource,
+        defaultFileExtension: '.ts',
+    });
+    if (!isSupportedOutputFile(outputInfo)) {
+        console.log(`Invalid output file extension: ${outputInfo.extension}. Only TypeScript (.ts) or JavaScript (.js) file is supported.`);
+        // exit code 2: Incorrect usage, such as invalid options or missing arguments
+        process.exit(2);
+    }
+    // if username is provided but password is not, prompt for password interactively
+    if (username && !password) {
+        ({ maskedPassword: password } = await promptPasswordInteractive(username));
+    }
+    const httpClient = getHttpClient(url, username, password, token, wat);
+    try {
+        await handleHttpClientLogin(httpClient);
+        trackExecution(httpClient, commandName, options);
+        await createDataModel(httpClient, dataSource).then((model) => {
+            return writeFile(model, outputInfo);
+        });
+    }
+    catch (err) {
+        if (err)
+            console.log(err);
+        // exit code 1: One or more generic errors encountered upon exit
+        process.exit(1);
+    }
+};
+const handler = (options) => getDataModel(options, 'get-data-model');
+export const getDataModelCommand = {
+    command,
+    describe,
+    builder,
+    handler,
+};

package/dist/commands/helpers.d.ts

@@ -0,0 +1,30 @@
+import { HttpClient } from '@sisense/sdk-rest-client';
+import { DataModel } from '@sisense/sdk-data';
+declare function getHttpClient(url: string, username?: string, password?: string, token?: string, wat?: string): HttpClient;
+export declare const handleHttpClientLogin: (httpClient: HttpClient) => Promise<void>;
+/**
+ * Create a data model for a Sisense data source
+ */
+declare function createDataModel(httpClient: HttpClient, dataSource: string): Promise<DataModel>;
+declare function rewriteDataModel(dataModel: any): DataModel;
+declare function writeFile(dataModel: DataModel, outputFilePathInfo: SupportedOutputFilePathInfo): Promise<void>;
+export declare type FilePathInfo = {
+    dir: string;
+    baseName: string;
+    extension: string;
+};
+/**
+ * Gets the directory, base name, and extension of a file path.
+ * If the file path is not provided, the default values are used.
+ */
+declare function getFilePathInfo({ filePath, defaultBaseName, defaultFileExtension, }: {
+    filePath?: string;
+    defaultFileExtension: SupportedOutputFileExtension;
+    defaultBaseName: string;
+}): FilePathInfo;
+export declare type SupportedOutputFileExtension = '.ts' | '.js';
+export declare type SupportedOutputFilePathInfo = FilePathInfo & {
+    extension: SupportedOutputFileExtension;
+};
+declare function isSupportedOutputFile(filePathInfo: FilePathInfo): filePathInfo is SupportedOutputFilePathInfo;
+export { getHttpClient, createDataModel, rewriteDataModel, writeFile, getFilePathInfo, isSupportedOutputFile, };

package/dist/commands/helpers.js

@@ -0,0 +1,166 @@
+/* eslint-disable max-lines */
+/* eslint-disable max-lines-per-function */
+/* eslint-disable max-params */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { HttpClient, getAuthenticator, WatAuthenticator, BearerAuthenticator, } from '@sisense/sdk-rest-client';
+import { MetadataTypes } from '@sisense/sdk-data';
+import { writeTypescript, writeJavascript } from '@sisense/sdk-modeling';
+import path from 'path';
+import { DimensionalQueryClient } from '@sisense/sdk-query-client';
+import { PKG_VERSION } from '../package-version.js';
+import { trackCliError } from '@sisense/sdk-common';
+function getHttpClient(url, username, password, token, wat) {
+    const auth = getAuthenticator(url, username, password, token, wat, false);
+    if (!auth) {
+        throw new Error('Invalid authentication method');
+    }
+    return new HttpClient(url, auth, 'sdk-cli' + (PKG_VERSION ? `-${PKG_VERSION}` : ''));
+}
+export const handleHttpClientLogin = async (httpClient) => {
+    console.log('Logging in... ');
+    try {
+        const isLoggedIn = await httpClient.login();
+        if (!isLoggedIn) {
+            console.log(`Failed. ${httpClient.auth instanceof WatAuthenticator ||
+                httpClient.auth instanceof BearerAuthenticator
+                ? 'Double-check your token'
+                : 'Wrong credentials'}.\r\n`);
+        }
+        console.log('OK!\r\n');
+    }
+    catch (err) {
+        console.log(`Error connecting to ${httpClient.url}. \r\n${err}\r\n`);
+        return Promise.reject();
+    }
+    return Promise.resolve();
+};
+/**
+ * Create a data model for a Sisense data source
+ */
+async function createDataModel(httpClient, dataSource) {
+    const queryClient = new DimensionalQueryClient(httpClient);
+    console.log('Getting fields... ');
+    try {
+        return await queryClient.getDataSourceFields(dataSource).then((fields) => {
+            console.log('OK!\r\n');
+            const dataModel = {
+                name: dataSource,
+                dataSource: dataSource,
+                metadata: fields,
+            };
+            return rewriteDataModel(dataModel);
+        });
+    }
+    catch (err) {
+        trackCliError({
+            packageVersion: PKG_VERSION,
+            component: 'createDataModel',
+            error: err,
+        }, httpClient).catch(() => { });
+        console.log(`Error fetching metadata. Reason: ${err}\r\n`);
+        return Promise.reject();
+    }
+}
+function rewriteDataModel(dataModel) {
+    console.log(`Cleaning metadata... `);
+    dataModel.metadata = dataModel.metadata
+        .filter((item) => !item.dimensionTable)
+        .map((item) => {
+        const result = {
+            name: item.title,
+            expression: item.id,
+            type: MetadataTypes.Dimension,
+            group: undefined,
+        };
+        result.group = item.table;
+        switch (item.dimtype) {
+            case 'text':
+                result.type = MetadataTypes.TextAttribute;
+                break;
+            case 'numeric':
+                result.type = MetadataTypes.NumericAttribute;
+                break;
+            case 'datetime':
+                result.type = MetadataTypes.DateDimension;
+                break;
+        }
+        return result;
+    });
+    console.log('OK!\r\n');
+    console.log(`Grouping metadata... `);
+    const grouped = dataModel.metadata.reduce((r, a) => {
+        if (!r[a.group]) {
+            r[a.group] = {
+                name: a.group,
+                type: MetadataTypes.Dimension,
+                dimensions: [],
+                attributes: [],
+            };
+        }
+        // If the field is date, model it as a date dimension
+        // otherwise, model the field as a dimension attribute.
+        if (a.type === MetadataTypes.DateDimension) {
+            r[a.group].dimensions.push(a);
+        }
+        else {
+            r[a.group].attributes.push(a);
+        }
+        delete a.group;
+        return r;
+    }, {});
+    dataModel.metadata = Object.values(grouped);
+    console.log('OK!\r\n');
+    return dataModel;
+}
+async function writeFile(dataModel, outputFilePathInfo) {
+    const { dir, baseName, extension } = outputFilePathInfo;
+    try {
+        console.log(`Writing '${getFullFilePath(outputFilePathInfo)}'...`);
+        if (extension === '.ts') {
+            await writeTypescript(dataModel, { filename: baseName, dir });
+        }
+        else if (extension === '.js') {
+            await writeJavascript(dataModel, { filename: baseName, dir });
+            // Currently, we don't allow writing JSON files. Can be uncommented in the future to enable supporting JSON.
+            // } else if (extension === '.json') {
+            //   writeFileSync(outputFileName, JSON.stringify(dataModel, null, '    '), 'utf-8');
+            // }
+        }
+        console.log(`OK!\r\n`);
+    }
+    catch (err) {
+        console.log(`Error writing file. Reason: ${err}\r\n`);
+        throw err;
+    }
+}
+/**
+ * Gets the directory, base name, and extension of a file path.
+ * If the file path is not provided, the default values are used.
+ */
+function getFilePathInfo({ filePath, defaultBaseName, defaultFileExtension, }) {
+    const dir = filePath ? path.dirname(filePath) : '.';
+    const extension = filePath ? getExtension(filePath, defaultFileExtension) : defaultFileExtension;
+    const baseName = filePath ? path.basename(filePath, extension) : defaultBaseName;
+    return { dir, baseName, extension };
+}
+function getExtension(filePath, defaultFileExtension) {
+    const extname = path.extname(filePath);
+    if (extname === '') {
+        return defaultFileExtension;
+    }
+    else {
+        return extname;
+    }
+}
+function getFullFilePath(filePathInfo) {
+    return path.join(filePathInfo.dir, filePathInfo.baseName + filePathInfo.extension);
+}
+function isSupportedOutputFile(filePathInfo) {
+    return ['.ts', '.js'].includes(filePathInfo.extension);
+}
+export { getHttpClient, createDataModel, rewriteDataModel, writeFile, getFilePathInfo, isSupportedOutputFile, };

package/dist/commands/interactive.d.ts

@@ -0,0 +1,9 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { GetDataModelOptions } from '../types.js';
+export declare const handleHelper: (combinedAnswers: ArgumentsCamelCase<GetDataModelOptions>) => Promise<void>;
+export declare const validateNotEmpty: (input: string) => Promise<true | "this field cannot be blank">;
+export declare const interactiveCommand: {
+    command: "interactive";
+    desc: string;
+    handler: () => Promise<void>;
+};

package/dist/commands/interactive.js

@@ -0,0 +1,52 @@
+/* eslint-disable max-lines-per-function */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable max-lines */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+import { getDataModel } from './get-data-model.js';
+import { promptCommand, promptUrl, promptAuth, promptPasswordAuth, promptTokenAuth, promptWatAuth, promptDataModel, } from './prompts.js';
+const command = 'interactive';
+const desc = 'Run in interactive mode';
+export const handleHelper = (combinedAnswers) => getDataModel(combinedAnswers, 'interactive');
+const handler = async () => {
+    const cmd = await promptCommand();
+    if (cmd.command !== 'get-data-model')
+        return;
+    const urlInput = await promptUrl();
+    const url = `${urlInput.protocol}://${urlInput.hostname}:${urlInput.port}`;
+    console.log(`\nSisense host URL: ${url}\n`);
+    const auth = await promptAuth();
+    let passwordAuthAnswers, tokenAuthAnswers, watAuthAnswers;
+    if (auth.auth === 'password') {
+        passwordAuthAnswers = await promptPasswordAuth();
+    }
+    else if (auth.auth === 'token') {
+        tokenAuthAnswers = await promptTokenAuth();
+    }
+    else if (auth.auth === 'web access token') {
+        watAuthAnswers = await promptWatAuth();
+    }
+    const answers = await promptDataModel();
+    answers.url = url;
+    return handleHelper({
+        ...passwordAuthAnswers,
+        ...tokenAuthAnswers,
+        ...watAuthAnswers,
+        ...answers,
+    });
+};
+export const validateNotEmpty = async (input) => {
+    if (input === undefined || input.trim() === '')
+        return 'this field cannot be blank';
+    return true;
+};
+export const interactiveCommand = {
+    command,
+    desc,
+    handler,
+};

package/dist/commands/prompts.d.ts

@@ -0,0 +1,30 @@
+import inquirer from 'inquirer';
+import { ArgumentsCamelCase } from 'yargs';
+export declare const promptPasswordInteractive: (username: string) => Promise<ArgumentsCamelCase<{
+    maskedPassword: string;
+}>> & {
+    ui: inquirer.ui.Prompt<ArgumentsCamelCase<{
+        maskedPassword: string;
+    }>>;
+};
+export declare const promptCommand: () => Promise<any> & {
+    ui: inquirer.ui.Prompt<any>;
+};
+export declare const promptUrl: () => Promise<any> & {
+    ui: inquirer.ui.Prompt<any>;
+};
+export declare const promptAuth: () => Promise<any> & {
+    ui: inquirer.ui.Prompt<any>;
+};
+export declare const promptPasswordAuth: () => Promise<any> & {
+    ui: inquirer.ui.Prompt<any>;
+};
+export declare const promptTokenAuth: () => Promise<any> & {
+    ui: inquirer.ui.Prompt<any>;
+};
+export declare const promptWatAuth: () => Promise<any> & {
+    ui: inquirer.ui.Prompt<any>;
+};
+export declare const promptDataModel: () => Promise<any> & {
+    ui: inquirer.ui.Prompt<any>;
+};

package/dist/commands/prompts.js

@@ -0,0 +1,101 @@
+import inquirer from 'inquirer';
+import { validateNotEmpty } from './interactive.js';
+export const promptPasswordInteractive = (username) => inquirer.prompt([
+    {
+        type: 'password',
+        name: 'maskedPassword',
+        mask: '*',
+        message: `Enter password for username '${username}':`,
+        validate: (answer) => {
+            if (!answer || answer === '') {
+                return 'Password cannot be blank';
+            }
+            return true;
+        },
+    },
+]);
+export const promptCommand = () => inquirer.prompt([
+    {
+        type: 'rawlist',
+        name: 'command',
+        message: 'Select command to run:',
+        choices: ['get-data-model'],
+    },
+]);
+export const promptUrl = () => inquirer.prompt([
+    {
+        type: 'input',
+        name: 'hostname',
+        message: 'Specify the Sisense server IP address or hostname (example: 10.50.1.5):',
+        validate: validateNotEmpty,
+    },
+    {
+        type: 'number',
+        name: 'port',
+        message: 'Specify the Sisense server port or leave blank for default port:',
+        default: 30845,
+    },
+    {
+        type: 'list',
+        name: 'protocol',
+        message: 'Select http/https:',
+        choices: ['http', 'https'],
+        default: 'http',
+    },
+]);
+export const promptAuth = () => inquirer.prompt([
+    {
+        type: 'list',
+        name: 'auth',
+        message: 'Select authentication method:',
+        choices: ['password', 'token', 'web access token'],
+        default: 'password',
+    },
+]);
+export const promptPasswordAuth = () => inquirer.prompt([
+    {
+        type: 'input',
+        name: 'username',
+        message: 'Specify the username for username/password authentication:',
+    },
+    {
+        type: 'password',
+        name: 'password',
+        mask: '*',
+        message: 'Specify the password for username/password authentication:',
+        validate: (input, answers) => {
+            if (answers.username && answers.username !== '' && !input) {
+                return 'if username is provided password cannot be blank';
+            }
+            return true;
+        },
+    },
+]);
+export const promptTokenAuth = () => inquirer.prompt([
+    {
+        type: 'input',
+        name: 'token',
+        message: 'Specify the Bearer token for token-based authentication:',
+    },
+]);
+export const promptWatAuth = () => inquirer.prompt([
+    {
+        type: 'input',
+        name: 'wat',
+        message: 'Specify the web access token for token-based authentication:',
+    },
+]);
+export const promptDataModel = () => inquirer.prompt([
+    {
+        type: 'input',
+        name: 'dataSource',
+        message: 'Specify the data source name (for example: Sample ECommerce):',
+        validate: validateNotEmpty,
+    },
+    {
+        type: 'input',
+        name: 'output',
+        message: 'Specify the output filename:',
+        validate: validateNotEmpty,
+    },
+]);

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare enum TrackingActions {
+    Execution = "sdkCliExec"
+}

package/dist/constants.js

@@ -0,0 +1,4 @@
+export var TrackingActions;
+(function (TrackingActions) {
+    TrackingActions["Execution"] = "sdkCliExec";
+})(TrackingActions = TrackingActions || (TrackingActions = {}));

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * @packageDocumentation
+ * @beta
+ */
+import 'cross-fetch/dist/node-polyfill.js';
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * @packageDocumentation
+ * @beta
+ */
+// Native fetch() is not available in Node.js until version 18.
+// Polyfill fetch() with cross-fetch for CLI commands if needed.
+// Somehow import 'cross-fetch/polyfill' does not work thus the following workaround
+// eslint-disable-next-line import/extensions
+import 'cross-fetch/dist/node-polyfill.js';
+import { runCli } from './run-cli.js';
+export * from './types.js';
+runCli();

package/dist/package-version.d.ts

@@ -0,0 +1 @@
+export declare const PKG_VERSION = "0.11.3";

package/dist/package-version.js

@@ -0,0 +1 @@
+export const PKG_VERSION = "0.11.3";

package/dist/run-cli.d.ts

@@ -0,0 +1 @@
+export declare const runCli: () => void;

package/dist/run-cli.js

@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/no-floating-promises */
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { getDataModelCommand } from './commands/get-data-model.js';
+import { getApiTokenCommand } from './commands/get-api-token.js';
+import { interactiveCommand } from './commands/interactive.js';
+export const runCli = () => {
+    yargs(hideBin(process.argv))
+        .command(getDataModelCommand)
+        .command(interactiveCommand)
+        .command(getApiTokenCommand)
+        .scriptName('sdk-cli')
+        .showHelpOnFail(true)
+        .demandCommand(1, 'You need to specify a command to continue')
+        .help()
+        .strict().argv;
+};

package/dist/tracking.d.ts

@@ -0,0 +1,2 @@
+import { HttpClient } from '@sisense/sdk-rest-client';
+export declare const trackExecution: <T extends {}>(httpClient: HttpClient, commandName: string, args: T) => void;

package/dist/tracking.js

@@ -0,0 +1,15 @@
+import { trackProductEvent } from '@sisense/sdk-common';
+import { PKG_VERSION } from './package-version.js';
+import { TrackingActions } from './constants.js';
+export const trackExecution = (httpClient, commandName, args) => {
+    const payload = {
+        packageVersion: PKG_VERSION,
+        commandName,
+        argumentsPassed: Object.entries(args)
+            .filter(([, v]) => !!v)
+            .map(([k]) => k)
+            .join(', '),
+    };
+    const action = TrackingActions.Execution;
+    void trackProductEvent(action, payload, httpClient).catch((e) => console.log(`An error occurred when sending the ${action} event`, e));
+};

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+import { DataSource } from '@sisense/sdk-data';
+declare const COMMANDS: readonly ["get-data-model", "interactive", "get-api-token"];
+/**
+ * The commands supported by the CLI tool.
+ *
+ * @expandType
+ */
+export declare type Command = (typeof COMMANDS)[number];
+export declare type GetDataModelOptions = {
+    url: string;
+    dataSource: DataSource;
+    username: string | undefined;
+    password: string | undefined;
+    token: string | undefined;
+    wat: string | undefined;
+    output: string | undefined;
+};
+export declare type GetApiTokenOptions = {
+    url: string;
+    username: string;
+    password: string | undefined;
+};
+export {};

package/dist/types.js

@@ -0,0 +1,2 @@
+const COMMANDS = ['get-data-model', 'interactive', 'get-api-token'];
+export {};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@sisense/sdk-cli",
+  "description": "CLI for generating programmatic interface from Sisense data model",
+  "version": "0.11.3",
+  "type": "module",
+  "exports": "./dist/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "author": "Sisense",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "bin": "./dist/index.js",
+  "dependencies": {
+    "@sisense/sdk-common": "^0.11.3",
+    "@sisense/sdk-data": "^0.11.3",
+    "@sisense/sdk-modeling": "^0.11.3",
+    "@sisense/sdk-query-client": "^0.11.3",
+    "@sisense/sdk-rest-client": "^0.11.3",
+    "cross-fetch": "^4.0.0",
+    "inquirer": "^8.1.2",
+    "yargs": "17.7.1"
+  },
+  "scripts": {
+    "cli": "node ./dist/index.js",
+    "prebuild": "node -p \"'export const PKG_VERSION = ' + JSON.stringify(require('./package.json').version) + ';'\" > src/package-version.ts",
+    "type-check": "run prebuild && tsc --noEmit",
+    "build": "run prebuild && tsc --build tsconfig.build.json",
+    "build:prod": "run prebuild && tsc --project tsconfig.prod.json",
+    "clean": "rm -rf dist coverage tsconfig.build.tsbuildinfo tsconfig.prod.tsbuildinfo",
+    "lint": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "vitest": "run -T vitest",
+    "test": "run vitest run",
+    "test:watch": "run vitest watch",
+    "test:coverage": "run vitest run --coverage"
+  },
+  "files": [
+    "src-js/",
+    "dist/",
+    "./"
+  ],
+  "devDependencies": {
+    "@babel/preset-env": "^7.20.2",
+    "@types/inquirer": "8.2.6",
+    "@types/yargs": "^17.0.22",
+    "eslint": "^8.40.0",
+    "prettier": "2.8.4",
+    "typescript": "4.8.4",
+    "vitest-fetch-mock": "^0.2.2"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  }
+}