@ixon-cdk/core 1.0.0-alpha.1 → 1.0.0-alpha.13

package/api/auth.service.js

@@ -1,30 +1,31 @@
-const fs = require("fs");
-const axios = require("axios");
-const ApiBaseService = require("./base.service");
+const fs = require('fs');
+const ApiBaseService = require('./base.service');
+const httpRequest = require('../http-request');
 
 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")}`,
-        },
-      }
-    );
+    return httpRequest({
+      method: 'POST',
+      url: `${this._getApiBaseUrl()}/access-tokens`,
+      data: { 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`, {
+      return httpRequest({
+        method: 'DELETE',
+        url: `${this._getApiBaseUrl()}/access-tokens/me`,
         headers: {
           ...this._getApiDefaultHeaders(),
           Authorization: this._getApiAuthHeaderValue(),
@@ -40,8 +41,8 @@ module.exports = class AuthService extends ApiBaseService {
 
   remember(secretId) {
     fs.writeFileSync(this._getAccessTokenFilePath(), secretId, {
-      encoding: "utf8",
-      flag: "w",
+      encoding: 'utf8',
+      flag: 'w',
     });
   }
 

package/api/base.service.js

@@ -1,12 +1,12 @@
-const fs = require("fs");
-const path = require("path");
-const ConfigService = require("../config/config.service");
+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");
+    return path.join(require('../utils').getRootDir(), '.accesstoken');
   }
 
   _getApiAuthHeaderValue() {
@@ -19,9 +19,9 @@ module.exports = class ApiBaseService {
 
   _getApiDefaultHeaders() {
     return {
-      "Content-Type": "application/json",
-      "Api-Application": this._configSrv.getApiApplication(),
-      "Api-Version": this._configSrv.getApiVersion(),
+      'Content-Type': 'application/json',
+      'Api-Application': this._configSrv.getApiApplication(),
+      'Api-Version': this._configSrv.getApiVersion(),
     };
   }
 
@@ -29,7 +29,7 @@ module.exports = class ApiBaseService {
     let secretId;
     try {
       secretId = fs.readFileSync(this._getAccessTokenFilePath(), {
-        encoding: "utf-8",
+        encoding: 'utf-8',
       });
     } catch {
       // do nothing

package/api/deploy.service.js

@@ -1,44 +1,65 @@
-const fs = require("fs");
-const path = require("path");
-const axios = require("axios");
-const ApiBaseService = require("./base.service");
+const fs = require('fs');
+const path = require('path');
+const ApiBaseService = require('./base.service');
+const httpRequest = require('../http-request');
 
 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 body = fs.readFileSync(path.join(require('../utils').getRootDir(), file));
     const headers = {
       ...this._getApiDefaultHeaders(),
-      "Content-Type": "application/x-www-form-urlencoded",
-      "Api-Company": companyId,
+      'Content-Type': 'application/x-www-form-urlencoded',
+      'Api-Company': companyId,
       Authorization: this._getApiAuthHeaderValue(),
     };
-    return axios.post(url, body, { headers }).then((res) => res.data.data);
+    return httpRequest({ method: 'POST', url, data: body, headers }).then((res) => res.data.data);
   }
 
   deployAndPublish(companyId, templateId, file) {
     return this.deploy(companyId, templateId, file).then((data) =>
-      this._publish(companyId, data.publicId)
+      this._publish(companyId, data.publicId),
     );
   }
 
   fetchPublishable(companyId, templateId) {
     return this._fetchDescTemplateVersions(companyId, templateId).then((versions) => {
-      const publishedIdx = versions.findIndex(
-        (v) => typeof v.publishedOn === "string"
-      );
+      const publishedIdx = versions.findIndex((v) => typeof v.publishedOn === 'string');
       return publishedIdx !== -1 ? versions.slice(0, publishedIdx) : versions;
     });
   }
 
+  generatePreviewLink(companyId, versionId) {
+    return Promise.all([
+      this._fetchBrandingFqdn(companyId),
+      this._fetchTemplateVersion(companyId, versionId),
+    ])
+      .then(([fqdn, version]) =>
+        this._fetchTemplate(companyId, version.template.publicId).then((template) => [
+          fqdn,
+          version,
+          template,
+        ]),
+      )
+      .then(([fqdn, version, template]) => {
+        const hash = require('../utils').generatePreviewHash(
+          template.publicId,
+          template.name,
+          version.publicId,
+          version.number,
+          version.mainPath,
+        );
+        const search = `?pctpvw=${encodeURIComponent(hash)}`;
+        return `https://${fqdn || '[YOUR-PLATFORM-DOMAIN]'}/portal/${search}`;
+      });
+  }
+
   publishLatestVersion(companyId, templateId) {
     return this.fetchPublishable(companyId, templateId).then((data) => {
       if (!data.length) {
-        return Promise.reject("Template has no publishable versions");
+        return Promise.reject('Template has no publishable versions');
       }
-      const latest = data.sort(
-        (v1, v2) => Number(v2.number) - Number(v1.number)
-      )[0];
+      const latest = data.sort((v1, v2) => Number(v2.number) - Number(v1.number))[0];
       return this._publish(companyId, latest.publicId);
     });
   }
@@ -46,33 +67,80 @@ module.exports = class DeployService extends ApiBaseService {
   publishVersion(companyId, templateId, versionNumber) {
     return this.fetchPublishable(companyId, templateId).then((data) => {
       if (!data.length) {
-        return Promise.reject("Template has no publishable versions");
+        return Promise.reject('Template has no publishable versions');
       }
       const _version = data.find((v) => v.number === String(versionNumber));
-      if (!!_version) {
+      if (_version) {
         return this._publish(companyId, _version.publicId);
       }
-      return Promise.reject("Could not match!");
+      return Promise.reject('Could not match!');
+    });
+  }
+
+  _fetchBrandingFqdn(companyId) {
+    const url = `${this._getApiBaseUrl()}/companies/me`;
+    const params = { fields: 'branding(fqdn)' };
+    const headers = {
+      ...this._getApiDefaultHeaders(),
+      'Api-Company': companyId,
+      Authorization: this._getApiAuthHeaderValue(),
+    };
+    // Lookup company FQDN (premium branding)
+    return httpRequest({ method: 'GET', url, params, headers }).then((res) => {
+      const myCompany = res.data.data;
+      if (myCompany.branding && myCompany.branding.fqdn) {
+        return myCompany.branding.fqdn;
+      }
+      // Or fallback to sector FQDN
+      const _url = `${this._getApiBaseUrl()}/sectors/me`;
+      const _headers = { ...this._getApiDefaultHeaders() };
+      return httpRequest({ method: 'GET', url: _url, params, headers: _headers }).then((res) => {
+        const mySector = res.data.data;
+        if (mySector.branding && mySector.branding.fqdn) {
+          return mySector.branding.fqdn;
+        }
+        return null;
+      });
     });
   }
 
   _fetchDescTemplateVersions(companyId, templateId) {
     const url = `${this._getApiBaseUrl()}/page-component-template-versions`;
     const params = {
-      fields: "*,template(*)",
+      fields: '*,template(*)',
       filters: `eq(template.publicId,"${templateId}")`,
-      "page-size": "100",
+      'page-size': '100',
     };
     const headers = {
       ...this._getApiDefaultHeaders(),
-      "Api-Company": companyId,
+      '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)
-      );
-    });
+    return httpRequest({ method: 'GET', url, params, headers }).then((res) =>
+      res.data.data.sort((v1, v2) => Number(v2.number) - Number(v1.number)),
+    );
+  }
+
+  _fetchTemplate(companyId, templateId) {
+    const url = `${this._getApiBaseUrl()}/page-component-templates/${templateId}`;
+    const params = { fields: '*' };
+    const headers = {
+      ...this._getApiDefaultHeaders(),
+      'Api-Company': companyId,
+      Authorization: this._getApiAuthHeaderValue(),
+    };
+    return httpRequest({ method: 'GET', url, params, headers }).then((res) => res.data.data);
+  }
+
+  _fetchTemplateVersion(companyId, versionId) {
+    const url = `${this._getApiBaseUrl()}/page-component-template-versions/${versionId}`;
+    const params = { fields: '*,template(*)' };
+    const headers = {
+      ...this._getApiDefaultHeaders(),
+      'Api-Company': companyId,
+      Authorization: this._getApiAuthHeaderValue(),
+    };
+    return httpRequest({ method: 'GET', url, params, headers }).then((res) => res.data.data);
   }
 
   _publish(companyId, versionId) {
@@ -80,9 +148,9 @@ module.exports = class DeployService extends ApiBaseService {
     const body = { published: true };
     const headers = {
       ...this._getApiDefaultHeaders(),
-      "Api-Company": companyId,
+      'Api-Company': companyId,
       Authorization: this._getApiAuthHeaderValue(),
     };
-    return axios.patch(url, body, { headers });
+    return httpRequest({ method: 'PATCH', url, data: body, headers });
   }
 };

package/config/config.service.js

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

package/config/schema.d.ts

@@ -37,6 +37,8 @@ interface component {
       builder: string;
       /** The component input-file */
       input: string;
+      /** List of static component assets. */
+      assets?: string[];
     };
     deploy?: {
       /** Company ID */

package/config/schema.json

@@ -55,6 +55,13 @@
                 "input": {
                   "type": "string",
                   "description": "The component input-file"
+                },
+                "assets": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  },
+                  "description": "List of static component assets."
                 }
               },
               "required": [

package/http-request.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const { getRootDir, logErrorMessage } = require('./utils');
+
+module.exports = function request(options) {
+  const customPath = path.join(getRootDir(), 'http-request.js');
+
+  if (fs.existsSync(customPath)) {
+    const customRequest = require(customPath);
+
+    if (typeof customRequest !== 'function') {
+      logErrorMessage('The custom "http-request.js" file must export a function.');
+      process.exit();
+    }
+
+    const promise = customRequest(options);
+
+    if (typeof promise !== 'object' || typeof promise.then !== 'function') {
+      logErrorMessage('The exported function in the custom "http-request.js" file must return a Promise.');
+      process.exit();
+    }
+
+    return promise;
+  }
+
+  return axios.request(options);
+};

package/index.js

@@ -1,10 +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"),
+  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

@@ -1,22 +1,84 @@
-const fs = require("fs");
-const path = require("path");
+const fs = require('fs');
+const path = require('path');
+const { debounce, uniq } = require('lodash');
+const rimraf = require('rimraf');
 
-const ICON_FILE_NAME = "icon.svg";
-const MANIFEST_FILE_NAME = "manifest.json";
+const ICON_FILE_NAME = 'icon.svg';
+const MANIFEST_FILE_NAME = 'manifest.json';
+const WATCH_OPTIONS = {
+  cwd: require('./utils').getRootDir(),
+  usePolling: process.platform !== 'darwin',
+};
 
 module.exports = {
-  copyMetaFiles: function copyMetaFiles(inputDir, outputDir) {
-    [MANIFEST_FILE_NAME, ICON_FILE_NAME].forEach((fileName) => {
-      _copyFileNameFromToSync(fileName, inputDir, outputDir);
+  cleanDir(dir) {
+    if (fs.existsSync(dir)) {
+      rimraf.sync(dir);
+    }
+    fs.mkdirSync(dir, { recursive: true });
+  },
+  copyAssets(assets, inputDir, outputDir) {
+    const paths = uniq([MANIFEST_FILE_NAME, ICON_FILE_NAME, ...assets]).map((asset) =>
+      path.join(inputDir, asset),
+    );
+    paths.forEach((_path) => {
+      require('glob')
+        .sync(_path)
+        .forEach((file) => {
+          const fileName = file.slice(inputDir.length + 1);
+          _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());
+  watchAssets(assets, inputDir, outputDir) {
+    const root = require('./utils').getRootDir();
+    return require('chokidar')
+      .watch(
+        uniq([MANIFEST_FILE_NAME, ICON_FILE_NAME, ...assets]).map((asset) =>
+          path.join(inputDir, asset),
+        ),
+        WATCH_OPTIONS,
+      )
+      .on('all', (type, file) => {
+        const fileName = path.join(root, file).slice(inputDir.length + 1);
+        switch (type) {
+          case 'add':
+          case 'change':
+            _copyFileNameFromToSync(fileName, inputDir, outputDir);
+            break;
+          case 'unlink':
+            if (fs.existsSync(path.join(outputDir, fileName))) {
+              rimraf.sync(path.join(outputDir, fileName));
+            }
+            break;
+          default:
+            break;
+        }
+      });
+  },
+  watchInputDir(dir, watchCallback) {
+    const _debouncedCallback = debounce(() => watchCallback(), 300);
+    require('chokidar')
+      .watch([`${dir}/**`], WATCH_OPTIONS)
+      .on('all', (_, _path) => {
+        if (
+          _path.endsWith(path.join(dir, MANIFEST_FILE_NAME)) ||
+          _path.endsWith(path.join(dir, ICON_FILE_NAME))
+        ) {
+          watchCallback(true);
+        } else {
+          _debouncedCallback();
+        }
+      });
+  },
+  writeDemoFile: function writeDemoFile(tag, outputDir, outputFile) {
+    const demoFileContent = `<meta charset="utf-8">\n<title>${tag} demo</title>\n<script src="./${path.basename(
+      outputFile,
+    )}"></script>\n\n\n<${tag}></${tag}>\n\n`;
+    fs.writeFileSync(`${outputDir}/demo.html`, demoFileContent, {
+      encoding: 'utf8',
+      flag: 'w',
+    });
   },
 };
 
@@ -27,6 +89,11 @@ function _copyFileNameFromToSync(fileName, sourceDir, destDir) {
     if (!fs.existsSync(destDir)) {
       fs.mkdirSync(destDir, { recursive: true });
     }
+    if (!fs.existsSync(path.dirname(path.join(destDir, fileName)))) {
+      fs.mkdirSync(path.dirname(path.join(destDir, fileName)), {
+        recursive: true,
+      });
+    }
     fs.copyFileSync(sourceFile, destFile);
   }
 }

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "@ixon-cdk/core",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.13",
   "description": "",
   "main": "index.js",
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "app-root-dir": "^1.0.2",
     "archiver": "^5.3.0",
     "axios": "^0.21.4",
     "chalk": "^4.1.2",
     "chokidar": "^3.5.2",
-    "debounce": "^1.2.1",
+    "crypto-js": "^4.1.1",
     "express": "^4.17.1",
+    "glob": "^7.2.0",
     "livereload": "^0.9.3",
     "lodash": "^4.17.21",
     "opener": "^1.5.2",

package/prompts.js

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

package/server/index.js

@@ -1,31 +1,33 @@
-const path = require("path");
-const express = require("express");
-const ConfigService = require("../config/config.service");
+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
-    );
+    this._rootDir = require('../utils').getRootDir();
+    this._opts = {
+      port: 8000,
+      componentBasePath: 'components',
+      ...opts,
+    };
   }
 
   serve(names) {
     const app = express();
 
     // Cache
-    app.use(function(_, res, next) {
-      res.header("Cache-Control", "no-store");
+    app.use((_, res, next) => {
+      res.header('Cache-Control', 'no-store');
       next();
     });
 
     // CORS
-    app.use(function(_, res, next) {
-      res.header("Access-Control-Allow-Origin", "*");
+    app.use((_, res, next) => {
+      res.header('Access-Control-Allow-Origin', '*');
       res.header(
-        "Access-Control-Allow-Headers",
-        "Origin, X-Requested-With, Content-Type, Accept"
+        'Access-Control-Allow-Headers',
+        'Origin, X-Requested-With, Content-Type, Accept',
       );
       next();
     });
@@ -35,36 +37,32 @@ module.exports = class Server {
       names.forEach((name) => {
         const outputDir = this._getOutputDir(name);
         if (outputDir) {
-          const dir = path.resolve(process.cwd(), outputDir);
+          const dir = path.resolve(this._rootDir, outputDir);
           app.use(
             `/${this._opts.componentBasePath}/${name}`,
-            express.static(dir)
+            express.static(dir),
           );
         }
       });
     }
 
     // Adds live reload watchers
-    const lrServer = require("livereload").createServer();
-    const watchHandler = () => lrServer.refresh("/");
-    const outputs = names.flatMap((name) => [
-      this._getOutput(name),
-      `dist/${name}/manifest.json`,
-    ]);
-
-    const watcher = require("chokidar").watch(outputs, { ignoreInitial: true });
-    watcher.on("change", require("debounce")(watchHandler, 500));
-    process.on("exit", () => {
-      lrServer.close();
-      watcher.close();
-    });
+    const lrServer = require('livereload').createServer();
+    const _refresh = () => lrServer.refresh('/');
+    const _debouncedRefresh = require('lodash/debounce')(_refresh, 250);
+    names
+      .flatMap((name) => [
+        [path.join(this._rootDir, this._getOutput(name)), 100],
+        [path.join(this._rootDir, `dist/${name}/manifest.json`), 500],
+      ])
+      .forEach(([filename, interval]) => require('fs').watchFile(filename, { interval }, _debouncedRefresh));
 
     // Simulator app
-    const appDir = path.dirname(require.resolve("@ixon-cdk/simulator"));
-    app.get(`/${this._opts.componentBasePath}/*`, function(req, res) {
+    const appDir = path.dirname(require.resolve('@ixon-cdk/simulator'));
+    app.get(`/${this._opts.componentBasePath}/*`, (req, res) => {
       res.sendStatus(404);
     });
-    app.get(`/config.json`, (req, res) => {
+    app.get('/config.json', (req, res) => {
       res.send({
         api: {
           appId: this._configSrv.getApiApplication(),
@@ -73,9 +71,9 @@ module.exports = class Server {
         },
       });
     });
-    app.get("*.*", express.static(appDir));
-    app.all("*", function(req, res) {
-      res.status(200).sendFile(`/index.html`, { root: appDir });
+    app.get('*.*', express.static(appDir));
+    app.all('*', (req, res) => {
+      res.status(200).sendFile('/index.html', { root: appDir });
     });
 
     app.listen(this._opts.port);
@@ -83,8 +81,8 @@ module.exports = class Server {
 
   openSimulator(name = null) {
     const url = this._getComponentUrl(name);
-    const queryString = url ? `?pct-url=${encodeURIComponent(url)}` : "";
-    require("opener")(`${this._getBaseUrl()}/${queryString}`);
+    const queryString = url ? `?pct-url=${encodeURIComponent(url)}` : '';
+    require('opener')(`${this._getBaseUrl()}/${queryString}`);
   }
 
   _getBaseUrl() {

package/template/template.service.js

@@ -1,9 +1,14 @@
-const fs = require("fs");
-const path = require("path");
-const prompts = require("prompts");
-
-const { ensureModule, logFileCrudMessage, pascalCase } = require("../utils");
-const ConfigService = require("../config/config.service");
+const fs = require('fs');
+const path = require('path');
+const prompts = require('prompts');
+
+const {
+  getRootDir,
+  ensureModule,
+  logFileCrudMessage,
+  pascalCase,
+} = require('../utils');
+const ConfigService = require('../config/config.service');
 
 module.exports = class TemplateService {
   _configSrv = new ConfigService();
@@ -18,9 +23,9 @@ module.exports = class TemplateService {
     let schema;
 
     const result = await prompts({
-      type: "select",
-      name: "templateName",
-      message: "Pick a template",
+      type: 'select',
+      name: 'templateName',
+      message: 'Pick a template',
       choices: Object.keys(this._schemas).map((key) => ({
         title: this._schemas[key].name,
         value: key,
@@ -42,9 +47,9 @@ module.exports = class TemplateService {
 
       if (schema.variants) {
         const _result = await prompts({
-          type: "select",
-          name: "variantIdx",
-          message: "Pick a variant",
+          type: 'select',
+          name: 'variantIdx',
+          message: 'Pick a variant',
           choices: schema.variants.map((variant, index) => ({
             title: variant.name,
             value: index,
@@ -63,14 +68,14 @@ module.exports = class TemplateService {
         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];
+              const name = schema.config.runner[cmd].builder.split(':')[0];
               if (!names.includes(name)) {
                 return [...names, name];
               }
             }
             return names;
           },
-          []
+          [],
         );
         modulesNames.forEach((name) => ensureModule(name));
       }
@@ -94,42 +99,43 @@ module.exports = class TemplateService {
   }
 
   createFile(file, ctx) {
-    fs.mkdirSync(path.dirname(path.join(process.cwd(), file.dest)), {
+    const rootDir = getRootDir();
+    fs.mkdirSync(path.dirname(path.join(rootDir, file.dest)), {
       recursive: true,
     });
     if (file.interpolateContent) {
       const text = fs.readFileSync(
         path.join(
-          path.dirname(require.resolve("@ixon-cdk/templates")),
-          file.source
+          path.dirname(require.resolve('@ixon-cdk/templates')),
+          file.source,
         ),
-        { encoding: "utf-8" }
+        { encoding: 'utf-8' },
       );
       const data = this._interpolateText(text, ctx);
-      fs.writeFileSync(path.join(process.cwd(), file.dest), data, {
-        encoding: "utf-8",
+      fs.writeFileSync(path.join(rootDir, file.dest), data, {
+        encoding: 'utf-8',
       });
     } else {
       fs.copyFileSync(
         path.join(
-          path.dirname(require.resolve("@ixon-cdk/templates")),
-          file.source
+          path.dirname(require.resolve('@ixon-cdk/templates')),
+          file.source,
         ),
-        path.join(process.cwd(), file.dest)
+        path.join(rootDir, file.dest),
       );
     }
-    logFileCrudMessage("CREATE", file.dest);
+    logFileCrudMessage('CREATE', file.dest);
   }
 
   _discover() {
-    const dir = path.dirname(require.resolve("@ixon-cdk/templates"));
+    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");
+        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 });
+          this._schemas = { ...this._schemas, [file]: schema };
         }
       }
     });

package/utils.js

@@ -1,20 +1,18 @@
-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");
+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;
+  const { argv } = require('yargs/yargs')(remain);
 
   // version argument fix
-  if ("version" in argv) {
-    const versionArg = remain.find((arg) =>
-      /^--version=("[0-9]+"|'[0-9]+'|[0-9]+)$/.test(arg)
-    );
-    if (!!versionArg) {
+  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]);
     }
@@ -23,16 +21,22 @@ function getArgv() {
   return argv;
 }
 
+function getRootDir() {
+  return require('app-root-dir').get();
+}
+
 function logErrorMessage(message) {
   console.log(chalk.redBright.bold(message));
 }
 
 function logFileCrudMessage(crud, file) {
   switch (crud) {
-    case "CREATE":
-    case "UPDATE":
+    case 'CREATE':
+    case 'UPDATE':
       console.log(`${chalk.green(crud)} ${file}`);
       break;
+    default:
+      break;
   }
 }
 
@@ -51,24 +55,25 @@ function moduleExists(moduleName) {
 }
 
 function ensureModule(moduleName) {
-  if (!moduleName.startsWith("@ixon-cdk/")) {
-    return logErrorMessage("Cannot install this module.");
+  if (!moduleName.startsWith('@ixon-cdk/')) {
+    logErrorMessage('Cannot install this module.');
+    return;
   }
   if (!moduleExists(moduleName)) {
     console.log(`Installing package '${moduleName}'...`);
-    require("child_process").execSync(`npm install --save-dev ${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 zipFile = path.join(`${outputDir}.zip`);
   const stream = fs.createWriteStream(zipFile);
-  stream.on("close", () => {
-    require("rimraf").sync(outputDir);
+  stream.on('close', () => {
+    require('rimraf').sync(outputDir);
     callback(zipFile);
   });
-  const archive = require("archiver")("zip", { zlib: { level: 9 } });
+  const archive = require('archiver')('zip', { zlib: { level: 9 } });
   archive.pipe(stream);
   archive.directory(outputDir, path.basename(outputDir));
   archive.finalize();
@@ -77,7 +82,7 @@ function zip(output, callback) {
 const pascalCase = flow(camelCase, upperFirst);
 
 function apiHttpErrorToMessage(error) {
-  if (typeof error === "string") {
+  if (typeof error === 'string') {
     logErrorMessage(error);
     process.exit();
   }
@@ -86,23 +91,32 @@ function apiHttpErrorToMessage(error) {
     if (errors) {
       logErrorMessage(
         errors
-          .map((err) =>
-            !!err.propertyName
-              ? `${err.propertyName}: ${err.message}`
-              : err.message
-          )
-          .join("\n")
+          .map((err) => (err.propertyName ? `${err.propertyName}: ${err.message}` : err.message))
+          .join('\n'),
       );
       process.exit();
     }
   }
-  logErrorMessage("Unexpected error.");
+  logErrorMessage('Unexpected error.');
   console.log(error);
   process.exit();
 }
 
+function generatePreviewHash(templateId, templateName, versionId, versionNumber, versionMainPath) {
+  const ref = {
+    tid: templateId,
+    tnm: templateName,
+    vid: versionId,
+    vnr: versionNumber,
+    vmp: versionMainPath,
+  };
+  const salt = 'A9qJ03jh';
+  return require('crypto-js').AES.encrypt(JSON.stringify(ref), salt).toString();
+}
+
 module.exports = {
   getArgv,
+  getRootDir,
   logErrorMessage,
   logFileCrudMessage,
   logSuccessMessage,
@@ -111,4 +125,5 @@ module.exports = {
   zip,
   pascalCase,
   apiHttpErrorToMessage,
+  generatePreviewHash,
 };