ezekiel-cli 5.8.2

package/gui/v3/vite.config.ts

@@ -0,0 +1,43 @@
+import { defineConfig } from "vite";
+import viteReact from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+
+import { tanstackRouter } from "@tanstack/router-plugin/vite";
+import { resolve } from "node:path";
+
+import $monacoEditorPlugin from "vite-plugin-monaco-editor";
+const monacoEditorPlugin = ($monacoEditorPlugin as any).default ?? $monacoEditorPlugin;
+
+const testConfig = {
+  test: {
+    globals: true,
+    environment: "jsdom",
+  },
+};
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  build: {
+    outDir: "out",
+  },
+  plugins: [
+    tanstackRouter({ autoCodeSplitting: true }),
+    viteReact(),
+    tailwindcss(),
+    monacoEditorPlugin({
+      languageWorkers: ["editorWorkerService", "json"],
+      customWorkers: [
+        {
+          label: "graphql",
+          entry: "monaco-graphql/esm/graphql.worker.js",
+        },
+      ],
+    }),
+  ],
+  ...testConfig,
+  resolve: {
+    alias: {
+      "@": resolve(__dirname, "./src"),
+    },
+  },
+});

package/lib/ServerError.js

@@ -0,0 +1,122 @@
+const logger = require("./logger");
+
+const shouldExit = (request) => {
+    const endsWith = (str) => request.options.uri.endsWith(str);
+
+    if (endsWith("releases/sync") || endsWith("/api/graph")) {
+        return false;
+    }
+};
+
+const ServerError = {
+    gatewayTimeout: (request) => {
+        logger.Debug(
+            `Gateway timeout error: ${JSON.stringify(request, null, 2)}`
+        );
+        logger.Error("Gateway timed out.", {
+            hideTimestamp: true,
+            exit: shouldExit(request),
+        });
+    },
+
+    badGateway: (request) => {
+        logger.Debug(`Bad gateway error: ${JSON.stringify(request, null, 2)}`);
+        logger.Error("Bad gateway.", {
+            hideTimestamp: true,
+            exit: shouldExit(request),
+        });
+    },
+
+    internal: (request) => {
+        logger.Debug(
+            `Internal server error: ${JSON.stringify(request, null, 2)}`
+        );
+        logger.Error(
+            "Something went wrong on the server.",
+            {
+                hideTimestamp: true,
+                exit: shouldExit(request),
+            }
+        );
+    },
+
+    entityTooLarge: (request) => {
+        logger.Debug(
+            `Entity too large: ${JSON.stringify(request.response, null, 2)}`
+        );
+        logger.Error(
+            "Archive you are trying to send is too large. Limit is 50MB.",
+            { hideTimestamp: true }
+        );
+    },
+
+    unprocessableEntity: (request) => {
+        logger.Debug(
+            `Unprocessable entity: ${JSON.stringify(request, null, 2)}`
+        );
+        const body = request.response.body;
+        const error = body.error || (body.errors && body.errors.join(", "));
+        if (error) {
+            const message = `${error}\n${
+                (body.details && body.details.file_path) || ""
+            }`;
+            logger.Error(message, {
+                hideTimestamp: true,
+                exit: shouldExit(request),
+            });
+        }
+    },
+
+    notFound: (request) => {
+        logger.Debug(`Not found: ${JSON.stringify(request, null, 2)}`);
+        const body = request.response.body;
+        logger.Error(
+            `${body.error}\n${(body.details && body.details.file_path) || ""}`,
+            {
+                hideTimestamp: true,
+                exit: shouldExit(request),
+            }
+        );
+    },
+
+    unauthorized: (request) => {
+        logger.Debug(`Unauthorized: ${JSON.stringify(request, null, 2)}`);
+        logger.Error(
+            "You are unauthorized to do this operation. Check if your Token/Instance UUID or email/password are correct.",
+            {
+                hideTimestamp: true,
+                exit: shouldExit(request),
+            }
+        );
+    },
+
+    addressNotFound: (request) => {
+        logger.Debug(
+            `Host name not found: ${JSON.stringify(request, null, 2)}`
+        );
+        logger.Error(`Could not resolve hostname: ${request.cause.hostname}`, {
+            hideTimestamp: true,
+        });
+    },
+
+    netDown: (request) => {
+        logger.Debug(`Net down: ${JSON.stringify(request, null, 2)}`);
+        logger.Error("Network is down", {
+            hideTimestamp: true,
+            exit: shouldExit(request),
+        });
+    },
+
+    default: (request) => {
+        logger.Debug(
+            `Default error: ${JSON.stringify(request.response, null, 2)}`
+        );
+        const err = JSON.stringify(request.response, null, 2).replace(
+            /Token [a-f0-9]{40}/,
+            "Token: <censored>"
+        );
+        logger.Error(err, { hideTimestamp: true });
+    },
+};
+
+module.exports = ServerError;

package/lib/apiRequest.js

@@ -0,0 +1,15 @@
+const requestPromise = require('request-promise');
+// const errors = require('request-promise/errors');
+
+const logger = require('./logger');
+// const ServerError = require('./ServerError');
+
+const apiRequest = ({ method = 'GET', uri, body, headers, formData, json = true, forever, request = requestPromise }) => {
+  logger.Debug(`[${method}] ${uri}`);
+  return request({method, uri, body, headers, formData, json, forever})
+  //  when we catch the error here we are not able to react to them later
+  // .catch(errors.StatusCodeError, ServerError.handler)
+  // .catch(errors.RequestError, ServerError.requestHandler)
+}
+
+module.exports = apiRequest;

package/lib/archive.js

@@ -0,0 +1,126 @@
+const fs = require('fs');
+const shell = require('shelljs');
+const glob = require('fast-glob');
+const unzipper = require('unzipper');
+
+const templates = require('../lib/templates');
+const logger = require('../lib/logger');
+const settings = require('../lib/settings');
+const dir = require('../lib/directories');
+const prepareArchive = require('../lib/prepareArchive');
+
+const isEmpty = (dir) => shell.ls(dir).length == 0;
+
+const addModulesToArchive = async (archive, withoutAssets) => {
+  if (!fs.existsSync(dir.MODULES)) {
+    return Promise.resolve(true);
+  }
+  const modules = await glob('*', { cwd: dir.MODULES, onlyFiles: false });
+  return Promise.all(modules.map((module) => addModuleToArchive(module, archive, withoutAssets)));
+};
+
+const addModuleToArchive = (module, archive, withoutAssets, pattern = '**/{private,public}/**') => {
+  return new Promise((resolve, reject) => {
+    glob(pattern, {
+      cwd: `${dir.MODULES}/${module}`,
+      filesOnly: true,
+    })
+      .then((files) => {
+        const moduleTemplateData = settings.loadSettingsFileForModule(module);
+
+        return Promise.all(
+          files
+            .filter((file) => {
+              return !withoutAssets || !(file.startsWith('public/assets/') || file.startsWith('private/assets'));
+            })
+            .map((f) => {
+              const path = `${dir.MODULES}/${module}/${f}`;
+              return new Promise((resolve, reject) => {
+                fs.lstat(path, (err, stat) => {
+                  if (!stat.isDirectory()) {
+                    const filledTemplate = templates.fillInTemplateValues(path, moduleTemplateData);
+                    archive.append(filledTemplate, { name: path });
+                  }
+                  resolve();
+                });
+              });
+            })
+        ).then(() => resolve());
+      })
+      .catch((e) => {
+        logger.Error(e);
+      });
+  });
+};
+
+const findAppDirectory = () => {
+  let appDirectory = dir.APP;
+  if (dir.toWatch().length === 0) {
+    return logger.Error(
+      `Could not find any directory to deploy. Looked for ${dir.APP}, and ${dir.MODULES}`,
+      { exit: false }
+    );
+  }
+
+  if (!fs.existsSync(dir.APP) && fs.existsSync(dir.LEGACY_APP)) {
+    logger.Debug(`${dir.APP} not found, but ${dir.LEGACY_APP} is present. Setting ${dir.LEGACY_APP} as app dir.`);
+    logger.Warn(`Falling back to legacy app directory name. Please consider renaming ${dir.LEGACY_APP} to ${dir.APP}`);
+    appDirectory = dir.LEGACY_APP;
+  }
+  return appDirectory;
+};
+
+const makeArchive = async (env, { withoutAssets }) => {
+  const path = env.TARGET || './tmp/release.zip';
+  const directory = findAppDirectory();
+  if (!directory) return false;
+  if (dir.available().length === 0) {
+    return logger.Error(`At least one of ${dir.ALLOWED.join(', ')} directories is needed to deploy`, {
+      hideTimestamp: true,
+      exit: false,
+    });
+  }
+
+  if (isEmpty(dir.currentApp()) && !withoutAssets) {
+    return logger.Error(
+      `${dir.currentApp()} can't be empty if the deploy is not partial - it would remove all the files from the instance`,
+      { hideTimestamp: true, exit: false }
+    );
+  }
+  const options = {
+    cwd: directory,
+    ignore: withoutAssets ? ['assets/**'] : [],
+  };
+
+  return new Promise(async (resolve, reject) => {
+    const releaseArchive = prepareArchive(path, resolve, !withoutAssets);
+    // Think and decide
+    // Whitelist extensions that need to be included in deploy?
+    // Blacklist extensions that are most likely to be problematic (ie. break deploy, like .zip)
+    releaseArchive.glob('**/!(*.zip)*', options, { prefix: directory });
+    await addModulesToArchive(releaseArchive, withoutAssets);
+    await releaseArchive.finalize();
+  });
+};
+
+async function unArchive(packagePath, successMessage = 'Extraction complete!') {
+  const extractPath = process.cwd();
+  fs.createReadStream(packagePath)
+    .pipe(unzipper.Extract({ path: extractPath }))
+    .on('finish', () => {
+      fs.unlink(packagePath, (err) => {
+        if (err) {
+          console.error('Error deleting zip file:', err);
+        }
+        console.log(successMessage);
+      });
+    })
+    .on('error', (err) => {
+      console.error('Error extracting zip file:', err);
+    });
+}
+
+module.exports = {
+  makeArchive: makeArchive,
+  unArchive,
+};

package/lib/assets/manifest.js

@@ -0,0 +1,34 @@
+const fs = require('fs'),
+  normalize = require('normalize-path'),
+  dir = require('../directories'),
+  files = require('../files');
+
+const appDirectory = fs.existsSync(dir.APP) ? dir.APP : dir.LEGACY_APP;
+
+const serializerManifestEntry = file => {
+  const fileProperties = fs.statSync(file);
+  const fileUpdatedAt = Math.floor(new Date(fileProperties['mtime']) / 1000);
+  const fileSize = fileProperties['size'];
+  return { physical_file_path: file.replace(new RegExp(`^${appDirectory}/`), ''), updated_at: fileUpdatedAt, file_size: fileSize };
+};
+
+const manifestGenerate = async () => {
+  const assets  = await files.getAssets();
+  return manifestGenerateForAssets(assets);
+};
+
+const manifestGenerateForAssets = (assets) => {
+  let manifest = {};
+  for (const file of assets) {
+    const normalizedFile = normalize(file);
+    const path = normalizedFile.replace(new RegExp(`(public|private)/assets/|(${appDirectory})/assets/`), '');
+    manifest[path] = serializerManifestEntry(normalizedFile);
+  }
+
+  return manifest;
+}
+
+module.exports = {
+  manifestGenerate: manifestGenerate,
+  manifestGenerateForAssets: manifestGenerateForAssets
+};

package/lib/assets/packAssets.js

@@ -0,0 +1,53 @@
+const archiver = require('archiver-promise'),
+  fs = require('fs'),
+  glob = require('fast-glob'),
+  shell = require('shelljs'),
+  templates = require('../templates'),
+  settings = require('../settings'),
+  dir = require('../directories');
+
+const appDirectory = fs.existsSync(dir.APP) ? dir.APP : dir.LEGACY_APP;
+
+const addModulesToArchive = async archive => {
+  if (!fs.existsSync(dir.MODULES)) return true;
+
+  let modules = await glob('./*', { cwd: dir.MODULES, onlyDirectories: true });
+  for (const module of modules) {
+    await addModuleToArchive(module, archive);
+  }
+};
+
+const publicAssetsSameAsPrivate = (file, files) => {
+  return file.startsWith('public/assets') && files.includes(file.replace(/public/, 'private'));
+};
+
+const addModuleToArchive = async (module, archive, pattern = '{public,private}/assets/**') => {
+  let files = await glob(pattern, { cwd: `${dir.MODULES}/${module}` });
+  for (const f of files) {
+    if (publicAssetsSameAsPrivate(f, files)) {
+      continue;
+    }
+
+    const path = `${dir.MODULES}/${module}/${f}`;
+    const pathInArchive = path.replace(/(public|private)\/assets\//, '');
+    const filledTemplate = templates.fillInTemplateValues(path, settings.loadSettingsFileForModule(module));
+    archive.append(filledTemplate, {
+      name: pathInArchive
+    });
+  }
+};
+
+const prepareDestination = path => {
+  shell.mkdir('-p', 'tmp');
+  if (path && path.length > 0) shell.rm('-rf', path);
+};
+
+const packAssets = async path => {
+  prepareDestination(path);
+  const assetsArchive = archiver(path, { zlib: { level: 6 }, store: true });
+  assetsArchive.glob('**/*', { cwd: `${appDirectory}/assets` });
+  await addModulesToArchive(assetsArchive);
+  return assetsArchive.finalize();
+};
+
+module.exports = packAssets;

package/lib/assets.js

@@ -0,0 +1,56 @@
+const request = require('request-promise');
+const packAssets = require('./assets/packAssets'),
+  manifestGenerate = require('./assets/manifest').manifestGenerate,
+  logger = require('./logger'),
+  uploadFile = require('./s3UploadFile').uploadFile,
+  presignUrl = require('./presignUrl').presignUrl;
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const waitForUnpack = async fileUrl => {
+  logger.Debug('Waiting for assets to be propagated to CDN');
+
+  let fileExists = false;
+  let counter = 0;
+  do {
+    logger.Debug(`Waiting for: ${fileUrl} to be deleted.`);
+    counter += 1;
+    if (fileExists) await sleep(1000);
+    fileExists = await request
+      .head(fileUrl)
+      .then(() => true)
+      .catch({ statusCode: 403 }, () => false)
+      .catch(error => logger.Error(error));
+  } while (fileExists && counter < 90);
+};
+
+const deployAssets = async (gateway, authData) => {
+  logger.Debug('Generating and uploading new assets manifest...');
+  const assetsArchiveName = './tmp/assets.zip';
+  const instance = await gateway.getInstance();
+  const now = Math.floor(new Date() / 1000);
+  const remoteAssetsArchiveName = `instances/${instance.id}/assets/${now}.assets_deploy.zip`;
+  logger.Debug(remoteAssetsArchiveName);
+  try {
+    await packAssets(assetsArchiveName);
+    const data = await presignUrl(remoteAssetsArchiveName, assetsArchiveName, authData.url, authData.key);
+    logger.Debug(data);
+    logger.Debug(assetsArchiveName)
+    await uploadFile(assetsArchiveName, data.uploadUrl);
+    logger.Debug('Assets uploaded to S3.');
+    await waitForUnpack(data.accessUrl);
+    const manifest = await manifestGenerate();
+    logger.Debug(manifest);
+    await gateway.sendManifest(manifest);
+    logger.Debug('Uploading assets');
+  } catch (e) {
+    logger.Error(e);
+    logger.Error(e.message);
+    logger.Error(e.stack);
+    logger.Error('Deploy assets failed.');
+  }
+};
+
+module.exports = {
+  deployAssets: deployAssets
+};

package/lib/audit/detailed.js

@@ -0,0 +1,97 @@
+const fs = require('fs');
+const glob = require('fast-glob');
+
+/*
+  glob [string - glob]
+    Try to be as specific as possible to make it fast.
+    Omit `app` and `modules` in your definition
+
+  test [string - regexp]
+    What test will look for in the file contents. Make sure you escape as this is JS string (ie. doube backslash \)
+
+  message [string]
+    Message to be displayed if offence is found
+*/
+const detailed = [
+  {
+    name: 'profiler',
+    glob: 'views/pages/**/*.liquid',
+    test: '^enable_profiler: true$',
+    message: `[PERFORMANCE] Please remove "enable_profiler: true" setting for performance reasons.`
+  },
+  {
+    name: 'unnecessary_brackets',
+    glob: '*.liquid',
+    test: '\\.name\\s*-?}}\\[\\]',
+    message: `[DEPRECATED] Please remove hardcoded array indicators ([]) from your input names.
+      \nExample: <input name="{{ fields.company.name }}[]"> becomes <input name="{{ fields.company.name }}">`
+  },
+  {
+    name: 'resource_id',
+    glob: 'views/**/*.liquid',
+    test: '{%-?\\s*include_form.*resource_id:',
+    message: '[DEPRECATED ARGUMENT] "resource_id" of include_form tag, please replace with "id"'
+  },
+  {
+    name: 'configuration',
+    glob: '{form_configurations,forms}/**/*.liquid',
+    test: '^configuration:',
+    message: '[DEPRECATED KEY] "configuration", please replace with "fields"'
+  },
+  {
+    name: 'attribute_type',
+    glob: '{transactable_types,instance_profile_types,user_profile_types,custom_model_types,model_schemas}/**/*.yml',
+    test: '\\s*attribute_type:',
+    message: '[DEPRECATED KEY] "attribute_type", please replace with "type"'
+  },
+  {
+    name: 'custom_attributes',
+    glob: '{transactable_types,instance_profile_types,user_profile_types,custom_model_types,model_schemas}/**/*.yml',
+    test: '^custom_attributes:',
+    message: '[DEPRECATED KEY] "custom_attributes", please replace with "properties"'
+  },
+  {
+    name: 'camel_case',
+    glob: '{transactable_types,instance_profile_types,user_profile_types,custom_model_types,model_schemas}/**/*.yml',
+    test: '^name:\\s+([a-z\\_]*( |[A-Z]|-)[a-z\\_]*)+',
+    message: '[CONVENTION] Please use snake_case naming convention in model names'
+  },
+  {
+    name: 'headers',
+    glob: 'api_calls/**/*.liquid',
+    test: '^headers:',
+    message: '[DEPRECATED] "headers" has been renamed to "request_headers"',
+  }
+];
+
+module.exports = {
+  audit: async () => {
+    let results = {};
+
+    for (let rule of detailed) {
+      const files = await glob(`{app,modules,marketplace_builder}/**/${rule.glob}`);
+
+      for (let file of files) {
+        const fileContents = fs.readFileSync(file, { encoding: 'utf8' });
+        const match = RegExp(rule.test, 'm').test(fileContents);
+
+        if (!match) {
+          continue;
+        }
+
+        const currentFiles = results[rule.name] && results[rule.name].files;
+        const updatedFiles = (currentFiles || []).concat(file);
+
+        results = {
+          ...results,
+          [rule.name]: {
+            files: updatedFiles,
+            message: rule.message
+          }
+        };
+      }
+    }
+
+    return results;
+  }
+};

package/lib/audit/duplicateFile.js

@@ -0,0 +1,31 @@
+const glob = require('fast-glob');
+const fs = require('fs');
+
+const underScorePrefix = /^_*/;
+
+module.exports = {
+  audit: async () => {
+    let results = {};
+
+    const files = await glob(['app/views/partials/**/_*.liquid', 'modules/**/{private,public}/views/partials/**/_*.liquid']);
+    for (let file of files) {
+      let parts = file.split('/');
+      let fileName = parts[parts.length - 1];
+      parts[parts.length - 1] = fileName.replace(underScorePrefix, '', -1);
+      const fileWithoutUndescore = parts.join('/');
+
+      if (fs.existsSync(fileWithoutUndescore)) {
+        results = {
+          ...results,
+          [`Multiple file names with the same partial for ${fileName}`]: {
+            files: [file, fileWithoutUndescore],
+            message: 'Multiple file names with the same partial path'
+          }
+
+        };
+      }
+    }
+
+    return results;
+  }
+};

package/lib/audit/extensions.js

@@ -0,0 +1,53 @@
+const glob = require('fast-glob');
+
+const rules = [
+  {
+    directories: [
+      'forms',
+      'form_configurations',
+      'authorization_policies',
+      'notifications',
+      'emails',
+      'api_calls',
+      'smses'
+    ],
+    extension: '.liquid'
+  },
+  {
+    directories: [
+      'model_schemas',
+      'custom_model_types',
+      'user_profile_types',
+      'instance_profile_types'
+    ],
+    extension: '.yml'
+  },
+  {
+    directories: ['graphql', 'graph_queries'],
+    extension: '.graphql'
+  }
+];
+
+module.exports = {
+  audit: async () => {
+    let results = {};
+
+    for (let rule of rules) {
+      for (let dir of rule.directories) {
+        const files = (await glob([`app/${dir}/**/*`, `modules/*/{public,private}/${dir}/**/*`]))
+          .filter(file => !file.match(`\\${rule.extension}$`));
+        if (files.length > 0) {
+          results = {
+            ...results,
+            [`Only ${rule.extension} files should be in ${dir}`]: {
+              files: files,
+              message: `Only ${rule.extension} files should be in ${dir} directory`
+            }
+          };
+        }
+      }
+    }
+
+    return results;
+  }
+};

package/lib/audit/fileName.js

@@ -0,0 +1,20 @@
+const glob = require('fast-glob');
+const isValidFilePath = require('../utils/valid-file-path');
+
+module.exports = {
+  audit: async () => {
+    const files = await glob(['app/**/*', 'modules/*/{private,public}/**/*']);
+
+    const invalidFileNames = files.filter(filepath => !isValidFilePath(filepath));
+    if (invalidFileNames.length > 0) {
+      return {
+        ['Invalid filename']: {
+          files: invalidFileNames,
+          message: 'Invalid filename. It contains prohibited special characters.'
+        }
+      };
+    }
+
+    return {};
+  }
+};