@accordproject/cicero-core/lib/templateloader.js

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
'use strict';

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

const fs = require('fs');

const fsPath = require('path');

const JSZip = require('jszip');

const xregexp = require('xregexp');

const languageTagRegex = require('ietf-language-tag-regex');

const DefaultArchiveLoader = require('./loaders/defaultarchiveloader');

const Logger = require('@accordproject/ergo-compiler').Logger;

const promisify = require('util').promisify;

const readdir = fs.readdir ? promisify(fs.readdir) : undefined;
const stat = fs.stat ? promisify(fs.stat) : undefined;
const ENCODING = 'utf8'; // Matches 'sample.txt' or 'sample_TAG.txt' where TAG is an IETF language tag (BCP 47)

const IETF_REGEXP = languageTagRegex({
  exact: false
}).toString().slice(1, -2);
const SAMPLE_FILE_REGEXP = xregexp('sample(_(' + IETF_REGEXP + '))?.txt$');
/**
 * A utility class to create templates from data sources.
 * @class
 * @interal
 * @abstract
 * @memberof module:cicero-core
 */

class TemplateLoader {
  /**
   * Loads a required file from the zip, displaying an error if missing
   * @internal
   * @param {*} zip the JSZip instance
   * @param {string} path the file path within the zip
   * @param {boolean} json if true the file is converted to a JS Object using JSON.parse
   * @param {boolean} required whether the file is required
   * @return {Promise<string>} a promise to the contents of the zip file or null if it does not exist and
   * required is false
   */
  static loadZipFileContents(zip, path) {
    var _arguments = arguments;
    return _asyncToGenerator(function* () {
      let json = _arguments.length > 2 && _arguments[2] !== undefined ? _arguments[2] : false;
      let required = _arguments.length > 3 && _arguments[3] !== undefined ? _arguments[3] : false;
      Logger.debug('loadZipFileContents', 'Loading ' + path);
      let zipFile = zip.file(path);

      if (!zipFile && required) {
        throw new Error("Failed to find ".concat(path, " in archive file."));
      }

      if (zipFile) {
        const content = yield zipFile.async('string');

        if (json && content) {
          return JSON.parse(content);
        } else {
          return content;
        }
      }

      return null;
    })();
  }
  /**
   * Loads the contents of all files in the zip that match a regex
   * @internal
   * @param {*} zip the JSZip instance
   * @param {RegExp} regex the regex to use to match files
   * @return {Promise<object[]>} a promise to an array of objects with the name and contents of the zip files
   */


  static loadZipFilesContents(zip, regex) {
    return _asyncToGenerator(function* () {
      const results = [];
      let matchedFiles = zip.file(regex); // do not use forEach, because we need to call an async function!

      for (let n = 0; n < matchedFiles.length; n++) {
        const file = matchedFiles[n];
        const result = {
          name: file.name
        };
        result.contents = yield TemplateLoader.loadZipFileContents(zip, file.name, false, true);
        results.push(result);
      }

      return results;
    })();
  }
  /**
   * Loads a required file from a directory, displaying an error if missing
   * @internal
   * @param {*} path the root path
   * @param {string} fileName the relative file name
   * @param {boolean} json if true the file is converted to a JS Object using JSON.parse
   * @param {boolean} required whether the file is required
   * @return {Promise<string>} a promise to the contents of the file or null if it does not exist and
   * required is false
   */


  static loadFileContents(path, fileName) {
    var _arguments2 = arguments;
    return _asyncToGenerator(function* () {
      let json = _arguments2.length > 2 && _arguments2[2] !== undefined ? _arguments2[2] : false;
      let required = _arguments2.length > 3 && _arguments2[3] !== undefined ? _arguments2[3] : false;
      Logger.debug('loadFileContents', 'Loading ' + fileName);
      const filePath = fsPath.resolve(path, fileName);

      if (fs.existsSync(filePath)) {
        const contents = fs.readFileSync(filePath, ENCODING);

        if (json && contents) {
          return JSON.parse(contents);
        } else {
          return contents;
        }
      } else {
        if (required) {
          throw new Error("Failed to find ".concat(fileName, " in directory."));
        }
      }

      return null;
    })();
  }
  /**
   * Loads the contents of all files under a path that match a regex
   * Note that any directories called node_modules are ignored.
   * @internal
   * @param {*} path the file path
   * @param {RegExp} regex the regex to match files
   * @return {Promise<object[]>} a promise to an array of objects with the name and contents of the files
   */


  static loadFilesContents(path, regex) {
    return _asyncToGenerator(function* () {
      Logger.debug('loadFilesContents', 'Loading ' + path);
      const subdirs = yield readdir(path);
      const result = yield Promise.all(subdirs.map(
      /*#__PURE__*/
      function () {
        var _ref = _asyncToGenerator(function* (subdir) {
          const res = fsPath.resolve(path, subdir);

          if ((yield stat(res)).isDirectory()) {
            if (/.*node_modules$/.test(res) === false) {
              return TemplateLoader.loadFilesContents(res, regex);
            } else {
              return null;
            }
          } else {
            if (regex.test(res)) {
              return {
                name: res,
                contents: yield TemplateLoader.loadFileContents(path, res, false, true)
              };
            } else {
              return null;
            }
          }
        });

        return function (_x) {
          return _ref.apply(this, arguments);
        };
      }()));
      return result.reduce((a, f) => a.concat(f), []).filter(f => f !== null);
    })();
  }
  /**
   * Create a template from an archive.
   * @param {*} Template - the type to construct
   * @param {Buffer} buffer  - the buffer to a Cicero Template Archive (cta) file
   * @return {Promise<Template>} a Promise to the template
   */


  static fromArchive(Template, buffer) {
    return _asyncToGenerator(function* () {
      const method = 'fromArchive';
      const zip = yield JSZip.loadAsync(buffer); // const allFiles = await TemplateLoader.loadZipFilesContents(zip, /.*/);
      // console.log(allFiles);

      const ctoModelFiles = [];
      const ctoModelFileNames = [];
      const sampleTextFiles = {};
      const readmeContents = yield TemplateLoader.loadZipFileContents(zip, 'README.md');
      let sampleFiles = yield TemplateLoader.loadZipFilesContents(zip, SAMPLE_FILE_REGEXP);
      sampleFiles.forEach(
      /*#__PURE__*/
      function () {
        var _ref2 = _asyncToGenerator(function* (sampleFile) {
          let matches = sampleFile.name.match(SAMPLE_FILE_REGEXP);
          let locale = 'default'; // Locale match found

          if (matches !== null && matches[2]) {
            locale = matches[2];
          }

          sampleTextFiles[locale] = sampleFile.contents;
        });

        return function (_x2) {
          return _ref2.apply(this, arguments);
        };
      }());
      const requestContents = yield TemplateLoader.loadZipFileContents(zip, 'request.json', true);
      const packageJsonObject = yield TemplateLoader.loadZipFileContents(zip, 'package.json', true, true);
      const templatizedGrammar = yield TemplateLoader.loadZipFileContents(zip, 'grammar/template.tem', false, true);
      Logger.debug(method, 'Looking for model files');
      let ctoFiles = yield TemplateLoader.loadZipFilesContents(zip, /models\/.*\.cto$/);
      ctoFiles.forEach(
      /*#__PURE__*/
      function () {
        var _ref3 = _asyncToGenerator(function* (file) {
          ctoModelFileNames.push(file.name);
          ctoModelFiles.push(file.contents);
        });

        return function (_x3) {
          return _ref3.apply(this, arguments);
        };
      }()); // create the template

      const template = new (Function.prototype.bind.call(Template, null, packageJsonObject, readmeContents, sampleTextFiles, requestContents))(); // add model files

      Logger.debug(method, 'Adding model files to model manager');
      template.getModelManager().addModelFiles(ctoModelFiles, ctoModelFileNames, true); // validation is disabled
      // load and add the ergo files

      if (template.getMetadata().getErgoVersion()) {
        Logger.debug(method, 'Adding Ergo files to script manager');
        const scriptFiles = yield TemplateLoader.loadZipFilesContents(zip, /lib\/.*\.ergo$/);
        scriptFiles.forEach(function (obj) {
          template.getTemplateLogic().addLogicFile(obj.contents, obj.name);
        });
      } // load and add compiled JS files - we assume all runtimes are JS based (review!)


      if (template.getMetadata().getRuntime()) {
        Logger.debug(method, 'Adding JS files to script manager');
        const scriptFiles = yield TemplateLoader.loadZipFilesContents(zip, /lib\/.*\.js$/);
        scriptFiles.forEach(function (obj) {
          template.getTemplateLogic().addLogicFile(obj.contents, obj.name);
        });
      } // check the integrity of the model and logic of the template


      template.validate();
      Logger.debug(method, 'Setting grammar');
      template.parserManager.buildGrammar(templatizedGrammar);
      return template; // Returns template
    })();
  }
  /**
   * Create a template from an URL.
   * @param {*} Template - the type to construct
   * @param {String} url  - the URL to a Cicero Template Archive (cta) file
   * @param {object} options - additional options
   * @return {Promise} a Promise to the template
   */


  static fromUrl(Template, url, options) {
    return _asyncToGenerator(function* () {
      const loader = new DefaultArchiveLoader();
      const buffer = yield loader.load(url, options);
      return TemplateLoader.fromArchive(Template, buffer);
    })();
  }
  /**
   * Builds a Template from the contents of a directory.
   * The directory must include a package.json in the root (used to specify
   * the name, version and description of the template).
   *
   * @param {*} Template - the type to construct
   * @param {String} path to a local directory
   * @param {Object} [options] - an optional set of options to configure the instance.
   * @return {Promise<Template>} a Promise to the instantiated template
   */


  static fromDirectory(Template, path, options) {
    return _asyncToGenerator(function* () {
      if (!options) {
        options = {};
      }

      const method = 'fromDirectory'; // grab the README.md

      const readmeContents = yield TemplateLoader.loadFileContents(path, 'README.md'); // grab the request.json

      const requestJsonObject = yield TemplateLoader.loadFileContents(path, 'request.json', true); // grab the package.json

      const packageJsonObject = yield TemplateLoader.loadFileContents(path, 'package.json', true, true); // grab the sample files

      Logger.debug(method, 'Looking for sample files');
      const sampleFiles = yield TemplateLoader.loadFilesContents(path, SAMPLE_FILE_REGEXP);
      const sampleTextFiles = {};
      sampleFiles.forEach(file => {
        const matches = file.name.match(SAMPLE_FILE_REGEXP);
        let locale = 'default'; // Match found

        if (matches !== null && matches[2]) {
          locale = matches[2];
        }

        Logger.debug(method, 'Using sample file locale', locale);
        sampleTextFiles[locale] = file.contents;
      }); // create the template

      const template = new (Function.prototype.bind.call(Template, null, packageJsonObject, readmeContents, sampleTextFiles, requestJsonObject))();
      const modelFiles = [];
      const modelFileNames = [];
      const ctoFiles = yield TemplateLoader.loadFilesContents(path, /models\/.*\.cto$/);
      ctoFiles.forEach(file => {
        modelFileNames.push(file.name);
        modelFiles.push(file.contents);
      });
      template.getModelManager().addModelFiles(modelFiles, modelFileNames, true);
      yield template.getModelManager().updateExternalModels();
      Logger.debug(method, 'Added model files', modelFiles.length); // load and add the ergo files

      if (template.getMetadata().getErgoVersion()) {
        const ergoFiles = yield TemplateLoader.loadFilesContents(path, /lib\/.*\.ergo$/);
        ergoFiles.forEach(file => {
          const resolvedPath = fsPath.resolve(path);
          const resolvedFilePath = fsPath.resolve(file.name);
          const truncatedPath = resolvedFilePath.replace(resolvedPath + '/', '');
          template.getTemplateLogic().addLogicFile(file.contents, truncatedPath);
        });
      } // load and add compiled JS files - we assume all runtimes are JS based (review!)


      if (template.getMetadata().getRuntime()) {
        const jsFiles = yield TemplateLoader.loadFilesContents(path, /lib\/.*\.js$/);
        jsFiles.forEach(file => {
          const resolvedPath = fsPath.resolve(path);
          const resolvedFilePath = fsPath.resolve(file.name);
          const truncatedPath = resolvedFilePath.replace(resolvedPath + '/', '');
          template.getTemplateLogic().addLogicFile(file.contents, truncatedPath);
        });
      } // check the template


      template.validate();
      let template_txt = yield TemplateLoader.loadFileContents(path, 'grammar/template.tem', false, true);
      template.parserManager.buildGrammar(template_txt);
      Logger.debug(method, 'Loaded template.tem', template_txt);
      return template;
    })();
  }

}

module.exports = TemplateLoader;