ezekiel-cli 5.8.2

package/lib/presignUrl.js

@@ -0,0 +1,71 @@
+const fs = require('fs'),
+  url = require('url'),
+  request = require('request-promise'),
+  mime = require('mime');
+const logger = require('./logger');
+
+// const Portal = require('./portal');
+// const deployServiceUrl = () => process.env.DEPLOY_SERVICE_URL || url.resolve(instanceUrl, '/api/private/urls');
+
+const presignUrl = (s3FileName, fileName, instanceUrl, instanceKey) => {
+  const serviceUrl = `${instanceUrl}/api/private/urls/presign-url`;
+  const params = {
+    fileName: s3FileName,
+    contentLength: fs.statSync(fileName)['size'],
+    contentType: mime.getType(fileName)
+  };
+
+  return request
+    .get({
+      url: serviceUrl,
+      headers: {
+        token: instanceKey,
+        marketplace_domain: url.parse(instanceUrl).hostname
+      },
+      qs: params,
+      json: true
+    })
+    .then(body => {
+      return { uploadUrl: body.url, accessUrl: url.parse(body.accessUrl).href };
+    });
+};
+
+const presignDirectory = (instanceUrl, instanceKey, path) => {
+  const serviceUrl = `${instanceUrl}/api/private/urls/presign-directory`;
+  const params = { directory: path };
+
+  return request
+    .get({
+      url: serviceUrl,
+      headers: {
+        token: instanceKey,
+        marketplace_domain: url.parse(instanceUrl).hostname
+      },
+      qs: params,
+      json: true
+    })
+    .then(body => body);
+};
+
+const presignUrlForPortal = (token, moduleName, filename) => {
+  const HOST = process.env.PARTNER_PORTAL_HOST || 'https://partners.platformos.com';
+  const serviceUrl = `${HOST}/api/pos_modules/${moduleName}/presign_url`;
+
+  return request
+    .get({
+      url: serviceUrl,
+      headers: {
+        Authorization: `Bearer ${token}`
+      },
+      json: true
+    })
+    .then(body => {
+      return { uploadUrl: body.upload_url, accessUrl: body.access_url };
+    });
+};
+
+module.exports = {
+  presignDirectory: presignDirectory,
+  presignUrl: presignUrl,
+  presignUrlForPortal: presignUrlForPortal
+};

package/lib/proxy.js

@@ -0,0 +1,75 @@
+const requestPromise = require('request-promise');
+const axios = require('axios');
+
+// const apiRequest = require('./apiRequest');
+const logger = require('./logger');
+const version = require('../package.json').version;
+
+const HOST = process.env.INSITES_CONSOLE_HOST || 'https://console.insites.io';
+const API_HOST =
+  process.env.INSITES_CONSOLE_API_HOST || 'https://ybn9n8m7cc.execute-api.ap-southeast-2.amazonaws.com/api/';
+
+class Gateway {
+  headers = {};
+  constructor({ token, email, instanceUuid }) {
+    this.url = HOST;
+    this.api_url = `${HOST}/api/console/cli`;
+    this.private_api_url = `${API_HOST}/v1`;
+
+    const headers = {
+      Authorization: `Token ${token}`,
+      InstanceUUID: instanceUuid,
+      'User-Agent': `insites-cli/${version}`,
+      From: email,
+      'Content-Type': 'application/json',
+    };
+
+    const censored = Object.assign({}, headers, {
+      Authorization: 'Token: <censored>',
+    });
+    logger.Debug(`Request headers: ${JSON.stringify(censored, null, 2)}`);
+
+    // this.authorizedRequest = requestPromise.defaults({ headers });
+    this.authorizedRequest = axios.create({ headers });
+    this.headers = headers;
+  }
+
+  apiRequest({ method = 'GET', uri, formData, headers = this.headers, json = true, forever }) {
+    return this.authorizedRequest({
+      method: method,
+      url: uri,
+      data: formData,
+      headers,
+      // json: json,
+      // forever: forever,
+    });
+  }
+
+  getStatus(id) {
+    return this.apiRequest({
+      uri: `${this.private_api_url}/deploy/${id}`,
+      forever: true,
+    });
+  }
+
+  push(formData) {
+    return this.apiRequest({
+      method: 'POST',
+      uri: `${this.private_api_url}/deploy`,
+      formData,
+      headers: {
+        ...this.headers,
+        'Content-Type': 'application/octet-stream',
+      },
+    });
+  }
+
+  init() {
+    return this.apiRequest({
+      uri: `${this.private_api_url}/package/init`,
+      forever: true,
+    });
+  }
+}
+
+module.exports = Gateway;

package/lib/push.js

@@ -0,0 +1,62 @@
+const fs = require('fs');
+const { performance } = require('perf_hooks');
+
+const logger = require('../lib/logger');
+const Gateway = require('../lib/proxy');
+const duration = require('../lib/duration');
+
+let gateway;
+
+const getDeploymentStatus = ({ command_id: id  }) => {
+  return new Promise((resolve, reject) => {
+    (getStatus = () => {
+      gateway
+        .getStatus(id)
+        .then(({ data }) => {
+          const { data: response } = data
+          if (response && (response.status === 'ready_for_import' || response.status === "initialized")) {
+            setTimeout(getStatus, 1500);
+          } else if (response && response.status === 'error') {
+            const message = response.message
+            return logger.Error(message, { exit: true });
+          } else {
+            resolve(response);
+          }
+        })
+        .catch((error) => {
+          reject(false);
+        });
+    })();
+  });
+};
+
+const push = async (env) => {
+  const program = {
+    email: env.CONSOLE_USER_EMAIL,
+    token: env.CONSOLE_USER_TOKEN,
+    instanceUuid: env.CONSOLE_USER_INSTANCE_UUID,
+  };
+  const t0 = performance.now();
+  const formData = fs.readFileSync('./tmp/release.zip').toString('base64');
+
+  gateway = new Gateway(program);
+  const { data } = await gateway.push(formData)
+  return getDeploymentStatus(data)
+    .then((response) => {
+      logger.Debug('Release deployed');
+      if (response.warning) {
+        logger.Warn(response.warning);
+      }
+      const t1 = performance.now();
+      return duration(t0, t1);
+    })
+    .then((duration) => {
+      logger.Info(`Deployment finished after: ${duration}`)
+      return true
+    })
+    .catch(() => false);
+};
+
+module.exports = {
+  push: push,
+};

package/lib/s3UploadFile.js

@@ -0,0 +1,56 @@
+const fs = require('fs'),
+  request = require('request'),
+  mime = require('mime');
+
+const uploadFile = (fileName, s3Url) => {
+  var stats = fs.statSync(fileName);
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(fileName).pipe(
+      request
+        .put({
+          url: s3Url,
+          headers: {
+            'Content-Length': stats['size']
+          }
+        })
+        .on('error', e => reject(e))
+        .on('response', response => {
+          if (response.statusCode >= 200 && response.statusCode < 300) {
+            resolve(s3Url);
+          } else {
+            reject(response.statusCode);
+          }
+        })
+    );
+  });
+};
+
+const uploadFileFormData = (filePath, data) => {
+  const formData = {};
+  Object.entries(data.fields).forEach(([k, v]) => {
+    formData[k] = v;
+  });
+  formData['Content-Type'] = mime.getType(filePath);
+  formData['file'] = fs.createReadStream(filePath);
+
+  return new Promise((resolve, reject) => {
+    request
+      .post({
+        url: data.url,
+        formData: formData
+      })
+      .on('error', e => reject(e))
+      .on('response', response => {
+        if (response.statusCode >= 200 && response.statusCode < 300) {
+          resolve(true);
+        } else {
+          reject(response.statusCode);
+        }
+      });
+  });
+};
+
+module.exports = {
+  uploadFile: uploadFile,
+  uploadFileFormData: uploadFileFormData
+};

package/lib/server.js

@@ -0,0 +1,123 @@
+const path = require('path');
+const express = require('express');
+const compression = require('compression');
+const bodyParser = require('body-parser');
+const multer = require('multer');
+const upload = multer();
+
+const Gateway = require('../lib/pos-proxy');
+const logger = require('../lib/logger');
+
+const GUI_VERSION = 'v3';
+
+const start = (env) => {
+  const port = env.PORT || 3030;
+  const app = express();
+
+  const gateway = new Gateway({
+    url: env.CONSOLE_USER_INSTANCE_URL,
+    key: env.CONSOLE_USER_KEY,
+    email: env.CONSOLE_USER_EMAIL,
+  });
+
+  // Middleware
+  app.use(bodyParser.json());
+  app.use(compression());
+
+  // CORS setup
+  app.use((req, res, next) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
+    next();
+  });
+
+  // Static file serving
+  app.use('/gui/graphql', express.static(path.resolve(__dirname, '..', 'gui', 'graphql', 'public')));
+  app.use('/gui/liquid', express.static(path.resolve(__dirname, '..', 'gui', 'liquid', 'public')));
+  app.use('/', express.static(path.resolve(__dirname, '..', 'gui', GUI_VERSION, 'out')));
+
+  // INFO endpoint
+  app.get('/info', (req, res) => {
+    res.send(JSON.stringify({ INSTANCE_URL: env.CONSOLE_USER_INSTANCE_URL }));
+  });
+
+  // API Routes
+  const graphqlRouting = async (req, res) => {
+    try {
+      const result = await gateway.graph(req.body);
+      res.send(result);
+    } catch (error) {
+      res.send(error);
+    }
+  };
+
+  const liquidRouting = async (req, res) => {
+    try {
+      const result = await gateway.liquid(req.body);
+      res.send(result);
+    } catch (error) {
+      res.send(error);
+    }
+  };
+
+  app.post('/graphql', graphqlRouting);
+  app.post('/api/graphql', graphqlRouting);
+  app.post('/api/graph', graphqlRouting);
+  app.post('/api/liquid', liquidRouting);
+  app.get('/api/liquid', liquidRouting);
+  app.get('/api/logs', (req, res) => {
+    gateway
+      .logs({ lastId: req.query.lastId })
+      .then(body => res.send(body))
+      .catch(error => res.send(error));
+  });
+
+  // Sync endpoint
+  app.put(
+    '/api/app_builder/marketplace_releases/sync',
+    upload.fields([{ name: 'path' }, { name: 'marketplace_builder_file_body' }]),
+    (req, res) => {
+      const formData = {
+        path: req.body.path,
+        marketplace_builder_file_body: req.files.marketplace_builder_file_body[0].buffer,
+      };
+
+      gateway
+        .sync(formData)
+        .then((body) => res.send(body))
+        .catch((error) => res.send(error));
+    }
+  );
+
+  // 404 Redirect
+  app.get('/*', (req, res) => {
+    res.sendFile(path.resolve(__dirname, '..', 'gui', GUI_VERSION, 'out', 'index.html'));
+  });
+
+  // Start the server
+  const server = app.listen(port, () => {
+    logger.Debug(`Server is listening on ${port}`);
+    logger.Success(`Connected to ${env.CONSOLE_USER_INSTANCE_URL}`);
+    logger.Success(`---`);
+    logger.Success(`CLI GUI Dashboard: http://localhost:${port}`);
+    logger.Success(`GraphQL Explorer: http://localhost:${port}/graphql`);
+    logger.Success(`Liquid Evaluator: http://localhost:${port}/liquid`);
+    logger.Success(`Instance Logs: http://localhost:${port}/logs`);
+  });
+
+  // Error handling
+  server.on('error', (err) => {
+    if (err.errno === 'EADDRINUSE') {
+      logger.Error(`Port ${port} is already in use.`, { exit: false });
+      logger.Print('\n');
+      logger.Warn('Please use -p <port> to run server on a different port.\n');
+      logger.Warn('Example: insites-cli gui serve staging -p 31337');
+    } else {
+      logger.Error(`Something wrong happened when trying to run Express server: ${err}`);
+    }
+  });
+};
+
+module.exports = {
+  start,
+};

package/lib/settings.js

@@ -0,0 +1,42 @@
+const fs = require('fs');
+
+const logger = require('./logger'),
+  files = require('./files'),
+  dir = require('./directories');
+
+const loadSettingsFileForModule = (module) => {
+  const templatePath = `${dir.MODULES}/${module}/template-values.json`;
+  if (fs.existsSync(templatePath)) {
+    return files.readJSON(templatePath, { exit: false });
+  } else {
+    return {};
+  }
+};
+
+// TODO: Get rid off program. Just return false in here and show help wherever it was executed.
+const fetchSettings = (environment, program) => {
+  const settings = settingsFromEnv() || files.getConfig()[environment];
+  if (settings) return settings;
+
+  if (program) program.outputHelp();
+  if (environment) {
+    logger.Error(`No settings for ${environment} environment, please see insites-cli env add`);
+  } else {
+    logger.Error('No environment specified, please pass environment for a command `insites-cli <command> [environment]`');
+  }
+};
+
+const settingsFromEnv = () => {
+  const {
+    INSITES_URL: url,
+    INSITES_EMAIL: email,
+    INSITES_TOKEN: token,
+    INSITES_INSTANCE: instance_uuid,
+    INSITES_POS_KEY: key,
+  } = process.env;
+  if (url && token && email && instance_uuid && key) {
+    return { url, email, token, instance_uuid, key };
+  }
+};
+
+module.exports = { fetchSettings, loadSettingsFileForModule };

package/lib/shouldBeSynced.js

@@ -0,0 +1,89 @@
+const fs = require('fs');
+const path = require('path');
+const ignore = require('ignore');
+
+const watchFilesExtensions = require('./watch-files-extensions'),
+  files = require('./files'),
+  logger = require('./logger'),
+  isValidFilePath = require('./utils/valid-file-path');
+
+const win = path.sep === path.win32.sep;
+
+// path.extname returns ext with . ~_~
+const ext = filePath => filePath.split('.').pop();
+
+const isEmpty = filePath => {
+  let isEmpty;
+  try {
+    isEmpty =
+      fs
+        .readFileSync(filePath)
+        .toString()
+        .trim().length === 0;
+  } catch (err) {
+    // Ignore missing files, no need to check if they are empty.
+    // This can happen on sync if the file got deleted.
+    if (err.code === 'ENOENT') {
+      return false;
+    }
+  }
+
+  return isEmpty;
+};
+
+const isValidExtension = filePath => {
+  const valid = watchFilesExtensions.includes(ext(filePath));
+  if (!valid) {
+    logger.Warn(`[Sync] Not recognized extension: ${filePath}. Not syncing.`);
+  }
+  return valid;
+};
+
+const isNotEmptyYML = filePath => {
+  if (ext(filePath) === 'yml' && isEmpty(filePath)) {
+    logger.Warn(`[Sync] Detected empty YML file: ${filePath}. Not syncing.`);
+    return false;
+  }
+
+  return true;
+};
+
+const isValidModuleFile = filePath => {
+  // In modules/* accept only files from public and private folders, reject rest
+  if (filePath.startsWith('modules')) {
+    // Ignore template values, explicit test, would work without it
+    const reTemplate = win ? new RegExp(`^modules\\[^\\]+\\${files.templateValues}`) : new RegExp(`^modules/[^/]+/${files.templateValues}`);
+    if(reTemplate.test(filePath)) return false;
+
+    // TODO: Use glob to avoid if
+    const re = win ? /^modules\\.*\\(public|private)/ : /^modules\/.*\/(public|private)/;
+    return re.test(filePath);
+  } else {
+    return true; // If its not file in modules/, accept
+  }
+};
+
+const isNotOnIgnoreList = (filePath, ignoreList) => {
+  const ig = ignore().add(ignoreList);
+  return ig.ignores(filePath) === false;
+};
+
+const hasNoInvalidChars = filePath => {
+  const valid = isValidFilePath(filePath);
+
+  if (!valid) {
+    logger.Warn(`[Sync] Invalid characters in file path: ${filePath}. Not syncing.`);
+  }
+
+  return true;
+};
+
+module.exports = (filePath, ignoreList) => {
+  return (
+    isNotOnIgnoreList(filePath, ignoreList) &&
+    isValidExtension(filePath) &&
+    isNotEmptyYML(filePath) &&
+    isValidModuleFile(filePath) &&
+    hasNoInvalidChars(filePath)
+  );
+};