ezekiel-cli 5.8.2

package/.editorconfig

@@ -0,0 +1,24 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+
+# Change these settings to your own preference
+indent_style = space
+indent_size = 2
+
+# We recommend you to keep these unchanged
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.js]
+max_line_length = 120
+quote_type = single
+spaces_around_brackets = inside

package/.eslintrc

@@ -0,0 +1,40 @@
+{
+  "parser": "babel-eslint",
+  "parserOptions": {
+    "ecmaVersion": 6,
+    "sourceType": "module",
+    "ecmaFeatures": {
+      "experimentalObjectRestSpread": true
+    }
+  },
+  "extends": "eslint:recommended",
+  "rules": {
+    "comma-dangle": 0,
+    "brace-style": [2, "1tbs"],
+    "no-console": 0,
+    "padded-blocks": 0,
+    "indent": [2, 2, { "SwitchCase": 1 }],
+    "spaced-comment": 1,
+    "quotes": ["error", "single", { "avoidEscape": true }],
+    "no-underscore-dangle": 0,
+    "no-magic-numbers": 0,
+    "quote-props": 0,
+    "prefer-arrow-callback": 0,
+    "space-before-function-paren": 0,
+    "no-new": 0,
+    "func-names": 0,
+    "global-require": 0,
+    "new-cap": 0,
+    "arrow-body-style": 0,
+    "class-methods-use-this": 0,
+    "consistent-return": 0,
+    "semi": [2, "always"],
+    "max-len": [1, 140]
+  },
+  "env": {
+    "browser": true,
+    "es6": true,
+    "node": true,
+    "commonjs": true
+  }
+}

package/.prettierignore

@@ -0,0 +1 @@
+package.json

package/README.md

@@ -0,0 +1,139 @@
+# Insites CLI
+The Insites CLI Tool is a command line interface that helps you deploy configuration files and assets to your Insites instance. It expects you to follow a certain file structure to communicate correctly with Insites API's.
+
+## Requirements
+The Insites CLI Tool requires Node.js in at least the latest LTS version to work properly.
+https://www.npmjs.com/package/@insites/insites-cli
+
+
+## Installation
+Open your terminal and enter the following command: 
+```
+npm i -g @insites/insites-cli
+```
+
+To verify that the installation was successful, type: 
+```
+insites-cli
+```
+
+
+## Commands and Options
+Run all commands in the project root directory - one level above the app or modules directory.
+
+#### Add Instance to Your Environment
+For effective integration between your codebase and its associated instance you will need to authenticate your environement via `instance-uuid`.
+
+In order to get the Instance UUID, follow the steps below: 
+* Login to [Insites Console](https://console.insites.io/).
+* Go to [Instances page](https://console.insites.io/console#/instances)
+* Find and select your instance to view Instance Details page
+* Under the General tab, get the Instance UUID
+
+
+In order to connect your codebase to your instance, open your project in your terminal. Since you can connect multiple instances to a single codebase, to have different environments for development and production, you need to give your instance a name in the <environment-name> parameter.
+
+Enter the following command to authenticate your instance: 
+```
+insites-cli env add <environment-name> --email <console-user-email> --instance-uuid <instance-uuid>
+```
+* Verify that your instance has been added by typing this which will display all the available environments: 
+```
+insites-cli env list
+```
+
+#### Deploy
+To deploy changes to your instance, enter the following command to your project's terminal: 
+```
+insites-cli deploy <environment-name>
+```
+
+#### Sync Instance on File Change
+To ensure that the instance promptly mirrors the code changes you make on a daily basis with minimal manual intervention and upload code changes automatically when you save the file, enter the following command on the project root directory:
+```
+insites-cli sync <environment-name>
+```
+
+#### Graphical User Interface (GUI)
+This command offers an integrated development environment for drafting and executing your `GraphQL queries` and `Liquid snippets` as well as an option to view your `data`, `constants`, and `logs`. This command establishes a direct connection to your environment thus you gain access to a live preview of data derived from your application.
+
+This direct communication eliminates the potential for errors that might arise when data traverses other layers and features within the system.
+
+```
+insites-cli gui serve <environment-name>
+```
+
+#### Code audit
+Runs statical analysis on files in your current application directory to check your code for deprecations, recommendations, or syntax errors.
+```
+insites-cli audit
+```
+
+#### Modules
+##### List <sub>(Expiremental)</sub>
+Lists all installed modules on a given environment. This command will not list modules that you deployed via the `modules/` directory.
+```
+insites-cli module list <environment-name>
+```
+##### Initialize
+Create a new module based on module starter repository.
+```
+insites-cli modules init <module-name>
+```
+##### Pull
+Download the installed modules from a given environment.
+```
+insites-cli modules pull <environment-name>
+```
+#### Remove
+Removes a module from your application.
+```
+insites-cli modules remove [environment] <module name>
+```
+
+### Data
+
+#### Export
+
+Exports data from the environment to a given file in JSON format.
+
+```
+insites-cli data export staging --path=data.json
+```
+Options:
+* `--path` (short: `-p`): A file path to a JSON file which will be created by the CLI and where the exported data is stored.
+* `--export-internal-ids`: By default, export will use the autogenerated external_id for the id field. When this option is set, it will use the normal id from the object.
+
+#### Import
+
+Imports data from a given JSON file with proper data structure.
+```
+insites-cli data import staging --path=data.json
+```
+Option:
+* `--path` (short: -p): A path to a JSON or ZIP files to be imported
+
+#### Clean (only staging)
+
+Cleans data on an Instance. Keep in mind that this only removes rows of data, not the structure definition.
+
+For example, if you have a model schema `car` and there are 10 entries of type `car`, those will be deleted, but the model schema `car` will remain intact.
+
+This is useful for testing your imports/exports or resetting your database to a pristine state between tests.
+
+**This operation is irreversible**. `insites-cli` will ask you twice if you are sure you want to do it.
+
+    insites-cli data clean staging
+
+
+## Upgrade Version
+Need to use CMD as administrator
+ 
+```
+npm update -g @insites/insites-cli
+```
+
+### Configuration Files
+* `.insitesignore` - specifies intentionally untracked files to ignore
+* `.insites` - contains the environment credentials to connect to the instance
+* `.insites.legacy` - configuration file for legacy instances

package/bin/insites-cli-archive.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+const program = require('commander');
+
+const audit = require('../lib/audit');
+const archive = require('../lib/archive');
+
+const createArchive = async (env) => {
+  const numberOfFiles = await archive.makeArchive(env, { withoutAssets: false });
+  if (numberOfFiles == 0) throw 'Archive failed to create.';
+};
+
+const runAudit = async () => {
+  if (process.env.CI == 'true') {
+    return;
+  }
+
+  await audit.run();
+};
+
+program
+  .name('insites-cli archive')
+  .option('-o --output <output>', 'archive filename', './tmp/release.zip')
+  .action(async (params) => {
+    // await runAudit();
+
+    const env = Object.assign(
+      process.env, {
+        CI: process.env.CI === 'true',
+        TARGET: params.output
+      });
+
+    await createArchive(env)
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-audit.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const audit = require('../lib/audit');
+
+audit.run();

package/bin/insites-cli-data-clean.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+const program = require('commander'),
+  prompts = require('prompts'),
+  ora = require('ora');
+
+const Gateway = require('../lib/pos-proxy'),
+  waitForStatus = require('../lib/data/waitForStatus'),
+  fetchAuthData = require('../lib/settings').fetchSettings,
+  logger = require('../lib/logger'),
+  ServerError = require('../lib/ServerError');
+
+const confirmationText = 'CLEAN DATA';
+
+const confirmCleanup = async (autoConfirm, includeSchema, url) => {
+  if (autoConfirm) return true;
+  try {
+    let schemaText = includeSchema ? 'and database schemas ' : '';
+
+    logger.Warn('');
+    logger.Warn(`WARNING!!! You are going to REMOVE your data ${schemaText}from instance: ${url}`);
+    logger.Warn('There is no coming back.');
+    logger.Warn('');
+
+    const message = `If you still want to continue please type: '${confirmationText}' `;
+    const response = await prompts({ type: 'text', name: 'confirmation', message: message });
+
+    return response.confirmation == confirmationText;
+  } catch (e) {
+    logger.Error(e);
+    return false;
+  }
+};
+
+program
+  .name('insites-cli data clean')
+  .argument('[environment]', 'name of the environment. Example: staging')
+  .option('--auto-confirm', 'auto confirm instance clean without prompt')
+  .option('-i, --include-schema', 'also remove instance files: pages, schemas etc.')
+  .action(async (environment, params) => {
+    const spinner = ora({ text: 'Sending data', stream: process.stdout, spinner: 'bouncingBar' });
+    try {
+      const gateway = new Gateway(fetchAuthData(environment));
+      const confirmed = await confirmCleanup(params.autoConfirm, params.includeSchema, gateway.url);
+      if (confirmed) {
+        spinner.start(`Cleaning instance`);
+
+        const response = await gateway.dataClean(confirmationText, params.includeSchema);
+        logger.Debug(`Cleanup request id: ${response}`);
+
+        const checkDataCleanJobStatus = () => {
+          return gateway.dataCleanStatus(response.id);
+        };
+        await waitForStatus(checkDataCleanJobStatus, 'pending', 'done');
+
+        spinner.stopAndPersist().succeed('DONE. Instance cleaned');
+      } else logger.Error('Wrong confirmation. Closed without cleaning instance data.');
+    } catch (e) {
+      spinner.fail(`Instance cleanup has failed.`);
+      console.log(e.name);
+
+      // custom handle 422
+      if (e.statusCode == 422)
+        logger.Error('[422] Data clean is either not supported by the server or has been disabled.');
+      else if (ServerError.isNetworkError(e)) ServerError.handler(e);
+      else logger.Error(e);
+    }
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-data-export.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+const program = require('commander'),
+  fs = require('fs'),
+  ora = require('ora'),
+  shell = require('shelljs'),
+  Gateway = require('../lib/pos-proxy'),
+  fetchAuthData = require('../lib/settings').fetchSettings,
+  fetchFiles = require('../lib/data/fetchFiles'),
+  waitForStatus = require('../lib/data/waitForStatus'),
+  downloadFile = require('../lib/downloadFile');
+
+const logger = require('../lib/logger');
+
+let gateway;
+
+const spinner = ora({ text: 'Exporting', stream: process.stdout, spinner: 'bouncingBar' });
+const transform = ({ users = { results: [] }, transactables = { results: [] }, models = { results: [] } }) => {
+  return {
+    users: users.results,
+    transactables: transactables.results,
+    models: models.results,
+  };
+};
+
+const fetchFilesForData = async (data) => {
+  // TODO: user properties
+  data.users = await Promise.all(
+    data.users.map(async (user) => {
+      user.profiles = await Promise.all(user.profiles.map((profile) => fetchFiles(profile)));
+      return user;
+    })
+  );
+  data.transactables = await Promise.all(data.transactables.map((model) => fetchFiles(model)));
+  data.models = await Promise.all(data.models.map((model) => fetchFiles(model)));
+
+  return data;
+};
+
+program
+  .name('insites-cli data export')
+  .arguments('[environment]', 'name of the environment. Example: staging')
+  .requiredOption('-p --path <export-file-path>', 'output for exported data. Example: data.json, data.zip')
+  .option(
+    '-e --export-internal-ids <export-internal-ids>',
+    'use normal object `id` instead of `external_id` in exported json data',
+    'false'
+  )
+  .option('-z --zip', 'export to zip archive', true)
+  .action((environment, params) => {
+    const isZipFile = params.zip;
+    let filename = params.path;
+    if (!filename) {
+      filename = isZipFile ? 'data.zip' : 'data.json';
+    }
+    const exportInternalIds = params.exportInternalIds;
+    const authData = fetchAuthData(environment, program);
+    gateway = new Gateway(authData);
+
+    const exportFinished = () => {
+      spinner.stopAndPersist().succeed(`Done. Exported to: ${filename}`);
+    };
+
+    const handleZipFileExport = (exportTask, filename) => {
+      downloadFile(exportTask.zip_file_url, filename).then(exportFinished);
+    };
+
+    const handleJsonFileExport = (exportTask, filename) => {
+      shell.mkdir('-p', 'tmp');
+      fs.writeFileSync('tmp/exported.json', JSON.stringify(exportTask.data));
+      let data = transform(exportTask.data);
+      spinner.succeed('Downloading files');
+      fetchFilesForData(data)
+        .then((data) => {
+          fs.writeFileSync(filename, JSON.stringify(data));
+          exportFinished();
+        })
+        .catch((e) => {
+          logger.Warn('export error');
+          logger.Warn(e.message);
+        });
+    };
+
+    spinner.start();
+    gateway
+      .dataExportStart(exportInternalIds, isZipFile)
+      .then((exportTask) => {
+        waitForStatus(() => gateway.dataExportStatus(exportTask.id, isZipFile), 'pending', 'done')
+          .then((exportTask) => {
+            if (isZipFile) {
+              handleZipFileExport(exportTask, filename);
+            } else {
+              handleJsonFileExport(exportTask, filename);
+            }
+          })
+          .catch((error) => {
+            logger.Debug(error);
+            spinner.fail('Export failed');
+          });
+      })
+      .catch({ statusCode: 404 }, () => {
+        spinner.fail('Export failed');
+        logger.Error('[404] Data export is not supported by the server');
+      })
+      .catch((e) => {
+        spinner.fail('Export failed');
+        logger.Error(e.message);
+      });
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-data-import.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+const program = require('commander'),
+  fs = require('fs'),
+  ora = require('ora'),
+  shell = require('shelljs'),
+  crypto = require('crypto'),
+  Gateway = require('../lib/pos-proxy'),
+  fetchAuthData = require('../lib/settings').fetchSettings,
+  transform = require('../lib/data/uploadFiles'),
+  isValidJSON = require('../lib/data/isValidJSON'),
+  waitForStatus = require('../lib/data/waitForStatus'),
+  uploadFile = require('../lib/s3UploadFile').uploadFile,
+  presignUrl = require('../lib/presignUrl').presignUrl;
+
+const logger = require('../lib/logger'),
+  report = require('../lib/logger/report');
+
+let gateway;
+const spinner = ora({ text: 'Sending data', stream: process.stdout, spinner: 'bouncingBar' });
+const tmpFileName = './tmp/data-imported.json';
+
+const logInvalidFile = (filename) => {
+  return logger.Error(`
+Invalid format of ${filename}. Must be a valid json file. Do you want to import a zip file? Use --zip.
+`);
+};
+
+const dataImport = async (filename, rawIds, isZipFile) => {
+  spinner.start();
+
+  let formData = {};
+  if (isZipFile) {
+    const instanceId = (await gateway.getInstance()).id;
+    const uploadedFilename = `instances/${instanceId}/data_imports/${crypto.randomBytes(32).toString('hex')}`;
+    try {
+      const { uploadUrl, accessUrl } = await presignUrl(uploadedFilename, filename);
+      await uploadFile(filename, uploadUrl);
+      formData = { zip_file_url: accessUrl };
+    } catch (error) {
+      logger.Debug(error);
+      spinner.fail('Import failed');
+      logger.Error('Unable to upload archive file');
+    }
+  } else {
+    const data = fs.readFileSync(filename, 'utf8');
+    if (!isValidJSON(data)) return logInvalidFile(filename);
+    const transformedData = await transform(JSON.parse(data));
+    shell.mkdir('-p', './tmp');
+    fs.writeFileSync(tmpFileName, JSON.stringify(transformedData));
+    formData = { 'import[data]': fs.createReadStream(tmpFileName) };
+  }
+
+  formData['raw_ids'] = rawIds;
+  gateway
+    .dataImportStart(formData)
+    .then((importTask) => {
+      spinner.stopAndPersist().succeed('Data sent').start(`Importing ${filename}`);
+      waitForStatus(() => gateway.dataImportStatus(importTask.id, isZipFile), 'pending', 'done')
+        .then(() => {
+          spinner.stopAndPersist().succeed('Import done.');
+          report('[OK] Data: Import');
+        })
+        .catch((error) => {
+          logger.Debug(error);
+          spinner.fail('Import failed');
+          logger.Error(`Unable to import data file. Error: ${error.error}`);
+        });
+    })
+    .catch({ statusCode: 404 }, () => {
+      spinner.fail('Import failed');
+      logger.Error('[404] Data import is not supported by the server');
+    })
+    .catch((e) => {
+      spinner.fail('Import failed');
+      logger.Error(e.message);
+      report('[ERR] Data: Import');
+    });
+};
+
+program
+  .name('insites-cli data import')
+  .argument('[environment]', 'name of the environment. Example: staging')
+  .option(
+    '-p --path <import-file-path>',
+    'path of import .json or .zip file. Example: data.json, data.zip',
+    'data.json'
+  )
+  .option('--raw-ids <raw-ids>', 'do not remap ids after import', false)
+  .option('-z --zip', 'import from zip archive', false)
+  .action((environment, params) => {
+    const filename = params.path;
+    const rawIds = params.rawIds;
+    const zip = params.zip;
+    const authData = fetchAuthData(environment);
+
+    if (!fs.existsSync(filename)) {
+      logger.Error(`File not found: ${filename}`);
+    }
+
+    gateway = new Gateway(authData);
+    dataImport(filename, rawIds, zip);
+  });
+
+program.parse(process.argv);

package/bin/insites-cli-data.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+const program = require('commander');
+
+program
+  .name('insites-cli data')
+  .command('export [environment]', 'export instance data to a json file')
+  .command('import [environment]', 'import instance data(from external source) from a json file')
+  // .command('update [environment]', 'update existing instance data from a json file')
+  .command(
+    'clean [environment]',
+    'remove all stored data in users, models, etc. Execute with caution there is not coming back.'
+  )
+  .parse(process.argv);
+

package/bin/insites-cli-deploy.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+const program = require('commander');
+
+const fetchAuthData = require('../lib/settings').fetchSettings;
+const logger = require('../lib/logger');
+const deployStrategy = require('../lib/deploy/strategy');
+const audit = require('../lib/audit');
+
+const runAudit = async () => {
+  if (process.env.CI == 'true') {
+    return;
+  }
+
+  await audit.run();
+};
+
+program
+  .name('insites-cli deploy')
+  .arguments('[environment]', 'name of environment. Example: staging')
+  // .option('-o --old-assets-upload', 'use old assets upload strategy')
+  .option('-p --partial-deploy', 'Partial deployment, does not remove data from directories missing from the build')
+  .action(async (environment, params) => {
+    // const strategy = !params.oldAssetsUpload ? 'directAssetsUpload' : 'default';
+    const strategy = 'directAssetsUpload';
+    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,
+      CI: process.env.CI === 'true',
+      // TODO: Get rid off global system env, make it normal argument to function.
+      PARTIAL_DEPLOY: !!params.partialDeploy,
+      DIRECT_ASSETS_UPLOAD: !params.oldAssetsUpload,
+    });
+
+    await runAudit();
+    deployStrategy.run({ strategy, opts: { env, authData, params } });
+  });
+
+program.parse(process.argv);