Concerto Release 1.0

package.json

@@ -1,7 +1,8 @@
 {
   "private": true,
   "devDependencies": {
-    "colors": "^1.4.0",
+    "colors": "1.4.0",
+    "eslint": "6.0.1",
     "coveralls": "3.0.4",
     "eslint": "6.0.1",
     "istanbul-combine": "0.3.0",
@@ -94,4 +95,4 @@
       }
     }
   }
-}
+}

packages/concerto-cli/index.js

@@ -29,10 +29,6 @@ require('yargs')
             describe: 'sample JSON to validate',
             type: 'string'
         });
-        yargs.option('ctoSystem', {
-            describe: 'system model to be used',
-            type: 'string'
-        });
         yargs.option('ctoFiles', {
             describe: 'array of CTO files',
             type: 'string',
@@ -52,7 +48,7 @@ require('yargs')
             argv = Commands.validateValidateArgs(argv);
             const options = {};
             options.offline = argv.offline;
-            return Commands.validate(argv.sample, argv.ctoSystem, argv.ctoFiles, options)
+            return Commands.validate(argv.sample, argv.ctoFiles, options)
                 .then((result) => {
                     Logger.info(result);
                 })
@@ -66,10 +62,6 @@ require('yargs')
     })
     .command('compile', 'generate code for a target platform', (yargs) => {
         yargs.demandOption(['ctoFiles'], 'Please provide at least the CTO files');
-        yargs.option('ctoSystem', {
-            describe: 'system model to be used',
-            type: 'string'
-        });
         yargs.option('ctoFiles', {
             describe: 'array of CTO files',
             type: 'string',
@@ -97,7 +89,7 @@ require('yargs')
 
         const options = {};
         options.offline = argv.offline;
-        return Commands.compile(argv.target, argv.ctoSystem, argv.ctoFiles, argv.output, options)
+        return Commands.compile(argv.target, argv.ctoFiles, argv.output, options)
             .then((result) => {
                 Logger.info(result);
             })
@@ -112,10 +104,6 @@ require('yargs')
             type: 'string',
             array: true
         });
-        yargs.option('ctoSystem', {
-            describe: 'system model to be used',
-            type: 'string'
-        });
         yargs.option('output', {
             describe: 'output directory path',
             type: 'string',
@@ -126,7 +114,7 @@ require('yargs')
             Logger.info(`saving external models from ${argv.ctoFiles} into directory: ${argv.output}`);
         }
 
-        return Commands.get(argv.ctoSystem, argv.ctoFiles, argv.output)
+        return Commands.get(argv.ctoFiles, argv.output)
             .then((result) => {
                 Logger.info(result);
             })

packages/concerto-cli/lib/commands.js

@@ -97,16 +97,15 @@ class Commands {
      * Validate a sample JSON against the model
      *
      * @param {string} sample - the sample to validate
-     * @param {string} ctoSystemFile - the system model file
      * @param {string[]} ctoFiles - the CTO files to convert to code
      * @param {object} options - optional parameters
      * @param {boolean} [options.offline] - do not resolve external models
      * @returns {string} serialized form of the validated JSON
      */
-    static async validate(sample, ctoSystemFile, ctoFiles, options) {
+    static async validate(sample, ctoFiles, options) {
         const json = JSON.parse(fs.readFileSync(sample, 'utf8'));
 
-        const modelManager = await ModelLoader.loadModelManager(ctoSystemFile, ctoFiles, options);
+        const modelManager = await ModelLoader.loadModelManager(ctoFiles, options);
         const factory = new Factory(modelManager);
         const serializer = new Serializer(factory, modelManager);
 
@@ -118,14 +117,13 @@ class Commands {
      * Compile the model for a given target
      *
      * @param {string} target - the target of the code to compile
-     * @param {string} ctoSystemFile - the system model file
      * @param {string[]} ctoFiles - the CTO files to convert to code
      * @param {string} output the output directory
      * @param {object} options - optional parameters
      * @param {boolean} [options.offline] - do not resolve external models
      */
-    static async compile(target, ctoSystemFile, ctoFiles, output, options) {
-        const modelManager = await ModelLoader.loadModelManager(ctoSystemFile, ctoFiles, options);
+    static async compile(target, ctoFiles, output, options) {
+        const modelManager = await ModelLoader.loadModelManager(ctoFiles, options);
 
         let visitor = null;
 
@@ -165,12 +163,11 @@ class Commands {
      * Fetches all external for a set of models dependencies and
      * saves all the models to a target directory
      *
-     * @param {string} ctoSystemFile the system model
      * @param {string[]} ctoFiles the CTO files (can be local file paths or URLs)
      * @param {string} output the output directory
      */
-    static async get(ctoSystemFile, ctoFiles, output) {
-        const modelManager = await ModelLoader.loadModelManager(ctoSystemFile, ctoFiles);
+    static async get(ctoFiles, output) {
+        const modelManager = await ModelLoader.loadModelManager(ctoFiles);
         mkdirp.sync(output);
         modelManager.writeModelsToFileSystem(output);
         return `Loaded external models in '${output}'.`;

packages/concerto-cli/test/cli.js

@@ -28,7 +28,6 @@ const Commands = require('../lib/commands');
 describe('cicero-cli', () => {
     const models = [path.resolve(__dirname, 'models/dom.cto'),path.resolve(__dirname, 'models/money.cto')];
     const offlineModels = [path.resolve(__dirname, 'models/contract.cto'),path.resolve(__dirname, 'models/dom.cto'),path.resolve(__dirname, 'models/money.cto')];
-    const hlModel = path.resolve(__dirname, 'models/org.hyperledger.composer.system.cto');
     const sample1 = path.resolve(__dirname, 'data/sample1.json');
     const sample2 = path.resolve(__dirname, 'data/sample2.json');
     const sampleText1 = fs.readFileSync(sample1, 'utf8');
@@ -55,30 +54,30 @@ describe('cicero-cli', () => {
 
     describe('#validate', () => {
         it('should validate against a model', async () => {
-            const result = await Commands.validate(sample1, null, models, {offline:false});
+            const result = await Commands.validate(sample1, models, {offline:false});
             JSON.parse(result).should.deep.equal(JSON.parse(sampleText1));
         });
 
         it('should fail to validate against a model', async () => {
             try {
-                const result = await Commands.validate(sample2, null, models, {offline:false});
+                const result = await Commands.validate(sample2, models, {offline:false});
                 JSON.parse(result).should.deep.equal(JSON.parse(sampleText2));
             } catch (err) {
-                err.message.should.equal('Instance undefined invalid enum value true for field CurrencyCode');
+                err.message.should.equal('Instance org.accordproject.money.MonetaryAmount#null invalid enum value true for field CurrencyCode');
             }
         });
 
         it('should validate against a model (offline)', async () => {
-            const result = await Commands.validate(sample1, null, offlineModels, {offline:true});
+            const result = await Commands.validate(sample1, offlineModels, {offline:true});
             JSON.parse(result).should.deep.equal(JSON.parse(sampleText1));
         });
 
         it('should fail to validate against a model (offline)', async () => {
             try {
-                const result = await Commands.validate(sample2, null, offlineModels, {offline:true});
+                const result = await Commands.validate(sample2, offlineModels, {offline:true});
                 JSON.parse(result).should.deep.equal(JSON.parse(sampleText2));
             } catch (err) {
-                err.message.should.equal('Instance undefined invalid enum value true for field CurrencyCode');
+                err.message.should.equal('Instance org.accordproject.money.MonetaryAmount#null invalid enum value true for field CurrencyCode');
             }
         });
 
@@ -111,43 +110,43 @@ describe('cicero-cli', () => {
 
         it('should compile to a Go model', async () => {
             const dir = await tmp.dir({ unsafeCleanup: true});
-            await Commands.compile('Go', null, models, dir.path, {offline:false});
+            await Commands.compile('Go', models, dir.path, {offline:false});
             fs.readdirSync(dir.path).length.should.be.above(0);
             dir.cleanup();
         });
         it('should compile to a PlantUML model', async () => {
             const dir = await tmp.dir({ unsafeCleanup: true});
-            await Commands.compile('PlantUML', null, models, dir.path, {offline:false});
+            await Commands.compile('PlantUML', models, dir.path, {offline:false});
             fs.readdirSync(dir.path).length.should.be.above(0);
             dir.cleanup();
         });
         it('should compile to a Typescript model', async () => {
             const dir = await tmp.dir({ unsafeCleanup: true});
-            await Commands.compile('Typescript', null, models, dir.path, {offline:false});
+            await Commands.compile('Typescript', models, dir.path, {offline:false});
             fs.readdirSync(dir.path).length.should.be.above(0);
             dir.cleanup();
         });
         it('should compile to a Java model', async () => {
             const dir = await tmp.dir({ unsafeCleanup: true});
-            await Commands.compile('Java', null, models, dir.path);
+            await Commands.compile('Java', models, dir.path);
             fs.readdirSync(dir.path).length.should.be.above(0);
             dir.cleanup();
         });
         it('should compile to a JSONSchema model', async () => {
             const dir = await tmp.dir({ unsafeCleanup: true});
-            await Commands.compile('JSONSchema', null, models, dir.path, {offline:false});
+            await Commands.compile('JSONSchema', models, dir.path, {offline:false});
             fs.readdirSync(dir.path).length.should.be.above(0);
             dir.cleanup();
         });
         it('should compile to a XMLSchema model', async () => {
             const dir = await tmp.dir({ unsafeCleanup: true});
-            await Commands.compile('XMLSchema', null, models, dir.path, {offline:false});
+            await Commands.compile('XMLSchema', models, dir.path, {offline:false});
             fs.readdirSync(dir.path).length.should.be.above(0);
             dir.cleanup();
         });
         it('should not compile to an unknown model', async () => {
             const dir = await tmp.dir({ unsafeCleanup: true});
-            await Commands.compile('BLAH', null, models, dir.path, {offline:false});
+            await Commands.compile('BLAH', models, dir.path, {offline:false});
             fs.readdirSync(dir.path).length.should.be.equal(0);
             dir.cleanup();
         });
@@ -156,7 +155,7 @@ describe('cicero-cli', () => {
     describe('#get', () => {
         it('should save external dependencies', async () => {
             const dir = await tmp.dir({ unsafeCleanup: true});
-            await Commands.get(null, models, dir.path);
+            await Commands.get(models, dir.path);
             fs.readdirSync(dir.path).should.eql([
                 '@models.accordproject.org.cicero.contract.cto',
                 'dom.cto',
@@ -167,7 +166,7 @@ describe('cicero-cli', () => {
 
         it('should save external dependencies for an external model', async () => {
             const dir = await tmp.dir({ unsafeCleanup: true});
-            await Commands.get(null,['https://models.accordproject.org/patents/patent.cto'], dir.path);
+            await Commands.get(['https://models.accordproject.org/patents/patent.cto'], dir.path);
             fs.readdirSync(dir.path).should.eql([
                 '@models.accordproject.org.address.cto',
                 '@models.accordproject.org.geo.cto',
@@ -181,14 +180,5 @@ describe('cicero-cli', () => {
             ]);
             dir.cleanup();
         });
-
-        it('should fail saving external dependencies for an external model but with the wrong system model', async () => {
-            const dir = await tmp.dir({ unsafeCleanup: true});
-            try {
-                await Commands.get(hlModel,['https://models.accordproject.org/patents/patent.cto'], dir.path);
-            } catch (err) {
-                err.message.should.contain('Relationship transactionInvoked must be to an asset or participant, but is to org.hyperledger.composer.system.Transaction');
-            }
-        });
     });
 });