@accordproject/concerto-util 1.2.2-20211130213656

package/LICENSE

@@ -0,0 +1,11 @@
+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.

package/README.md

@@ -0,0 +1,13 @@
+# Concerto Core
+
+Main library for Concerto models, model manager, JSON instance validation and serialization.
+
+# Installation
+
+```
+npm install @accordproject/concerto-core --save
+```
+
+## License <a name="license"></a>
+Accord Project source code files are made available under the Apache License, Version 2.0 (Apache-2.0), located in the LICENSE file. Accord Project documentation files are made available under the Creative Commons Attribution 4.0 International License (CC-BY-4.0), available at http://creativecommons.org/licenses/by/4.0/.
+

package/changelog.txt

@@ -0,0 +1,109 @@
+#
+# 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.
+#
+# This is the changelog for Hyperledger Concerto. It lists all significant changes to
+# functionality and public API.
+#
+# The most recent entry in the changelog should be at the top of this file
+# and must follow the format: Version <number> {public api digest} <date>. The version
+# number must match that specified in package.json. The public api digest is computed
+# and validated using ./scripts/api-changelog.sh
+#
+# Any changes to the public API must have an associated changelog entry.
+#
+# Note that the latest public API is documented using JSDocs and is available in api.txt.
+#
+
+Version 1.2.2 {a17601f3c2c7e81f521c8779093b03fa} 2021-11-24
+- Remove custom instanceof and add methods to check runtime type
+- Remove support for Node 12
+- Generate Typescript definitions from JSDoc
+- Parser directly constructs metamodel instance
+- Convert MetaModel to a class for Typescript + Webpack compatability
+- Update Acorn to latest and refactor the JavaScript parser so we can use static class members
+
+Version 1.2.2 {b19318bb094e5da7bdff192cf9a3b4f2} 2021-08-12
+- Fixes to metamodel, including terminology changes
+- Ability to roundtrip model manager to metamodel
+- Expose name resolution to MetaModel API
+
+Version 1.1.2 {2c9512d9d90bde289b47942937d252ca} 2021-08-12
+- Add Factory.newId for creating new unique IDs
+
+Version 1.1.0 {16fb2d5684ec917532a19428c74f1ebf} 2021-07-13
+- Add support for Concerto metamodel with import/export to CTO
+
+Version 1.0.3 {1fe469fe1a79af5d5a4f5ec7dee6b7d4} 2021-06-25
+- Aligns JSDoc and the TypeScript interface
+
+Version 1.0.0-alpha.8 {08b0c809336354e7d1b17a2e44fca8b0} 2021-04-22
+- Add datetimeutil & Consolidate UTC offset support
+- Delete Concerto.instanceOf replace by ModelManager.derivesFrom
+
+Version 1.0.0-alpha.7 {aec0f0d4e25be4dab03d6b94be60767b} 2021-04-17
+- Remove unused systemtime options in modelfile API
+- Fixes to the validation option targeting the ergo ES6 runtime
+
+Version 1.0.0-alpha.5 {446997953e3ac90783ff9d492a8e7fdc} 2021-04-08
+- Support Concerto version pragma at the beginning of model files
+- Remove allowEmptyId option in factory API
+
+Version 1.0.0-alpha.4 {3b7ebc06a536a5e81624225c7b0079ee} 2021-04-08
+- Allow optional UTC offset for validating DateTime values
+
+Version 1.0.0-alpha.3 {7b8763c243f937d84579350aef348c3c} 2020-12-25
+- Concepts may now be identified
+- assets/participants have a system identifier created ($identifier) automatically
+- /transaction/events have a system timestamp created ($timestamp) automatically
+- Can no longer redefine the identifier declared by a super type
+- 'concerto' namespace is now reserved and cannot be used by user code
+- All types extend concerto.Concept
+- Removed System Models APIs
+- Remove notion of system table
+- Remove user ability to change system model
+- Update JsDoc for ModelManager.addModelFiles
+- Add Logger API
+- Add instanceof alternatives to Factory and Serializer
+- Add new Concerto API (experimental)
+
+Version 0.82.9 {c96bafdd4a2bb7402f6b520a0cefe537} 2020-09-09
+- Add option parameters to ModelLoader
+
+Version 0.82.6 {03fa6481ffdf0e58cb110c6f24009d18} 2020-02-26
+- Update JsDoc for ModelManager.addModelFiles
+
+Version 0.82.1 {dee013e99a3c2d6acc4eddfb00aad2a2} 2019-10-22
+- Make several constructors public
+- Add model loader utility class
+
+Version 0.80.3 {6f5a9ab45943cb76732c14b11f47d044} 2019-08-24
+- Add Ergo option to serializer
+
+Version 0.80.1 {297c88d29ce911ec6efc0f28ceeeb660} 2019-08-24
+- Adds getModels and writeModelsToFileSystem functions to ModelManager
+- Fixes API generation for hasSymbol function
+
+Version 0.71.7 {2b5649f2b8f13d52241959f613cbfdd7} 2019-07-29
+- Add static hasInstance as alternative instanceof implementation for AssetDeclaration, ClassDeclaration, EnumDeclaration, ConceptDeclaration, EnumValueDeclaration, Field, ModelFile, ModelManager, RelationshipDeclaration, TransactionDeclaration
+
+Version 0.70.5 {db48b7eb8404d9206e9bc8efb3de0009} 2019-06-23
+- Update exception triggered when creating EventDeclaration class
+
+Version 0.31.0 {82c0c10648bd10fb79b84db3fcda1776} 2018-10-03
+- Remove built-in system model file
+
+Version 0.30.1 {fd4b813bc0bda4042db3c4657893593f} 2018-10-03
+- Remove Wallet
+
+Version 0.30.0 {785896a0c4c91e70dcbbfcc5bab33938} 2018-10-02
+- Refactor to make model manager its own module

package/index.js

@@ -0,0 +1,40 @@
+/*
+ * 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';
+
+/**
+ * Concerto module. Concerto is a framework for defining domain
+ * specific models.
+ *
+ * @module concerto-util
+ */
+
+// Transitive closure downloader
+module.exports.FileDownloader = require('./lib/filedownloader');
+
+// File Loaders
+module.exports.CompositeFileLoader = require('./lib/loaders/compositefileloader');
+module.exports.DefaultFileLoader = require('./lib/loaders/defaultfileloader');
+module.exports.GitHubFileLoader = require('./lib/loaders/githubfileloader');
+module.exports.HTTPFileLoader = require('./lib/loaders/httpfileloader');
+
+// Writers
+module.exports.Writer = require('./lib/writer');
+
+// Logger
+module.exports.Logger = require('./lib/logger');
+
+// TypedStack
+module.exports.TypedStack = require('./lib/typedstack');

package/lib/filedownloader.js

@@ -0,0 +1,135 @@
+/*
+ * 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';
+
+const debug = require('debug')('concerto:FileDownloader');
+const PromisePool = require('@supercharge/promise-pool');
+
+const flatten = arr => [].concat(...arr);
+const filterUndefined = arr => arr.filter(Boolean);
+
+const handleJobError = async (error, job) => {
+    const badHttpResponse = error.response && error.response.status && error.response.status !== 200;
+    const dnsFailure = error.code && error.code === 'ENOTFOUND';
+    if(badHttpResponse || dnsFailure){
+        const err = new Error(`Unable to download external model dependency '${job.url}'`);
+        err.code = 'MISSING_DEPENDENCY';
+        throw err;
+    }
+    throw new Error('Failed to load model file. Job: ' + job.url + ' Details: ' + error);
+};
+
+/**
+ * Downloads the transitive closure of a set of model files.
+ * @class
+ * @memberof module:concerto-core
+ */
+class FileDownloader {
+    /**
+     * Create a FileDownloader and bind to a FileLoader.
+     * @param {fileLoader} fileLoader - the loader to use to download model files
+     * @param {*} getExternalImports - a function taking a file and returning new files
+     * @param {Number} concurrency - the number of model files to download concurrently
+     */
+    constructor(fileLoader, getExternalImports, concurrency = 10) {
+        this.fileLoader = fileLoader;
+        this.concurrency = concurrency;
+        this.getExternalImports = getExternalImports;
+    }
+
+    /**
+     * Download all external dependencies for an array of model files
+     * @param {File[]} files - the model files
+     * @param {Object} [options] - Options object passed to FileLoaders
+     * @return {Promise} a promise that resolves to Files[] for the external model files
+     */
+    downloadExternalDependencies(files, options) {
+        const method = 'downloadExternalDependencies';
+        debug(method);
+
+        const downloadedUris = new Set();
+
+        if (!options) {
+            options = {};
+        }
+
+        const jobs = flatten(files.map(file => {
+            const externalImports = this.getExternalImports(file);
+            return Object.keys(externalImports).map(importDeclaration => ({
+                downloadedUris: downloadedUris,
+                url: externalImports[importDeclaration],
+                options: options
+            }));
+        }));
+
+        return PromisePool
+            .withConcurrency(this.concurrency)
+            .for(jobs)
+            .handleError(handleJobError)
+            .process(x => this.runJob(x, this.fileLoader))
+            .then(({ results }) => filterUndefined(flatten(results)));
+    }
+
+    /**
+     * Execute a Job
+     * @param {Object} job - the job to execute
+     * @param {Object} fileLoader - the loader to use to download model files.
+     * @return {Promise} a promise to the job results
+     */
+    runJob(job, fileLoader) {
+        const downloadedUris = job.downloadedUris;
+        const options = job.options;
+        const url = job.url;
+
+        // cache the URI, so we don't download it again
+        downloadedUris.add(url);
+
+        debug('runJob', 'Loading', url);
+        return fileLoader.load(url, options).
+            then(async file => {
+                debug('runJob', 'Loaded', url, );
+
+                // get the external imports
+                const externalImports = this.getExternalImports(file);
+                const importedUris = Array.from(
+                    new Set(
+                        Object.keys(externalImports)
+                            .map((importDeclaration) => externalImports[importDeclaration])
+                    )
+                );
+                debug('runJob', 'importedUris', importedUris);
+
+                const externalImportsFiles = await PromisePool
+                    .withConcurrency(this.concurrency)
+                    .for(importedUris)
+                    .handleError(handleJobError)
+                    .process(uri => {
+                        if (!downloadedUris.has(uri)) {
+                            // recurse and add a new job for the referenced URI
+                            return this.runJob({
+                                options: options,
+                                url: uri,
+                                downloadedUris: downloadedUris
+                            }, fileLoader);
+                        }
+                    })
+                    .then(({ results }) => filterUndefined(flatten(results)));
+
+                return externalImportsFiles.concat([file]);
+            });
+    }
+}
+
+module.exports = FileDownloader;

package/lib/loaders/compositefileloader.js

@@ -0,0 +1,95 @@
+/*
+ * 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';
+
+/**
+ * <p>
+ * Manages a set of model file loaders, delegating to the first model file
+ * loader that accepts a URL.
+ * </p>
+ * @private
+ * @class
+ * @memberof module:concerto-util
+ */
+class CompositeFileLoader {
+    /**
+     * Create the CompositeFileLoader. Used to delegate to a set of FileLoaders.
+     */
+    constructor() {
+        this.fileLoaders = [];
+    }
+
+    /**
+     * Adds a FileLoader implemenetation to the FileLoader
+     * @param {FileLoader} fileLoader - The script to add to the ScriptManager
+     */
+    addFileLoader(fileLoader) {
+        this.fileLoaders.push(fileLoader);
+    }
+
+    /**
+     * Get the array of FileLoader instances
+     * @return {FileLoaders[]} The FileLoader registered
+     * @private
+     */
+    getFileLoaders() {
+        return this.fileLoaders;
+    }
+
+    /**
+     * Remove all registered FileLoaders
+     */
+    clearFileLoaders() {
+        this.fileLoaders = [];
+    }
+
+    /**
+     * Returns true if this ModelLoader can process the URL
+     * @param {string} url - the URL
+     * @return {boolean} true if this ModelLoader accepts the URL
+     * @abstract
+     */
+    accepts(url) {
+        for (let n = 0; n < this.fileLoaders.length; n++) {
+            const ml = this.fileLoaders[n];
+
+            if (ml.accepts(url)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Load a File from a URL and return it
+     * @param {string} url - the url to get
+     * @param {object} options - additional options
+     * @return {Promise} a promise to the File
+     */
+    load(url, options) {
+        for (let n = 0; n < this.fileLoaders.length; n++) {
+            const ml = this.fileLoaders[n];
+
+            if (ml.accepts(url)) {
+                return ml.load(url, options);
+            }
+        }
+
+        throw new Error('Failed to find a model file loader that can handle: ' + url);
+    }
+}
+
+module.exports = CompositeFileLoader;

package/lib/loaders/defaultfileloader.js

@@ -0,0 +1,45 @@
+/*
+ * 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';
+
+const CompositeFileLoader = require('./compositefileloader');
+const HTTPFileLoader = require('./httpfileloader');
+const GitHubFileLoader = require('./githubfileloader');
+
+/**
+ * <p>
+ * A default CompositeFileLoader implementation which supports
+ * github://, http:// and https:// URLs.
+ * </p>
+ * @private
+ * @class
+ * @see See {@link CompositeFileLoader}
+ * @memberof module:concerto-util
+ */
+class DefaultFileLoader extends CompositeFileLoader {
+    /**
+     * Create the DefaultFileLoader.
+     * @param {*} processFile - a function to apply to the content of the file
+     */
+    constructor(processFile) {
+        super();
+        const http = new HTTPFileLoader(processFile);
+        const github = new GitHubFileLoader(processFile);
+        this.addFileLoader(github);
+        this.addFileLoader(http);
+    }
+}
+
+module.exports = DefaultFileLoader;

package/lib/loaders/githubfileloader.js

@@ -0,0 +1,58 @@
+/*
+ * 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';
+
+const HTTPFileLoader = require('./httpfileloader');
+
+/**
+ * Loads Files from an external source, such as a URL.
+ *
+ * @class
+ * @private
+ * @memberof module:concerto-util
+ */
+class GitHubFileLoader extends HTTPFileLoader {
+    /**
+     * Create the GitHubFileLoader.
+     * @param {*} processFile - a function to apply to the content of the file
+     */
+    constructor(processFile) {
+        super(processFile);
+    }
+
+    /**
+     * Returns true if this ModelLoader can process the URL
+     * @param {string} url - the URL
+     * @return {boolean} true if this ModelLoader accepts the URL
+     * @abstract
+     */
+    accepts(url) {
+        return url.startsWith('github://');
+    }
+
+    /**
+     * Load a File from a URL and return it
+     * @param {string} url - the url to get
+     * @param {object} options - additional options
+     * @return {Promise} a promise to the File
+     */
+    load(url, options) {
+        const rewrittenUrl = 'https://raw.githubusercontent.com/' + url.substring(9);
+        const result = super.load(rewrittenUrl, options);
+        return result;
+    }
+}
+
+module.exports = GitHubFileLoader;

package/lib/loaders/httpfileloader.js

@@ -0,0 +1,73 @@
+/*
+ * 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';
+
+const axios = require('axios');
+const url = require('url');
+
+/**
+ * Loads Files from an HTTP(S) URL using the axios library.
+ * @class
+ * @private
+ * @memberof module:concerto-util
+ */
+class HTTPFileLoader {
+    /**
+     * Create the HTTPFileLoader.
+     * @param {*} processFile - a function to apply to the content of the file
+     */
+    constructor(processFile) {
+        this.processFile = processFile;
+    }
+
+    /**
+     * Returns true if this ModelLoader can process the URL
+     * @param {string} url - the URL
+     * @return {boolean} true if this ModelLoader accepts the URL
+     * @abstract
+     */
+    accepts(url) {
+        return url.startsWith('http://') || url.startsWith('https://');
+    }
+
+    /**
+     * Load a File from a URL and return it
+     * @param {string} requestUrl - the url to get
+     * @param {object} options - additional options
+     * @return {Promise} a promise to the File
+     */
+    load(requestUrl, options) {
+
+        if(!options) {
+            options = {};
+        }
+
+        const request = JSON.parse(JSON.stringify(options));
+        request.url = requestUrl;
+        request.method = 'get';
+        request.responseType = 'text';
+
+        return axios(request)
+            .then((response) => {
+                let parsedUrl = url.parse(requestUrl);
+                // external Files have a name that starts with '@'
+                // (so that they are identified as external when an archive is read back in)
+                const name = '@' + (parsedUrl.host + parsedUrl.pathname).replace(/\//g, '.');
+                return this.processFile(name, response.data);
+            });
+    }
+}
+
+module.exports = HTTPFileLoader;

package/lib/logger.js

@@ -0,0 +1,250 @@
+/*
+ * 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';
+
+/* eslint-disable no-console */
+/* eslint-disable no-use-before-define */
+
+const colors = require('colors/safe');
+const jsonColorize = require('json-colorizer');
+
+/**
+ * Default levels for the npm configuration.
+ * @type {Object}
+ */
+const levels = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    http: 3,
+    verbose: 4,
+    debug: 5,
+    silly: 6
+};
+
+/**
+ * Default levels for the npm configuration.
+ * @type {Object}
+ */
+const colorMap = {
+    error: 'red',
+    warn: 'yellow',
+    info: 'green',
+    verbose: 'cyan',
+    debug: 'blue',
+    silly: 'magenta'
+};
+
+const timestamp = () => (new Date()).toLocaleTimeString();
+const colorize = level => colors[colorMap[level]](level.toUpperCase());
+
+/**
+* Helper function to test if a string is a stringified version of a JSON object
+* @param {string} str - the input string to test
+* @returns {boolean} - true iff the string can be parsed as JSON
+* @private
+*/
+const isJson = (str) => {
+    try {
+        return (JSON.parse(str) && !!str);
+    } catch (e) {
+        return false;
+    }
+};
+
+/**
+* Helper function to color and format JSON objects
+* @param {any} obj - the input obj to prettify
+* @returns {any} - the prettified object
+* @private
+*/
+const prettifyJson = (obj) => {
+    if(typeof obj === 'object' || isJson(obj)) {
+        return jsonColorize(obj, { pretty: true, colors });
+    }
+    return obj;
+};
+
+/**
+* The default transport for logging at multiple levels to the console
+* @param {string} level - the required log level. e.g. error, warn, info, debug, etc.
+* @param {any} obj - the input obj to prettify
+* @returns {void} -
+* @private
+*/
+const defaultTransportShim = (level, ...args) => {
+    let mutatedLevel = level;
+    let data = args;
+    let first = data.shift();
+
+    // Flatten log object
+    if(first && typeof first === 'object' && first.level && first.message){
+        const padding = first.padding && first.padding[first.level];
+        if (first.level === 'error' && first.stack) {
+            mutatedLevel = 'error';
+            first = `${first.message}\n${first.stack}`;
+        } else if (Object.keys(levels).includes(first.level)) {
+            mutatedLevel = first.level;
+            first = first.message;
+        }
+        first = padding ? `${padding} ${first}` : first;
+    }
+
+    data.unshift(first);
+
+    const stream = ['error', 'warn'].includes(mutatedLevel) ? console.error : console.log;
+
+    stream(
+        `${timestamp()} - ${colorize(mutatedLevel)}:`,
+        ...data
+            .map(obj => obj instanceof Error ? `${obj.message}\n${obj.stack}`: obj)
+            .map(prettifyJson)
+    );
+};
+const defaultTransport = {};
+Object.keys(levels).forEach(level => {
+    defaultTransport[level] = (...args) => defaultTransportShim(level, ...args);
+});
+
+/**
+ * A utility class with static function that print to the console
+ * @private
+ */
+class Logger {
+    /**
+    * A reusable function for logging at multiple levels
+    * @param {string} level - the required log level. e.g. error, warn, info, debug, etc.
+    * @param {any} obj - the input obj to prettify
+    * @returns {void} -
+    * @private
+    */
+    static dispatch(level, ...args) {
+        if (levels[level] > levels[this.level]){
+            return;
+        }
+
+        this.transports.forEach(t => {
+            if(t[level]){
+                t[level](...args);
+            }
+        });
+    }
+
+    /**
+    * Add a custom transport for logging
+    * @param {Object} transport - The transport object should have function for the usual logging operations e.g. error, warn, info, debug, etc.
+    * @returns {void} -
+    * @private
+    */
+    static add(transport) {
+        this.transports.push(transport);
+    }
+
+    /**
+     * Write an error statement to the console.
+     *
+     * Prints to `stderr` with newline.
+     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
+     * @param {any} args -
+     * @returns {void} -
+     * @private
+     */
+    static error(...args){ return this.dispatch('error', ...args); }
+
+    /**
+     * Write a warning statement to the console.
+     *
+     * Prints to `stderr` with newline.
+     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
+     * @param {any} args -
+     * @returns {void} -
+     * @private
+     */
+    static warn(...args){ return this.dispatch('warn', ...args); }
+
+    /**
+     * Write an info statement to the console.
+     *
+     * Prints to `stdout` with newline.
+     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
+     * @param {any} args -
+     * @returns {void} -
+     * @private
+     */
+    static info(...args){ return this.dispatch('info', ...args); }
+
+    /**
+     * Write an info statement to the console. Alias for `logger.log`
+     *
+     * Prints to `stdout` with newline.
+     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
+     * @param {any} args -
+     * @returns {void} -
+     * @private
+     */
+    static log(...args){ return this.info(...args); }
+
+    /**
+     * Write an http statement to the console.
+     *
+     * Prints to `stdout` with newline.
+     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
+     * @param {any} args -
+     * @returns {void} -
+     * @private
+     */
+    static http(...args){ return this.dispatch('http', ...args); }
+
+    /**
+     * Write a verbose log statement to the console.
+     *
+     * Prints to `stdout` with newline.
+     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
+     * @param {any} args -
+     * @returns {void} -
+     * @private
+     */
+    static verbose(...args){ return this.dispatch('verbose', ...args); }
+
+    /**
+     * Write a debug statement to the console.
+     *
+     * Prints to `stdout` with newline.
+     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
+     * @param {any} args -
+     * @returns {void} -
+     * @private
+     */
+    static debug(...args){ return this.dispatch('debug', ...args); }
+
+    /**
+     * Write a silly level statement to the console.
+     *
+     * Prints to `stdout` with newline.
+     * @param {any|object} data - if this is an object with properties `level` and `message` it will be flattened first
+     * @param {any} args -
+     * @returns {void} -
+     * @private
+     */
+    static silly(...args){ return this.dispatch('silly', ...args); }
+}
+
+// Set the default logging level
+Logger.level = 'info';
+
+// A list of user-provided logging tranports
+Logger.transports = [ defaultTransport ];
+
+module.exports = Logger;

package/lib/typedstack.js

@@ -0,0 +1,88 @@
+/*
+ * 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';
+
+/**
+ * Tracks a stack of typed instances. The type information is used to detect
+ * overflow / underflow bugs by the caller. It also performs basic sanity
+ * checking on push/pop to make detecting bugs easier.
+ * @class
+ * @memberof module:concerto-core
+ */
+class TypedStack {
+
+    /**
+   * Create the Stack with the resource at the head.
+   * @param {Object} resource - the resource to be put at the head of the stack
+   */
+    constructor(resource) {
+        this.stack = [];
+        this.push(resource);
+    }
+
+    /**
+     * Push a new object.
+     * @param {Object} obj - the object being visited
+     * @param {Object} expectedType - the expected type of the object being pushed
+     */
+    push(obj, expectedType) {
+        if(expectedType && !(obj instanceof expectedType)) {
+            throw new Error('Did not find expected type ' + expectedType.constructor.name + ' as argument to push. Found: ' + obj.toString());
+        }
+
+        this.stack.push(obj);
+        //console.log('Push depth is: ' + this.stack.length + ', contents: ' + this.stack.toString() );
+    }
+
+    /**
+     * Push a new object.
+     * @param {Object} expectedType - the type that should be the result of pop
+     * @return {Object} the result of pop
+     */
+    pop(expectedType) {
+        this.peek(expectedType);
+        return this.stack.pop();
+    }
+
+    /**
+     * Peek the top of the stack
+     * @param {Object} expectedType - the type that should be the result of pop
+     * @return {Object} the result of peek
+     */
+    peek(expectedType) {
+
+        //console.log( 'pop ' );
+
+        if(this.stack.length < 1) {
+            throw new Error('Stack is empty!');
+        }
+
+        const result = this.stack[this.stack.length-1];
+        if(expectedType && !(result instanceof expectedType)) {
+            throw new Error('Did not find expected type ' + expectedType + ' on head of stack. Found: ' + result);
+        }
+
+        return result;
+    }
+
+    /**
+     * Clears the stack
+     */
+    clear() {
+        this.stack = [];
+    }
+}
+
+module.exports = TypedStack;

package/lib/writer.js

@@ -0,0 +1,116 @@
+/*
+ * 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';
+
+/**
+ * Writer buffers text to be written in memory. It handles simple
+ * indentation and tracks the number of lines written.
+ * @private
+ * @class
+ * @memberof module:concerto-util
+ */
+class Writer {
+    /**
+     * Create a Writer.
+     */
+    constructor() {
+        this.beforeBuffer = '';
+        this.buffer = '';
+        this.linesWritten = 0;
+    }
+
+    /**
+     * Writes text to the start of the buffer
+     * @param {int} tabs - the number of tabs to use
+     * @param {string} text - the text to write
+     */
+    writeBeforeLine(tabs, text) {
+        for(let n=0; n < tabs; n++) {
+            this.beforeBuffer += '   ';
+        }
+        this.beforeBuffer += text;
+        this.beforeBuffer += '\n';
+        this.linesWritten++;
+    }
+
+    /**
+     * Append text to the buffer
+     * @param {int} tabs - the number of tabs to use
+     * @param {string} text - the text to write
+     */
+    writeLine(tabs, text) {
+        for(let n=0; n < tabs; n++) {
+            this.write('   ');
+        }
+        this.write(text);
+        this.write('\n');
+        this.linesWritten++;
+    }
+
+    /**
+     * Returns the number of lines that have been written to the buffer.
+     * @return {int} the number of lines written to the buffer.
+     */
+    getLineCount() {
+        return this.linesWritten;
+    }
+
+
+    /**
+     * Append text to the buffer, prepending tabs
+     * @param {int} tabs - the number of tabs to use
+     * @param {string} text - the text to write
+     */
+    writeIndented(tabs,text) {
+        for(let n=0; n < tabs; n++) {
+            this.write('   ');
+        }
+        this.write(text);
+    }
+
+    /**
+     * Append text to the buffer (no automatic newline). The
+     * text may contain newline, and these will increment the linesWritten
+     * counter.
+     * @param {string} msg - the text to write
+     */
+    write(msg) {
+        if(typeof msg !== 'string' ) {
+            throw new Error('Can only append strings. Argument ' + msg + ' has type ' + typeof msg);
+        }
+
+        this.buffer += msg;
+        this.linesWritten += msg.split(/\r\n|\r|\n/).length;
+    }
+
+    /**
+     * Returns the text that has been buffered in this Writer.
+     * @return {string} the buffered text.
+     */
+    getBuffer() {
+        return this.beforeBuffer + this.buffer;
+    }
+
+    /**
+     * Empties the underyling buffer and resets the line count.
+     */
+    clearBuffer() {
+        this.beforeBuffer = '';
+        this.buffer = '';
+        this.linesWritten = 0;
+    }
+}
+
+module.exports = Writer;

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "@accordproject/concerto-util",
+  "version": "1.2.2-20211130213656",
+  "description": "Utilities for Concerto Modeling Language",
+  "homepage": "https://github.com/accordproject/concerto",
+  "engines": {
+    "node": ">=12",
+    "npm": ">=6"
+  },
+  "main": "index.js",
+  "scripts": {
+    "pretest": "npm run lint",
+    "lint": "eslint .",
+    "postlint": "npm run licchk",
+    "licchk": "license-check-and-add",
+    "postlicchk": "npm run doc",
+    "doc": "jsdoc --pedantic --recurse -c jsdoc.json",
+    "test": "nyc mocha --recursive -t 10000",
+    "test:watch": "nyc mocha --watch --recursive -t 10000",
+    "mocha": "mocha --recursive -t 10000",
+    "nyc": "nyc mocha --recursive -t 10000"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/accordproject/concerto.git",
+    "directory": "packages/concerto-util"
+  },
+  "keywords": [
+    "blockchain",
+    "hyperledger",
+    "solutions"
+  ],
+  "author": "accordproject.org",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "chai": "4.3.4",
+    "chai-as-promised": "7.1.1",
+    "chai-things": "0.2.0",
+    "eslint": "8.2.0",
+    "jsdoc": "^3.6.7",
+    "license-check-and-add": "2.3.6",
+    "mocha": "8.3.2",
+    "moxios": "0.4.0",
+    "nyc": "15.1.0",
+    "sinon": "10.0.0",
+    "sinon-chai": "3.6.0"
+  },
+  "dependencies": {
+    "@supercharge/promise-pool": "1.7.0",
+    "axios": "0.23.0",
+    "colors": "1.4.0",
+    "debug": "4.3.1",
+    "json-colorizer": "2.2.2"
+  },
+  "browserslist": "> 0.25%, not dead",
+  "license-check-and-add-config": {
+    "folder": "./lib",
+    "license": "HEADER",
+    "exact_paths_method": "EXCLUDE",
+    "exact_paths": [
+      "api.txt",
+      "composer-logs",
+      "coverage",
+      "./parser.js",
+      "LICENSE",
+      "node_modules",
+      ".nyc-output",
+      "out",
+      ".tern-project"
+    ],
+    "file_type_method": "EXCLUDE",
+    "file_types": [
+      ".yml",
+      ".yaml",
+      ".zip",
+      ".tgz"
+    ],
+    "insert_license": false,
+    "license_formats": {
+      "js|njk|pegjs|cto|acl|qry": {
+        "prepend": "/*",
+        "append": " */",
+        "eachLine": {
+          "prepend": " * "
+        }
+      },
+      "npmrc|editorconfig|txt": {
+        "eachLine": {
+          "prepend": "# "
+        }
+      },
+      "md": {
+        "file": "HEADER.md"
+      }
+    }
+  },
+  "nyc": {
+    "produce-source-map": "true",
+    "sourceMap": "inline",
+    "reporter": [
+      "lcov",
+      "text-summary",
+      "html",
+      "json"
+    ],
+    "include": [
+      "lib/**/*.js"
+    ],
+    "exclude": [
+      "lib/parser.js"
+    ],
+    "all": true,
+    "check-coverage": true,
+    "statements": 99,
+    "branches": 93,
+    "functions": 98,
+    "lines": 99
+  }
+}