@ixon-cdk/core 1.0.0-alpha.0

package/README.md

@@ -0,0 +1,3 @@
+# IXON Component Development Kit Core Library
+
+This library contains basic building blocks of the IXON Component Development Kit (CDK). It defines the core classes, utilities and schemas that are used throughout the rest of the CDK tooling.

package/api/auth.service.js

@@ -0,0 +1,53 @@
+const fs = require("fs");
+const axios = require("axios");
+const ApiBaseService = require("./base.service");
+
+module.exports = class AuthService extends ApiBaseService {
+  logIn(credentials) {
+    const c = credentials;
+    return axios.post(
+      `${this._getApiBaseUrl()}/access-tokens`,
+      { expiresIn: 86400 },
+      {
+        headers: {
+          ...this._getApiDefaultHeaders(),
+          "User-Agent": "ComponentDevKit",
+          Authorization: `Basic ${Buffer.from(
+            c.email + ":" + (c.otp || "") + ":" + c.password,
+            "utf-8"
+          ).toString("base64")}`,
+        },
+      }
+    );
+  }
+
+  logOut() {
+    const secretId = this._getSecretId();
+    if (secretId) {
+      return axios.delete(`${this._getApiBaseUrl()}/access-tokens/me`, {
+        headers: {
+          ...this._getApiDefaultHeaders(),
+          Authorization: this._getApiAuthHeaderValue(),
+        },
+      });
+    }
+    return Promise.resolve(null);
+  }
+
+  isAuthenticated() {
+    return !!this._getSecretId();
+  }
+
+  remember(secretId) {
+    fs.writeFileSync(this._getAccessTokenFilePath(), secretId, {
+      encoding: "utf8",
+      flag: "w",
+    });
+  }
+
+  forget() {
+    if (fs.existsSync(this._getAccessTokenFilePath())) {
+      fs.rmSync(this._getAccessTokenFilePath());
+    }
+  }
+};

package/api/base.service.js

@@ -0,0 +1,39 @@
+const fs = require("fs");
+const path = require("path");
+const ConfigService = require("../config/config.service");
+
+module.exports = class ApiBaseService {
+  _configSrv = new ConfigService();
+
+  _getAccessTokenFilePath() {
+    return path.join(process.cwd(), ".accesstoken");
+  }
+
+  _getApiAuthHeaderValue() {
+    return `Bearer ${this._getSecretId()}`;
+  }
+
+  _getApiBaseUrl() {
+    return this._configSrv.getApiBaseUrl();
+  }
+
+  _getApiDefaultHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "Api-Application": this._configSrv.getApiApplication(),
+      "Api-Version": this._configSrv.getApiVersion(),
+    };
+  }
+
+  _getSecretId() {
+    let secretId;
+    try {
+      secretId = fs.readFileSync(this._getAccessTokenFilePath(), {
+        encoding: "utf-8",
+      });
+    } catch {
+      // do nothing
+    }
+    return secretId;
+  }
+};

package/api/deploy.service.js

@@ -0,0 +1,88 @@
+const fs = require("fs");
+const path = require("path");
+const axios = require("axios");
+const ApiBaseService = require("./base.service");
+
+module.exports = class DeployService extends ApiBaseService {
+  deploy(companyId, templateId, file) {
+    const url = `${this._getApiBaseUrl()}/page-component-templates/${templateId}/version-upload`;
+    const body = fs.readFileSync(path.join(process.cwd(), file));
+    const headers = {
+      ...this._getApiDefaultHeaders(),
+      "Content-Type": "application/x-www-form-urlencoded",
+      "Api-Company": companyId,
+      Authorization: this._getApiAuthHeaderValue(),
+    };
+    return axios.post(url, body, { headers }).then((res) => res.data.data);
+  }
+
+  deployAndPublish(companyId, templateId, file) {
+    return this.deploy(companyId, templateId, file).then((data) =>
+      this._publish(companyId, data.publicId)
+    );
+  }
+
+  fetchPublishable(companyId, templateId) {
+    return this._fetchDescTemplateVersions(companyId, templateId).then((versions) => {
+      const publishedIdx = versions.findIndex(
+        (v) => typeof v.publishedOn === "string"
+      );
+      return publishedIdx !== -1 ? versions.slice(0, publishedIdx) : versions;
+    });
+  }
+
+  publishLatestVersion(companyId, templateId) {
+    return this.fetchPublishable(companyId, templateId).then((data) => {
+      if (!data.length) {
+        return Promise.reject("Template has no publishable versions");
+      }
+      const latest = data.sort(
+        (v1, v2) => Number(v2.number) - Number(v1.number)
+      )[0];
+      return this._publish(companyId, latest.publicId);
+    });
+  }
+
+  publishVersion(companyId, templateId, versionNumber) {
+    return this.fetchPublishable(companyId, templateId).then((data) => {
+      if (!data.length) {
+        return Promise.reject("Template has no publishable versions");
+      }
+      const _version = data.find((v) => v.number === String(versionNumber));
+      if (!!_version) {
+        return this._publish(companyId, _version.publicId);
+      }
+      return Promise.reject("Could not match!");
+    });
+  }
+
+  _fetchDescTemplateVersions(companyId, templateId) {
+    const url = `${this._getApiBaseUrl()}/page-component-template-versions`;
+    const params = {
+      fields: "*,template(*)",
+      filters: `eq(template.publicId,"${templateId}")`,
+      "page-size": "100",
+    };
+    const headers = {
+      ...this._getApiDefaultHeaders(),
+      "Api-Company": companyId,
+      Authorization: this._getApiAuthHeaderValue(),
+    };
+    return axios.get(url, { params, headers }).then((res) => {
+      return res.data.data.sort(
+        (v1, v2) => Number(v2.number) - Number(v1.number)
+      );
+    });
+  }
+
+  _publish(companyId, versionId) {
+    const url = `${this._getApiBaseUrl()}/page-component-template-versions/${versionId}`;
+    const body = { published: true };
+    const headers = {
+      ...this._getApiDefaultHeaders(),
+      "Api-Company": companyId,
+      Authorization: this._getApiAuthHeaderValue(),
+    };
+    return axios.patch(url, body, { headers });
+  }
+};

package/config/config.service.js

@@ -0,0 +1,78 @@
+const fs = require("fs");
+const { merge } = require("lodash");
+const path = require("path");
+const { logFileCrudMessage, logErrorMessage } = require("../utils");
+
+module.exports = class ConfigService {
+  _config = { components: {} };
+
+  _path = path.join(process.cwd(), "config.json");
+
+  constructor() {
+    let config;
+
+    if (!fs.existsSync(this._path)) {
+      logErrorMessage(`No config file.`);
+      process.exit();
+    }
+
+    try {
+      config = require(this._path);
+    } catch {
+      logErrorMessage(`Couldn't parse config file.`);
+      process.exit();
+    }
+
+    this._config = config;
+  }
+
+  hasComponent(name) {
+    return name in this._config.components;
+  }
+
+  getComponent(name) {
+    return this._config.components[name];
+  }
+
+  getNewComponentRoot() {
+    return this._config.newComponentRoot || 'components';
+  }
+
+  getPrefix() {
+    return this._config.prefix || null;
+  }
+
+  getApiApplication() {
+    return this._config.apiApplication || "LtDdZKEPa5lK";
+  }
+
+  getApiBaseUrl() {
+    return this._config.apiBaseUrl || "https://api.ayayot.com";
+  }
+
+  getApiVersion() {
+    return this._config.apiVersion || "2";
+  }
+
+  addComponent(name, config) {
+    this._config.components[name] = config;
+    this._sync();
+  }
+
+  extendComponent(name, config) {
+    this._config.components[name] = merge(
+      {},
+      this._config.components[name],
+      config
+    );
+    this._sync();
+  }
+
+  _sync() {
+    fs.writeFileSync(this._path, JSON.stringify(this._config, null, 2) + "\n", {
+      encoding: "utf8",
+      flag: "w",
+    });
+    logFileCrudMessage("UPDATE", "config.json");
+  }
+};

package/config/schema.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @title Custom Component Workspace Configuration
+ */
+export interface schema {
+  /**
+   * The path where new components will be created, relative to the workspace root.
+   * @default "components"
+   */
+  newComponentRoot?: string;
+  /**
+   * API application ID
+   * @default "LtDdZKEPa5lK"
+   */
+  apiApplication?: string;
+  /**
+   * API base URL
+   * @default "https://api.ayayot.com"
+   */
+  apiBaseUrl?: string;
+  /**
+   * API version
+   * @default "2"
+   */
+  apiVersion?: string;
+  /**
+   * The prefix to apply to generated selectors.
+   * @minLength 1
+   */
+  prefix?: string;
+  components: { [name: string]: component };
+}
+
+interface component {
+  runner: {
+    build: {
+      /** The builder package name and build command */
+      builder: string;
+      /** The component input-file */
+      input: string;
+    };
+    deploy?: {
+      /** Company ID */
+      company: string;
+      /** PageComponentTemplate ID */
+      template: string;
+    };
+  };
+}

package/config/schema.json

@@ -0,0 +1,93 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "newComponentRoot": {
+      "type": "string",
+      "description": "The path where new components will be created, relative to the workspace root.",
+      "default": "components"
+    },
+    "apiApplication": {
+      "type": "string",
+      "description": "API application ID",
+      "default": "LtDdZKEPa5lK"
+    },
+    "apiBaseUrl": {
+      "type": "string",
+      "description": "API base URL",
+      "default": "https://api.ayayot.com"
+    },
+    "apiVersion": {
+      "type": "string",
+      "description": "API version",
+      "default": "2"
+    },
+    "prefix": {
+      "type": "string",
+      "description": "The prefix to apply to generated selectors.",
+      "minLength": 1
+    },
+    "components": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/definitions/component"
+      }
+    }
+  },
+  "required": [
+    "components"
+  ],
+  "title": "Custom Component Workspace Configuration",
+  "definitions": {
+    "component": {
+      "type": "object",
+      "properties": {
+        "runner": {
+          "type": "object",
+          "properties": {
+            "build": {
+              "type": "object",
+              "properties": {
+                "builder": {
+                  "type": "string",
+                  "description": "The builder package name and build command"
+                },
+                "input": {
+                  "type": "string",
+                  "description": "The component input-file"
+                }
+              },
+              "required": [
+                "builder",
+                "input"
+              ]
+            },
+            "deploy": {
+              "type": "object",
+              "properties": {
+                "company": {
+                  "type": "string",
+                  "description": "Company ID"
+                },
+                "template": {
+                  "type": "string",
+                  "description": "PageComponentTemplate ID"
+                }
+              },
+              "required": [
+                "company",
+                "template"
+              ]
+            }
+          },
+          "required": [
+            "build"
+          ]
+        }
+      },
+      "required": [
+        "runner"
+      ]
+    }
+  }
+}

package/index.js

@@ -0,0 +1,10 @@
+module.exports = {
+  AuthService: require("./api/auth.service"),
+  DeployService: require("./api/deploy.service"),
+  ConfigService: require("./config/config.service"),
+  Server: require("./server"),
+  TemplateService: require("./template/template.service"),
+  ...require("./meta-files"),
+  ...require("./prompts"),
+  ...require("./utils"),
+};

package/meta-files.js

@@ -0,0 +1,32 @@
+const fs = require("fs");
+const path = require("path");
+
+const ICON_FILE_NAME = "icon.svg";
+const MANIFEST_FILE_NAME = "manifest.json";
+
+module.exports = {
+  copyMetaFiles: function copyMetaFiles(inputDir, outputDir) {
+    [MANIFEST_FILE_NAME, ICON_FILE_NAME].forEach((fileName) => {
+      _copyFileNameFromToSync(fileName, inputDir, outputDir);
+    });
+  },
+  watchMetaFiles: function watchMetaFiles(dir, watchCallback) {
+    require("chokidar")
+      .watch([
+        path.join(dir, MANIFEST_FILE_NAME),
+        path.join(dir, ICON_FILE_NAME),
+      ])
+      .on("all", () => watchCallback());
+  },
+};
+
+function _copyFileNameFromToSync(fileName, sourceDir, destDir) {
+  const sourceFile = path.join(sourceDir, fileName);
+  if (fs.existsSync(sourceFile)) {
+    const destFile = path.join(destDir, fileName);
+    if (!fs.existsSync(destDir)) {
+      fs.mkdirSync(destDir, { recursive: true });
+    }
+    fs.copyFileSync(sourceFile, destFile);
+  }
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@ixon-cdk/core",
+  "version": "1.0.0-alpha.0",
+  "description": "",
+  "main": "index.js",
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "archiver": "^5.3.0",
+    "axios": "^0.21.4",
+    "chalk": "^4.1.2",
+    "chokidar": "^3.5.2",
+    "debounce": "^1.2.1",
+    "express": "^4.17.1",
+    "livereload": "^0.9.3",
+    "lodash": "^4.17.21",
+    "opener": "^1.5.2",
+    "prompts": "^2.4.1",
+    "rimraf": "^3.0.2",
+    "yargs": "^17.1.1"
+  }
+}

package/prompts.js

@@ -0,0 +1,34 @@
+module.exports = {
+  promptCompanyId: function(name) {
+    return {
+      type: "text",
+      name,
+      message: "What is the ID of your Company?",
+      validate: (value) => {
+        if (!value) {
+          return "Company ID is required.";
+        }
+        if (!/^[0-9]{4}-[0-9]{4}-[0-9]{4}-[0-9]{4}-[0-9]{4}$/.test(value)) {
+          return "Invalid company ID.";
+        }
+        return true;
+      },
+    };
+  },
+  promptPageComponentTemplateId: function(name) {
+    return {
+      type: "text",
+      name,
+      message: "What is the ID of the PageComponentTemplate?",
+      validate: (value) => {
+        if (!value) {
+          return "Template ID is required.";
+        }
+        if (!/^[a-zA-Z0-9]{12}$/.test(value)) {
+          return "Invalid template ID.";
+        }
+        return true;
+      },
+    };
+  },
+};

package/server/index.js

@@ -0,0 +1,116 @@
+const path = require("path");
+const express = require("express");
+const ConfigService = require("../config/config.service");
+
+module.exports = class Server {
+  constructor(opts) {
+    this._configSrv = new ConfigService();
+    this._opts = Object.assign(
+      { port: 8000, componentBasePath: "components" },
+      opts
+    );
+  }
+
+  serve(names) {
+    const app = express();
+
+    // Cache
+    app.use(function(_, res, next) {
+      res.header("Cache-Control", "no-store");
+      next();
+    });
+
+    // CORS
+    app.use(function(_, res, next) {
+      res.header("Access-Control-Allow-Origin", "*");
+      res.header(
+        "Access-Control-Allow-Headers",
+        "Origin, X-Requested-With, Content-Type, Accept"
+      );
+      next();
+    });
+
+    // Components
+    if (names) {
+      names.forEach((name) => {
+        const outputDir = this._getOutputDir(name);
+        if (outputDir) {
+          const dir = path.resolve(process.cwd(), outputDir);
+          app.use(
+            `/${this._opts.componentBasePath}/${name}`,
+            express.static(dir)
+          );
+        }
+      });
+    }
+
+    // Adds live reload watchers
+    const lrServer = require("livereload").createServer();
+    const watchHandler = () => lrServer.refresh("/");
+    const outputs = names.map((name) => this._getOutput(name));
+    const watcher = require("chokidar").watch(outputs, { ignoreInitial: true });
+    watcher.on("change", require("debounce")(watchHandler, 500));
+    process.on("exit", () => {
+      lrServer.close();
+      watcher.close();
+    });
+
+    // Simulator app
+    const appDir = path.dirname(require.resolve("@ixon-cdk/simulator"));
+    app.get(`/${this._opts.componentBasePath}/*`, function(req, res) {
+      res.sendStatus(404);
+    });
+    app.get(`/config.json`, (req, res) => {
+      res.send({
+        api: {
+          appId: this._configSrv.getApiApplication(),
+          baseUrl: this._configSrv.getApiBaseUrl(),
+          version: this._configSrv.getApiVersion(),
+        },
+      });
+    });
+    app.get("*.*", express.static(appDir));
+    app.all("*", function(req, res) {
+      res.status(200).sendFile(`/index.html`, { root: appDir });
+    });
+
+    app.listen(this._opts.port);
+  }
+
+  openSimulator(name = null) {
+    const url = this._getComponentUrl(name);
+    const queryString = url ? `?pct-url=${encodeURIComponent(url)}` : "";
+    require("opener")(`${this._getBaseUrl()}/${queryString}`);
+  }
+
+  _getBaseUrl() {
+    return `http://localhost:${this._opts.port}`;
+  }
+
+  _getComponentUrl(name) {
+    if (name) {
+      const output = this._getOutput(name);
+      const outputDir = this._getOutputDir(name);
+      if (outputDir) {
+        const baseUrl = this._getBaseUrl();
+        const servePath = this._opts.componentBasePath;
+        const outputFileName = output.slice(outputDir.length + 1);
+        return `${baseUrl}/${servePath}/${name}/${outputFileName}`;
+      }
+    }
+    return null;
+  }
+
+  _getOutput(name) {
+    if (name) {
+      const prefix = this._configSrv.getPrefix();
+      const tag = prefix ? `${prefix}-${name}` : name;
+      return `dist/${name}/${tag}.min.js`;
+    }
+    return null;
+  }
+
+  _getOutputDir(name) {
+    return name ? `dist/${name}` : null;
+  }
+};

package/template/template.service.js

@@ -0,0 +1,148 @@
+const fs = require("fs");
+const path = require("path");
+const prompts = require("prompts");
+
+const { ensureModule, logFileCrudMessage, pascalCase } = require("../utils");
+const ConfigService = require("../config/config.service");
+
+module.exports = class TemplateService {
+  _configSrv = new ConfigService();
+
+  _schemas = {};
+
+  constructor() {
+    this._discover();
+  }
+
+  async add(componentName, componentPrefix) {
+    let schema;
+
+    const result = await prompts({
+      type: "select",
+      name: "templateName",
+      message: "Pick a template",
+      choices: Object.keys(this._schemas).map((key) => ({
+        title: this._schemas[key].name,
+        value: key,
+      })),
+      initial: 0,
+    });
+
+    const tag = componentPrefix
+      ? `${componentPrefix}-${componentName}`
+      : componentName;
+
+    if (result) {
+      schema = this._schemas[result.templateName];
+    }
+
+    if (schema) {
+      const context = { name: componentName, tag };
+      let variantIdx = null;
+
+      if (schema.variants) {
+        const _result = await prompts({
+          type: "select",
+          name: "variantIdx",
+          message: "Pick a variant",
+          choices: schema.variants.map((variant, index) => ({
+            title: variant.name,
+            value: index,
+          })),
+          initial: 0,
+        });
+
+        if (_result) {
+          variantIdx = _result.variantIdx;
+        }
+      }
+
+      schema = this._interpolateSchema(schema, context);
+
+      if (schema.config.runner) {
+        const modulesNames = Object.keys(schema.config.runner).reduce(
+          (names, cmd) => {
+            if (schema.config.runner[cmd].builder) {
+              const name = schema.config.runner[cmd].builder.split(":")[0];
+              if (!names.includes(name)) {
+                return [...names, name];
+              }
+            }
+            return names;
+          },
+          []
+        );
+        modulesNames.forEach((name) => ensureModule(name));
+      }
+
+      const root = this._configSrv.getNewComponentRoot();
+
+      schema.files.forEach((file) => {
+        file.dest = `${root}/${componentName}/${file.dest}`;
+        this.createFile(file, context);
+      });
+
+      if (variantIdx !== null) {
+        schema.variants[variantIdx].files.forEach((file) => {
+          file.dest = `${root}/${componentName}/${file.dest}`;
+          this.createFile(file, context);
+        });
+      }
+    }
+
+    return schema;
+  }
+
+  createFile(file, ctx) {
+    fs.mkdirSync(path.dirname(path.join(process.cwd(), file.dest)), {
+      recursive: true,
+    });
+    if (file.interpolateContent) {
+      const text = fs.readFileSync(
+        path.join(
+          path.dirname(require.resolve("@ixon-cdk/templates")),
+          file.source
+        ),
+        { encoding: "utf-8" }
+      );
+      const data = this._interpolateText(text, ctx);
+      fs.writeFileSync(path.join(process.cwd(), file.dest), data, {
+        encoding: "utf-8",
+      });
+    } else {
+      fs.copyFileSync(
+        path.join(
+          path.dirname(require.resolve("@ixon-cdk/templates")),
+          file.source
+        ),
+        path.join(process.cwd(), file.dest)
+      );
+    }
+    logFileCrudMessage("CREATE", file.dest);
+  }
+
+  _discover() {
+    const dir = path.dirname(require.resolve("@ixon-cdk/templates"));
+    const files = fs.readdirSync(dir);
+    files.forEach((file) => {
+      if (fs.lstatSync(path.join(dir, file)).isDirectory()) {
+        const schemaFile = path.join(dir, file, "schema.json");
+        if (fs.existsSync(schemaFile)) {
+          const schema = JSON.parse(fs.readFileSync(schemaFile));
+          this._schemas = Object.assign({}, this._schemas, { [file]: schema });
+        }
+      }
+    });
+  }
+
+  _interpolateSchema(schema, params) {
+    return JSON.parse(this._interpolateText(JSON.stringify(schema), params));
+  }
+
+  _interpolateText(text, params) {
+    return text
+      .replace(/\{name\}/g, params.name)
+      .replace(/\{tag\}/g, params.tag)
+      .replace(/\{pascalCase\(tag\)\}/g, pascalCase(params.tag));
+  }
+};

package/utils.js

@@ -0,0 +1,114 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+const flow = require("lodash/flow");
+const camelCase = require("lodash/camelCase");
+const upperFirst = require("lodash/upperFirst");
+
+function getArgv() {
+  const remain = process.argv.slice(2);
+  const argv = require("yargs/yargs")(remain).argv;
+
+  // version argument fix
+  if ("version" in argv) {
+    const versionArg = remain.find((arg) =>
+      /^--version=("[0-9]+"|'[0-9]+'|[0-9]+)$/.test(arg)
+    );
+    if (!!versionArg) {
+      const matches = versionArg.match(/^--version=['"]?([0-9]+)['"]?$/);
+      argv.version = Number(matches[1]);
+    }
+  }
+
+  return argv;
+}
+
+function logErrorMessage(message) {
+  console.log(chalk.redBright.bold(message));
+}
+
+function logFileCrudMessage(crud, file) {
+  switch (crud) {
+    case "CREATE":
+    case "UPDATE":
+      console.log(`${chalk.green(crud)} ${file}`);
+      break;
+  }
+}
+
+function logSuccessMessage(message) {
+  console.log(chalk.green(message));
+}
+
+function moduleExists(moduleName) {
+  let exists = true;
+  try {
+    require.resolve(moduleName);
+  } catch {
+    exists = false;
+  }
+  return exists;
+}
+
+function ensureModule(moduleName) {
+  if (!moduleName.startsWith("@ixon-cdk/")) {
+    return logErrorMessage("Cannot install this module.");
+  }
+  if (!moduleExists(moduleName)) {
+    console.log(`Installing package '${moduleName}'...`);
+    require("child_process").execSync(`npm install --save-dev ${moduleName}`);
+  }
+}
+
+function zip(output, callback) {
+  const outputDir = path.dirname(output);
+  const zipFile = path.join(outputDir + ".zip");
+  const stream = fs.createWriteStream(zipFile);
+  stream.on("close", () => {
+    require("rimraf").sync(outputDir);
+    callback(zipFile);
+  });
+  const archive = require("archiver")("zip", { zlib: { level: 9 } });
+  archive.pipe(stream);
+  archive.directory(outputDir, path.basename(outputDir));
+  archive.finalize();
+}
+
+const pascalCase = flow(camelCase, upperFirst);
+
+function apiHttpErrorToMessage(error) {
+  if (typeof error === "string") {
+    logErrorMessage(error);
+    process.exit();
+  }
+  if (error && error.response && error.response.data) {
+    const errors = error.response.data.data;
+    if (errors) {
+      logErrorMessage(
+        errors
+          .map((err) =>
+            !!err.propertyName
+              ? `${err.propertyName}: ${err.message}`
+              : err.message
+          )
+          .join("\n")
+      );
+      process.exit();
+    }
+  }
+  logErrorMessage("Unexpected error.");
+  console.log(error);
+  process.exit();
+}
+
+module.exports = {
+  getArgv,
+  logErrorMessage,
+  logFileCrudMessage,
+  logSuccessMessage,
+  moduleExists,
+  ensureModule,
+  zip,
+  pascalCase,
+  apiHttpErrorToMessage,
+};