ezekiel-cli 5.8.2

package/bin/insites-cli-env-add.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+const program = require('commander');
+const fs = require('fs');
+const createPrompt = require('prompt-sync');
+
+const logger = require('../lib/logger');
+const validate = require('../lib/validators');
+const files = require('../lib/files');
+
+const Console = require('../lib/insites-console');
+
+const getPassword = () => {
+  const prompt = createPrompt({});
+  return prompt('Password:', { echo: '*' });
+};
+
+const storeEnvironment = (settings) => {
+  logger.Debug(`[storeEnvironment] ${JSON.stringify(settings, null, 2)}`);
+
+  const environmentSettings = {
+    [settings.endpoint]: {
+      instance_uuid: settings.instanceUuid,
+      token: settings.token,
+      email: settings.email,
+      url: settings.url,
+      key: settings.key,
+    },
+  };
+
+  const configPath = files.getConfigPath();
+  logger.Debug(`[storeEnvironment] Current config path: ${configPath}`);
+
+  const newSettings = Object.assign({}, files.getConfig(), environmentSettings);
+  fs.writeFileSync(configPath, JSON.stringify(newSettings, null, 2));
+};
+
+const help = () => {
+  program.outputHelp();
+  process.exit(1);
+};
+
+const checkParams = (params) => {
+  validate.existence({
+    argumentValue: params.email,
+    argumentName: 'email',
+    fail: help,
+  });
+  validate.existence({
+    argumentValue: params.instanceUuid,
+    argumentName: 'instance uuid',
+    fail: help,
+  });
+  validate.existence({
+    argumentValue: program.args[0],
+    argumentName: 'environment',
+    fail: help,
+  });
+  validate.email(params.email);
+};
+
+program
+  .name('insites-cli env add')
+  .arguments('[environment]', 'name of environment. Example: staging')
+  .option('--email <email>', 'Insites Console account email. Example: admin@example.com')
+  .option('--instance-uuid <instance-uuid>', 'Instance UUID.')
+  .action((environment, params) => {
+    checkParams(params);
+    const settings = {
+      instanceUuid: params.instanceUuid,
+      endpoint: environment,
+      email: params.email,
+    };
+
+    logger.Info(`Please make sure that you have permission to deploy.`, { hideTimestamp: true });
+
+    const password = getPassword();
+    logger.Info(`Asking ${Console.HOST} for access token...`);
+
+    const { email, instanceUuid } = params;
+
+    Console.login(email, password, instanceUuid)
+      .then((response) => {
+        const token = response.token;
+        if (token) {
+          const url = response.url;
+          const key = response['pos_login'].token;
+          storeEnvironment(Object.assign(settings, { token, url, key }));
+          return logger.Success(`Environment ${instanceUuid} as ${environment} has been added successfuly.`);
+        }
+
+        const message = response.message;
+        if (message) return logger.Info(message);
+        return logger.Error('Error generating token. Please check your credentials and try again.');
+      })
+      .catch((e) => {
+        if (e.statusCode === 401) {
+          logger.Error('Either email or password is incorrect.');
+        } else if (e.statusCode === 403) {
+          logger.Error('Insufficient Access');
+        } else {
+          logger.Error(e.message);
+        }
+      });
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-env-list.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+const logger = require('../lib/logger'),
+  files = require('../lib/files');
+
+const listEnvironments = () => {
+  const settings = Object(files.getConfig());
+  const list = Object.keys(settings);
+
+  if (list.length) {
+    logger.Info('Available environments: ');
+    for (const id in list) {
+      const env = list[id];
+      logger.Info(`- [${env}]\t${settings[env]['instance_uuid']}\t${settings[env]['email']}`, { hideTimestamp: true });
+    }
+  } else {
+    logger.Error('No environments registered yet, please see insites-cli env add', { exit: true });
+  }
+  process.exit(0)
+};
+
+listEnvironments();

package/bin/insites-cli-env.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+const program = require('commander');
+
+program
+  .name('insites-cli env')
+  .command(
+    'add [environment]',
+    'Add new environment. Example: insites-cli env add staging --email user@example.com --instance-uuid abcd-ef123-4567'
+  )
+  .command('list', 'list all environments')
+  .parse(process.argv);

package/bin/insites-cli-gui-serve.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+const program = require('commander'),
+  watch = require('../lib/watch'),
+  open = require('open');
+
+const fetchAuthData = require('../lib/settings').fetchSettings,
+  server = require('../lib/server'),
+  logger = require('../lib/logger');
+
+const DEFAULT_CONCURRENCY = 3;
+
+program
+  .name('insites-cli gui serve')
+  .arguments('[environment]', 'Name of environment. Example: staging')
+  .option('-p, --port <port>', 'Use PORT', '3030')
+  .option('-o, --open', 'When ready, open default browser with graphiql')
+  .option('-s, --sync', 'Sync files')
+  .action(async (environment, params) => {
+    const authData = fetchAuthData(environment, program);
+
+    const env = Object.assign(process.env, {
+      CONSOLE_USER_EMAIL: authData.email,
+      CONSOLE_USER_TOKEN: authData.token,
+      CONSOLE_USER_INSTANCE_UUID: authData.instance_uuid,
+      CONSOLE_USER_INSTANCE_URL: authData.url,
+      CONSOLE_USER_ENV: environment,
+      CONSOLE_USER_KEY: authData.key,
+      CONCURRENCY: process.env.CONCURRENCY || DEFAULT_CONCURRENCY,
+      PORT: process.env.PORT || params.port,
+    });
+
+    try {
+      await server.start(env);
+      if (params.open) {
+        await open(`http://localhost:${params.port}`);
+      }
+
+      if (params.sync) {
+        watch.start(env, false);
+      }
+    } catch (e) {
+      logger.Error('✖ Failed.');
+    }
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-gui.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+const program = require('commander');
+
+program
+  .name('insites-cli gui')
+  .command('serve [environment]', 'Serve graphic user interface for files from given environment')
+  .parse(process.argv);

package/bin/insites-cli-init.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+const program = require('commander');
+const fs = require('fs');
+const path = require('path');
+const rp = require('request-promise');
+const url = require('url');
+
+const APIG = require('../lib/insites-apig');
+const { unArchive } = require('../lib/archive');
+
+function extractFilenameFromUrl(s3Url) {
+  const parsedUrl = url.parse(s3Url);
+
+  const pathParts = parsedUrl.pathname.split('/');
+  const filename = pathParts[pathParts.length - 1];
+
+  return filename;
+}
+
+async function downloadPackage(s3Url, filename) {
+  try {
+    const downloadDir = path.join(process.cwd(), filename);
+
+    const response = await rp({ uri: s3Url, encoding: null });
+    fs.writeFileSync(downloadDir, response);
+
+    return downloadDir;
+  } catch (error) {
+    throw new Error(`Error downloading package: ${error.message || error}`);
+  }
+}
+
+program.name('insites-cli init').action(async () => {
+  APIG.getInitPackageURL().then(async (response) => {
+    const { url } = response;
+    const filename = extractFilenameFromUrl(url);
+
+    const downloadedPackagePath = await downloadPackage(url, filename);
+    await unArchive(downloadedPackagePath, 'Project Structure Initialized');
+  });
+});
+
+program.parse(process.argv);

package/bin/insites-cli-logs.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+const EventEmitter = require('events'),
+  path = require('path'),
+  url = require('url');
+
+const program = require('commander'),
+  notifier = require('node-notifier');
+
+const fetchAuthData = require('../lib/settings').fetchSettings,
+  logger = require('../lib/logger'),
+  Gateway = require('../lib/pos-proxy');
+
+class LogStream extends EventEmitter {
+  constructor(authData, interval, filter) {
+    super();
+    this.authData = authData;
+    this.gateway = new Gateway(authData);
+    this.interval = interval
+    this.filter = !!filter && filter.toLowerCase()
+  }
+
+  start() {
+    const t = this;
+    setInterval(() => t.fetchData(), t.interval);
+    logger.Info('Starting live logging...');
+  }
+
+  filterByLogType(row) {
+    if (!this.filter) return;
+
+    try {
+      return this.filter !== (row.error_type || 'error').toLowerCase()
+    }
+    catch(e) {
+      logger.Error(`${row.error_type} error`)
+      return false
+    }
+  }
+
+  fetchData() {
+    this.gateway.logs({ lastId: storage.lastId })
+      .then((response) => {
+        const logs = response && response.logs;
+        if (!logs) {
+          return false;
+        }
+
+        for (let k in logs) {
+          const row = logs[k];
+
+          if (this.filterByLogType(row)) continue;
+
+          if (!storage.exists(row.id)) {
+            storage.add(row);
+            this.emit('message', row);
+          }
+        }
+      })
+  }
+}
+
+const storage = {
+  logs: {},
+  lastId: 0,
+  add: (item) => {
+    storage.logs[item.id] = item;
+    storage.lastId = item.id;
+  },
+  exists: (key) => storage.logs.hasOwnProperty(key),
+};
+
+const isError = (msg) => /error/.test(msg.error_type);
+
+
+program
+  .name('insites-cli logs')
+  .arguments('[environment]', 'Name of environment. Example: staging')
+  .option('--interval <interval>', 'Time to wait between updates in ms', 3000)
+  .option('--filter <log type>', 'Display only logs of given type, example: error')
+  .option('-q, --quiet', 'Show only log message, without context')
+  .action((environment, opts) => {
+    const authData = fetchAuthData(environment, program);
+    const stream = new LogStream(authData, opts.interval, opts.filter);
+
+    // const opts = program.opts();
+    stream.on('message', ({ created_at, error_type, message, data }) => {
+      if (message == null) message = '';
+      if (typeof message != 'string') message = JSON.stringify(message);
+
+      const text = `[${created_at.replace('T', ' ')}] - ${error_type}: ${message.replace(/\n$/, '')}`;
+      const options = { exit: false, hideTimestamp: true };
+
+      if (isError(message)) {
+        notifier.notify({
+          title: error_type,
+          message: message.slice(0, 100),
+          icon: path.resolve(__dirname, '../lib/assets/insites-icon.png'),
+          'app-name': 'insites-cli',
+        });
+
+        logger.Error(text, options);
+      } else {
+        logger.Info(text, options);
+        if (!opts.quiet && data) {
+          let parts = [];
+          if (data.url) {
+            requestUrl = url.parse(`https://${data.url}`);
+            let line = `path: ${requestUrl.pathname}`;
+            if (requestUrl.search) line += `${requestUrl.search}`;
+            parts.push(line);
+          }
+          if (data.page) parts.push(`page: ${data.page}`);
+          if (data.partial) parts.push(`partial: ${data.partial}`);
+          if (data.user && data.user.email) parts.push(`email: ${data.user.email}`);
+          if (parts.length > 0) logger.Quiet(parts.join(' '), options);
+        }
+      }
+    });
+
+    stream.start();
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-logsv2-alerts-add.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+const program = require('commander'),
+      logger = require('../lib/logger'),
+      swagger = require('../lib/swagger-client');
+
+program
+  .name('insites-cli logsv2 alerts add')
+  .arguments('[environment]', 'name of environment. Example: staging')
+  .option('--url <url>', 'post alarms to this url')
+  .option('--name <name>', 'alert name')
+  .option('--keyword <keyword>', 'alert keyword trigger')
+  .option('--operator <operator>', 'operator', "Contains")
+  .option('--column <column>', 'column', "message")
+  .option('--channel <channel>')
+  .option('--json', 'output as json')
+  .action(async (environment, params) => {
+    try {
+      if (!params.channel) {
+        throw Error("--channel is required")
+      }
+
+      const client = await swagger.SwaggerProxy.client(environment, program);
+      const response = await client.createAlert(params)
+
+      if (!params.json)
+        console.log(response)
+      else
+        console.log(response)
+
+    } catch(e) { logger.Error(e) }
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-logsv2-alerts-list.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+const program = require('commander'),
+      logger = require('../lib/logger'),
+      swagger = require('../lib/swagger-client');
+
+program
+  .name('insites-cli logsv2 alerts list')
+  .arguments('[environment]', 'name of environment. Example: staging')
+  .option('--json', 'output as json')
+  .action(async (environment) => {
+    try {
+      const client = await swagger.SwaggerProxy.client(environment, program);
+      const response = await client.alerts(program)
+
+      if (!program.json)
+        console.log(response)
+      else
+        console.log(response)
+    }
+    catch(e) { logger.Error(e) }
+  })
+
+program.parse(process.argv);

package/bin/insites-cli-logsv2-alerts-trigger.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const program = require('commander'),
+      logger = require('../lib/logger'),
+      swagger = require('../lib/swagger-client');
+
+program
+  .name('insites-cli logsv2 alerts trigger')
+  .arguments('[environment]', 'name of environment. Example: staging')
+  .option('--name <name>', 'alert name')
+  .option('--json', 'output as json')
+  .action(async (environment, params) => {
+    try {
+      const client = await swagger.SwaggerProxy.client(environment, program);
+      const response = await client.triggerAlert(params)
+
+      if (!params.json)
+        console.log(response)
+      else
+        console.log(response)
+
+    } catch(e) { logger.Error(e) }
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-logsv2-alerts.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+const program = require('commander');
+
+program
+  .name('insites-cli logsv2 alerts')
+  .command('list [environment]', 'list alerts')
+  .command('add [environment]', 'add alert')
+  .command('rm [environment]', 'remove alert')
+  .command('trigger [environment]', 'trigger alert')
+  .parse(process.argv);

package/bin/insites-cli-logsv2-reports.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const program = require('commander'),
+      logger = require('../lib/logger'),
+      swagger = require('../lib/swagger-client'),
+      path = require('path'),
+      fs = require('fs');
+const ServerError = require('../lib/ServerError');
+
+program.showHelpAfterError();
+program
+  .name('insites-cli logsv2 search')
+  .arguments('[environment]', 'name of environment. Example: staging')
+  // .option('--from <from>', 'start from', 0)
+  // .option('--size <size>', 'rows size', 20)
+  // .option('--start_time <st>', 'starttime')
+  // .option('--end_time <et>', 'endtime')
+  .option('--json', 'output as json')
+  .requiredOption('--report <report>', 'available reports: r-4xx, r-slow, r-slow-by-count')
+  .action(async (environment, program) => {
+    try {
+      const client = await swagger.SwaggerProxy.client(environment, program);
+
+      const report = JSON.parse(fs.readFileSync(path.join(__dirname, `../lib/reports/${program.report}.json`)));
+      const response = await client.searchSQLByQuery(report)
+
+      if (!program.json)
+        swagger.search.printReport(response, report)
+      else
+        console.log(JSON.stringify(response))
+
+    } catch(e) {
+      logger.Error(e);
+    }
+  });
+program.parse(process.argv);

package/bin/insites-cli-logsv2-search.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+const program = require('commander'),
+      logger = require('../lib/logger'),
+      swagger = require('../lib/swagger-client');
+const ServerError = require('../lib/ServerError');
+
+program
+  .name('insites-cli logsv2 search')
+  .arguments('[environment]', 'name of environment. Example: staging')
+  .option('--sql <sql>', 'SQL query to fetch logs')
+  .option('--size <size>', 'rows size', 10)
+  .option('--from <from>', 'start from', 0)
+  .option('--start_time <st>', 'starttime')
+  .option('--end_time <et>', 'endtime')
+  .option('--json', 'output as json')
+  .action(async (environment, params) => {
+    if (!environment) {
+      logger.Error('Please provide environment name', { hideTimestamp: true });
+      process.exit(1);
+    }
+    try {
+      const client = await swagger.SwaggerProxy.client(environment, program);
+      const response = await client.searchSQL(params)
+
+      if (!params.json)
+        swagger.search.printLogs(response)
+      else
+        console.log(response)
+
+    } catch(e) {
+      if (e) {
+        logger.Error(e);
+      } else {
+        logger.Error("An error occurred");
+      }
+    }
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-logsv2-searchAround.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+const program = require('commander'),
+      logger = require('../lib/logger'),
+      swagger = require('../lib/swagger-client');
+
+program
+  .name('insites-cli logsv2 search')
+  .arguments('[environment]', 'name of environment. Example: staging')
+  .option('--stream_name <stream_name>', 'stream name to search around in', 'logs')
+  .option('--key <key>', 'key, timestamp you want to search logs around, eg: 1701428187696722')
+  .option('--size <size>', 'rows size', 10)
+  .option('--json', 'output as json')
+  .action(async (environment, params) => {
+    try {
+      const client = await swagger.SwaggerProxy.client(environment, program);
+      const response = await client.searchAround(params)
+
+      if (!params.json)
+        swagger.search.printLogs(response, params.key)
+      else
+        console.log(response)
+
+    } catch(e) {
+      logger.Error(e);
+    }
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-logsv2.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+const program = require('commander');
+
+program
+  .name('insites-cli logsv2')
+  .command('search', 'search logs')
+  .command('searchAround', 'search stream for records around timestamp')
+  .command('alerts', 'manage alerts')
+  .command('reports', 'predefined reports based on logs')
+  .parse(process.argv);

package/bin/insites-cli-modules-init.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const program = require('commander');
+const degit = require('degit');
+
+const logger = require('../lib/logger'),
+  dir = require('../lib/directories');
+
+const moduleRepo = 'Platform-OS/pos-module-template';
+
+const removeExtraFiles = (moduleName) => {
+  const filesToRemove = [
+    '.gitignore',
+    'package.json',
+    'changelog-template.hbs',
+    'pull_request_template.md',
+    'LICENSE',
+    'CHANGELOG.md',
+  ];
+
+  // Loop through the files and remove them
+  filesToRemove.forEach((file) => {
+    const currentDirectory = process.cwd();
+    const filePath = path.join(currentDirectory, 'modules/', moduleName, file);
+
+    try {
+      fs.unlinkSync(filePath);
+    } catch (err) {
+      return;
+    }
+  });
+};
+
+function createModuleStructure(moduleName) {
+  degit(moduleRepo, { force: true, cache: false, verbose: false })
+    .clone(`${dir.MODULES}/${moduleName}`)
+    .then(() => {
+      removeExtraFiles(moduleName);
+      logger.Success('Module directory structure successfully created.');
+    })
+    .catch((error) => {
+      logger.Error(`Module structure cloning is failed. Reason: ${error.message}`);
+    });
+}
+
+program
+  .name('insites-cli modules init')
+  .arguments('<name>', 'Name of the module to create. Example: profile')
+  .action((name) => {
+    createModuleStructure(name);
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-modules-list.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+const program = require('commander');
+
+const Gateway = require('../lib/pos-proxy'),
+  logger = require('../lib/logger'),
+  fetchAuthData = require('../lib/settings').fetchSettings;
+
+program
+  .name('insites-cli modules list')
+  .arguments('[environment]', 'Name of the environment. Example: staging')
+  .action(environment => {
+    const authData = fetchAuthData(environment, program);
+    const gateway = new Gateway(authData);
+
+    gateway.listModules().then(response => {
+      if (!response.data || response.data.length === 0) {
+        logger.Info('There are no installed modules');
+      } else {
+        logger.Info('Installed modules:');
+        response.data.map(module => {
+          logger.Info(`\t- ${module}`, { hideTimestamp: true });
+        });
+      }
+    }).catch(logger.Debug);
+  });
+
+program.parse(process.argv);