ezekiel-cli 5.8.2

package/lib/files.js

@@ -0,0 +1,96 @@
+const path = require('path');
+const fs = require('fs');
+const glob = require('fast-glob');
+
+const logger = require('./logger');
+const dir = require('./directories');
+
+const config = {
+  CONFIG: '.insites',
+  LEGACY_CONFIG: '.insites.legacy',
+  IGNORE_LIST: '.insitesignore',
+  templateValues: 'template-values.json'
+};
+
+const _paths = customConfig => [customConfig, config.CONFIG, config.LEGACY_CONFIG];
+
+const _getConfigPath = customConfig => {
+  const firstExistingConfig = _paths(customConfig).filter(fs.existsSync)[0];
+  logger.Debug(`[_getConfigPath] First existing config file: ${firstExistingConfig}`);
+  return path.resolve(firstExistingConfig || config.CONFIG);
+};
+
+const _readJSON = (filePath, opts = { exit: true, throwDoesNotExistError: false }) => {
+  if (fs.existsSync(filePath)) {
+    logger.Debug(`[_readJSON] File exist: ${filePath}.`);
+
+    const fileContent = fs.readFileSync(filePath, { encoding: 'utf8' });
+
+    try {
+      return JSON.parse(fileContent);
+    } catch (error) {
+      logger.Debug(`${error.message}`);
+      logger.Error(`${filePath} is not a valid JSON file. Use https://jsonlint.com to lint your JSON syntax.`, {
+        exit: false
+      });
+      logger.Error(`Error thrown by the parser: ${error.message}`, { exit: opts.exit });
+    }
+  } else {
+    if (opts.throwDoesNotExistError) {
+      logger.Error(`File doesn't exist: ${filePath}`, { exit: opts.exit });
+    } else {
+      logger.Debug(`[_readJSON] File doesn't exist: ${filePath}`);
+    }
+    return {};
+  }
+};
+
+const _writeJSON = (filePath, content, opts = { exit: true, replacer: null, space: 2}) => {
+  if (!fs.existsSync(filePath)) {
+    logger.Error(`File doesn't exist: ${filePath}`, { exit: opts.exit });
+    return {};
+  }
+
+  try {
+    fs.writeFileSync(filePath, JSON.stringify(content, opts.replacer, opts.space));
+  } catch (error) {
+    logger.Debug(`${error.message}`);
+    logger.Error(`Error thrown when writing a json to ${filePath}: ${error.message}`, { exit: opts.exit });
+  }
+};
+
+const _readIgnoreList = filePath => {
+  if (fs.existsSync(filePath) === false) {
+    return [];
+  }
+
+  const rules = fs
+    .readFileSync(filePath, { encoding: 'utf8' })
+    .split('\n')
+    .filter(Boolean) // remove empty lines
+    .filter(line => line.indexOf('#') !== 0); // remove commented lines
+
+  return rules;
+};
+
+const _getAssets = async () => {
+  const appAssets = fs.existsSync(`${dir.currentApp()}/assets`) ? await glob(`${dir.currentApp()}/assets/**`) : [];
+  const modulesAssets = fs.existsSync(dir.MODULES) ? await glob('modules/*/{private,public}/assets/**') : [];
+
+  return [...appAssets, ...modulesAssets] || [];
+};
+
+const methods = {
+  readJSON: _readJSON,
+  writeJSON: _writeJSON,
+  getConfigPath: _getConfigPath,
+  getConfig: () => {
+    const configPath = _getConfigPath(process.env.CONFIG_FILE_PATH);
+    logger.Debug(`[getConfig] Looking for config in: ${configPath}`);
+    return _readJSON(configPath) || {};
+  },
+  getAssets: _getAssets,
+  getIgnoreList: ignoreListPath => _readIgnoreList(ignoreListPath || config.IGNORE_LIST) || []
+};
+
+module.exports = Object.assign({}, config, methods);

package/lib/insites-apig.js

@@ -0,0 +1,18 @@
+const apiRequest = require('./apiRequest');
+require("dotenv").config();
+
+const HOST = process.env.INSITES_CONSOLE_API_HOST || 'https://ybn9n8m7cc.execute-api.ap-southeast-2.amazonaws.com/api/';
+// const HOST = "https://bpf0fvgyw9.execute-api.ap-southeast-2.amazonaws.com/dev/"
+
+const APIG = {
+  getInitPackageURL: () => {
+    return apiRequest({
+      uri: `${HOST}/v1/package/init`,
+      method: 'GET',
+      json: true,
+    });
+  },
+  HOST: HOST,
+};
+
+module.exports = APIG;

package/lib/insites-console.js

@@ -0,0 +1,24 @@
+const apiRequest = require("./apiRequest");
+const logger = require("./logger");
+
+require("dotenv").config();
+
+const HOST = process.env.INSITES_CONSOLE_HOST || "https://console.insites.io";
+
+const Console = {
+    login: (email, password, instanceUuid) => {
+        logger.Debug("Console.login " + email + " to " + HOST);
+        return apiRequest({
+            uri: `${HOST}/api/console/cli/login`,
+            headers: {
+                UserAuthorization: `${email}:${password}`,
+                InstanceUUID: instanceUuid,
+            },
+            method: 'POST',
+            json: true,
+        });
+    },
+    HOST: HOST,
+};
+
+module.exports = Console;

package/lib/logger/rainbow.js

@@ -0,0 +1,11 @@
+const chalk = require('chalk');
+
+const Error = message => console.error(chalk.red.bold(message));
+const Success = message => console.log(chalk.green.bold(message));
+const Quiet = message => console.log(chalk.grey(message));
+const Info = message => console.log(chalk.bold(message));
+const Warn = message => console.log(chalk.yellow.dim(message));
+const News = message => console.log(chalk.cyan(message));
+const Print = txt => process.stdout.write(txt);
+
+module.exports = { Error, Success, Quiet, Info, Warn, News, Print };

package/lib/logger/simple.js

@@ -0,0 +1,9 @@
+const Error = console.error;
+const Success = console.log;
+const Quiet = console.log;
+const Info = console.log;
+const Warn = console.log;
+const News = message => console.log(chalk.cyan(message));
+const Print = txt => process.stdout.write(txt);
+
+module.exports = { Error, Success, Quiet, Info, Warn, News, Print };

package/lib/logger.js

@@ -0,0 +1,63 @@
+const path = require('path');
+const notifier = require('node-notifier');
+
+const instance =
+  !!process.env.NO_COLOR || !!process.env.CI ? require('./logger/simple.js') : require('./logger/rainbow.js');
+
+const showNotification = (message) => {
+  if (!!process.env.CI) {
+    return;
+  }
+  const icon = path.resolve(__dirname, '../lib/assets/insites-icon.png');
+  notifier.notify({ title: 'Error', message, icon, 'app-name': 'insites-cli' });
+};
+
+const formatter = (msg, opts = { hideTimestamp: false }) => {
+  let message = msg;
+
+  if (typeof msg != 'string') {
+    message = JSON.stringify(msg, null, 2);
+  }
+
+  if (!opts.hideTimestamp) {
+    const HHMMSS = new Date().toTimeString().split(' ')[0];
+    message = `[${HHMMSS}] ${message}`;
+  }
+
+  return message.trim();
+};
+
+const logger = {
+  Error: (message, opts) => {
+    const options = Object.assign({}, { exit: true, notify: true }, opts);
+    instance.Print('\n');
+    instance.Error(formatter(message, options));
+    
+    if (message && options.notify) {
+      if (typeof msg != 'string') {
+        message = JSON.stringify(message, null, 2);
+      }
+      showNotification(message.slice(0, 100));
+    }
+
+    if (options.exit) {
+      process.exit(1);
+    } else {
+      return false;
+    }
+  },
+  Success: (message, opts = {}) => instance.Success(formatter(message, opts)),
+  Quiet: (message, opts = {}) => instance.Quiet(formatter(message, opts)),
+  Info: (message, opts = {}) => instance.Info(formatter(message, opts)),
+  Warn: (message, opts = {}) => instance.Warn(formatter(message, opts)),
+  News: (message, opts = {}) => instance.News(formatter(message, opts)),
+  Print: (message, opts = {}) => instance.Print(message, opts),
+  Debug: (message, opts = {}) => {
+    if (process.env.DEBUG) {
+      instance.Print('\n');
+      instance.Warn(formatter(message, opts));
+    }
+  },
+};
+
+module.exports = logger;

package/lib/logsv2/http.js

@@ -0,0 +1,40 @@
+const apiRequest = require('../apiRequest');
+
+class HTTP {
+  static async get(url, {params, securities}) {
+    return await apiRequest({
+      uri: url + '?' + new URLSearchParams(params),
+      method: 'GET',
+      json: true,
+      headers: {
+        Authorization: `Bearer ${securities.authorized.Authorization}`
+      }
+    });
+  }
+
+  static async post(url, {securities, body}) {
+    return await apiRequest({
+      uri: url,
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${securities.authorized.Authorization}`,
+        'Content-Type': 'application/json'
+      },
+      body: body
+    });
+  }
+
+  static async put(url, {securities, body}) {
+    return apiRequest({
+      uri: url,
+      method: 'PUT',
+      headers: {
+        Authorization: `Bearer ${securities.authorized.Authorization}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+  }
+}
+
+module.exports = HTTP

package/lib/modules.js

@@ -0,0 +1,129 @@
+const rl = require('readline');
+
+const files = require('./files');
+const logger = require('./logger');
+
+const portal = require('./portal');
+const prepareArchive = require('./prepareArchive');
+const presignUrl = require('./presignUrl').presignUrlForPortal;
+const uploadFile = require('./s3UploadFile').uploadFile;
+const waitForStatus = require('./data/waitForStatus');
+
+let moduleId;
+const archiveFileName = 'release.zip';
+const archivePath = `./tmp/${archiveFileName}`;
+
+const moduleConfig = () => {
+  return files.readJSON('template-values.json', { throwDoesNotExistError: true, exit: true });
+};
+
+const createArchive = async (moduleName) => {
+  return new Promise(async (resolve, reject) => {
+    const releaseArchive = prepareArchive(archivePath, resolve, true);
+    releaseArchive.glob('{private,public}/**', {}, { prefix: moduleName });
+    await releaseArchive.finalize();
+  });
+};
+
+const uploadArchive = async (token) => {
+  const data = await presignUrl(token, moduleId, archiveFileName);
+  logger.Debug(data);
+  await uploadFile(archivePath, data.uploadUrl);
+  logger.Info('Release Uploaded');
+  return data.accessUrl;
+};
+
+const createVersion = async (token, accessUrl, moduleVersionName) => {
+  try {
+    const version = await portal.createVersion(token, accessUrl, moduleVersionName, moduleId)
+    return version.id;
+  } catch(e) {
+    throw new Error(`Module Version not created`);
+  }
+};
+
+const waitForPublishing = async (token, moduleVersionId) => {
+  try {
+    await waitForStatus(() => portal.moduleVersionStatus(token, moduleId, moduleVersionId), 'pending', 'accepted');
+    logger.Success('Module Published');
+  } catch(e) {
+    throw new Error('Module not published. Check email for errors.');
+  }
+};
+
+const getModule = async (token, name) => {
+  const modules = await portal.findModules(token, name);
+  const module = modules[0];
+  if (module){
+    return module;
+  } else {
+    throw new Error(`Module "${name}" not found`);
+  }
+};
+
+const getPassword = () => {
+  return new Promise((resolve, reject) => {
+    const reader = rl.createInterface({ input: process.stdin, output: process.stdout });
+    reader.stdoutMuted = true;
+    reader.question('Password: ', password => {
+      reader.close();
+      console.log('');
+      resolve(password);
+    });
+
+    reader._writeToOutput = stringToWrite => (reader.stdoutMuted && reader.output.write('*')) || reader.output.write(stringToWrite);
+  });
+};
+
+const getToken = async (params) => {
+  let password;
+  if (process.env.POS_PORTAL_PASSWORD) {
+    password = process.env.POS_PORTAL_PASSWORD;
+  } else {
+    password = await getPassword();
+  }
+  logger.Info(`Asking ${portal.HOST} for access token...`);
+  const token = await portalAuthToken(params.email, password);
+  return token;
+}
+
+const portalAuthToken = async (email, password) => {
+  try {
+    const token = await portal.jwtToken(email, password)
+    return token.auth_token;
+  } catch (e) {
+    process.exit(1);
+  }
+};
+
+const publishVersion = async (params) => {
+  try {
+    const config = moduleConfig();
+    const moduleName = config['machine_name'];
+    const moduleVersionName = config['version'];
+    const numberOfFiles = await createArchive(moduleName);
+    if (numberOfFiles > 0) {
+      const token = await getToken(params);
+      const module = await getModule(token, moduleName);
+      moduleId = module.id;
+      const archiveUrl = await uploadArchive(token);
+      const posModuleVersionId = await createVersion(token, archiveUrl, moduleVersionName);
+      await waitForPublishing(token, posModuleVersionId);
+    } else {
+      throw new Error('There are no files in module release');
+    }
+
+    return true;
+  } catch (e) {
+    if (e.message){
+      logger.Error(e.message);
+    } else {
+      logger.Error('Error');
+    }
+    process.exit(1);
+  }
+};
+
+module.exports = {
+  publishVersion: publishVersion
+};

package/lib/portal.js

@@ -0,0 +1,52 @@
+const apiRequest = require('./apiRequest');
+const logger = require('./logger');
+
+const HOST = process.env.PARTNER_PORTAL_HOST || 'https://partners.platformos.com';
+
+const Portal = {
+  login: (email, password, url) => {
+    logger.Debug('Portal.login ' + email + ' to ' + HOST);
+
+    return apiRequest({
+      uri: `${HOST}/api/user_tokens`,
+      headers: { UserAuthorization: `${email}:${password}`, InstanceDomain: url },
+      json: true
+    });
+  },
+  jwtToken: (email, password) => {
+    return apiRequest({
+      method: 'POST',
+      uri: `${HOST}/api/authenticate`,
+      formData: { email: email, password: password },
+      json: true
+    });
+  },
+  findModules: (token, name) => {
+    return apiRequest({
+      method: 'GET',
+      uri: `${HOST}/api/pos_modules/?modules=${name}`,
+      headers: { Authorization: `Bearer ${token}` },
+      json: true
+    });
+  },
+  createVersion: (token, url, name, posModuleId) => {
+    return apiRequest({
+      method: 'POST',
+      uri: `${HOST}/api/pos_modules/${posModuleId}/pos_module_versions`,
+      body: { pos_module_version: { archive: url, name: name } },
+      headers: { Authorization: `Bearer ${token}` },
+      json: true
+    });
+  },
+  moduleVersionStatus: (token, posModuleId, moduleVersionId) => {
+    return apiRequest({
+      method: 'GET',
+      uri: `${HOST}/api/pos_modules/${posModuleId}/pos_module_versions/${moduleVersionId}`,
+      headers: { Authorization: `Bearer ${token}` },
+      json: true
+    });
+  },
+  HOST: HOST
+};
+
+module.exports = Portal;

package/lib/pos-proxy.js

@@ -0,0 +1,162 @@
+const requestPromise = require('request-promise');
+
+const apiRequest = require('./apiRequest');
+const logger = require('./logger');
+const version = '4.21.2';
+
+class Gateway {
+  constructor({ url, key: token, email }, client) {
+    this.url = url;
+    this.api_url = `${url}/api/app_builder`;
+    this.private_api_url = `${url}/api/private`;
+    this.client = client;
+
+    const headers = {
+      Authorization: `Token ${token}`,
+      InstanceDomain: url,
+      'User-Agent': `pos-cli/${version}`,
+      From: email
+    };
+
+    const censored = Object.assign({}, headers, { Authorization: 'Token: <censored>' });
+    logger.Debug(`Request headers: ${JSON.stringify(censored, null, 2)}`);
+
+    this.authorizedRequest = requestPromise.defaults({ headers });
+  }
+
+  apiRequest({ method = 'GET', uri, formData, json = true, forever }) {
+    return apiRequest({
+      method: method,
+      uri: uri,
+      formData: formData,
+      json: json,
+      forever: forever,
+      request: this.authorizedRequest,
+    });
+  }
+
+  appExportStart(formData = {}) {
+    return this.apiRequest({ method: 'POST', uri: `${this.api_url}/marketplace_releases/backup`, formData });
+  }
+
+  appExportStatus(id) {
+    return this.apiRequest({ uri: `${this.api_url}/marketplace_releases/${id}` });
+  }
+
+  dataExportStart(export_internal, csv_import = false) {
+    const formData = { export_internal };
+    let uri = `${this.api_url}/exports`;
+    if (csv_import) {
+      uri += '?csv_export=true';
+    }
+    return this.apiRequest({ method: 'POST', uri, formData });
+  }
+
+  dataExportStatus(id, csv_import = false) {
+    let uri = `${this.api_url}/exports/${id}`;
+    if (csv_import) {
+      uri += '?csv_export=true';
+    }
+    return this.apiRequest({ uri });
+  }
+
+  dataImportStart(formData) {
+    return this.apiRequest({ method: 'POST', uri: `${this.api_url}/imports`, formData });
+  }
+
+  dataImportStatus(id, csv_import = false) {
+    let uri = `${this.api_url}/imports/${id}`;
+    if (csv_import) {
+      uri += '?csv_import=true';
+    }
+    return this.apiRequest({ uri });
+  }
+
+  dataUpdate(formData) {
+    return this.apiRequest({ method: 'POST', uri: `${this.api_url}/data_updates`, formData });
+  }
+
+  dataClean(confirmation, include_schema) {
+    return this.apiRequest({
+      method: 'POST',
+      uri: `${this.api_url}/data_clean`,
+      json: { confirmation, include_schema },
+    });
+  }
+
+  dataCleanStatus(id) {
+    return this.apiRequest({ method: 'GET', uri: `${this.api_url}/data_clean/${id}` });
+  }
+
+  ping() {
+    return this.apiRequest({ uri: `${this.api_url}/logs` });
+  }
+
+  logs(json) {
+    return this.apiRequest({ uri: `${this.api_url}/logs?last_id=${json.lastId}`, json, forever: true });
+  }
+
+  getInstance() {
+    return this.apiRequest({ uri: `${this.api_url}/instance` });
+  }
+
+  getStatus(id) {
+    return this.apiRequest({ uri: `${this.api_url}/marketplace_releases/${id}`, forever: true });
+  }
+
+  graph(json) {
+    return this.apiRequest({ method: 'POST', uri: `${this.url}/api/graph`, json, forever: true });
+  }
+
+  liquid(json) {
+    return this.apiRequest({ method: 'POST', uri: `${this.api_url}/liquid_exec`, json, forever: true });
+  }
+
+  listModules() {
+    return this.apiRequest({ uri: `${this.api_url}/installed_modules` });
+  }
+
+  removeModule(formData) {
+    return this.apiRequest({ method: 'DELETE', uri: `${this.api_url}/installed_modules`, formData });
+  }
+
+  listMigrations() {
+    return this.apiRequest({ uri: `${this.api_url}/migrations` });
+  }
+
+  generateMigration(formData) {
+    return this.apiRequest({ method: 'POST', uri: `${this.api_url}/migrations`, formData });
+  }
+
+  runMigration(formData) {
+    return this.apiRequest({ method: 'POST', uri: `${this.api_url}/migrations/run`, formData });
+  }
+
+  sendManifest(manifest) {
+    return this.apiRequest({ method: 'POST', uri: `${this.api_url}/assets_manifest`, json: { manifest } });
+  }
+
+  sync(formData) {
+    return this.apiRequest({
+      method: 'PUT',
+      uri: `${this.api_url}/marketplace_releases/sync`,
+      formData,
+      forever: true,
+    });
+  }
+
+  delete(formData) {
+    return this.apiRequest({
+      method: 'DELETE',
+      uri: `${this.api_url}/marketplace_releases/sync`,
+      formData,
+      forever: true,
+    });
+  }
+
+  push(formData) {
+    return this.apiRequest({ method: 'POST', uri: `${this.api_url}/marketplace_releases`, formData });
+  }
+}
+
+module.exports = Gateway;

package/lib/prepareArchive.js

@@ -0,0 +1,49 @@
+const fs = require('fs');
+const shell = require('shelljs');
+const archiver = require('archiver');
+const logger = require('./logger');
+
+const prepareDestination = path => {
+  shell.mkdir('-p', 'tmp');
+  shell.rm('-rf', path);
+};
+
+const prepareArchive = (path, resolve, verbose = false) => {
+  let numberOfFiles = 0;
+  prepareDestination(path);
+  const output = fs.createWriteStream(path);
+  const archive = archiver('zip', { zlib: { level: 6 } });
+
+  // listen for all archive data to be written
+  // 'close' event is fired only when a file descriptor is involved
+  output.on('close', () => {
+    if (verbose) {
+      const sizeInMB = archive.pointer() / 1024 / 1024;
+      logger.Info(`Archive size: ${sizeInMB.toFixed(2)} MB at ${path}`);
+    }
+    resolve(numberOfFiles);
+  });
+
+  archive.on('warning', err => {
+    if (err.code === 'ENOENT') {
+      logger.Debug(err);
+      logger.Error('Archive creation failed.');
+    } else {
+      throw err;
+    }
+  });
+
+  archive.on('error', err => {
+    logger.Debug(err);
+  });
+
+  archive.on('entry', function(entry) {
+    if (entry.type == 'file') numberOfFiles++;
+  });
+
+  archive.pipe(output);
+
+  return archive;
+};
+
+module.exports = prepareArchive;